--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/ic/access-compiler.h"
+
+namespace v8 {
+namespace internal {
+
+#define __ ACCESS_MASM(masm)
+
+
+void PropertyAccessCompiler::GenerateTailCall(MacroAssembler* masm,
+ Handle<Code> code) {
+ __ Jump(code, RelocInfo::CODE_TARGET);
+}
+
+
+Register* PropertyAccessCompiler::load_calling_convention() {
+ // receiver, name, scratch1, scratch2, scratch3, scratch4.
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ Register name = LoadDescriptor::NameRegister();
+ static Register registers[] = {receiver, name, r6, r3, r7, r8};
+ return registers;
+}
+
+
+Register* PropertyAccessCompiler::store_calling_convention() {
+ // receiver, name, scratch1, scratch2, scratch3.
+ Register receiver = StoreDescriptor::ReceiverRegister();
+ Register name = StoreDescriptor::NameRegister();
+ DCHECK(r6.is(ElementTransitionAndStoreDescriptor::MapRegister()));
+ static Register registers[] = {receiver, name, r6, r7, r8};
+ return registers;
+}
+
+
+#undef __
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/ic/call-optimization.h"
+#include "src/ic/handler-compiler.h"
+#include "src/ic/ic.h"
+
+namespace v8 {
+namespace internal {
+
+#define __ ACCESS_MASM(masm)
+
+
+void NamedLoadHandlerCompiler::GenerateLoadViaGetter(
+ MacroAssembler* masm, Handle<HeapType> type, Register receiver,
+ Handle<JSFunction> getter) {
+ // ----------- S t a t e -------------
+ // -- r3 : receiver
+ // -- r5 : name
+ // -- lr : return address
+ // -----------------------------------
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+
+ if (!getter.is_null()) {
+ // Call the JavaScript getter with the receiver on the stack.
+ if (IC::TypeToMap(*type, masm->isolate())->IsJSGlobalObjectMap()) {
+ // Swap in the global receiver.
+ __ LoadP(receiver,
+ FieldMemOperand(receiver, JSGlobalObject::kGlobalProxyOffset));
+ }
+ __ push(receiver);
+ ParameterCount actual(0);
+ ParameterCount expected(getter);
+ __ InvokeFunction(getter, expected, actual, CALL_FUNCTION,
+ NullCallWrapper());
+ } else {
+ // If we generate a global code snippet for deoptimization only, remember
+ // the place to continue after deoptimization.
+ masm->isolate()->heap()->SetGetterStubDeoptPCOffset(masm->pc_offset());
+ }
+
+ // Restore context register.
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ }
+ __ Ret();
+}
+
+
+void NamedStoreHandlerCompiler::GenerateStoreViaSetter(
+ MacroAssembler* masm, Handle<HeapType> type, Register receiver,
+ Handle<JSFunction> setter) {
+ // ----------- S t a t e -------------
+ // -- lr : return address
+ // -----------------------------------
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+
+ // Save value register, so we can restore it later.
+ __ push(value());
+
+ if (!setter.is_null()) {
+ // Call the JavaScript setter with receiver and value on the stack.
+ if (IC::TypeToMap(*type, masm->isolate())->IsJSGlobalObjectMap()) {
+ // Swap in the global receiver.
+ __ LoadP(receiver,
+ FieldMemOperand(receiver, JSGlobalObject::kGlobalProxyOffset));
+ }
+ __ Push(receiver, value());
+ ParameterCount actual(1);
+ ParameterCount expected(setter);
+ __ InvokeFunction(setter, expected, actual, CALL_FUNCTION,
+ NullCallWrapper());
+ } else {
+ // If we generate a global code snippet for deoptimization only, remember
+ // the place to continue after deoptimization.
+ masm->isolate()->heap()->SetSetterStubDeoptPCOffset(masm->pc_offset());
+ }
+
+ // We have to return the passed value, not the return value of the setter.
+ __ pop(r3);
+
+ // Restore context register.
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ }
+ __ Ret();
+}
+
+
+void PropertyHandlerCompiler::GenerateDictionaryNegativeLookup(
+ MacroAssembler* masm, Label* miss_label, Register receiver,
+ Handle<Name> name, Register scratch0, Register scratch1) {
+ DCHECK(name->IsUniqueName());
+ DCHECK(!receiver.is(scratch0));
+ Counters* counters = masm->isolate()->counters();
+ __ IncrementCounter(counters->negative_lookups(), 1, scratch0, scratch1);
+ __ IncrementCounter(counters->negative_lookups_miss(), 1, scratch0, scratch1);
+
+ Label done;
+
+ const int kInterceptorOrAccessCheckNeededMask =
+ (1 << Map::kHasNamedInterceptor) | (1 << Map::kIsAccessCheckNeeded);
+
+ // Bail out if the receiver has a named interceptor or requires access checks.
+ Register map = scratch1;
+ __ LoadP(map, FieldMemOperand(receiver, HeapObject::kMapOffset));
+ __ lbz(scratch0, FieldMemOperand(map, Map::kBitFieldOffset));
+ __ andi(r0, scratch0, Operand(kInterceptorOrAccessCheckNeededMask));
+ __ bne(miss_label, cr0);
+
+ // Check that receiver is a JSObject.
+ __ lbz(scratch0, FieldMemOperand(map, Map::kInstanceTypeOffset));
+ __ cmpi(scratch0, Operand(FIRST_SPEC_OBJECT_TYPE));
+ __ blt(miss_label);
+
+ // Load properties array.
+ Register properties = scratch0;
+ __ LoadP(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
+ // Check that the properties array is a dictionary.
+ __ LoadP(map, FieldMemOperand(properties, HeapObject::kMapOffset));
+ Register tmp = properties;
+ __ LoadRoot(tmp, Heap::kHashTableMapRootIndex);
+ __ cmp(map, tmp);
+ __ bne(miss_label);
+
+ // Restore the temporarily used register.
+ __ LoadP(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
+
+
+ NameDictionaryLookupStub::GenerateNegativeLookup(
+ masm, miss_label, &done, receiver, properties, name, scratch1);
+ __ bind(&done);
+ __ DecrementCounter(counters->negative_lookups_miss(), 1, scratch0, scratch1);
+}
+
+
+void NamedLoadHandlerCompiler::GenerateDirectLoadGlobalFunctionPrototype(
+ MacroAssembler* masm, int index, Register prototype, Label* miss) {
+ Isolate* isolate = masm->isolate();
+ // Get the global function with the given index.
+ Handle<JSFunction> function(
+ JSFunction::cast(isolate->native_context()->get(index)));
+
+ // Check we're still in the same context.
+ Register scratch = prototype;
+ const int offset = Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX);
+ __ LoadP(scratch, MemOperand(cp, offset));
+ __ LoadP(scratch,
+ FieldMemOperand(scratch, GlobalObject::kNativeContextOffset));
+ __ LoadP(scratch, MemOperand(scratch, Context::SlotOffset(index)));
+ __ Move(ip, function);
+ __ cmp(ip, scratch);
+ __ bne(miss);
+
+ // Load its initial map. The global functions all have initial maps.
+ __ Move(prototype, Handle<Map>(function->initial_map()));
+ // Load the prototype from the initial map.
+ __ LoadP(prototype, FieldMemOperand(prototype, Map::kPrototypeOffset));
+}
+
+
+void NamedLoadHandlerCompiler::GenerateLoadFunctionPrototype(
+ MacroAssembler* masm, Register receiver, Register scratch1,
+ Register scratch2, Label* miss_label) {
+ __ TryGetFunctionPrototype(receiver, scratch1, scratch2, miss_label);
+ __ mr(r3, scratch1);
+ __ Ret();
+}
+
+
+// Generate code to check that a global property cell is empty. Create
+// the property cell at compilation time if no cell exists for the
+// property.
+void PropertyHandlerCompiler::GenerateCheckPropertyCell(
+ MacroAssembler* masm, Handle<JSGlobalObject> global, Handle<Name> name,
+ Register scratch, Label* miss) {
+ Handle<Cell> cell = JSGlobalObject::EnsurePropertyCell(global, name);
+ DCHECK(cell->value()->IsTheHole());
+ __ mov(scratch, Operand(cell));
+ __ LoadP(scratch, FieldMemOperand(scratch, Cell::kValueOffset));
+ __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
+ __ cmp(scratch, ip);
+ __ bne(miss);
+}
+
+
+static void PushInterceptorArguments(MacroAssembler* masm, Register receiver,
+ Register holder, Register name,
+ Handle<JSObject> holder_obj) {
+ STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsNameIndex == 0);
+ STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsInfoIndex == 1);
+ STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsThisIndex == 2);
+ STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsHolderIndex == 3);
+ STATIC_ASSERT(NamedLoadHandlerCompiler::kInterceptorArgsLength == 4);
+ __ push(name);
+ Handle<InterceptorInfo> interceptor(holder_obj->GetNamedInterceptor());
+ DCHECK(!masm->isolate()->heap()->InNewSpace(*interceptor));
+ Register scratch = name;
+ __ mov(scratch, Operand(interceptor));
+ __ push(scratch);
+ __ push(receiver);
+ __ push(holder);
+}
+
+
+static void CompileCallLoadPropertyWithInterceptor(
+ MacroAssembler* masm, Register receiver, Register holder, Register name,
+ Handle<JSObject> holder_obj, IC::UtilityId id) {
+ PushInterceptorArguments(masm, receiver, holder, name, holder_obj);
+ __ CallExternalReference(ExternalReference(IC_Utility(id), masm->isolate()),
+ NamedLoadHandlerCompiler::kInterceptorArgsLength);
+}
+
+
+// Generate call to api function.
+void PropertyHandlerCompiler::GenerateFastApiCall(
+ MacroAssembler* masm, const CallOptimization& optimization,
+ Handle<Map> receiver_map, Register receiver, Register scratch_in,
+ bool is_store, int argc, Register* values) {
+ DCHECK(!receiver.is(scratch_in));
+ __ push(receiver);
+ // Write the arguments to stack frame.
+ for (int i = 0; i < argc; i++) {
+ Register arg = values[argc - 1 - i];
+ DCHECK(!receiver.is(arg));
+ DCHECK(!scratch_in.is(arg));
+ __ push(arg);
+ }
+ DCHECK(optimization.is_simple_api_call());
+
+ // Abi for CallApiFunctionStub.
+ Register callee = r3;
+ Register call_data = r7;
+ Register holder = r5;
+ Register api_function_address = r4;
+
+ // Put holder in place.
+ CallOptimization::HolderLookup holder_lookup;
+ Handle<JSObject> api_holder =
+ optimization.LookupHolderOfExpectedType(receiver_map, &holder_lookup);
+ switch (holder_lookup) {
+ case CallOptimization::kHolderIsReceiver:
+ __ Move(holder, receiver);
+ break;
+ case CallOptimization::kHolderFound:
+ __ Move(holder, api_holder);
+ break;
+ case CallOptimization::kHolderNotFound:
+ UNREACHABLE();
+ break;
+ }
+
+ Isolate* isolate = masm->isolate();
+ Handle<JSFunction> function = optimization.constant_function();
+ Handle<CallHandlerInfo> api_call_info = optimization.api_call_info();
+ Handle<Object> call_data_obj(api_call_info->data(), isolate);
+
+ // Put callee in place.
+ __ Move(callee, function);
+
+ bool call_data_undefined = false;
+ // Put call_data in place.
+ if (isolate->heap()->InNewSpace(*call_data_obj)) {
+ __ Move(call_data, api_call_info);
+ __ LoadP(call_data,
+ FieldMemOperand(call_data, CallHandlerInfo::kDataOffset));
+ } else if (call_data_obj->IsUndefined()) {
+ call_data_undefined = true;
+ __ LoadRoot(call_data, Heap::kUndefinedValueRootIndex);
+ } else {
+ __ Move(call_data, call_data_obj);
+ }
+
+ // Put api_function_address in place.
+ Address function_address = v8::ToCData<Address>(api_call_info->callback());
+ ApiFunction fun(function_address);
+ ExternalReference::Type type = ExternalReference::DIRECT_API_CALL;
+ ExternalReference ref = ExternalReference(&fun, type, masm->isolate());
+ __ mov(api_function_address, Operand(ref));
+
+ // Jump to stub.
+ CallApiFunctionStub stub(isolate, is_store, call_data_undefined, argc);
+ __ TailCallStub(&stub);
+}
+
+
+void NamedStoreHandlerCompiler::GenerateSlow(MacroAssembler* masm) {
+ // Push receiver, key and value for runtime call.
+ __ Push(StoreDescriptor::ReceiverRegister(), StoreDescriptor::NameRegister(),
+ StoreDescriptor::ValueRegister());
+
+ // The slow case calls into the runtime to complete the store without causing
+ // an IC miss that would otherwise cause a transition to the generic stub.
+ ExternalReference ref =
+ ExternalReference(IC_Utility(IC::kStoreIC_Slow), masm->isolate());
+ __ TailCallExternalReference(ref, 3, 1);
+}
+
+
+void ElementHandlerCompiler::GenerateStoreSlow(MacroAssembler* masm) {
+ // Push receiver, key and value for runtime call.
+ __ Push(StoreDescriptor::ReceiverRegister(), StoreDescriptor::NameRegister(),
+ StoreDescriptor::ValueRegister());
+
+ // The slow case calls into the runtime to complete the store without causing
+ // an IC miss that would otherwise cause a transition to the generic stub.
+ ExternalReference ref =
+ ExternalReference(IC_Utility(IC::kKeyedStoreIC_Slow), masm->isolate());
+ __ TailCallExternalReference(ref, 3, 1);
+}
+
+
+#undef __
+#define __ ACCESS_MASM(masm())
+
+
+void NamedStoreHandlerCompiler::GenerateRestoreName(Label* label,
+ Handle<Name> name) {
+ if (!label->is_unused()) {
+ __ bind(label);
+ __ mov(this->name(), Operand(name));
+ }
+}
+
+
+void NamedStoreHandlerCompiler::GenerateRestoreNameAndMap(
+ Handle<Name> name, Handle<Map> transition) {
+ __ mov(this->name(), Operand(name));
+ __ mov(StoreTransitionDescriptor::MapRegister(), Operand(transition));
+}
+
+
+void NamedStoreHandlerCompiler::GenerateConstantCheck(Object* constant,
+ Register value_reg,
+ Label* miss_label) {
+ __ Move(scratch1(), handle(constant, isolate()));
+ __ cmp(value_reg, scratch1());
+ __ bne(miss_label);
+}
+
+
+void NamedStoreHandlerCompiler::GenerateFieldTypeChecks(HeapType* field_type,
+ Register value_reg,
+ Label* miss_label) {
+ __ JumpIfSmi(value_reg, miss_label);
+ HeapType::Iterator<Map> it = field_type->Classes();
+ if (!it.Done()) {
+ __ LoadP(scratch1(), FieldMemOperand(value_reg, HeapObject::kMapOffset));
+ Label do_store;
+ while (true) {
+ __ CompareMap(scratch1(), it.Current(), &do_store);
+ it.Advance();
+ if (it.Done()) {
+ __ bne(miss_label);
+ break;
+ }
+ __ beq(&do_store);
+ }
+ __ bind(&do_store);
+ }
+}
+
+
+Register PropertyHandlerCompiler::CheckPrototypes(
+ Register object_reg, Register holder_reg, Register scratch1,
+ Register scratch2, Handle<Name> name, Label* miss,
+ PrototypeCheckType check) {
+ Handle<Map> receiver_map(IC::TypeToMap(*type(), isolate()));
+
+ // Make sure there's no overlap between holder and object registers.
+ DCHECK(!scratch1.is(object_reg) && !scratch1.is(holder_reg));
+ DCHECK(!scratch2.is(object_reg) && !scratch2.is(holder_reg) &&
+ !scratch2.is(scratch1));
+
+ // Keep track of the current object in register reg.
+ Register reg = object_reg;
+ int depth = 0;
+
+ Handle<JSObject> current = Handle<JSObject>::null();
+ if (type()->IsConstant()) {
+ current = Handle<JSObject>::cast(type()->AsConstant()->Value());
+ }
+ Handle<JSObject> prototype = Handle<JSObject>::null();
+ Handle<Map> current_map = receiver_map;
+ Handle<Map> holder_map(holder()->map());
+ // Traverse the prototype chain and check the maps in the prototype chain for
+ // fast and global objects or do negative lookup for normal objects.
+ while (!current_map.is_identical_to(holder_map)) {
+ ++depth;
+
+ // Only global objects and objects that do not require access
+ // checks are allowed in stubs.
+ DCHECK(current_map->IsJSGlobalProxyMap() ||
+ !current_map->is_access_check_needed());
+
+ prototype = handle(JSObject::cast(current_map->prototype()));
+ if (current_map->is_dictionary_map() &&
+ !current_map->IsJSGlobalObjectMap()) {
+ DCHECK(!current_map->IsJSGlobalProxyMap()); // Proxy maps are fast.
+ if (!name->IsUniqueName()) {
+ DCHECK(name->IsString());
+ name = factory()->InternalizeString(Handle<String>::cast(name));
+ }
+ DCHECK(current.is_null() ||
+ current->property_dictionary()->FindEntry(name) ==
+ NameDictionary::kNotFound);
+
+ GenerateDictionaryNegativeLookup(masm(), miss, reg, name, scratch1,
+ scratch2);
+
+ __ LoadP(scratch1, FieldMemOperand(reg, HeapObject::kMapOffset));
+ reg = holder_reg; // From now on the object will be in holder_reg.
+ __ LoadP(reg, FieldMemOperand(scratch1, Map::kPrototypeOffset));
+ } else {
+ Register map_reg = scratch1;
+ if (depth != 1 || check == CHECK_ALL_MAPS) {
+ // CheckMap implicitly loads the map of |reg| into |map_reg|.
+ __ CheckMap(reg, map_reg, current_map, miss, DONT_DO_SMI_CHECK);
+ } else {
+ __ LoadP(map_reg, FieldMemOperand(reg, HeapObject::kMapOffset));
+ }
+
+ // Check access rights to the global object. This has to happen after
+ // the map check so that we know that the object is actually a global
+ // object.
+ // This allows us to install generated handlers for accesses to the
+ // global proxy (as opposed to using slow ICs). See corresponding code
+ // in LookupForRead().
+ if (current_map->IsJSGlobalProxyMap()) {
+ __ CheckAccessGlobalProxy(reg, scratch2, miss);
+ } else if (current_map->IsJSGlobalObjectMap()) {
+ GenerateCheckPropertyCell(masm(), Handle<JSGlobalObject>::cast(current),
+ name, scratch2, miss);
+ }
+
+ reg = holder_reg; // From now on the object will be in holder_reg.
+
+ // Two possible reasons for loading the prototype from the map:
+ // (1) Can't store references to new space in code.
+ // (2) Handler is shared for all receivers with the same prototype
+ // map (but not necessarily the same prototype instance).
+ bool load_prototype_from_map =
+ heap()->InNewSpace(*prototype) || depth == 1;
+ if (load_prototype_from_map) {
+ __ LoadP(reg, FieldMemOperand(map_reg, Map::kPrototypeOffset));
+ } else {
+ __ mov(reg, Operand(prototype));
+ }
+ }
+
+ // Go to the next object in the prototype chain.
+ current = prototype;
+ current_map = handle(current->map());
+ }
+
+ // Log the check depth.
+ LOG(isolate(), IntEvent("check-maps-depth", depth + 1));
+
+ if (depth != 0 || check == CHECK_ALL_MAPS) {
+ // Check the holder map.
+ __ CheckMap(reg, scratch1, current_map, miss, DONT_DO_SMI_CHECK);
+ }
+
+ // Perform security check for access to the global object.
+ DCHECK(current_map->IsJSGlobalProxyMap() ||
+ !current_map->is_access_check_needed());
+ if (current_map->IsJSGlobalProxyMap()) {
+ __ CheckAccessGlobalProxy(reg, scratch1, miss);
+ }
+
+ // Return the register containing the holder.
+ return reg;
+}
+
+
+void NamedLoadHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) {
+ if (!miss->is_unused()) {
+ Label success;
+ __ b(&success);
+ __ bind(miss);
+ TailCallBuiltin(masm(), MissBuiltin(kind()));
+ __ bind(&success);
+ }
+}
+
+
+void NamedStoreHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) {
+ if (!miss->is_unused()) {
+ Label success;
+ __ b(&success);
+ GenerateRestoreName(miss, name);
+ TailCallBuiltin(masm(), MissBuiltin(kind()));
+ __ bind(&success);
+ }
+}
+
+
+void NamedLoadHandlerCompiler::GenerateLoadConstant(Handle<Object> value) {
+ // Return the constant value.
+ __ Move(r3, value);
+ __ Ret();
+}
+
+
+void NamedLoadHandlerCompiler::GenerateLoadCallback(
+ Register reg, Handle<ExecutableAccessorInfo> callback) {
+ // Build AccessorInfo::args_ list on the stack and push property name below
+ // the exit frame to make GC aware of them and store pointers to them.
+ STATIC_ASSERT(PropertyCallbackArguments::kHolderIndex == 0);
+ STATIC_ASSERT(PropertyCallbackArguments::kIsolateIndex == 1);
+ STATIC_ASSERT(PropertyCallbackArguments::kReturnValueDefaultValueIndex == 2);
+ STATIC_ASSERT(PropertyCallbackArguments::kReturnValueOffset == 3);
+ STATIC_ASSERT(PropertyCallbackArguments::kDataIndex == 4);
+ STATIC_ASSERT(PropertyCallbackArguments::kThisIndex == 5);
+ STATIC_ASSERT(PropertyCallbackArguments::kArgsLength == 6);
+ DCHECK(!scratch2().is(reg));
+ DCHECK(!scratch3().is(reg));
+ DCHECK(!scratch4().is(reg));
+ __ push(receiver());
+ if (heap()->InNewSpace(callback->data())) {
+ __ Move(scratch3(), callback);
+ __ LoadP(scratch3(),
+ FieldMemOperand(scratch3(), ExecutableAccessorInfo::kDataOffset));
+ } else {
+ __ Move(scratch3(), Handle<Object>(callback->data(), isolate()));
+ }
+ __ push(scratch3());
+ __ LoadRoot(scratch3(), Heap::kUndefinedValueRootIndex);
+ __ mr(scratch4(), scratch3());
+ __ Push(scratch3(), scratch4());
+ __ mov(scratch4(), Operand(ExternalReference::isolate_address(isolate())));
+ __ Push(scratch4(), reg);
+ __ push(name());
+
+ // Abi for CallApiGetter
+ Register getter_address_reg = ApiGetterDescriptor::function_address();
+
+ Address getter_address = v8::ToCData<Address>(callback->getter());
+ ApiFunction fun(getter_address);
+ ExternalReference::Type type = ExternalReference::DIRECT_GETTER_CALL;
+ ExternalReference ref = ExternalReference(&fun, type, isolate());
+ __ mov(getter_address_reg, Operand(ref));
+
+ CallApiGetterStub stub(isolate());
+ __ TailCallStub(&stub);
+}
+
+
+void NamedLoadHandlerCompiler::GenerateLoadInterceptorWithFollowup(
+ LookupIterator* it, Register holder_reg) {
+ DCHECK(holder()->HasNamedInterceptor());
+ DCHECK(!holder()->GetNamedInterceptor()->getter()->IsUndefined());
+
+ // Compile the interceptor call, followed by inline code to load the
+ // property from further up the prototype chain if the call fails.
+ // Check that the maps haven't changed.
+ DCHECK(holder_reg.is(receiver()) || holder_reg.is(scratch1()));
+
+ // Preserve the receiver register explicitly whenever it is different from the
+ // holder and it is needed should the interceptor return without any result.
+ // The ACCESSOR case needs the receiver to be passed into C++ code, the FIELD
+ // case might cause a miss during the prototype check.
+ bool must_perform_prototype_check =
+ !holder().is_identical_to(it->GetHolder<JSObject>());
+ bool must_preserve_receiver_reg =
+ !receiver().is(holder_reg) &&
+ (it->state() == LookupIterator::ACCESSOR || must_perform_prototype_check);
+
+ // Save necessary data before invoking an interceptor.
+ // Requires a frame to make GC aware of pushed pointers.
+ {
+ FrameAndConstantPoolScope frame_scope(masm(), StackFrame::INTERNAL);
+ if (must_preserve_receiver_reg) {
+ __ Push(receiver(), holder_reg, this->name());
+ } else {
+ __ Push(holder_reg, this->name());
+ }
+ // Invoke an interceptor. Note: map checks from receiver to
+ // interceptor's holder has been compiled before (see a caller
+ // of this method.)
+ CompileCallLoadPropertyWithInterceptor(
+ masm(), receiver(), holder_reg, this->name(), holder(),
+ IC::kLoadPropertyWithInterceptorOnly);
+
+ // Check if interceptor provided a value for property. If it's
+ // the case, return immediately.
+ Label interceptor_failed;
+ __ LoadRoot(scratch1(), Heap::kNoInterceptorResultSentinelRootIndex);
+ __ cmp(r3, scratch1());
+ __ beq(&interceptor_failed);
+ frame_scope.GenerateLeaveFrame();
+ __ Ret();
+
+ __ bind(&interceptor_failed);
+ __ pop(this->name());
+ __ pop(holder_reg);
+ if (must_preserve_receiver_reg) {
+ __ pop(receiver());
+ }
+ // Leave the internal frame.
+ }
+
+ GenerateLoadPostInterceptor(it, holder_reg);
+}
+
+
+void NamedLoadHandlerCompiler::GenerateLoadInterceptor(Register holder_reg) {
+ // Call the runtime system to load the interceptor.
+ DCHECK(holder()->HasNamedInterceptor());
+ DCHECK(!holder()->GetNamedInterceptor()->getter()->IsUndefined());
+ PushInterceptorArguments(masm(), receiver(), holder_reg, this->name(),
+ holder());
+
+ ExternalReference ref = ExternalReference(
+ IC_Utility(IC::kLoadPropertyWithInterceptor), isolate());
+ __ TailCallExternalReference(
+ ref, NamedLoadHandlerCompiler::kInterceptorArgsLength, 1);
+}
+
+
+Handle<Code> NamedStoreHandlerCompiler::CompileStoreCallback(
+ Handle<JSObject> object, Handle<Name> name,
+ Handle<ExecutableAccessorInfo> callback) {
+ Register holder_reg = Frontend(receiver(), name);
+
+ __ Push(receiver(), holder_reg); // receiver
+ __ mov(ip, Operand(callback)); // callback info
+ __ push(ip);
+ __ mov(ip, Operand(name));
+ __ Push(ip, value());
+
+ // Do tail-call to the runtime system.
+ ExternalReference store_callback_property =
+ ExternalReference(IC_Utility(IC::kStoreCallbackProperty), isolate());
+ __ TailCallExternalReference(store_callback_property, 5, 1);
+
+ // Return the generated code.
+ return GetCode(kind(), Code::FAST, name);
+}
+
+
+Handle<Code> NamedStoreHandlerCompiler::CompileStoreInterceptor(
+ Handle<Name> name) {
+ __ Push(receiver(), this->name(), value());
+
+ // Do tail-call to the runtime system.
+ ExternalReference store_ic_property = ExternalReference(
+ IC_Utility(IC::kStorePropertyWithInterceptor), isolate());
+ __ TailCallExternalReference(store_ic_property, 3, 1);
+
+ // Return the generated code.
+ return GetCode(kind(), Code::FAST, name);
+}
+
+
+Register NamedStoreHandlerCompiler::value() {
+ return StoreDescriptor::ValueRegister();
+}
+
+
+Handle<Code> NamedLoadHandlerCompiler::CompileLoadGlobal(
+ Handle<PropertyCell> cell, Handle<Name> name, bool is_configurable) {
+ Label miss;
+ FrontendHeader(receiver(), name, &miss);
+
+ // Get the value from the cell.
+ Register result = StoreDescriptor::ValueRegister();
+ __ mov(result, Operand(cell));
+ __ LoadP(result, FieldMemOperand(result, Cell::kValueOffset));
+
+ // Check for deleted property if property can actually be deleted.
+ if (is_configurable) {
+ __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
+ __ cmp(result, ip);
+ __ beq(&miss);
+ }
+
+ Counters* counters = isolate()->counters();
+ __ IncrementCounter(counters->named_load_global_stub(), 1, r4, r6);
+ __ Ret();
+
+ FrontendFooter(name, &miss);
+
+ // Return the generated code.
+ return GetCode(kind(), Code::NORMAL, name);
+}
+
+
+#undef __
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_ARM
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/ic/ic.h"
+#include "src/ic/ic-compiler.h"
+
+namespace v8 {
+namespace internal {
+
+#define __ ACCESS_MASM(masm)
+
+
+void PropertyICCompiler::GenerateRuntimeSetProperty(MacroAssembler* masm,
+ StrictMode strict_mode) {
+ __ Push(StoreDescriptor::ReceiverRegister(), StoreDescriptor::NameRegister(),
+ StoreDescriptor::ValueRegister());
+
+ __ mov(r0, Operand(Smi::FromInt(strict_mode)));
+ __ Push(r0);
+
+ // Do tail-call to runtime routine.
+ __ TailCallRuntime(Runtime::kSetProperty, 4, 1);
+}
+
+
+#undef __
+#define __ ACCESS_MASM(masm())
+
+
+Handle<Code> PropertyICCompiler::CompilePolymorphic(TypeHandleList* types,
+ CodeHandleList* handlers,
+ Handle<Name> name,
+ Code::StubType type,
+ IcCheckType check) {
+ Label miss;
+
+ if (check == PROPERTY &&
+ (kind() == Code::KEYED_LOAD_IC || kind() == Code::KEYED_STORE_IC)) {
+ // In case we are compiling an IC for dictionary loads and stores, just
+ // check whether the name is unique.
+ if (name.is_identical_to(isolate()->factory()->normal_ic_symbol())) {
+ Register tmp = scratch1();
+ __ JumpIfSmi(this->name(), &miss);
+ __ LoadP(tmp, FieldMemOperand(this->name(), HeapObject::kMapOffset));
+ __ lbz(tmp, FieldMemOperand(tmp, Map::kInstanceTypeOffset));
+ __ JumpIfNotUniqueNameInstanceType(tmp, &miss);
+ } else {
+ __ Cmpi(this->name(), Operand(name), r0);
+ __ bne(&miss);
+ }
+ }
+
+ Label number_case;
+ Label* smi_target = IncludesNumberType(types) ? &number_case : &miss;
+ __ JumpIfSmi(receiver(), smi_target);
+
+ // Polymorphic keyed stores may use the map register
+ Register map_reg = scratch1();
+ DCHECK(kind() != Code::KEYED_STORE_IC ||
+ map_reg.is(ElementTransitionAndStoreDescriptor::MapRegister()));
+
+ int receiver_count = types->length();
+ int number_of_handled_maps = 0;
+ __ LoadP(map_reg, FieldMemOperand(receiver(), HeapObject::kMapOffset));
+ for (int current = 0; current < receiver_count; ++current) {
+ Handle<HeapType> type = types->at(current);
+ Handle<Map> map = IC::TypeToMap(*type, isolate());
+ if (!map->is_deprecated()) {
+ number_of_handled_maps++;
+ __ mov(ip, Operand(map));
+ __ cmp(map_reg, ip);
+ if (type->Is(HeapType::Number())) {
+ DCHECK(!number_case.is_unused());
+ __ bind(&number_case);
+ }
+ __ Jump(handlers->at(current), RelocInfo::CODE_TARGET, eq);
+ }
+ }
+ DCHECK(number_of_handled_maps != 0);
+
+ __ bind(&miss);
+ TailCallBuiltin(masm(), MissBuiltin(kind()));
+
+ // Return the generated code.
+ InlineCacheState state =
+ number_of_handled_maps > 1 ? POLYMORPHIC : MONOMORPHIC;
+ return GetCode(kind(), type, name, state);
+}
+
+
+Handle<Code> PropertyICCompiler::CompileKeyedStorePolymorphic(
+ MapHandleList* receiver_maps, CodeHandleList* handler_stubs,
+ MapHandleList* transitioned_maps) {
+ Label miss;
+ __ JumpIfSmi(receiver(), &miss);
+
+ int receiver_count = receiver_maps->length();
+ __ LoadP(scratch1(), FieldMemOperand(receiver(), HeapObject::kMapOffset));
+ for (int i = 0; i < receiver_count; ++i) {
+ __ mov(ip, Operand(receiver_maps->at(i)));
+ __ cmp(scratch1(), ip);
+ if (transitioned_maps->at(i).is_null()) {
+ __ Jump(handler_stubs->at(i), RelocInfo::CODE_TARGET, eq);
+ } else {
+ Label next_map;
+ __ bne(&next_map);
+ __ mov(transition_map(), Operand(transitioned_maps->at(i)));
+ __ Jump(handler_stubs->at(i), RelocInfo::CODE_TARGET, al);
+ __ bind(&next_map);
+ }
+ }
+
+ __ bind(&miss);
+ TailCallBuiltin(masm(), MissBuiltin(kind()));
+
+ // Return the generated code.
+ return GetCode(kind(), Code::NORMAL, factory()->empty_string(), POLYMORPHIC);
+}
+
+
+#undef __
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/codegen.h"
+#include "src/ic/ic.h"
+#include "src/ic/ic-compiler.h"
+#include "src/ic/stub-cache.h"
+
+namespace v8 {
+namespace internal {
+
+
+// ----------------------------------------------------------------------------
+// Static IC stub generators.
+//
+
+#define __ ACCESS_MASM(masm)
+
+
+static void GenerateGlobalInstanceTypeCheck(MacroAssembler* masm, Register type,
+ Label* global_object) {
+ // Register usage:
+ // type: holds the receiver instance type on entry.
+ __ cmpi(type, Operand(JS_GLOBAL_OBJECT_TYPE));
+ __ beq(global_object);
+ __ cmpi(type, Operand(JS_BUILTINS_OBJECT_TYPE));
+ __ beq(global_object);
+ __ cmpi(type, Operand(JS_GLOBAL_PROXY_TYPE));
+ __ beq(global_object);
+}
+
+
+// Helper function used from LoadIC GenerateNormal.
+//
+// elements: Property dictionary. It is not clobbered if a jump to the miss
+// label is done.
+// name: Property name. It is not clobbered if a jump to the miss label is
+// done
+// result: Register for the result. It is only updated if a jump to the miss
+// label is not done. Can be the same as elements or name clobbering
+// one of these in the case of not jumping to the miss label.
+// The two scratch registers need to be different from elements, name and
+// result.
+// The generated code assumes that the receiver has slow properties,
+// is not a global object and does not have interceptors.
+static void GenerateDictionaryLoad(MacroAssembler* masm, Label* miss,
+ Register elements, Register name,
+ Register result, Register scratch1,
+ Register scratch2) {
+ // Main use of the scratch registers.
+ // scratch1: Used as temporary and to hold the capacity of the property
+ // dictionary.
+ // scratch2: Used as temporary.
+ Label done;
+
+ // Probe the dictionary.
+ NameDictionaryLookupStub::GeneratePositiveLookup(masm, miss, &done, elements,
+ name, scratch1, scratch2);
+
+ // If probing finds an entry check that the value is a normal
+ // property.
+ __ bind(&done); // scratch2 == elements + 4 * index
+ const int kElementsStartOffset =
+ NameDictionary::kHeaderSize +
+ NameDictionary::kElementsStartIndex * kPointerSize;
+ const int kDetailsOffset = kElementsStartOffset + 2 * kPointerSize;
+ __ LoadP(scratch1, FieldMemOperand(scratch2, kDetailsOffset));
+ __ mr(r0, scratch2);
+ __ LoadSmiLiteral(scratch2, Smi::FromInt(PropertyDetails::TypeField::kMask));
+ __ and_(scratch2, scratch1, scratch2, SetRC);
+ __ bne(miss, cr0);
+ __ mr(scratch2, r0);
+
+ // Get the value at the masked, scaled index and return.
+ __ LoadP(result,
+ FieldMemOperand(scratch2, kElementsStartOffset + 1 * kPointerSize));
+}
+
+
+// Helper function used from StoreIC::GenerateNormal.
+//
+// elements: Property dictionary. It is not clobbered if a jump to the miss
+// label is done.
+// name: Property name. It is not clobbered if a jump to the miss label is
+// done
+// value: The value to store.
+// The two scratch registers need to be different from elements, name and
+// result.
+// The generated code assumes that the receiver has slow properties,
+// is not a global object and does not have interceptors.
+static void GenerateDictionaryStore(MacroAssembler* masm, Label* miss,
+ Register elements, Register name,
+ Register value, Register scratch1,
+ Register scratch2) {
+ // Main use of the scratch registers.
+ // scratch1: Used as temporary and to hold the capacity of the property
+ // dictionary.
+ // scratch2: Used as temporary.
+ Label done;
+
+ // Probe the dictionary.
+ NameDictionaryLookupStub::GeneratePositiveLookup(masm, miss, &done, elements,
+ name, scratch1, scratch2);
+
+ // If probing finds an entry in the dictionary check that the value
+ // is a normal property that is not read only.
+ __ bind(&done); // scratch2 == elements + 4 * index
+ const int kElementsStartOffset =
+ NameDictionary::kHeaderSize +
+ NameDictionary::kElementsStartIndex * kPointerSize;
+ const int kDetailsOffset = kElementsStartOffset + 2 * kPointerSize;
+ int kTypeAndReadOnlyMask =
+ PropertyDetails::TypeField::kMask |
+ PropertyDetails::AttributesField::encode(READ_ONLY);
+ __ LoadP(scratch1, FieldMemOperand(scratch2, kDetailsOffset));
+ __ mr(r0, scratch2);
+ __ LoadSmiLiteral(scratch2, Smi::FromInt(kTypeAndReadOnlyMask));
+ __ and_(scratch2, scratch1, scratch2, SetRC);
+ __ bne(miss, cr0);
+ __ mr(scratch2, r0);
+
+ // Store the value at the masked, scaled index and return.
+ const int kValueOffset = kElementsStartOffset + kPointerSize;
+ __ addi(scratch2, scratch2, Operand(kValueOffset - kHeapObjectTag));
+ __ StoreP(value, MemOperand(scratch2));
+
+ // Update the write barrier. Make sure not to clobber the value.
+ __ mr(scratch1, value);
+ __ RecordWrite(elements, scratch2, scratch1, kLRHasNotBeenSaved,
+ kDontSaveFPRegs);
+}
+
+
+// Checks the receiver for special cases (value type, slow case bits).
+// Falls through for regular JS object.
+static void GenerateKeyedLoadReceiverCheck(MacroAssembler* masm,
+ Register receiver, Register map,
+ Register scratch,
+ int interceptor_bit, Label* slow) {
+ // Check that the object isn't a smi.
+ __ JumpIfSmi(receiver, slow);
+ // Get the map of the receiver.
+ __ LoadP(map, FieldMemOperand(receiver, HeapObject::kMapOffset));
+ // Check bit field.
+ __ lbz(scratch, FieldMemOperand(map, Map::kBitFieldOffset));
+ DCHECK(((1 << Map::kIsAccessCheckNeeded) | (1 << interceptor_bit)) < 0x8000);
+ __ andi(r0, scratch,
+ Operand((1 << Map::kIsAccessCheckNeeded) | (1 << interceptor_bit)));
+ __ bne(slow, cr0);
+ // Check that the object is some kind of JS object EXCEPT JS Value type.
+ // In the case that the object is a value-wrapper object,
+ // we enter the runtime system to make sure that indexing into string
+ // objects work as intended.
+ DCHECK(JS_OBJECT_TYPE > JS_VALUE_TYPE);
+ __ lbz(scratch, FieldMemOperand(map, Map::kInstanceTypeOffset));
+ __ cmpi(scratch, Operand(JS_OBJECT_TYPE));
+ __ blt(slow);
+}
+
+
+// Loads an indexed element from a fast case array.
+// If not_fast_array is NULL, doesn't perform the elements map check.
+static void GenerateFastArrayLoad(MacroAssembler* masm, Register receiver,
+ Register key, Register elements,
+ Register scratch1, Register scratch2,
+ Register result, Label* not_fast_array,
+ Label* out_of_range) {
+ // Register use:
+ //
+ // receiver - holds the receiver on entry.
+ // Unchanged unless 'result' is the same register.
+ //
+ // key - holds the smi key on entry.
+ // Unchanged unless 'result' is the same register.
+ //
+ // elements - holds the elements of the receiver on exit.
+ //
+ // result - holds the result on exit if the load succeeded.
+ // Allowed to be the the same as 'receiver' or 'key'.
+ // Unchanged on bailout so 'receiver' and 'key' can be safely
+ // used by further computation.
+ //
+ // Scratch registers:
+ //
+ // scratch1 - used to hold elements map and elements length.
+ // Holds the elements map if not_fast_array branch is taken.
+ //
+ // scratch2 - used to hold the loaded value.
+
+ __ LoadP(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
+ if (not_fast_array != NULL) {
+ // Check that the object is in fast mode and writable.
+ __ LoadP(scratch1, FieldMemOperand(elements, HeapObject::kMapOffset));
+ __ LoadRoot(ip, Heap::kFixedArrayMapRootIndex);
+ __ cmp(scratch1, ip);
+ __ bne(not_fast_array);
+ } else {
+ __ AssertFastElements(elements);
+ }
+ // Check that the key (index) is within bounds.
+ __ LoadP(scratch1, FieldMemOperand(elements, FixedArray::kLengthOffset));
+ __ cmpl(key, scratch1);
+ __ bge(out_of_range);
+ // Fast case: Do the load.
+ __ addi(scratch1, elements,
+ Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ // The key is a smi.
+ __ SmiToPtrArrayOffset(scratch2, key);
+ __ LoadPX(scratch2, MemOperand(scratch2, scratch1));
+ __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
+ __ cmp(scratch2, ip);
+ // In case the loaded value is the_hole we have to consult GetProperty
+ // to ensure the prototype chain is searched.
+ __ beq(out_of_range);
+ __ mr(result, scratch2);
+}
+
+
+// Checks whether a key is an array index string or a unique name.
+// Falls through if a key is a unique name.
+static void GenerateKeyNameCheck(MacroAssembler* masm, Register key,
+ Register map, Register hash,
+ Label* index_string, Label* not_unique) {
+ // The key is not a smi.
+ Label unique;
+ // Is it a name?
+ __ CompareObjectType(key, map, hash, LAST_UNIQUE_NAME_TYPE);
+ __ bgt(not_unique);
+ STATIC_ASSERT(LAST_UNIQUE_NAME_TYPE == FIRST_NONSTRING_TYPE);
+ __ beq(&unique);
+
+ // Is the string an array index, with cached numeric value?
+ __ lwz(hash, FieldMemOperand(key, Name::kHashFieldOffset));
+ __ mov(r8, Operand(Name::kContainsCachedArrayIndexMask));
+ __ and_(r0, hash, r8, SetRC);
+ __ beq(index_string, cr0);
+
+ // Is the string internalized? We know it's a string, so a single
+ // bit test is enough.
+ // map: key map
+ __ lbz(hash, FieldMemOperand(map, Map::kInstanceTypeOffset));
+ STATIC_ASSERT(kInternalizedTag == 0);
+ __ andi(r0, hash, Operand(kIsNotInternalizedMask));
+ __ bne(not_unique, cr0);
+
+ __ bind(&unique);
+}
+
+
+void LoadIC::GenerateNormal(MacroAssembler* masm) {
+ Register dictionary = r3;
+ DCHECK(!dictionary.is(LoadDescriptor::ReceiverRegister()));
+ DCHECK(!dictionary.is(LoadDescriptor::NameRegister()));
+
+ Label slow;
+
+ __ LoadP(dictionary, FieldMemOperand(LoadDescriptor::ReceiverRegister(),
+ JSObject::kPropertiesOffset));
+ GenerateDictionaryLoad(masm, &slow, dictionary,
+ LoadDescriptor::NameRegister(), r3, r6, r7);
+ __ Ret();
+
+ // Dictionary load failed, go slow (but don't miss).
+ __ bind(&slow);
+ GenerateRuntimeGetProperty(masm);
+}
+
+
+// A register that isn't one of the parameters to the load ic.
+static const Register LoadIC_TempRegister() { return r6; }
+
+
+void LoadIC::GenerateMiss(MacroAssembler* masm) {
+ // The return address is in lr.
+ Isolate* isolate = masm->isolate();
+
+ __ IncrementCounter(isolate->counters()->load_miss(), 1, r6, r7);
+
+ __ mr(LoadIC_TempRegister(), LoadDescriptor::ReceiverRegister());
+ __ Push(LoadIC_TempRegister(), LoadDescriptor::NameRegister());
+
+ // Perform tail call to the entry.
+ ExternalReference ref = ExternalReference(IC_Utility(kLoadIC_Miss), isolate);
+ __ TailCallExternalReference(ref, 2, 1);
+}
+
+
+void LoadIC::GenerateRuntimeGetProperty(MacroAssembler* masm) {
+ // The return address is in lr.
+
+ __ mr(LoadIC_TempRegister(), LoadDescriptor::ReceiverRegister());
+ __ Push(LoadIC_TempRegister(), LoadDescriptor::NameRegister());
+
+ __ TailCallRuntime(Runtime::kGetProperty, 2, 1);
+}
+
+
+static MemOperand GenerateMappedArgumentsLookup(
+ MacroAssembler* masm, Register object, Register key, Register scratch1,
+ Register scratch2, Register scratch3, Label* unmapped_case,
+ Label* slow_case) {
+ Heap* heap = masm->isolate()->heap();
+
+ // Check that the receiver is a JSObject. Because of the map check
+ // later, we do not need to check for interceptors or whether it
+ // requires access checks.
+ __ JumpIfSmi(object, slow_case);
+ // Check that the object is some kind of JSObject.
+ __ CompareObjectType(object, scratch1, scratch2, FIRST_JS_RECEIVER_TYPE);
+ __ blt(slow_case);
+
+ // Check that the key is a positive smi.
+ __ mov(scratch1, Operand(0x80000001));
+ __ and_(r0, key, scratch1, SetRC);
+ __ bne(slow_case, cr0);
+
+ // Load the elements into scratch1 and check its map.
+ Handle<Map> arguments_map(heap->sloppy_arguments_elements_map());
+ __ LoadP(scratch1, FieldMemOperand(object, JSObject::kElementsOffset));
+ __ CheckMap(scratch1, scratch2, arguments_map, slow_case, DONT_DO_SMI_CHECK);
+
+ // Check if element is in the range of mapped arguments. If not, jump
+ // to the unmapped lookup with the parameter map in scratch1.
+ __ LoadP(scratch2, FieldMemOperand(scratch1, FixedArray::kLengthOffset));
+ __ SubSmiLiteral(scratch2, scratch2, Smi::FromInt(2), r0);
+ __ cmpl(key, scratch2);
+ __ bge(unmapped_case);
+
+ // Load element index and check whether it is the hole.
+ const int kOffset =
+ FixedArray::kHeaderSize + 2 * kPointerSize - kHeapObjectTag;
+
+ __ SmiToPtrArrayOffset(scratch3, key);
+ __ addi(scratch3, scratch3, Operand(kOffset));
+
+ __ LoadPX(scratch2, MemOperand(scratch1, scratch3));
+ __ LoadRoot(scratch3, Heap::kTheHoleValueRootIndex);
+ __ cmp(scratch2, scratch3);
+ __ beq(unmapped_case);
+
+ // Load value from context and return it. We can reuse scratch1 because
+ // we do not jump to the unmapped lookup (which requires the parameter
+ // map in scratch1).
+ __ LoadP(scratch1, FieldMemOperand(scratch1, FixedArray::kHeaderSize));
+ __ SmiToPtrArrayOffset(scratch3, scratch2);
+ __ addi(scratch3, scratch3, Operand(Context::kHeaderSize - kHeapObjectTag));
+ return MemOperand(scratch1, scratch3);
+}
+
+
+static MemOperand GenerateUnmappedArgumentsLookup(MacroAssembler* masm,
+ Register key,
+ Register parameter_map,
+ Register scratch,
+ Label* slow_case) {
+ // Element is in arguments backing store, which is referenced by the
+ // second element of the parameter_map. The parameter_map register
+ // must be loaded with the parameter map of the arguments object and is
+ // overwritten.
+ const int kBackingStoreOffset = FixedArray::kHeaderSize + kPointerSize;
+ Register backing_store = parameter_map;
+ __ LoadP(backing_store, FieldMemOperand(parameter_map, kBackingStoreOffset));
+ Handle<Map> fixed_array_map(masm->isolate()->heap()->fixed_array_map());
+ __ CheckMap(backing_store, scratch, fixed_array_map, slow_case,
+ DONT_DO_SMI_CHECK);
+ __ LoadP(scratch, FieldMemOperand(backing_store, FixedArray::kLengthOffset));
+ __ cmpl(key, scratch);
+ __ bge(slow_case);
+ __ SmiToPtrArrayOffset(scratch, key);
+ __ addi(scratch, scratch, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ return MemOperand(backing_store, scratch);
+}
+
+
+void KeyedStoreIC::GenerateSloppyArguments(MacroAssembler* masm) {
+ Register receiver = StoreDescriptor::ReceiverRegister();
+ Register key = StoreDescriptor::NameRegister();
+ Register value = StoreDescriptor::ValueRegister();
+ DCHECK(receiver.is(r4));
+ DCHECK(key.is(r5));
+ DCHECK(value.is(r3));
+
+ Label slow, notin;
+ MemOperand mapped_location = GenerateMappedArgumentsLookup(
+ masm, receiver, key, r6, r7, r8, ¬in, &slow);
+ Register mapped_base = mapped_location.ra();
+ Register mapped_offset = mapped_location.rb();
+ __ StorePX(value, mapped_location);
+ __ add(r9, mapped_base, mapped_offset);
+ __ mr(r11, value);
+ __ RecordWrite(mapped_base, r9, r11, kLRHasNotBeenSaved, kDontSaveFPRegs);
+ __ Ret();
+ __ bind(¬in);
+ // The unmapped lookup expects that the parameter map is in r6.
+ MemOperand unmapped_location =
+ GenerateUnmappedArgumentsLookup(masm, key, r6, r7, &slow);
+ Register unmapped_base = unmapped_location.ra();
+ Register unmapped_offset = unmapped_location.rb();
+ __ StorePX(value, unmapped_location);
+ __ add(r9, unmapped_base, unmapped_offset);
+ __ mr(r11, value);
+ __ RecordWrite(unmapped_base, r9, r11, kLRHasNotBeenSaved, kDontSaveFPRegs);
+ __ Ret();
+ __ bind(&slow);
+ GenerateMiss(masm);
+}
+
+
+void KeyedLoadIC::GenerateMiss(MacroAssembler* masm) {
+ // The return address is in lr.
+ Isolate* isolate = masm->isolate();
+
+ __ IncrementCounter(isolate->counters()->keyed_load_miss(), 1, r6, r7);
+
+ __ Push(LoadDescriptor::ReceiverRegister(), LoadDescriptor::NameRegister());
+
+ // Perform tail call to the entry.
+ ExternalReference ref =
+ ExternalReference(IC_Utility(kKeyedLoadIC_Miss), isolate);
+
+ __ TailCallExternalReference(ref, 2, 1);
+}
+
+
+void KeyedLoadIC::GenerateRuntimeGetProperty(MacroAssembler* masm) {
+ // The return address is in lr.
+
+ __ Push(LoadDescriptor::ReceiverRegister(), LoadDescriptor::NameRegister());
+
+ __ TailCallRuntime(Runtime::kKeyedGetProperty, 2, 1);
+}
+
+
+void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) {
+ // The return address is in lr.
+ Label slow, check_name, index_smi, index_name, property_array_property;
+ Label probe_dictionary, check_number_dictionary;
+
+ Register key = LoadDescriptor::NameRegister();
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ DCHECK(key.is(r5));
+ DCHECK(receiver.is(r4));
+
+ Isolate* isolate = masm->isolate();
+
+ // Check that the key is a smi.
+ __ JumpIfNotSmi(key, &check_name);
+ __ bind(&index_smi);
+ // Now the key is known to be a smi. This place is also jumped to from below
+ // where a numeric string is converted to a smi.
+
+ GenerateKeyedLoadReceiverCheck(masm, receiver, r3, r6,
+ Map::kHasIndexedInterceptor, &slow);
+
+ // Check the receiver's map to see if it has fast elements.
+ __ CheckFastElements(r3, r6, &check_number_dictionary);
+
+ GenerateFastArrayLoad(masm, receiver, key, r3, r6, r7, r3, NULL, &slow);
+ __ IncrementCounter(isolate->counters()->keyed_load_generic_smi(), 1, r7, r6);
+ __ Ret();
+
+ __ bind(&check_number_dictionary);
+ __ LoadP(r7, FieldMemOperand(receiver, JSObject::kElementsOffset));
+ __ LoadP(r6, FieldMemOperand(r7, JSObject::kMapOffset));
+
+ // Check whether the elements is a number dictionary.
+ // r6: elements map
+ // r7: elements
+ __ LoadRoot(ip, Heap::kHashTableMapRootIndex);
+ __ cmp(r6, ip);
+ __ bne(&slow);
+ __ SmiUntag(r3, key);
+ __ LoadFromNumberDictionary(&slow, r7, key, r3, r3, r6, r8);
+ __ Ret();
+
+ // Slow case, key and receiver still in r3 and r4.
+ __ bind(&slow);
+ __ IncrementCounter(isolate->counters()->keyed_load_generic_slow(), 1, r7,
+ r6);
+ GenerateRuntimeGetProperty(masm);
+
+ __ bind(&check_name);
+ GenerateKeyNameCheck(masm, key, r3, r6, &index_name, &slow);
+
+ GenerateKeyedLoadReceiverCheck(masm, receiver, r3, r6,
+ Map::kHasNamedInterceptor, &slow);
+
+ // If the receiver is a fast-case object, check the keyed lookup
+ // cache. Otherwise probe the dictionary.
+ __ LoadP(r6, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
+ __ LoadP(r7, FieldMemOperand(r6, HeapObject::kMapOffset));
+ __ LoadRoot(ip, Heap::kHashTableMapRootIndex);
+ __ cmp(r7, ip);
+ __ beq(&probe_dictionary);
+
+ // Load the map of the receiver, compute the keyed lookup cache hash
+ // based on 32 bits of the map pointer and the name hash.
+ __ LoadP(r3, FieldMemOperand(receiver, HeapObject::kMapOffset));
+ __ srawi(r6, r3, KeyedLookupCache::kMapHashShift);
+ __ lwz(r7, FieldMemOperand(key, Name::kHashFieldOffset));
+ __ srawi(r7, r7, Name::kHashShift);
+ __ xor_(r6, r6, r7);
+ int mask = KeyedLookupCache::kCapacityMask & KeyedLookupCache::kHashMask;
+ __ mov(r7, Operand(mask));
+ __ and_(r6, r6, r7, LeaveRC);
+
+ // Load the key (consisting of map and unique name) from the cache and
+ // check for match.
+ Label load_in_object_property;
+ static const int kEntriesPerBucket = KeyedLookupCache::kEntriesPerBucket;
+ Label hit_on_nth_entry[kEntriesPerBucket];
+ ExternalReference cache_keys =
+ ExternalReference::keyed_lookup_cache_keys(isolate);
+
+ __ mov(r7, Operand(cache_keys));
+ __ mr(r0, r5);
+ __ ShiftLeftImm(r5, r6, Operand(kPointerSizeLog2 + 1));
+ __ add(r7, r7, r5);
+ __ mr(r5, r0);
+
+ for (int i = 0; i < kEntriesPerBucket - 1; i++) {
+ Label try_next_entry;
+ // Load map and move r7 to next entry.
+ __ LoadP(r8, MemOperand(r7));
+ __ addi(r7, r7, Operand(kPointerSize * 2));
+ __ cmp(r3, r8);
+ __ bne(&try_next_entry);
+ __ LoadP(r8, MemOperand(r7, -kPointerSize)); // Load name
+ __ cmp(key, r8);
+ __ beq(&hit_on_nth_entry[i]);
+ __ bind(&try_next_entry);
+ }
+
+ // Last entry: Load map and move r7 to name.
+ __ LoadP(r8, MemOperand(r7));
+ __ addi(r7, r7, Operand(kPointerSize));
+ __ cmp(r3, r8);
+ __ bne(&slow);
+ __ LoadP(r8, MemOperand(r7));
+ __ cmp(key, r8);
+ __ bne(&slow);
+
+ // Get field offset.
+ // r3 : receiver's map
+ // r6 : lookup cache index
+ ExternalReference cache_field_offsets =
+ ExternalReference::keyed_lookup_cache_field_offsets(isolate);
+
+ // Hit on nth entry.
+ for (int i = kEntriesPerBucket - 1; i >= 0; i--) {
+ __ bind(&hit_on_nth_entry[i]);
+ __ mov(r7, Operand(cache_field_offsets));
+ if (i != 0) {
+ __ addi(r6, r6, Operand(i));
+ }
+ __ ShiftLeftImm(r8, r6, Operand(2));
+ __ lwzx(r8, MemOperand(r8, r7));
+ __ lbz(r9, FieldMemOperand(r3, Map::kInObjectPropertiesOffset));
+ __ sub(r8, r8, r9);
+ __ cmpi(r8, Operand::Zero());
+ __ bge(&property_array_property);
+ if (i != 0) {
+ __ b(&load_in_object_property);
+ }
+ }
+
+ // Load in-object property.
+ __ bind(&load_in_object_property);
+ __ lbz(r9, FieldMemOperand(r3, Map::kInstanceSizeOffset));
+ __ add(r9, r9, r8); // Index from start of object.
+ __ subi(receiver, receiver, Operand(kHeapObjectTag)); // Remove the heap tag.
+ __ ShiftLeftImm(r3, r9, Operand(kPointerSizeLog2));
+ __ LoadPX(r3, MemOperand(r3, receiver));
+ __ IncrementCounter(isolate->counters()->keyed_load_generic_lookup_cache(), 1,
+ r7, r6);
+ __ Ret();
+
+ // Load property array property.
+ __ bind(&property_array_property);
+ __ LoadP(receiver, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
+ __ addi(receiver, receiver,
+ Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ __ ShiftLeftImm(r3, r8, Operand(kPointerSizeLog2));
+ __ LoadPX(r3, MemOperand(r3, receiver));
+ __ IncrementCounter(isolate->counters()->keyed_load_generic_lookup_cache(), 1,
+ r7, r6);
+ __ Ret();
+
+ // Do a quick inline probe of the receiver's dictionary, if it
+ // exists.
+ __ bind(&probe_dictionary);
+ // r6: elements
+ __ LoadP(r3, FieldMemOperand(receiver, HeapObject::kMapOffset));
+ __ lbz(r3, FieldMemOperand(r3, Map::kInstanceTypeOffset));
+ GenerateGlobalInstanceTypeCheck(masm, r3, &slow);
+ // Load the property to r3.
+ GenerateDictionaryLoad(masm, &slow, r6, key, r3, r8, r7);
+ __ IncrementCounter(isolate->counters()->keyed_load_generic_symbol(), 1, r7,
+ r6);
+ __ Ret();
+
+ __ bind(&index_name);
+ __ IndexFromHash(r6, key);
+ // Now jump to the place where smi keys are handled.
+ __ b(&index_smi);
+}
+
+
+void KeyedStoreIC::GenerateMiss(MacroAssembler* masm) {
+ // Push receiver, key and value for runtime call.
+ __ Push(StoreDescriptor::ReceiverRegister(), StoreDescriptor::NameRegister(),
+ StoreDescriptor::ValueRegister());
+
+ ExternalReference ref =
+ ExternalReference(IC_Utility(kKeyedStoreIC_Miss), masm->isolate());
+ __ TailCallExternalReference(ref, 3, 1);
+}
+
+
+static void KeyedStoreGenerateMegamorphicHelper(
+ MacroAssembler* masm, Label* fast_object, Label* fast_double, Label* slow,
+ KeyedStoreCheckMap check_map, KeyedStoreIncrementLength increment_length,
+ Register value, Register key, Register receiver, Register receiver_map,
+ Register elements_map, Register elements) {
+ Label transition_smi_elements;
+ Label finish_object_store, non_double_value, transition_double_elements;
+ Label fast_double_without_map_check;
+
+ // Fast case: Do the store, could be either Object or double.
+ __ bind(fast_object);
+ Register scratch_value = r7;
+ Register address = r8;
+ if (check_map == kCheckMap) {
+ __ LoadP(elements_map, FieldMemOperand(elements, HeapObject::kMapOffset));
+ __ mov(scratch_value,
+ Operand(masm->isolate()->factory()->fixed_array_map()));
+ __ cmp(elements_map, scratch_value);
+ __ bne(fast_double);
+ }
+
+ // HOLECHECK: guards "A[i] = V"
+ // We have to go to the runtime if the current value is the hole because
+ // there may be a callback on the element
+ Label holecheck_passed1;
+ __ addi(address, elements, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ __ SmiToPtrArrayOffset(scratch_value, key);
+ __ LoadPX(scratch_value, MemOperand(address, scratch_value));
+ __ Cmpi(scratch_value, Operand(masm->isolate()->factory()->the_hole_value()),
+ r0);
+ __ bne(&holecheck_passed1);
+ __ JumpIfDictionaryInPrototypeChain(receiver, elements_map, scratch_value,
+ slow);
+
+ __ bind(&holecheck_passed1);
+
+ // Smi stores don't require further checks.
+ Label non_smi_value;
+ __ JumpIfNotSmi(value, &non_smi_value);
+
+ if (increment_length == kIncrementLength) {
+ // Add 1 to receiver->length.
+ __ AddSmiLiteral(scratch_value, key, Smi::FromInt(1), r0);
+ __ StoreP(scratch_value, FieldMemOperand(receiver, JSArray::kLengthOffset),
+ r0);
+ }
+ // It's irrelevant whether array is smi-only or not when writing a smi.
+ __ addi(address, elements, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ __ SmiToPtrArrayOffset(scratch_value, key);
+ __ StorePX(value, MemOperand(address, scratch_value));
+ __ Ret();
+
+ __ bind(&non_smi_value);
+ // Escape to elements kind transition case.
+ __ CheckFastObjectElements(receiver_map, scratch_value,
+ &transition_smi_elements);
+
+ // Fast elements array, store the value to the elements backing store.
+ __ bind(&finish_object_store);
+ if (increment_length == kIncrementLength) {
+ // Add 1 to receiver->length.
+ __ AddSmiLiteral(scratch_value, key, Smi::FromInt(1), r0);
+ __ StoreP(scratch_value, FieldMemOperand(receiver, JSArray::kLengthOffset),
+ r0);
+ }
+ __ addi(address, elements, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ __ SmiToPtrArrayOffset(scratch_value, key);
+ __ StorePUX(value, MemOperand(address, scratch_value));
+ // Update write barrier for the elements array address.
+ __ mr(scratch_value, value); // Preserve the value which is returned.
+ __ RecordWrite(elements, address, scratch_value, kLRHasNotBeenSaved,
+ kDontSaveFPRegs, EMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
+ __ Ret();
+
+ __ bind(fast_double);
+ if (check_map == kCheckMap) {
+ // Check for fast double array case. If this fails, call through to the
+ // runtime.
+ __ CompareRoot(elements_map, Heap::kFixedDoubleArrayMapRootIndex);
+ __ bne(slow);
+ }
+
+ // HOLECHECK: guards "A[i] double hole?"
+ // We have to see if the double version of the hole is present. If so
+ // go to the runtime.
+ __ addi(address, elements,
+ Operand((FixedDoubleArray::kHeaderSize + Register::kExponentOffset -
+ kHeapObjectTag)));
+ __ SmiToDoubleArrayOffset(scratch_value, key);
+ __ lwzx(scratch_value, MemOperand(address, scratch_value));
+ __ Cmpi(scratch_value, Operand(kHoleNanUpper32), r0);
+ __ bne(&fast_double_without_map_check);
+ __ JumpIfDictionaryInPrototypeChain(receiver, elements_map, scratch_value,
+ slow);
+
+ __ bind(&fast_double_without_map_check);
+ __ StoreNumberToDoubleElements(value, key, elements, r6, d0,
+ &transition_double_elements);
+ if (increment_length == kIncrementLength) {
+ // Add 1 to receiver->length.
+ __ AddSmiLiteral(scratch_value, key, Smi::FromInt(1), r0);
+ __ StoreP(scratch_value, FieldMemOperand(receiver, JSArray::kLengthOffset),
+ r0);
+ }
+ __ Ret();
+
+ __ bind(&transition_smi_elements);
+ // Transition the array appropriately depending on the value type.
+ __ LoadP(r7, FieldMemOperand(value, HeapObject::kMapOffset));
+ __ CompareRoot(r7, Heap::kHeapNumberMapRootIndex);
+ __ bne(&non_double_value);
+
+ // Value is a double. Transition FAST_SMI_ELEMENTS ->
+ // FAST_DOUBLE_ELEMENTS and complete the store.
+ __ LoadTransitionedArrayMapConditional(
+ FAST_SMI_ELEMENTS, FAST_DOUBLE_ELEMENTS, receiver_map, r7, slow);
+ AllocationSiteMode mode =
+ AllocationSite::GetMode(FAST_SMI_ELEMENTS, FAST_DOUBLE_ELEMENTS);
+ ElementsTransitionGenerator::GenerateSmiToDouble(masm, receiver, key, value,
+ receiver_map, mode, slow);
+ __ LoadP(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
+ __ b(&fast_double_without_map_check);
+
+ __ bind(&non_double_value);
+ // Value is not a double, FAST_SMI_ELEMENTS -> FAST_ELEMENTS
+ __ LoadTransitionedArrayMapConditional(FAST_SMI_ELEMENTS, FAST_ELEMENTS,
+ receiver_map, r7, slow);
+ mode = AllocationSite::GetMode(FAST_SMI_ELEMENTS, FAST_ELEMENTS);
+ ElementsTransitionGenerator::GenerateMapChangeElementsTransition(
+ masm, receiver, key, value, receiver_map, mode, slow);
+ __ LoadP(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
+ __ b(&finish_object_store);
+
+ __ bind(&transition_double_elements);
+ // Elements are FAST_DOUBLE_ELEMENTS, but value is an Object that's not a
+ // HeapNumber. Make sure that the receiver is a Array with FAST_ELEMENTS and
+ // transition array from FAST_DOUBLE_ELEMENTS to FAST_ELEMENTS
+ __ LoadTransitionedArrayMapConditional(FAST_DOUBLE_ELEMENTS, FAST_ELEMENTS,
+ receiver_map, r7, slow);
+ mode = AllocationSite::GetMode(FAST_DOUBLE_ELEMENTS, FAST_ELEMENTS);
+ ElementsTransitionGenerator::GenerateDoubleToObject(
+ masm, receiver, key, value, receiver_map, mode, slow);
+ __ LoadP(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
+ __ b(&finish_object_store);
+}
+
+
+void KeyedStoreIC::GenerateMegamorphic(MacroAssembler* masm,
+ StrictMode strict_mode) {
+ // ---------- S t a t e --------------
+ // -- r3 : value
+ // -- r4 : key
+ // -- r5 : receiver
+ // -- lr : return address
+ // -----------------------------------
+ Label slow, fast_object, fast_object_grow;
+ Label fast_double, fast_double_grow;
+ Label array, extra, check_if_double_array, maybe_name_key, miss;
+
+ // Register usage.
+ Register value = StoreDescriptor::ValueRegister();
+ Register key = StoreDescriptor::NameRegister();
+ Register receiver = StoreDescriptor::ReceiverRegister();
+ DCHECK(receiver.is(r4));
+ DCHECK(key.is(r5));
+ DCHECK(value.is(r3));
+ Register receiver_map = r6;
+ Register elements_map = r9;
+ Register elements = r10; // Elements array of the receiver.
+ // r7 and r8 are used as general scratch registers.
+
+ // Check that the key is a smi.
+ __ JumpIfNotSmi(key, &maybe_name_key);
+ // Check that the object isn't a smi.
+ __ JumpIfSmi(receiver, &slow);
+ // Get the map of the object.
+ __ LoadP(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset));
+ // Check that the receiver does not require access checks and is not observed.
+ // The generic stub does not perform map checks or handle observed objects.
+ __ lbz(ip, FieldMemOperand(receiver_map, Map::kBitFieldOffset));
+ __ andi(r0, ip,
+ Operand(1 << Map::kIsAccessCheckNeeded | 1 << Map::kIsObserved));
+ __ bne(&slow, cr0);
+ // Check if the object is a JS array or not.
+ __ lbz(r7, FieldMemOperand(receiver_map, Map::kInstanceTypeOffset));
+ __ cmpi(r7, Operand(JS_ARRAY_TYPE));
+ __ beq(&array);
+ // Check that the object is some kind of JSObject.
+ __ cmpi(r7, Operand(FIRST_JS_OBJECT_TYPE));
+ __ blt(&slow);
+
+ // Object case: Check key against length in the elements array.
+ __ LoadP(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
+ // Check array bounds. Both the key and the length of FixedArray are smis.
+ __ LoadP(ip, FieldMemOperand(elements, FixedArray::kLengthOffset));
+ __ cmpl(key, ip);
+ __ blt(&fast_object);
+
+ // Slow case, handle jump to runtime.
+ __ bind(&slow);
+ // Entry registers are intact.
+ // r3: value.
+ // r4: key.
+ // r5: receiver.
+ PropertyICCompiler::GenerateRuntimeSetProperty(masm, strict_mode);
+ // Never returns to here.
+
+ __ bind(&maybe_name_key);
+ __ LoadP(r7, FieldMemOperand(key, HeapObject::kMapOffset));
+ __ lbz(r7, FieldMemOperand(r7, Map::kInstanceTypeOffset));
+ __ JumpIfNotUniqueNameInstanceType(r7, &slow);
+ Code::Flags flags = Code::RemoveTypeAndHolderFromFlags(
+ Code::ComputeHandlerFlags(Code::STORE_IC));
+ masm->isolate()->stub_cache()->GenerateProbe(masm, flags, false, receiver,
+ key, r6, r7, r8, r9);
+ // Cache miss.
+ __ b(&miss);
+
+ // Extra capacity case: Check if there is extra capacity to
+ // perform the store and update the length. Used for adding one
+ // element to the array by writing to array[array.length].
+ __ bind(&extra);
+ // Condition code from comparing key and array length is still available.
+ __ bne(&slow); // Only support writing to writing to array[array.length].
+ // Check for room in the elements backing store.
+ // Both the key and the length of FixedArray are smis.
+ __ LoadP(ip, FieldMemOperand(elements, FixedArray::kLengthOffset));
+ __ cmpl(key, ip);
+ __ bge(&slow);
+ __ LoadP(elements_map, FieldMemOperand(elements, HeapObject::kMapOffset));
+ __ mov(ip, Operand(masm->isolate()->factory()->fixed_array_map()));
+ __ cmp(elements_map, ip); // PPC - I think I can re-use ip here
+ __ bne(&check_if_double_array);
+ __ b(&fast_object_grow);
+
+ __ bind(&check_if_double_array);
+ __ mov(ip, Operand(masm->isolate()->factory()->fixed_double_array_map()));
+ __ cmp(elements_map, ip); // PPC - another ip re-use
+ __ bne(&slow);
+ __ b(&fast_double_grow);
+
+ // Array case: Get the length and the elements array from the JS
+ // array. Check that the array is in fast mode (and writable); if it
+ // is the length is always a smi.
+ __ bind(&array);
+ __ LoadP(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
+
+ // Check the key against the length in the array.
+ __ LoadP(ip, FieldMemOperand(receiver, JSArray::kLengthOffset));
+ __ cmpl(key, ip);
+ __ bge(&extra);
+
+ KeyedStoreGenerateMegamorphicHelper(
+ masm, &fast_object, &fast_double, &slow, kCheckMap, kDontIncrementLength,
+ value, key, receiver, receiver_map, elements_map, elements);
+ KeyedStoreGenerateMegamorphicHelper(masm, &fast_object_grow,
+ &fast_double_grow, &slow, kDontCheckMap,
+ kIncrementLength, value, key, receiver,
+ receiver_map, elements_map, elements);
+ __ bind(&miss);
+ GenerateMiss(masm);
+}
+
+
+void StoreIC::GenerateMegamorphic(MacroAssembler* masm) {
+ Register receiver = StoreDescriptor::ReceiverRegister();
+ Register name = StoreDescriptor::NameRegister();
+ DCHECK(receiver.is(r4));
+ DCHECK(name.is(r5));
+ DCHECK(StoreDescriptor::ValueRegister().is(r3));
+
+ // Get the receiver from the stack and probe the stub cache.
+ Code::Flags flags = Code::RemoveTypeAndHolderFromFlags(
+ Code::ComputeHandlerFlags(Code::STORE_IC));
+
+ masm->isolate()->stub_cache()->GenerateProbe(masm, flags, false, receiver,
+ name, r6, r7, r8, r9);
+
+ // Cache miss: Jump to runtime.
+ GenerateMiss(masm);
+}
+
+
+void StoreIC::GenerateMiss(MacroAssembler* masm) {
+ __ Push(StoreDescriptor::ReceiverRegister(), StoreDescriptor::NameRegister(),
+ StoreDescriptor::ValueRegister());
+
+ // Perform tail call to the entry.
+ ExternalReference ref =
+ ExternalReference(IC_Utility(kStoreIC_Miss), masm->isolate());
+ __ TailCallExternalReference(ref, 3, 1);
+}
+
+
+void StoreIC::GenerateNormal(MacroAssembler* masm) {
+ Label miss;
+ Register receiver = StoreDescriptor::ReceiverRegister();
+ Register name = StoreDescriptor::NameRegister();
+ Register value = StoreDescriptor::ValueRegister();
+ Register dictionary = r6;
+ DCHECK(receiver.is(r4));
+ DCHECK(name.is(r5));
+ DCHECK(value.is(r3));
+
+ __ LoadP(dictionary, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
+
+ GenerateDictionaryStore(masm, &miss, dictionary, name, value, r7, r8);
+ Counters* counters = masm->isolate()->counters();
+ __ IncrementCounter(counters->store_normal_hit(), 1, r7, r8);
+ __ Ret();
+
+ __ bind(&miss);
+ __ IncrementCounter(counters->store_normal_miss(), 1, r7, r8);
+ GenerateMiss(masm);
+}
+
+
+#undef __
+
+
+Condition CompareIC::ComputeCondition(Token::Value op) {
+ switch (op) {
+ case Token::EQ_STRICT:
+ case Token::EQ:
+ return eq;
+ case Token::LT:
+ return lt;
+ case Token::GT:
+ return gt;
+ case Token::LTE:
+ return le;
+ case Token::GTE:
+ return ge;
+ default:
+ UNREACHABLE();
+ return kNoCondition;
+ }
+}
+
+
+bool CompareIC::HasInlinedSmiCode(Address address) {
+ // The address of the instruction following the call.
+ Address cmp_instruction_address =
+ Assembler::return_address_from_call_start(address);
+
+ // If the instruction following the call is not a cmp rx, #yyy, nothing
+ // was inlined.
+ Instr instr = Assembler::instr_at(cmp_instruction_address);
+ return Assembler::IsCmpImmediate(instr);
+}
+
+
+//
+// This code is paired with the JumpPatchSite class in full-codegen-ppc.cc
+//
+void PatchInlinedSmiCode(Address address, InlinedSmiCheck check) {
+ Address cmp_instruction_address =
+ Assembler::return_address_from_call_start(address);
+
+ // If the instruction following the call is not a cmp rx, #yyy, nothing
+ // was inlined.
+ Instr instr = Assembler::instr_at(cmp_instruction_address);
+ if (!Assembler::IsCmpImmediate(instr)) {
+ return;
+ }
+
+ // The delta to the start of the map check instruction and the
+ // condition code uses at the patched jump.
+ int delta = Assembler::GetCmpImmediateRawImmediate(instr);
+ delta += Assembler::GetCmpImmediateRegister(instr).code() * kOff16Mask;
+ // If the delta is 0 the instruction is cmp r0, #0 which also signals that
+ // nothing was inlined.
+ if (delta == 0) {
+ return;
+ }
+
+ if (FLAG_trace_ic) {
+ PrintF("[ patching ic at %p, cmp=%p, delta=%d\n", address,
+ cmp_instruction_address, delta);
+ }
+
+ Address patch_address =
+ cmp_instruction_address - delta * Instruction::kInstrSize;
+ Instr instr_at_patch = Assembler::instr_at(patch_address);
+ Instr branch_instr =
+ Assembler::instr_at(patch_address + Instruction::kInstrSize);
+ // This is patching a conditional "jump if not smi/jump if smi" site.
+ // Enabling by changing from
+ // cmp cr0, rx, rx
+ // to
+ // rlwinm(r0, value, 0, 31, 31, SetRC);
+ // bc(label, BT/BF, 2)
+ // and vice-versa to be disabled again.
+ CodePatcher patcher(patch_address, 2);
+ Register reg = Assembler::GetRA(instr_at_patch);
+ if (check == ENABLE_INLINED_SMI_CHECK) {
+ DCHECK(Assembler::IsCmpRegister(instr_at_patch));
+ DCHECK_EQ(Assembler::GetRA(instr_at_patch).code(),
+ Assembler::GetRB(instr_at_patch).code());
+ patcher.masm()->TestIfSmi(reg, r0);
+ } else {
+ DCHECK(check == DISABLE_INLINED_SMI_CHECK);
+#if V8_TARGET_ARCH_PPC64
+ DCHECK(Assembler::IsRldicl(instr_at_patch));
+#else
+ DCHECK(Assembler::IsRlwinm(instr_at_patch));
+#endif
+ patcher.masm()->cmp(reg, reg, cr0);
+ }
+ DCHECK(Assembler::IsBranch(branch_instr));
+
+ // Invert the logic of the branch
+ if (Assembler::GetCondition(branch_instr) == eq) {
+ patcher.EmitCondition(ne);
+ } else {
+ DCHECK(Assembler::GetCondition(branch_instr) == ne);
+ patcher.EmitCondition(eq);
+ }
+}
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/codegen.h"
+#include "src/ic/stub-cache.h"
+
+namespace v8 {
+namespace internal {
+
+#define __ ACCESS_MASM(masm)
+
+
+static void ProbeTable(Isolate* isolate, MacroAssembler* masm,
+ Code::Flags flags, bool leave_frame,
+ StubCache::Table table, Register receiver, Register name,
+ // Number of the cache entry, not scaled.
+ Register offset, Register scratch, Register scratch2,
+ Register offset_scratch) {
+ ExternalReference key_offset(isolate->stub_cache()->key_reference(table));
+ ExternalReference value_offset(isolate->stub_cache()->value_reference(table));
+ ExternalReference map_offset(isolate->stub_cache()->map_reference(table));
+
+ uintptr_t key_off_addr = reinterpret_cast<uintptr_t>(key_offset.address());
+ uintptr_t value_off_addr =
+ reinterpret_cast<uintptr_t>(value_offset.address());
+ uintptr_t map_off_addr = reinterpret_cast<uintptr_t>(map_offset.address());
+
+ // Check the relative positions of the address fields.
+ DCHECK(value_off_addr > key_off_addr);
+ DCHECK((value_off_addr - key_off_addr) % 4 == 0);
+ DCHECK((value_off_addr - key_off_addr) < (256 * 4));
+ DCHECK(map_off_addr > key_off_addr);
+ DCHECK((map_off_addr - key_off_addr) % 4 == 0);
+ DCHECK((map_off_addr - key_off_addr) < (256 * 4));
+
+ Label miss;
+ Register base_addr = scratch;
+ scratch = no_reg;
+
+ // Multiply by 3 because there are 3 fields per entry (name, code, map).
+ __ ShiftLeftImm(offset_scratch, offset, Operand(1));
+ __ add(offset_scratch, offset, offset_scratch);
+
+ // Calculate the base address of the entry.
+ __ mov(base_addr, Operand(key_offset));
+ __ ShiftLeftImm(scratch2, offset_scratch, Operand(kPointerSizeLog2));
+ __ add(base_addr, base_addr, scratch2);
+
+ // Check that the key in the entry matches the name.
+ __ LoadP(ip, MemOperand(base_addr, 0));
+ __ cmp(name, ip);
+ __ bne(&miss);
+
+ // Check the map matches.
+ __ LoadP(ip, MemOperand(base_addr, map_off_addr - key_off_addr));
+ __ LoadP(scratch2, FieldMemOperand(receiver, HeapObject::kMapOffset));
+ __ cmp(ip, scratch2);
+ __ bne(&miss);
+
+ // Get the code entry from the cache.
+ Register code = scratch2;
+ scratch2 = no_reg;
+ __ LoadP(code, MemOperand(base_addr, value_off_addr - key_off_addr));
+
+ // Check that the flags match what we're looking for.
+ Register flags_reg = base_addr;
+ base_addr = no_reg;
+ __ lwz(flags_reg, FieldMemOperand(code, Code::kFlagsOffset));
+
+ DCHECK(!r0.is(flags_reg));
+ __ li(r0, Operand(Code::kFlagsNotUsedInLookup));
+ __ andc(flags_reg, flags_reg, r0);
+ __ mov(r0, Operand(flags));
+ __ cmpl(flags_reg, r0);
+ __ bne(&miss);
+
+#ifdef DEBUG
+ if (FLAG_test_secondary_stub_cache && table == StubCache::kPrimary) {
+ __ b(&miss);
+ } else if (FLAG_test_primary_stub_cache && table == StubCache::kSecondary) {
+ __ b(&miss);
+ }
+#endif
+
+ if (leave_frame) __ LeaveFrame(StackFrame::INTERNAL);
+
+ // Jump to the first instruction in the code stub.
+ __ addi(r0, code, Operand(Code::kHeaderSize - kHeapObjectTag));
+ __ mtctr(r0);
+ __ bctr();
+
+ // Miss: fall through.
+ __ bind(&miss);
+}
+
+
+void StubCache::GenerateProbe(MacroAssembler* masm, Code::Flags flags,
+ bool leave_frame, Register receiver,
+ Register name, Register scratch, Register extra,
+ Register extra2, Register extra3) {
+ Isolate* isolate = masm->isolate();
+ Label miss;
+
+#if V8_TARGET_ARCH_PPC64
+ // Make sure that code is valid. The multiplying code relies on the
+ // entry size being 24.
+ DCHECK(sizeof(Entry) == 24);
+#else
+ // Make sure that code is valid. The multiplying code relies on the
+ // entry size being 12.
+ DCHECK(sizeof(Entry) == 12);
+#endif
+
+ // Make sure the flags does not name a specific type.
+ DCHECK(Code::ExtractTypeFromFlags(flags) == 0);
+
+ // Make sure that there are no register conflicts.
+ DCHECK(!scratch.is(receiver));
+ DCHECK(!scratch.is(name));
+ DCHECK(!extra.is(receiver));
+ DCHECK(!extra.is(name));
+ DCHECK(!extra.is(scratch));
+ DCHECK(!extra2.is(receiver));
+ DCHECK(!extra2.is(name));
+ DCHECK(!extra2.is(scratch));
+ DCHECK(!extra2.is(extra));
+
+ // Check scratch, extra and extra2 registers are valid.
+ DCHECK(!scratch.is(no_reg));
+ DCHECK(!extra.is(no_reg));
+ DCHECK(!extra2.is(no_reg));
+ DCHECK(!extra3.is(no_reg));
+
+ Counters* counters = masm->isolate()->counters();
+ __ IncrementCounter(counters->megamorphic_stub_cache_probes(), 1, extra2,
+ extra3);
+
+ // Check that the receiver isn't a smi.
+ __ JumpIfSmi(receiver, &miss);
+
+ // Get the map of the receiver and compute the hash.
+ __ lwz(scratch, FieldMemOperand(name, Name::kHashFieldOffset));
+ __ LoadP(ip, FieldMemOperand(receiver, HeapObject::kMapOffset));
+ __ add(scratch, scratch, ip);
+#if V8_TARGET_ARCH_PPC64
+ // Use only the low 32 bits of the map pointer.
+ __ rldicl(scratch, scratch, 0, 32);
+#endif
+ uint32_t mask = kPrimaryTableSize - 1;
+ // We shift out the last two bits because they are not part of the hash and
+ // they are always 01 for maps.
+ __ ShiftRightImm(scratch, scratch, Operand(kCacheIndexShift));
+ // Mask down the eor argument to the minimum to keep the immediate
+ // encodable.
+ __ xori(scratch, scratch, Operand((flags >> kCacheIndexShift) & mask));
+ // Prefer and_ to ubfx here because ubfx takes 2 cycles.
+ __ andi(scratch, scratch, Operand(mask));
+
+ // Probe the primary table.
+ ProbeTable(isolate, masm, flags, leave_frame, kPrimary, receiver, name,
+ scratch, extra, extra2, extra3);
+
+ // Primary miss: Compute hash for secondary probe.
+ __ ShiftRightImm(extra, name, Operand(kCacheIndexShift));
+ __ sub(scratch, scratch, extra);
+ uint32_t mask2 = kSecondaryTableSize - 1;
+ __ addi(scratch, scratch, Operand((flags >> kCacheIndexShift) & mask2));
+ __ andi(scratch, scratch, Operand(mask2));
+
+ // Probe the secondary table.
+ ProbeTable(isolate, masm, flags, leave_frame, kSecondary, receiver, name,
+ scratch, extra, extra2, extra3);
+
+ // Cache miss: Fall-through and let caller handle the miss by
+ // entering the runtime system.
+ __ bind(&miss);
+ __ IncrementCounter(counters->megamorphic_stub_cache_misses(), 1, extra2,
+ extra3);
+}
+
+
+#undef __
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright (c) 1994-2006 Sun Microsystems Inc.
+// All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// - Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// - Redistribution in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the
+// distribution.
+//
+// - Neither the name of Sun Microsystems or the names of contributors may
+// be used to endorse or promote products derived from this software without
+// specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The original source code covered by the above license above has been modified
+// significantly by Google Inc.
+// Copyright 2014 the V8 project authors. All rights reserved.
+
+#ifndef V8_PPC_ASSEMBLER_PPC_INL_H_
+#define V8_PPC_ASSEMBLER_PPC_INL_H_
+
+#include "src/ppc/assembler-ppc.h"
+
+#include "src/assembler.h"
+#include "src/debug.h"
+
+
+namespace v8 {
+namespace internal {
+
+
+bool CpuFeatures::SupportsCrankshaft() { return true; }
+
+
+void RelocInfo::apply(intptr_t delta, ICacheFlushMode icache_flush_mode) {
+#if ABI_USES_FUNCTION_DESCRIPTORS || V8_OOL_CONSTANT_POOL
+ if (RelocInfo::IsInternalReference(rmode_)) {
+ // absolute code pointer inside code object moves with the code object.
+ Assembler::RelocateInternalReference(pc_, delta, 0, icache_flush_mode);
+ }
+#endif
+ // We do not use pc relative addressing on PPC, so there is
+ // nothing else to do.
+}
+
+
+Address RelocInfo::target_address() {
+ DCHECK(IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_));
+ return Assembler::target_address_at(pc_, host_);
+}
+
+
+Address RelocInfo::target_address_address() {
+ DCHECK(IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_) ||
+ rmode_ == EMBEDDED_OBJECT || rmode_ == EXTERNAL_REFERENCE);
+
+#if V8_OOL_CONSTANT_POOL
+ if (Assembler::IsConstantPoolLoadStart(pc_)) {
+ // We return the PC for ool constant pool since this function is used by the
+ // serializerer and expects the address to reside within the code object.
+ return reinterpret_cast<Address>(pc_);
+ }
+#endif
+
+ // Read the address of the word containing the target_address in an
+ // instruction stream.
+ // The only architecture-independent user of this function is the serializer.
+ // The serializer uses it to find out how many raw bytes of instruction to
+ // output before the next target.
+ // For an instruction like LIS/ORI where the target bits are mixed into the
+ // instruction bits, the size of the target will be zero, indicating that the
+ // serializer should not step forward in memory after a target is resolved
+ // and written.
+ return reinterpret_cast<Address>(pc_);
+}
+
+
+Address RelocInfo::constant_pool_entry_address() {
+#if V8_OOL_CONSTANT_POOL
+ return Assembler::target_constant_pool_address_at(pc_,
+ host_->constant_pool());
+#else
+ UNREACHABLE();
+ return NULL;
+#endif
+}
+
+
+int RelocInfo::target_address_size() { return Assembler::kSpecialTargetSize; }
+
+
+void RelocInfo::set_target_address(Address target,
+ WriteBarrierMode write_barrier_mode,
+ ICacheFlushMode icache_flush_mode) {
+ DCHECK(IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_));
+ Assembler::set_target_address_at(pc_, host_, target, icache_flush_mode);
+ if (write_barrier_mode == UPDATE_WRITE_BARRIER && host() != NULL &&
+ IsCodeTarget(rmode_)) {
+ Object* target_code = Code::GetCodeFromTargetAddress(target);
+ host()->GetHeap()->incremental_marking()->RecordWriteIntoCode(
+ host(), this, HeapObject::cast(target_code));
+ }
+}
+
+
+Address Assembler::break_address_from_return_address(Address pc) {
+ return target_address_from_return_address(pc);
+}
+
+
+Address Assembler::target_address_from_return_address(Address pc) {
+// Returns the address of the call target from the return address that will
+// be returned to after a call.
+// Call sequence is :
+// mov ip, @ call address
+// mtlr ip
+// blrl
+// @ return address
+#if V8_OOL_CONSTANT_POOL
+ if (IsConstantPoolLoadEnd(pc - 3 * kInstrSize)) {
+ return pc - (kMovInstructionsConstantPool + 2) * kInstrSize;
+ }
+#endif
+ return pc - (kMovInstructionsNoConstantPool + 2) * kInstrSize;
+}
+
+
+Address Assembler::return_address_from_call_start(Address pc) {
+#if V8_OOL_CONSTANT_POOL
+ Address load_address = pc + (kMovInstructionsConstantPool - 1) * kInstrSize;
+ if (IsConstantPoolLoadEnd(load_address))
+ return pc + (kMovInstructionsConstantPool + 2) * kInstrSize;
+#endif
+ return pc + (kMovInstructionsNoConstantPool + 2) * kInstrSize;
+}
+
+
+Object* RelocInfo::target_object() {
+ DCHECK(IsCodeTarget(rmode_) || rmode_ == EMBEDDED_OBJECT);
+ return reinterpret_cast<Object*>(Assembler::target_address_at(pc_, host_));
+}
+
+
+Handle<Object> RelocInfo::target_object_handle(Assembler* origin) {
+ DCHECK(IsCodeTarget(rmode_) || rmode_ == EMBEDDED_OBJECT);
+ return Handle<Object>(
+ reinterpret_cast<Object**>(Assembler::target_address_at(pc_, host_)));
+}
+
+
+void RelocInfo::set_target_object(Object* target,
+ WriteBarrierMode write_barrier_mode,
+ ICacheFlushMode icache_flush_mode) {
+ DCHECK(IsCodeTarget(rmode_) || rmode_ == EMBEDDED_OBJECT);
+ Assembler::set_target_address_at(
+ pc_, host_, reinterpret_cast<Address>(target), icache_flush_mode);
+ if (write_barrier_mode == UPDATE_WRITE_BARRIER && host() != NULL &&
+ target->IsHeapObject()) {
+ host()->GetHeap()->incremental_marking()->RecordWrite(
+ host(), &Memory::Object_at(pc_), HeapObject::cast(target));
+ }
+}
+
+
+Address RelocInfo::target_reference() {
+ DCHECK(rmode_ == EXTERNAL_REFERENCE);
+ return Assembler::target_address_at(pc_, host_);
+}
+
+
+Address RelocInfo::target_runtime_entry(Assembler* origin) {
+ DCHECK(IsRuntimeEntry(rmode_));
+ return target_address();
+}
+
+
+void RelocInfo::set_target_runtime_entry(Address target,
+ WriteBarrierMode write_barrier_mode,
+ ICacheFlushMode icache_flush_mode) {
+ DCHECK(IsRuntimeEntry(rmode_));
+ if (target_address() != target)
+ set_target_address(target, write_barrier_mode, icache_flush_mode);
+}
+
+
+Handle<Cell> RelocInfo::target_cell_handle() {
+ DCHECK(rmode_ == RelocInfo::CELL);
+ Address address = Memory::Address_at(pc_);
+ return Handle<Cell>(reinterpret_cast<Cell**>(address));
+}
+
+
+Cell* RelocInfo::target_cell() {
+ DCHECK(rmode_ == RelocInfo::CELL);
+ return Cell::FromValueAddress(Memory::Address_at(pc_));
+}
+
+
+void RelocInfo::set_target_cell(Cell* cell, WriteBarrierMode write_barrier_mode,
+ ICacheFlushMode icache_flush_mode) {
+ DCHECK(rmode_ == RelocInfo::CELL);
+ Address address = cell->address() + Cell::kValueOffset;
+ Memory::Address_at(pc_) = address;
+ if (write_barrier_mode == UPDATE_WRITE_BARRIER && host() != NULL) {
+ // TODO(1550) We are passing NULL as a slot because cell can never be on
+ // evacuation candidate.
+ host()->GetHeap()->incremental_marking()->RecordWrite(host(), NULL, cell);
+ }
+}
+
+
+#if V8_OOL_CONSTANT_POOL
+static const int kNoCodeAgeInstructions = 7;
+#else
+static const int kNoCodeAgeInstructions = 6;
+#endif
+static const int kCodeAgingInstructions =
+ Assembler::kMovInstructionsNoConstantPool + 3;
+static const int kNoCodeAgeSequenceInstructions =
+ ((kNoCodeAgeInstructions >= kCodeAgingInstructions)
+ ? kNoCodeAgeInstructions
+ : kCodeAgingInstructions);
+static const int kNoCodeAgeSequenceNops =
+ (kNoCodeAgeSequenceInstructions - kNoCodeAgeInstructions);
+static const int kCodeAgingSequenceNops =
+ (kNoCodeAgeSequenceInstructions - kCodeAgingInstructions);
+static const int kCodeAgingTargetDelta = 1 * Assembler::kInstrSize;
+static const int kNoCodeAgeSequenceLength =
+ (kNoCodeAgeSequenceInstructions * Assembler::kInstrSize);
+
+
+Handle<Object> RelocInfo::code_age_stub_handle(Assembler* origin) {
+ UNREACHABLE(); // This should never be reached on PPC.
+ return Handle<Object>();
+}
+
+
+Code* RelocInfo::code_age_stub() {
+ DCHECK(rmode_ == RelocInfo::CODE_AGE_SEQUENCE);
+ return Code::GetCodeFromTargetAddress(
+ Assembler::target_address_at(pc_ + kCodeAgingTargetDelta, host_));
+}
+
+
+void RelocInfo::set_code_age_stub(Code* stub,
+ ICacheFlushMode icache_flush_mode) {
+ DCHECK(rmode_ == RelocInfo::CODE_AGE_SEQUENCE);
+ Assembler::set_target_address_at(pc_ + kCodeAgingTargetDelta, host_,
+ stub->instruction_start(),
+ icache_flush_mode);
+}
+
+
+Address RelocInfo::call_address() {
+ DCHECK((IsJSReturn(rmode()) && IsPatchedReturnSequence()) ||
+ (IsDebugBreakSlot(rmode()) && IsPatchedDebugBreakSlotSequence()));
+ // The pc_ offset of 0 assumes patched return sequence per
+ // BreakLocationIterator::SetDebugBreakAtReturn(), or debug break
+ // slot per BreakLocationIterator::SetDebugBreakAtSlot().
+ return Assembler::target_address_at(pc_, host_);
+}
+
+
+void RelocInfo::set_call_address(Address target) {
+ DCHECK((IsJSReturn(rmode()) && IsPatchedReturnSequence()) ||
+ (IsDebugBreakSlot(rmode()) && IsPatchedDebugBreakSlotSequence()));
+ Assembler::set_target_address_at(pc_, host_, target);
+ if (host() != NULL) {
+ Object* target_code = Code::GetCodeFromTargetAddress(target);
+ host()->GetHeap()->incremental_marking()->RecordWriteIntoCode(
+ host(), this, HeapObject::cast(target_code));
+ }
+}
+
+
+Object* RelocInfo::call_object() { return *call_object_address(); }
+
+
+void RelocInfo::set_call_object(Object* target) {
+ *call_object_address() = target;
+}
+
+
+Object** RelocInfo::call_object_address() {
+ DCHECK((IsJSReturn(rmode()) && IsPatchedReturnSequence()) ||
+ (IsDebugBreakSlot(rmode()) && IsPatchedDebugBreakSlotSequence()));
+ return reinterpret_cast<Object**>(pc_ + 2 * Assembler::kInstrSize);
+}
+
+
+void RelocInfo::WipeOut() {
+ DCHECK(IsEmbeddedObject(rmode_) || IsCodeTarget(rmode_) ||
+ IsRuntimeEntry(rmode_) || IsExternalReference(rmode_));
+ Assembler::set_target_address_at(pc_, host_, NULL);
+}
+
+
+bool RelocInfo::IsPatchedReturnSequence() {
+ //
+ // The patched return sequence is defined by
+ // BreakLocationIterator::SetDebugBreakAtReturn()
+ // FIXED_SEQUENCE
+
+ Instr instr0 = Assembler::instr_at(pc_);
+ Instr instr1 = Assembler::instr_at(pc_ + 1 * Assembler::kInstrSize);
+#if V8_TARGET_ARCH_PPC64
+ Instr instr3 = Assembler::instr_at(pc_ + (3 * Assembler::kInstrSize));
+ Instr instr4 = Assembler::instr_at(pc_ + (4 * Assembler::kInstrSize));
+ Instr binstr = Assembler::instr_at(pc_ + (7 * Assembler::kInstrSize));
+#else
+ Instr binstr = Assembler::instr_at(pc_ + 4 * Assembler::kInstrSize);
+#endif
+ bool patched_return =
+ ((instr0 & kOpcodeMask) == ADDIS && (instr1 & kOpcodeMask) == ORI &&
+#if V8_TARGET_ARCH_PPC64
+ (instr3 & kOpcodeMask) == ORIS && (instr4 & kOpcodeMask) == ORI &&
+#endif
+ (binstr == 0x7d821008)); // twge r2, r2
+
+ // printf("IsPatchedReturnSequence: %d\n", patched_return);
+ return patched_return;
+}
+
+
+bool RelocInfo::IsPatchedDebugBreakSlotSequence() {
+ Instr current_instr = Assembler::instr_at(pc_);
+ return !Assembler::IsNop(current_instr, Assembler::DEBUG_BREAK_NOP);
+}
+
+
+void RelocInfo::Visit(Isolate* isolate, ObjectVisitor* visitor) {
+ RelocInfo::Mode mode = rmode();
+ if (mode == RelocInfo::EMBEDDED_OBJECT) {
+ visitor->VisitEmbeddedPointer(this);
+ } else if (RelocInfo::IsCodeTarget(mode)) {
+ visitor->VisitCodeTarget(this);
+ } else if (mode == RelocInfo::CELL) {
+ visitor->VisitCell(this);
+ } else if (mode == RelocInfo::EXTERNAL_REFERENCE) {
+ visitor->VisitExternalReference(this);
+ } else if (RelocInfo::IsCodeAgeSequence(mode)) {
+ visitor->VisitCodeAgeSequence(this);
+ } else if (((RelocInfo::IsJSReturn(mode) && IsPatchedReturnSequence()) ||
+ (RelocInfo::IsDebugBreakSlot(mode) &&
+ IsPatchedDebugBreakSlotSequence())) &&
+ isolate->debug()->has_break_points()) {
+ visitor->VisitDebugTarget(this);
+ } else if (IsRuntimeEntry(mode)) {
+ visitor->VisitRuntimeEntry(this);
+ }
+}
+
+
+template <typename StaticVisitor>
+void RelocInfo::Visit(Heap* heap) {
+ RelocInfo::Mode mode = rmode();
+ if (mode == RelocInfo::EMBEDDED_OBJECT) {
+ StaticVisitor::VisitEmbeddedPointer(heap, this);
+ } else if (RelocInfo::IsCodeTarget(mode)) {
+ StaticVisitor::VisitCodeTarget(heap, this);
+ } else if (mode == RelocInfo::CELL) {
+ StaticVisitor::VisitCell(heap, this);
+ } else if (mode == RelocInfo::EXTERNAL_REFERENCE) {
+ StaticVisitor::VisitExternalReference(this);
+ } else if (RelocInfo::IsCodeAgeSequence(mode)) {
+ StaticVisitor::VisitCodeAgeSequence(heap, this);
+ } else if (heap->isolate()->debug()->has_break_points() &&
+ ((RelocInfo::IsJSReturn(mode) && IsPatchedReturnSequence()) ||
+ (RelocInfo::IsDebugBreakSlot(mode) &&
+ IsPatchedDebugBreakSlotSequence()))) {
+ StaticVisitor::VisitDebugTarget(heap, this);
+ } else if (IsRuntimeEntry(mode)) {
+ StaticVisitor::VisitRuntimeEntry(this);
+ }
+}
+
+Operand::Operand(intptr_t immediate, RelocInfo::Mode rmode) {
+ rm_ = no_reg;
+ imm_ = immediate;
+ rmode_ = rmode;
+}
+
+Operand::Operand(const ExternalReference& f) {
+ rm_ = no_reg;
+ imm_ = reinterpret_cast<intptr_t>(f.address());
+ rmode_ = RelocInfo::EXTERNAL_REFERENCE;
+}
+
+Operand::Operand(Smi* value) {
+ rm_ = no_reg;
+ imm_ = reinterpret_cast<intptr_t>(value);
+ rmode_ = kRelocInfo_NONEPTR;
+}
+
+Operand::Operand(Register rm) {
+ rm_ = rm;
+ rmode_ = kRelocInfo_NONEPTR; // PPC -why doesn't ARM do this?
+}
+
+void Assembler::CheckBuffer() {
+ if (buffer_space() <= kGap) {
+ GrowBuffer();
+ }
+}
+
+void Assembler::CheckTrampolinePoolQuick() {
+ if (pc_offset() >= next_buffer_check_) {
+ CheckTrampolinePool();
+ }
+}
+
+void Assembler::emit(Instr x) {
+ CheckBuffer();
+ *reinterpret_cast<Instr*>(pc_) = x;
+ pc_ += kInstrSize;
+ CheckTrampolinePoolQuick();
+}
+
+bool Operand::is_reg() const { return rm_.is_valid(); }
+
+
+// Fetch the 32bit value from the FIXED_SEQUENCE lis/ori
+Address Assembler::target_address_at(Address pc,
+ ConstantPoolArray* constant_pool) {
+ Instr instr1 = instr_at(pc);
+ Instr instr2 = instr_at(pc + kInstrSize);
+ // Interpret 2 instructions generated by lis/ori
+ if (IsLis(instr1) && IsOri(instr2)) {
+#if V8_TARGET_ARCH_PPC64
+ Instr instr4 = instr_at(pc + (3 * kInstrSize));
+ Instr instr5 = instr_at(pc + (4 * kInstrSize));
+ // Assemble the 64 bit value.
+ uint64_t hi = (static_cast<uint32_t>((instr1 & kImm16Mask) << 16) |
+ static_cast<uint32_t>(instr2 & kImm16Mask));
+ uint64_t lo = (static_cast<uint32_t>((instr4 & kImm16Mask) << 16) |
+ static_cast<uint32_t>(instr5 & kImm16Mask));
+ return reinterpret_cast<Address>((hi << 32) | lo);
+#else
+ // Assemble the 32 bit value.
+ return reinterpret_cast<Address>(((instr1 & kImm16Mask) << 16) |
+ (instr2 & kImm16Mask));
+#endif
+ }
+#if V8_OOL_CONSTANT_POOL
+ return Memory::Address_at(target_constant_pool_address_at(pc, constant_pool));
+#else
+ DCHECK(false);
+ return (Address)0;
+#endif
+}
+
+
+#if V8_OOL_CONSTANT_POOL
+bool Assembler::IsConstantPoolLoadStart(Address pc) {
+#if V8_TARGET_ARCH_PPC64
+ if (!IsLi(instr_at(pc))) return false;
+ pc += kInstrSize;
+#endif
+ return GetRA(instr_at(pc)).is(kConstantPoolRegister);
+}
+
+
+bool Assembler::IsConstantPoolLoadEnd(Address pc) {
+#if V8_TARGET_ARCH_PPC64
+ pc -= kInstrSize;
+#endif
+ return IsConstantPoolLoadStart(pc);
+}
+
+
+int Assembler::GetConstantPoolOffset(Address pc) {
+ DCHECK(IsConstantPoolLoadStart(pc));
+ Instr instr = instr_at(pc);
+ int offset = SIGN_EXT_IMM16((instr & kImm16Mask));
+ return offset;
+}
+
+
+void Assembler::SetConstantPoolOffset(Address pc, int offset) {
+ DCHECK(IsConstantPoolLoadStart(pc));
+ DCHECK(is_int16(offset));
+ Instr instr = instr_at(pc);
+ instr &= ~kImm16Mask;
+ instr |= (offset & kImm16Mask);
+ instr_at_put(pc, instr);
+}
+
+
+Address Assembler::target_constant_pool_address_at(
+ Address pc, ConstantPoolArray* constant_pool) {
+ Address addr = reinterpret_cast<Address>(constant_pool);
+ DCHECK(addr);
+ addr += GetConstantPoolOffset(pc);
+ return addr;
+}
+#endif
+
+
+// This sets the branch destination (which gets loaded at the call address).
+// This is for calls and branches within generated code. The serializer
+// has already deserialized the mov instructions etc.
+// There is a FIXED_SEQUENCE assumption here
+void Assembler::deserialization_set_special_target_at(
+ Address instruction_payload, Code* code, Address target) {
+ set_target_address_at(instruction_payload, code, target);
+}
+
+// This code assumes the FIXED_SEQUENCE of lis/ori
+void Assembler::set_target_address_at(Address pc,
+ ConstantPoolArray* constant_pool,
+ Address target,
+ ICacheFlushMode icache_flush_mode) {
+ Instr instr1 = instr_at(pc);
+ Instr instr2 = instr_at(pc + kInstrSize);
+ // Interpret 2 instructions generated by lis/ori
+ if (IsLis(instr1) && IsOri(instr2)) {
+#if V8_TARGET_ARCH_PPC64
+ Instr instr4 = instr_at(pc + (3 * kInstrSize));
+ Instr instr5 = instr_at(pc + (4 * kInstrSize));
+ // Needs to be fixed up when mov changes to handle 64-bit values.
+ uint32_t* p = reinterpret_cast<uint32_t*>(pc);
+ uintptr_t itarget = reinterpret_cast<uintptr_t>(target);
+
+ instr5 &= ~kImm16Mask;
+ instr5 |= itarget & kImm16Mask;
+ itarget = itarget >> 16;
+
+ instr4 &= ~kImm16Mask;
+ instr4 |= itarget & kImm16Mask;
+ itarget = itarget >> 16;
+
+ instr2 &= ~kImm16Mask;
+ instr2 |= itarget & kImm16Mask;
+ itarget = itarget >> 16;
+
+ instr1 &= ~kImm16Mask;
+ instr1 |= itarget & kImm16Mask;
+ itarget = itarget >> 16;
+
+ *p = instr1;
+ *(p + 1) = instr2;
+ *(p + 3) = instr4;
+ *(p + 4) = instr5;
+ if (icache_flush_mode != SKIP_ICACHE_FLUSH) {
+ CpuFeatures::FlushICache(p, 5 * kInstrSize);
+ }
+#else
+ uint32_t* p = reinterpret_cast<uint32_t*>(pc);
+ uint32_t itarget = reinterpret_cast<uint32_t>(target);
+ int lo_word = itarget & kImm16Mask;
+ int hi_word = itarget >> 16;
+ instr1 &= ~kImm16Mask;
+ instr1 |= hi_word;
+ instr2 &= ~kImm16Mask;
+ instr2 |= lo_word;
+
+ *p = instr1;
+ *(p + 1) = instr2;
+ if (icache_flush_mode != SKIP_ICACHE_FLUSH) {
+ CpuFeatures::FlushICache(p, 2 * kInstrSize);
+ }
+#endif
+ } else {
+#if V8_OOL_CONSTANT_POOL
+ Memory::Address_at(target_constant_pool_address_at(pc, constant_pool)) =
+ target;
+#else
+ UNREACHABLE();
+#endif
+ }
+}
+}
+} // namespace v8::internal
+
+#endif // V8_PPC_ASSEMBLER_PPC_INL_H_
--- /dev/null
+// Copyright (c) 1994-2006 Sun Microsystems Inc.
+// All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// - Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// - Redistribution in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the
+// distribution.
+//
+// - Neither the name of Sun Microsystems or the names of contributors may
+// be used to endorse or promote products derived from this software without
+// specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The original source code covered by the above license above has been
+// modified significantly by Google Inc.
+// Copyright 2014 the V8 project authors. All rights reserved.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/base/bits.h"
+#include "src/base/cpu.h"
+#include "src/macro-assembler.h"
+#include "src/ppc/assembler-ppc-inl.h"
+#include "src/serialize.h"
+
+namespace v8 {
+namespace internal {
+
+// Get the CPU features enabled by the build.
+static unsigned CpuFeaturesImpliedByCompiler() {
+ unsigned answer = 0;
+ return answer;
+}
+
+
+void CpuFeatures::ProbeImpl(bool cross_compile) {
+ supported_ |= CpuFeaturesImpliedByCompiler();
+ cache_line_size_ = 128;
+
+ // Only use statically determined features for cross compile (snapshot).
+ if (cross_compile) return;
+
+// Detect whether frim instruction is supported (POWER5+)
+// For now we will just check for processors we know do not
+// support it
+#ifndef USE_SIMULATOR
+ // Probe for additional features at runtime.
+ base::CPU cpu;
+#if V8_TARGET_ARCH_PPC64
+ if (cpu.part() == base::CPU::PPC_POWER8) {
+ supported_ |= (1u << FPR_GPR_MOV);
+ }
+#endif
+ if (cpu.part() == base::CPU::PPC_POWER6 ||
+ cpu.part() == base::CPU::PPC_POWER7 ||
+ cpu.part() == base::CPU::PPC_POWER8) {
+ supported_ |= (1u << LWSYNC);
+ }
+#if V8_OS_LINUX
+ if (!(cpu.part() == base::CPU::PPC_G5 || cpu.part() == base::CPU::PPC_G4)) {
+ // Assume support
+ supported_ |= (1u << FPU);
+ }
+ if (cpu.cache_line_size() != 0) {
+ cache_line_size_ = cpu.cache_line_size();
+ }
+#elif V8_OS_AIX
+ // Assume support FP support and default cache line size
+ supported_ |= (1u << FPU);
+#endif
+#else // Simulator
+ supported_ |= (1u << FPU);
+ supported_ |= (1u << LWSYNC);
+#if V8_TARGET_ARCH_PPC64
+ supported_ |= (1u << FPR_GPR_MOV);
+#endif
+#endif
+}
+
+
+void CpuFeatures::PrintTarget() {
+ const char* ppc_arch = NULL;
+
+#if V8_TARGET_ARCH_PPC64
+ ppc_arch = "ppc64";
+#else
+ ppc_arch = "ppc";
+#endif
+
+ printf("target %s\n", ppc_arch);
+}
+
+
+void CpuFeatures::PrintFeatures() {
+ printf("FPU=%d\n", CpuFeatures::IsSupported(FPU));
+}
+
+
+Register ToRegister(int num) {
+ DCHECK(num >= 0 && num < kNumRegisters);
+ const Register kRegisters[] = {r0, sp, r2, r3, r4, r5, r6, r7,
+ r8, r9, r10, r11, ip, r13, r14, r15,
+ r16, r17, r18, r19, r20, r21, r22, r23,
+ r24, r25, r26, r27, r28, r29, r30, fp};
+ return kRegisters[num];
+}
+
+
+const char* DoubleRegister::AllocationIndexToString(int index) {
+ DCHECK(index >= 0 && index < kMaxNumAllocatableRegisters);
+ const char* const names[] = {
+ "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10",
+ "d11", "d12", "d15", "d16", "d17", "d18", "d19", "d20", "d21", "d22",
+ "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31"};
+ return names[index];
+}
+
+
+// -----------------------------------------------------------------------------
+// Implementation of RelocInfo
+
+const int RelocInfo::kApplyMask = 1 << RelocInfo::INTERNAL_REFERENCE;
+
+
+bool RelocInfo::IsCodedSpecially() {
+ // The deserializer needs to know whether a pointer is specially
+ // coded. Being specially coded on PPC means that it is a lis/ori
+ // instruction sequence or is an out of line constant pool entry,
+ // and these are always the case inside code objects.
+ return true;
+}
+
+
+bool RelocInfo::IsInConstantPool() {
+#if V8_OOL_CONSTANT_POOL
+ return Assembler::IsConstantPoolLoadStart(pc_);
+#else
+ return false;
+#endif
+}
+
+
+void RelocInfo::PatchCode(byte* instructions, int instruction_count) {
+ // Patch the code at the current address with the supplied instructions.
+ Instr* pc = reinterpret_cast<Instr*>(pc_);
+ Instr* instr = reinterpret_cast<Instr*>(instructions);
+ for (int i = 0; i < instruction_count; i++) {
+ *(pc + i) = *(instr + i);
+ }
+
+ // Indicate that code has changed.
+ CpuFeatures::FlushICache(pc_, instruction_count * Assembler::kInstrSize);
+}
+
+
+// Patch the code at the current PC with a call to the target address.
+// Additional guard instructions can be added if required.
+void RelocInfo::PatchCodeWithCall(Address target, int guard_bytes) {
+ // Patch the code at the current address with a call to the target.
+ UNIMPLEMENTED();
+}
+
+
+// -----------------------------------------------------------------------------
+// Implementation of Operand and MemOperand
+// See assembler-ppc-inl.h for inlined constructors
+
+Operand::Operand(Handle<Object> handle) {
+ AllowDeferredHandleDereference using_raw_address;
+ rm_ = no_reg;
+ // Verify all Objects referred by code are NOT in new space.
+ Object* obj = *handle;
+ if (obj->IsHeapObject()) {
+ DCHECK(!HeapObject::cast(obj)->GetHeap()->InNewSpace(obj));
+ imm_ = reinterpret_cast<intptr_t>(handle.location());
+ rmode_ = RelocInfo::EMBEDDED_OBJECT;
+ } else {
+ // no relocation needed
+ imm_ = reinterpret_cast<intptr_t>(obj);
+ rmode_ = kRelocInfo_NONEPTR;
+ }
+}
+
+
+MemOperand::MemOperand(Register rn, int32_t offset) {
+ ra_ = rn;
+ rb_ = no_reg;
+ offset_ = offset;
+}
+
+
+MemOperand::MemOperand(Register ra, Register rb) {
+ ra_ = ra;
+ rb_ = rb;
+ offset_ = 0;
+}
+
+
+// -----------------------------------------------------------------------------
+// Specific instructions, constants, and masks.
+
+// Spare buffer.
+static const int kMinimalBufferSize = 4 * KB;
+
+
+Assembler::Assembler(Isolate* isolate, void* buffer, int buffer_size)
+ : AssemblerBase(isolate, buffer, buffer_size),
+ recorded_ast_id_(TypeFeedbackId::None()),
+#if V8_OOL_CONSTANT_POOL
+ constant_pool_builder_(),
+#endif
+ positions_recorder_(this) {
+ reloc_info_writer.Reposition(buffer_ + buffer_size_, pc_);
+
+ no_trampoline_pool_before_ = 0;
+ trampoline_pool_blocked_nesting_ = 0;
+ // We leave space (kMaxBlockTrampolineSectionSize)
+ // for BlockTrampolinePoolScope buffer.
+ next_buffer_check_ =
+ FLAG_force_long_branches ? kMaxInt : kMaxCondBranchReach -
+ kMaxBlockTrampolineSectionSize;
+ internal_trampoline_exception_ = false;
+ last_bound_pos_ = 0;
+ trampoline_emitted_ = FLAG_force_long_branches;
+ unbound_labels_count_ = 0;
+ ClearRecordedAstId();
+}
+
+
+void Assembler::GetCode(CodeDesc* desc) {
+ // Set up code descriptor.
+ desc->buffer = buffer_;
+ desc->buffer_size = buffer_size_;
+ desc->instr_size = pc_offset();
+ desc->reloc_size = (buffer_ + buffer_size_) - reloc_info_writer.pos();
+ desc->origin = this;
+}
+
+
+void Assembler::Align(int m) {
+#if V8_TARGET_ARCH_PPC64
+ DCHECK(m >= 4 && base::bits::IsPowerOfTwo64(m));
+#else
+ DCHECK(m >= 4 && base::bits::IsPowerOfTwo32(m));
+#endif
+ while ((pc_offset() & (m - 1)) != 0) {
+ nop();
+ }
+}
+
+
+void Assembler::CodeTargetAlign() { Align(8); }
+
+
+Condition Assembler::GetCondition(Instr instr) {
+ switch (instr & kCondMask) {
+ case BT:
+ return eq;
+ case BF:
+ return ne;
+ default:
+ UNIMPLEMENTED();
+ }
+ return al;
+}
+
+
+bool Assembler::IsLis(Instr instr) {
+ return ((instr & kOpcodeMask) == ADDIS) && GetRA(instr).is(r0);
+}
+
+
+bool Assembler::IsLi(Instr instr) {
+ return ((instr & kOpcodeMask) == ADDI) && GetRA(instr).is(r0);
+}
+
+
+bool Assembler::IsAddic(Instr instr) { return (instr & kOpcodeMask) == ADDIC; }
+
+
+bool Assembler::IsOri(Instr instr) { return (instr & kOpcodeMask) == ORI; }
+
+
+bool Assembler::IsBranch(Instr instr) { return ((instr & kOpcodeMask) == BCX); }
+
+
+Register Assembler::GetRA(Instr instr) {
+ Register reg;
+ reg.code_ = Instruction::RAValue(instr);
+ return reg;
+}
+
+
+Register Assembler::GetRB(Instr instr) {
+ Register reg;
+ reg.code_ = Instruction::RBValue(instr);
+ return reg;
+}
+
+
+#if V8_TARGET_ARCH_PPC64
+// This code assumes a FIXED_SEQUENCE for 64bit loads (lis/ori)
+bool Assembler::Is64BitLoadIntoR12(Instr instr1, Instr instr2, Instr instr3,
+ Instr instr4, Instr instr5) {
+ // Check the instructions are indeed a five part load (into r12)
+ // 3d800000 lis r12, 0
+ // 618c0000 ori r12, r12, 0
+ // 798c07c6 rldicr r12, r12, 32, 31
+ // 658c00c3 oris r12, r12, 195
+ // 618ccd40 ori r12, r12, 52544
+ return (((instr1 >> 16) == 0x3d80) && ((instr2 >> 16) == 0x618c) &&
+ (instr3 == 0x798c07c6) && ((instr4 >> 16) == 0x658c) &&
+ ((instr5 >> 16) == 0x618c));
+}
+#else
+// This code assumes a FIXED_SEQUENCE for 32bit loads (lis/ori)
+bool Assembler::Is32BitLoadIntoR12(Instr instr1, Instr instr2) {
+ // Check the instruction is indeed a two part load (into r12)
+ // 3d802553 lis r12, 9555
+ // 618c5000 ori r12, r12, 20480
+ return (((instr1 >> 16) == 0x3d80) && ((instr2 >> 16) == 0x618c));
+}
+#endif
+
+
+bool Assembler::IsCmpRegister(Instr instr) {
+ return (((instr & kOpcodeMask) == EXT2) &&
+ ((instr & kExt2OpcodeMask) == CMP));
+}
+
+
+bool Assembler::IsRlwinm(Instr instr) {
+ return ((instr & kOpcodeMask) == RLWINMX);
+}
+
+
+#if V8_TARGET_ARCH_PPC64
+bool Assembler::IsRldicl(Instr instr) {
+ return (((instr & kOpcodeMask) == EXT5) &&
+ ((instr & kExt5OpcodeMask) == RLDICL));
+}
+#endif
+
+
+bool Assembler::IsCmpImmediate(Instr instr) {
+ return ((instr & kOpcodeMask) == CMPI);
+}
+
+
+bool Assembler::IsCrSet(Instr instr) {
+ return (((instr & kOpcodeMask) == EXT1) &&
+ ((instr & kExt1OpcodeMask) == CREQV));
+}
+
+
+Register Assembler::GetCmpImmediateRegister(Instr instr) {
+ DCHECK(IsCmpImmediate(instr));
+ return GetRA(instr);
+}
+
+
+int Assembler::GetCmpImmediateRawImmediate(Instr instr) {
+ DCHECK(IsCmpImmediate(instr));
+ return instr & kOff16Mask;
+}
+
+
+// Labels refer to positions in the (to be) generated code.
+// There are bound, linked, and unused labels.
+//
+// Bound labels refer to known positions in the already
+// generated code. pos() is the position the label refers to.
+//
+// Linked labels refer to unknown positions in the code
+// to be generated; pos() is the position of the last
+// instruction using the label.
+
+
+// The link chain is terminated by a negative code position (must be aligned)
+const int kEndOfChain = -4;
+
+
+int Assembler::target_at(int pos) {
+ Instr instr = instr_at(pos);
+ // check which type of branch this is 16 or 26 bit offset
+ int opcode = instr & kOpcodeMask;
+ if (BX == opcode) {
+ int imm26 = ((instr & kImm26Mask) << 6) >> 6;
+ imm26 &= ~(kAAMask | kLKMask); // discard AA|LK bits if present
+ if (imm26 == 0) return kEndOfChain;
+ return pos + imm26;
+ } else if (BCX == opcode) {
+ int imm16 = SIGN_EXT_IMM16((instr & kImm16Mask));
+ imm16 &= ~(kAAMask | kLKMask); // discard AA|LK bits if present
+ if (imm16 == 0) return kEndOfChain;
+ return pos + imm16;
+ } else if ((instr & ~kImm26Mask) == 0) {
+ // Emitted link to a label, not part of a branch (regexp PushBacktrack).
+ if (instr == 0) {
+ return kEndOfChain;
+ } else {
+ int32_t imm26 = SIGN_EXT_IMM26(instr);
+ return (imm26 + pos);
+ }
+ }
+
+ PPCPORT_UNIMPLEMENTED();
+ DCHECK(false);
+ return -1;
+}
+
+
+void Assembler::target_at_put(int pos, int target_pos) {
+ Instr instr = instr_at(pos);
+ int opcode = instr & kOpcodeMask;
+
+ // check which type of branch this is 16 or 26 bit offset
+ if (BX == opcode) {
+ int imm26 = target_pos - pos;
+ DCHECK((imm26 & (kAAMask | kLKMask)) == 0);
+ instr &= ((~kImm26Mask) | kAAMask | kLKMask);
+ DCHECK(is_int26(imm26));
+ instr_at_put(pos, instr | (imm26 & kImm26Mask));
+ return;
+ } else if (BCX == opcode) {
+ int imm16 = target_pos - pos;
+ DCHECK((imm16 & (kAAMask | kLKMask)) == 0);
+ instr &= ((~kImm16Mask) | kAAMask | kLKMask);
+ DCHECK(is_int16(imm16));
+ instr_at_put(pos, instr | (imm16 & kImm16Mask));
+ return;
+ } else if ((instr & ~kImm26Mask) == 0) {
+ DCHECK(target_pos == kEndOfChain || target_pos >= 0);
+ // Emitted link to a label, not part of a branch (regexp PushBacktrack).
+ // Load the position of the label relative to the generated code object
+ // pointer in a register.
+
+ Register dst = r3; // we assume r3 for now
+ DCHECK(IsNop(instr_at(pos + kInstrSize)));
+ uint32_t target = target_pos + (Code::kHeaderSize - kHeapObjectTag);
+ CodePatcher patcher(reinterpret_cast<byte*>(buffer_ + pos), 2,
+ CodePatcher::DONT_FLUSH);
+ int target_hi = static_cast<int>(target) >> 16;
+ int target_lo = static_cast<int>(target) & 0XFFFF;
+
+ patcher.masm()->lis(dst, Operand(SIGN_EXT_IMM16(target_hi)));
+ patcher.masm()->ori(dst, dst, Operand(target_lo));
+ return;
+ }
+
+ DCHECK(false);
+}
+
+
+int Assembler::max_reach_from(int pos) {
+ Instr instr = instr_at(pos);
+ int opcode = instr & kOpcodeMask;
+
+ // check which type of branch this is 16 or 26 bit offset
+ if (BX == opcode) {
+ return 26;
+ } else if (BCX == opcode) {
+ return 16;
+ } else if ((instr & ~kImm26Mask) == 0) {
+ // Emitted label constant, not part of a branch (regexp PushBacktrack).
+ return 26;
+ }
+
+ DCHECK(false);
+ return 0;
+}
+
+
+void Assembler::bind_to(Label* L, int pos) {
+ DCHECK(0 <= pos && pos <= pc_offset()); // must have a valid binding position
+ int32_t trampoline_pos = kInvalidSlotPos;
+ if (L->is_linked() && !trampoline_emitted_) {
+ unbound_labels_count_--;
+ next_buffer_check_ += kTrampolineSlotsSize;
+ }
+
+ while (L->is_linked()) {
+ int fixup_pos = L->pos();
+ int32_t offset = pos - fixup_pos;
+ int maxReach = max_reach_from(fixup_pos);
+ next(L); // call next before overwriting link with target at fixup_pos
+ if (is_intn(offset, maxReach) == false) {
+ if (trampoline_pos == kInvalidSlotPos) {
+ trampoline_pos = get_trampoline_entry();
+ CHECK(trampoline_pos != kInvalidSlotPos);
+ target_at_put(trampoline_pos, pos);
+ }
+ target_at_put(fixup_pos, trampoline_pos);
+ } else {
+ target_at_put(fixup_pos, pos);
+ }
+ }
+ L->bind_to(pos);
+
+ // Keep track of the last bound label so we don't eliminate any instructions
+ // before a bound label.
+ if (pos > last_bound_pos_) last_bound_pos_ = pos;
+}
+
+
+void Assembler::bind(Label* L) {
+ DCHECK(!L->is_bound()); // label can only be bound once
+ bind_to(L, pc_offset());
+}
+
+
+void Assembler::next(Label* L) {
+ DCHECK(L->is_linked());
+ int link = target_at(L->pos());
+ if (link == kEndOfChain) {
+ L->Unuse();
+ } else {
+ DCHECK(link >= 0);
+ L->link_to(link);
+ }
+}
+
+
+bool Assembler::is_near(Label* L, Condition cond) {
+ DCHECK(L->is_bound());
+ if (L->is_bound() == false) return false;
+
+ int maxReach = ((cond == al) ? 26 : 16);
+ int offset = L->pos() - pc_offset();
+
+ return is_intn(offset, maxReach);
+}
+
+
+void Assembler::a_form(Instr instr, DoubleRegister frt, DoubleRegister fra,
+ DoubleRegister frb, RCBit r) {
+ emit(instr | frt.code() * B21 | fra.code() * B16 | frb.code() * B11 | r);
+}
+
+
+void Assembler::d_form(Instr instr, Register rt, Register ra,
+ const intptr_t val, bool signed_disp) {
+ if (signed_disp) {
+ if (!is_int16(val)) {
+ PrintF("val = %" V8PRIdPTR ", 0x%" V8PRIxPTR "\n", val, val);
+ }
+ DCHECK(is_int16(val));
+ } else {
+ if (!is_uint16(val)) {
+ PrintF("val = %" V8PRIdPTR ", 0x%" V8PRIxPTR
+ ", is_unsigned_imm16(val)=%d, kImm16Mask=0x%x\n",
+ val, val, is_uint16(val), kImm16Mask);
+ }
+ DCHECK(is_uint16(val));
+ }
+ emit(instr | rt.code() * B21 | ra.code() * B16 | (kImm16Mask & val));
+}
+
+
+void Assembler::x_form(Instr instr, Register ra, Register rs, Register rb,
+ RCBit r) {
+ emit(instr | rs.code() * B21 | ra.code() * B16 | rb.code() * B11 | r);
+}
+
+
+void Assembler::xo_form(Instr instr, Register rt, Register ra, Register rb,
+ OEBit o, RCBit r) {
+ emit(instr | rt.code() * B21 | ra.code() * B16 | rb.code() * B11 | o | r);
+}
+
+
+void Assembler::md_form(Instr instr, Register ra, Register rs, int shift,
+ int maskbit, RCBit r) {
+ int sh0_4 = shift & 0x1f;
+ int sh5 = (shift >> 5) & 0x1;
+ int m0_4 = maskbit & 0x1f;
+ int m5 = (maskbit >> 5) & 0x1;
+
+ emit(instr | rs.code() * B21 | ra.code() * B16 | sh0_4 * B11 | m0_4 * B6 |
+ m5 * B5 | sh5 * B1 | r);
+}
+
+
+void Assembler::mds_form(Instr instr, Register ra, Register rs, Register rb,
+ int maskbit, RCBit r) {
+ int m0_4 = maskbit & 0x1f;
+ int m5 = (maskbit >> 5) & 0x1;
+
+ emit(instr | rs.code() * B21 | ra.code() * B16 | rb.code() * B11 | m0_4 * B6 |
+ m5 * B5 | r);
+}
+
+
+// Returns the next free trampoline entry.
+int32_t Assembler::get_trampoline_entry() {
+ int32_t trampoline_entry = kInvalidSlotPos;
+
+ if (!internal_trampoline_exception_) {
+ trampoline_entry = trampoline_.take_slot();
+
+ if (kInvalidSlotPos == trampoline_entry) {
+ internal_trampoline_exception_ = true;
+ }
+ }
+ return trampoline_entry;
+}
+
+
+int Assembler::branch_offset(Label* L, bool jump_elimination_allowed) {
+ int target_pos;
+ if (L->is_bound()) {
+ target_pos = L->pos();
+ } else {
+ if (L->is_linked()) {
+ target_pos = L->pos(); // L's link
+ } else {
+ // was: target_pos = kEndOfChain;
+ // However, using branch to self to mark the first reference
+ // should avoid most instances of branch offset overflow. See
+ // target_at() for where this is converted back to kEndOfChain.
+ target_pos = pc_offset();
+ if (!trampoline_emitted_) {
+ unbound_labels_count_++;
+ next_buffer_check_ -= kTrampolineSlotsSize;
+ }
+ }
+ L->link_to(pc_offset());
+ }
+
+ return target_pos - pc_offset();
+}
+
+
+// Branch instructions.
+
+
+void Assembler::bclr(BOfield bo, LKBit lk) {
+ positions_recorder()->WriteRecordedPositions();
+ emit(EXT1 | bo | BCLRX | lk);
+}
+
+
+void Assembler::bcctr(BOfield bo, LKBit lk) {
+ positions_recorder()->WriteRecordedPositions();
+ emit(EXT1 | bo | BCCTRX | lk);
+}
+
+
+// Pseudo op - branch to link register
+void Assembler::blr() { bclr(BA, LeaveLK); }
+
+
+// Pseudo op - branch to count register -- used for "jump"
+void Assembler::bctr() { bcctr(BA, LeaveLK); }
+
+
+void Assembler::bctrl() { bcctr(BA, SetLK); }
+
+
+void Assembler::bc(int branch_offset, BOfield bo, int condition_bit, LKBit lk) {
+ if (lk == SetLK) {
+ positions_recorder()->WriteRecordedPositions();
+ }
+ DCHECK(is_int16(branch_offset));
+ emit(BCX | bo | condition_bit * B16 | (kImm16Mask & branch_offset) | lk);
+}
+
+
+void Assembler::b(int branch_offset, LKBit lk) {
+ if (lk == SetLK) {
+ positions_recorder()->WriteRecordedPositions();
+ }
+ DCHECK((branch_offset & 3) == 0);
+ int imm26 = branch_offset;
+ DCHECK(is_int26(imm26));
+ // todo add AA and LK bits
+ emit(BX | (imm26 & kImm26Mask) | lk);
+}
+
+
+void Assembler::xori(Register dst, Register src, const Operand& imm) {
+ d_form(XORI, src, dst, imm.imm_, false);
+}
+
+
+void Assembler::xoris(Register ra, Register rs, const Operand& imm) {
+ d_form(XORIS, rs, ra, imm.imm_, false);
+}
+
+
+void Assembler::xor_(Register dst, Register src1, Register src2, RCBit rc) {
+ x_form(EXT2 | XORX, dst, src1, src2, rc);
+}
+
+
+void Assembler::cntlzw_(Register ra, Register rs, RCBit rc) {
+ x_form(EXT2 | CNTLZWX, ra, rs, r0, rc);
+}
+
+
+void Assembler::and_(Register ra, Register rs, Register rb, RCBit rc) {
+ x_form(EXT2 | ANDX, ra, rs, rb, rc);
+}
+
+
+void Assembler::rlwinm(Register ra, Register rs, int sh, int mb, int me,
+ RCBit rc) {
+ sh &= 0x1f;
+ mb &= 0x1f;
+ me &= 0x1f;
+ emit(RLWINMX | rs.code() * B21 | ra.code() * B16 | sh * B11 | mb * B6 |
+ me << 1 | rc);
+}
+
+
+void Assembler::rlwnm(Register ra, Register rs, Register rb, int mb, int me,
+ RCBit rc) {
+ mb &= 0x1f;
+ me &= 0x1f;
+ emit(RLWNMX | rs.code() * B21 | ra.code() * B16 | rb.code() * B11 | mb * B6 |
+ me << 1 | rc);
+}
+
+
+void Assembler::rlwimi(Register ra, Register rs, int sh, int mb, int me,
+ RCBit rc) {
+ sh &= 0x1f;
+ mb &= 0x1f;
+ me &= 0x1f;
+ emit(RLWIMIX | rs.code() * B21 | ra.code() * B16 | sh * B11 | mb * B6 |
+ me << 1 | rc);
+}
+
+
+void Assembler::slwi(Register dst, Register src, const Operand& val, RCBit rc) {
+ DCHECK((32 > val.imm_) && (val.imm_ >= 0));
+ rlwinm(dst, src, val.imm_, 0, 31 - val.imm_, rc);
+}
+
+
+void Assembler::srwi(Register dst, Register src, const Operand& val, RCBit rc) {
+ DCHECK((32 > val.imm_) && (val.imm_ >= 0));
+ rlwinm(dst, src, 32 - val.imm_, val.imm_, 31, rc);
+}
+
+
+void Assembler::clrrwi(Register dst, Register src, const Operand& val,
+ RCBit rc) {
+ DCHECK((32 > val.imm_) && (val.imm_ >= 0));
+ rlwinm(dst, src, 0, 0, 31 - val.imm_, rc);
+}
+
+
+void Assembler::clrlwi(Register dst, Register src, const Operand& val,
+ RCBit rc) {
+ DCHECK((32 > val.imm_) && (val.imm_ >= 0));
+ rlwinm(dst, src, 0, val.imm_, 31, rc);
+}
+
+
+void Assembler::srawi(Register ra, Register rs, int sh, RCBit r) {
+ emit(EXT2 | SRAWIX | rs.code() * B21 | ra.code() * B16 | sh * B11 | r);
+}
+
+
+void Assembler::srw(Register dst, Register src1, Register src2, RCBit r) {
+ x_form(EXT2 | SRWX, dst, src1, src2, r);
+}
+
+
+void Assembler::slw(Register dst, Register src1, Register src2, RCBit r) {
+ x_form(EXT2 | SLWX, dst, src1, src2, r);
+}
+
+
+void Assembler::sraw(Register ra, Register rs, Register rb, RCBit r) {
+ x_form(EXT2 | SRAW, ra, rs, rb, r);
+}
+
+
+void Assembler::rotlw(Register ra, Register rs, Register rb, RCBit r) {
+ rlwnm(ra, rs, rb, 0, 31, r);
+}
+
+
+void Assembler::rotlwi(Register ra, Register rs, int sh, RCBit r) {
+ rlwinm(ra, rs, sh, 0, 31, r);
+}
+
+
+void Assembler::rotrwi(Register ra, Register rs, int sh, RCBit r) {
+ rlwinm(ra, rs, 32 - sh, 0, 31, r);
+}
+
+
+void Assembler::subi(Register dst, Register src, const Operand& imm) {
+ addi(dst, src, Operand(-(imm.imm_)));
+}
+
+void Assembler::addc(Register dst, Register src1, Register src2, OEBit o,
+ RCBit r) {
+ xo_form(EXT2 | ADDCX, dst, src1, src2, o, r);
+}
+
+
+void Assembler::addze(Register dst, Register src1, OEBit o, RCBit r) {
+ // a special xo_form
+ emit(EXT2 | ADDZEX | dst.code() * B21 | src1.code() * B16 | o | r);
+}
+
+
+void Assembler::sub(Register dst, Register src1, Register src2, OEBit o,
+ RCBit r) {
+ xo_form(EXT2 | SUBFX, dst, src2, src1, o, r);
+}
+
+
+void Assembler::subfc(Register dst, Register src1, Register src2, OEBit o,
+ RCBit r) {
+ xo_form(EXT2 | SUBFCX, dst, src2, src1, o, r);
+}
+
+
+void Assembler::subfic(Register dst, Register src, const Operand& imm) {
+ d_form(SUBFIC, dst, src, imm.imm_, true);
+}
+
+
+void Assembler::add(Register dst, Register src1, Register src2, OEBit o,
+ RCBit r) {
+ xo_form(EXT2 | ADDX, dst, src1, src2, o, r);
+}
+
+
+// Multiply low word
+void Assembler::mullw(Register dst, Register src1, Register src2, OEBit o,
+ RCBit r) {
+ xo_form(EXT2 | MULLW, dst, src1, src2, o, r);
+}
+
+
+// Multiply hi word
+void Assembler::mulhw(Register dst, Register src1, Register src2, OEBit o,
+ RCBit r) {
+ xo_form(EXT2 | MULHWX, dst, src1, src2, o, r);
+}
+
+
+// Divide word
+void Assembler::divw(Register dst, Register src1, Register src2, OEBit o,
+ RCBit r) {
+ xo_form(EXT2 | DIVW, dst, src1, src2, o, r);
+}
+
+
+void Assembler::addi(Register dst, Register src, const Operand& imm) {
+ DCHECK(!src.is(r0)); // use li instead to show intent
+ d_form(ADDI, dst, src, imm.imm_, true);
+}
+
+
+void Assembler::addis(Register dst, Register src, const Operand& imm) {
+ DCHECK(!src.is(r0)); // use lis instead to show intent
+ d_form(ADDIS, dst, src, imm.imm_, true);
+}
+
+
+void Assembler::addic(Register dst, Register src, const Operand& imm) {
+ d_form(ADDIC, dst, src, imm.imm_, true);
+}
+
+
+void Assembler::andi(Register ra, Register rs, const Operand& imm) {
+ d_form(ANDIx, rs, ra, imm.imm_, false);
+}
+
+
+void Assembler::andis(Register ra, Register rs, const Operand& imm) {
+ d_form(ANDISx, rs, ra, imm.imm_, false);
+}
+
+
+void Assembler::nor(Register dst, Register src1, Register src2, RCBit r) {
+ x_form(EXT2 | NORX, dst, src1, src2, r);
+}
+
+
+void Assembler::notx(Register dst, Register src, RCBit r) {
+ x_form(EXT2 | NORX, dst, src, src, r);
+}
+
+
+void Assembler::ori(Register ra, Register rs, const Operand& imm) {
+ d_form(ORI, rs, ra, imm.imm_, false);
+}
+
+
+void Assembler::oris(Register dst, Register src, const Operand& imm) {
+ d_form(ORIS, src, dst, imm.imm_, false);
+}
+
+
+void Assembler::orx(Register dst, Register src1, Register src2, RCBit rc) {
+ x_form(EXT2 | ORX, dst, src1, src2, rc);
+}
+
+
+void Assembler::cmpi(Register src1, const Operand& src2, CRegister cr) {
+ intptr_t imm16 = src2.imm_;
+#if V8_TARGET_ARCH_PPC64
+ int L = 1;
+#else
+ int L = 0;
+#endif
+ DCHECK(is_int16(imm16));
+ DCHECK(cr.code() >= 0 && cr.code() <= 7);
+ imm16 &= kImm16Mask;
+ emit(CMPI | cr.code() * B23 | L * B21 | src1.code() * B16 | imm16);
+}
+
+
+void Assembler::cmpli(Register src1, const Operand& src2, CRegister cr) {
+ uintptr_t uimm16 = src2.imm_;
+#if V8_TARGET_ARCH_PPC64
+ int L = 1;
+#else
+ int L = 0;
+#endif
+ DCHECK(is_uint16(uimm16));
+ DCHECK(cr.code() >= 0 && cr.code() <= 7);
+ uimm16 &= kImm16Mask;
+ emit(CMPLI | cr.code() * B23 | L * B21 | src1.code() * B16 | uimm16);
+}
+
+
+void Assembler::cmp(Register src1, Register src2, CRegister cr) {
+#if V8_TARGET_ARCH_PPC64
+ int L = 1;
+#else
+ int L = 0;
+#endif
+ DCHECK(cr.code() >= 0 && cr.code() <= 7);
+ emit(EXT2 | CMP | cr.code() * B23 | L * B21 | src1.code() * B16 |
+ src2.code() * B11);
+}
+
+
+void Assembler::cmpl(Register src1, Register src2, CRegister cr) {
+#if V8_TARGET_ARCH_PPC64
+ int L = 1;
+#else
+ int L = 0;
+#endif
+ DCHECK(cr.code() >= 0 && cr.code() <= 7);
+ emit(EXT2 | CMPL | cr.code() * B23 | L * B21 | src1.code() * B16 |
+ src2.code() * B11);
+}
+
+
+void Assembler::cmpwi(Register src1, const Operand& src2, CRegister cr) {
+ intptr_t imm16 = src2.imm_;
+ int L = 0;
+ DCHECK(is_int16(imm16));
+ DCHECK(cr.code() >= 0 && cr.code() <= 7);
+ imm16 &= kImm16Mask;
+ emit(CMPI | cr.code() * B23 | L * B21 | src1.code() * B16 | imm16);
+}
+
+
+void Assembler::cmplwi(Register src1, const Operand& src2, CRegister cr) {
+ uintptr_t uimm16 = src2.imm_;
+ int L = 0;
+ DCHECK(is_uint16(uimm16));
+ DCHECK(cr.code() >= 0 && cr.code() <= 7);
+ uimm16 &= kImm16Mask;
+ emit(CMPLI | cr.code() * B23 | L * B21 | src1.code() * B16 | uimm16);
+}
+
+
+void Assembler::cmpw(Register src1, Register src2, CRegister cr) {
+ int L = 0;
+ DCHECK(cr.code() >= 0 && cr.code() <= 7);
+ emit(EXT2 | CMP | cr.code() * B23 | L * B21 | src1.code() * B16 |
+ src2.code() * B11);
+}
+
+
+void Assembler::cmplw(Register src1, Register src2, CRegister cr) {
+ int L = 0;
+ DCHECK(cr.code() >= 0 && cr.code() <= 7);
+ emit(EXT2 | CMPL | cr.code() * B23 | L * B21 | src1.code() * B16 |
+ src2.code() * B11);
+}
+
+
+// Pseudo op - load immediate
+void Assembler::li(Register dst, const Operand& imm) {
+ d_form(ADDI, dst, r0, imm.imm_, true);
+}
+
+
+void Assembler::lis(Register dst, const Operand& imm) {
+ d_form(ADDIS, dst, r0, imm.imm_, true);
+}
+
+
+// Pseudo op - move register
+void Assembler::mr(Register dst, Register src) {
+ // actually or(dst, src, src)
+ orx(dst, src, src);
+}
+
+
+void Assembler::lbz(Register dst, const MemOperand& src) {
+ DCHECK(!src.ra_.is(r0));
+ d_form(LBZ, dst, src.ra(), src.offset(), true);
+}
+
+
+void Assembler::lbzx(Register rt, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | LBZX | rt.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::lbzux(Register rt, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | LBZUX | rt.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::lhz(Register dst, const MemOperand& src) {
+ DCHECK(!src.ra_.is(r0));
+ d_form(LHZ, dst, src.ra(), src.offset(), true);
+}
+
+
+void Assembler::lhzx(Register rt, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | LHZX | rt.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::lhzux(Register rt, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | LHZUX | rt.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::lwz(Register dst, const MemOperand& src) {
+ DCHECK(!src.ra_.is(r0));
+ d_form(LWZ, dst, src.ra(), src.offset(), true);
+}
+
+
+void Assembler::lwzu(Register dst, const MemOperand& src) {
+ DCHECK(!src.ra_.is(r0));
+ d_form(LWZU, dst, src.ra(), src.offset(), true);
+}
+
+
+void Assembler::lwzx(Register rt, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | LWZX | rt.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::lwzux(Register rt, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | LWZUX | rt.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::lwa(Register dst, const MemOperand& src) {
+#if V8_TARGET_ARCH_PPC64
+ int offset = src.offset();
+ DCHECK(!src.ra_.is(r0));
+ DCHECK(!(offset & 3) && is_int16(offset));
+ offset = kImm16Mask & offset;
+ emit(LD | dst.code() * B21 | src.ra().code() * B16 | offset | 2);
+#else
+ lwz(dst, src);
+#endif
+}
+
+
+void Assembler::stb(Register dst, const MemOperand& src) {
+ DCHECK(!src.ra_.is(r0));
+ d_form(STB, dst, src.ra(), src.offset(), true);
+}
+
+
+void Assembler::stbx(Register rs, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | STBX | rs.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::stbux(Register rs, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | STBUX | rs.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::sth(Register dst, const MemOperand& src) {
+ DCHECK(!src.ra_.is(r0));
+ d_form(STH, dst, src.ra(), src.offset(), true);
+}
+
+
+void Assembler::sthx(Register rs, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | STHX | rs.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::sthux(Register rs, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | STHUX | rs.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::stw(Register dst, const MemOperand& src) {
+ DCHECK(!src.ra_.is(r0));
+ d_form(STW, dst, src.ra(), src.offset(), true);
+}
+
+
+void Assembler::stwu(Register dst, const MemOperand& src) {
+ DCHECK(!src.ra_.is(r0));
+ d_form(STWU, dst, src.ra(), src.offset(), true);
+}
+
+
+void Assembler::stwx(Register rs, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | STWX | rs.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::stwux(Register rs, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | STWUX | rs.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::extsb(Register rs, Register ra, RCBit rc) {
+ emit(EXT2 | EXTSB | ra.code() * B21 | rs.code() * B16 | rc);
+}
+
+
+void Assembler::extsh(Register rs, Register ra, RCBit rc) {
+ emit(EXT2 | EXTSH | ra.code() * B21 | rs.code() * B16 | rc);
+}
+
+
+void Assembler::neg(Register rt, Register ra, OEBit o, RCBit r) {
+ emit(EXT2 | NEGX | rt.code() * B21 | ra.code() * B16 | o | r);
+}
+
+
+void Assembler::andc(Register dst, Register src1, Register src2, RCBit rc) {
+ x_form(EXT2 | ANDCX, dst, src1, src2, rc);
+}
+
+
+#if V8_TARGET_ARCH_PPC64
+// 64bit specific instructions
+void Assembler::ld(Register rd, const MemOperand& src) {
+ int offset = src.offset();
+ DCHECK(!src.ra_.is(r0));
+ DCHECK(!(offset & 3) && is_int16(offset));
+ offset = kImm16Mask & offset;
+ emit(LD | rd.code() * B21 | src.ra().code() * B16 | offset);
+}
+
+
+void Assembler::ldx(Register rd, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | LDX | rd.code() * B21 | ra.code() * B16 | rb.code() * B11);
+}
+
+
+void Assembler::ldu(Register rd, const MemOperand& src) {
+ int offset = src.offset();
+ DCHECK(!src.ra_.is(r0));
+ DCHECK(!(offset & 3) && is_int16(offset));
+ offset = kImm16Mask & offset;
+ emit(LD | rd.code() * B21 | src.ra().code() * B16 | offset | 1);
+}
+
+
+void Assembler::ldux(Register rd, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | LDUX | rd.code() * B21 | ra.code() * B16 | rb.code() * B11);
+}
+
+
+void Assembler::std(Register rs, const MemOperand& src) {
+ int offset = src.offset();
+ DCHECK(!src.ra_.is(r0));
+ DCHECK(!(offset & 3) && is_int16(offset));
+ offset = kImm16Mask & offset;
+ emit(STD | rs.code() * B21 | src.ra().code() * B16 | offset);
+}
+
+
+void Assembler::stdx(Register rs, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | STDX | rs.code() * B21 | ra.code() * B16 | rb.code() * B11);
+}
+
+
+void Assembler::stdu(Register rs, const MemOperand& src) {
+ int offset = src.offset();
+ DCHECK(!src.ra_.is(r0));
+ DCHECK(!(offset & 3) && is_int16(offset));
+ offset = kImm16Mask & offset;
+ emit(STD | rs.code() * B21 | src.ra().code() * B16 | offset | 1);
+}
+
+
+void Assembler::stdux(Register rs, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | STDUX | rs.code() * B21 | ra.code() * B16 | rb.code() * B11);
+}
+
+
+void Assembler::rldic(Register ra, Register rs, int sh, int mb, RCBit r) {
+ md_form(EXT5 | RLDIC, ra, rs, sh, mb, r);
+}
+
+
+void Assembler::rldicl(Register ra, Register rs, int sh, int mb, RCBit r) {
+ md_form(EXT5 | RLDICL, ra, rs, sh, mb, r);
+}
+
+
+void Assembler::rldcl(Register ra, Register rs, Register rb, int mb, RCBit r) {
+ mds_form(EXT5 | RLDCL, ra, rs, rb, mb, r);
+}
+
+
+void Assembler::rldicr(Register ra, Register rs, int sh, int me, RCBit r) {
+ md_form(EXT5 | RLDICR, ra, rs, sh, me, r);
+}
+
+
+void Assembler::sldi(Register dst, Register src, const Operand& val, RCBit rc) {
+ DCHECK((64 > val.imm_) && (val.imm_ >= 0));
+ rldicr(dst, src, val.imm_, 63 - val.imm_, rc);
+}
+
+
+void Assembler::srdi(Register dst, Register src, const Operand& val, RCBit rc) {
+ DCHECK((64 > val.imm_) && (val.imm_ >= 0));
+ rldicl(dst, src, 64 - val.imm_, val.imm_, rc);
+}
+
+
+void Assembler::clrrdi(Register dst, Register src, const Operand& val,
+ RCBit rc) {
+ DCHECK((64 > val.imm_) && (val.imm_ >= 0));
+ rldicr(dst, src, 0, 63 - val.imm_, rc);
+}
+
+
+void Assembler::clrldi(Register dst, Register src, const Operand& val,
+ RCBit rc) {
+ DCHECK((64 > val.imm_) && (val.imm_ >= 0));
+ rldicl(dst, src, 0, val.imm_, rc);
+}
+
+
+void Assembler::rldimi(Register ra, Register rs, int sh, int mb, RCBit r) {
+ md_form(EXT5 | RLDIMI, ra, rs, sh, mb, r);
+}
+
+
+void Assembler::sradi(Register ra, Register rs, int sh, RCBit r) {
+ int sh0_4 = sh & 0x1f;
+ int sh5 = (sh >> 5) & 0x1;
+
+ emit(EXT2 | SRADIX | rs.code() * B21 | ra.code() * B16 | sh0_4 * B11 |
+ sh5 * B1 | r);
+}
+
+
+void Assembler::srd(Register dst, Register src1, Register src2, RCBit r) {
+ x_form(EXT2 | SRDX, dst, src1, src2, r);
+}
+
+
+void Assembler::sld(Register dst, Register src1, Register src2, RCBit r) {
+ x_form(EXT2 | SLDX, dst, src1, src2, r);
+}
+
+
+void Assembler::srad(Register ra, Register rs, Register rb, RCBit r) {
+ x_form(EXT2 | SRAD, ra, rs, rb, r);
+}
+
+
+void Assembler::rotld(Register ra, Register rs, Register rb, RCBit r) {
+ rldcl(ra, rs, rb, 0, r);
+}
+
+
+void Assembler::rotldi(Register ra, Register rs, int sh, RCBit r) {
+ rldicl(ra, rs, sh, 0, r);
+}
+
+
+void Assembler::rotrdi(Register ra, Register rs, int sh, RCBit r) {
+ rldicl(ra, rs, 64 - sh, 0, r);
+}
+
+
+void Assembler::cntlzd_(Register ra, Register rs, RCBit rc) {
+ x_form(EXT2 | CNTLZDX, ra, rs, r0, rc);
+}
+
+
+void Assembler::extsw(Register rs, Register ra, RCBit rc) {
+ emit(EXT2 | EXTSW | ra.code() * B21 | rs.code() * B16 | rc);
+}
+
+
+void Assembler::mulld(Register dst, Register src1, Register src2, OEBit o,
+ RCBit r) {
+ xo_form(EXT2 | MULLD, dst, src1, src2, o, r);
+}
+
+
+void Assembler::divd(Register dst, Register src1, Register src2, OEBit o,
+ RCBit r) {
+ xo_form(EXT2 | DIVD, dst, src1, src2, o, r);
+}
+#endif
+
+
+void Assembler::fake_asm(enum FAKE_OPCODE_T fopcode) {
+ DCHECK(fopcode < fLastFaker);
+ emit(FAKE_OPCODE | FAKER_SUBOPCODE | fopcode);
+}
+
+
+void Assembler::marker_asm(int mcode) {
+ if (::v8::internal::FLAG_trace_sim_stubs) {
+ DCHECK(mcode < F_NEXT_AVAILABLE_STUB_MARKER);
+ emit(FAKE_OPCODE | MARKER_SUBOPCODE | mcode);
+ }
+}
+
+
+// Function descriptor for AIX.
+// Code address skips the function descriptor "header".
+// TOC and static chain are ignored and set to 0.
+void Assembler::function_descriptor() {
+ DCHECK(pc_offset() == 0);
+ RecordRelocInfo(RelocInfo::INTERNAL_REFERENCE);
+ emit_ptr(reinterpret_cast<uintptr_t>(pc_) + 3 * kPointerSize);
+ emit_ptr(0);
+ emit_ptr(0);
+}
+
+
+#if ABI_USES_FUNCTION_DESCRIPTORS || V8_OOL_CONSTANT_POOL
+void Assembler::RelocateInternalReference(Address pc, intptr_t delta,
+ Address code_start,
+ ICacheFlushMode icache_flush_mode) {
+ DCHECK(delta || code_start);
+#if ABI_USES_FUNCTION_DESCRIPTORS
+ uintptr_t* fd = reinterpret_cast<uintptr_t*>(pc);
+ if (fd[1] == 0 && fd[2] == 0) {
+ // Function descriptor
+ if (delta) {
+ fd[0] += delta;
+ } else {
+ fd[0] = reinterpret_cast<uintptr_t>(code_start) + 3 * kPointerSize;
+ }
+ return;
+ }
+#endif
+#if V8_OOL_CONSTANT_POOL
+ // mov for LoadConstantPoolPointerRegister
+ ConstantPoolArray* constant_pool = NULL;
+ if (delta) {
+ code_start = target_address_at(pc, constant_pool) + delta;
+ }
+ set_target_address_at(pc, constant_pool, code_start, icache_flush_mode);
+#endif
+}
+
+
+int Assembler::DecodeInternalReference(Vector<char> buffer, Address pc) {
+#if ABI_USES_FUNCTION_DESCRIPTORS
+ uintptr_t* fd = reinterpret_cast<uintptr_t*>(pc);
+ if (fd[1] == 0 && fd[2] == 0) {
+ // Function descriptor
+ SNPrintF(buffer, "[%08" V8PRIxPTR ", %08" V8PRIxPTR ", %08" V8PRIxPTR
+ "]"
+ " function descriptor",
+ fd[0], fd[1], fd[2]);
+ return kPointerSize * 3;
+ }
+#endif
+ return 0;
+}
+#endif
+
+
+int Assembler::instructions_required_for_mov(const Operand& x) const {
+#if V8_OOL_CONSTANT_POOL || DEBUG
+ bool canOptimize =
+ !(x.must_output_reloc_info(this) || is_trampoline_pool_blocked());
+#endif
+#if V8_OOL_CONSTANT_POOL
+ if (use_constant_pool_for_mov(x, canOptimize)) {
+ // Current usage guarantees that all constant pool references can
+ // use the same sequence.
+ return kMovInstructionsConstantPool;
+ }
+#endif
+ DCHECK(!canOptimize);
+ return kMovInstructionsNoConstantPool;
+}
+
+
+#if V8_OOL_CONSTANT_POOL
+bool Assembler::use_constant_pool_for_mov(const Operand& x,
+ bool canOptimize) const {
+ if (!is_ool_constant_pool_available() || is_constant_pool_full()) {
+ // If there is no constant pool available, we must use a mov
+ // immediate sequence.
+ return false;
+ }
+
+ intptr_t value = x.immediate();
+ if (canOptimize && is_int16(value)) {
+ // Prefer a single-instruction load-immediate.
+ return false;
+ }
+
+ return true;
+}
+
+
+void Assembler::EnsureSpaceFor(int space_needed) {
+ if (buffer_space() <= (kGap + space_needed)) {
+ GrowBuffer();
+ }
+}
+#endif
+
+
+bool Operand::must_output_reloc_info(const Assembler* assembler) const {
+ if (rmode_ == RelocInfo::EXTERNAL_REFERENCE) {
+ if (assembler != NULL && assembler->predictable_code_size()) return true;
+ return assembler->serializer_enabled();
+ } else if (RelocInfo::IsNone(rmode_)) {
+ return false;
+ }
+ return true;
+}
+
+
+// Primarily used for loading constants
+// This should really move to be in macro-assembler as it
+// is really a pseudo instruction
+// Some usages of this intend for a FIXED_SEQUENCE to be used
+// Todo - break this dependency so we can optimize mov() in general
+// and only use the generic version when we require a fixed sequence
+void Assembler::mov(Register dst, const Operand& src) {
+ intptr_t value = src.immediate();
+ bool canOptimize;
+ RelocInfo rinfo(pc_, src.rmode_, value, NULL);
+
+ if (src.must_output_reloc_info(this)) {
+ RecordRelocInfo(rinfo);
+ }
+
+ canOptimize =
+ !(src.must_output_reloc_info(this) || is_trampoline_pool_blocked());
+
+#if V8_OOL_CONSTANT_POOL
+ if (use_constant_pool_for_mov(src, canOptimize)) {
+ DCHECK(is_ool_constant_pool_available());
+ ConstantPoolAddEntry(rinfo);
+#if V8_TARGET_ARCH_PPC64
+ BlockTrampolinePoolScope block_trampoline_pool(this);
+ // We are forced to use 2 instruction sequence since the constant
+ // pool pointer is tagged.
+ li(dst, Operand::Zero());
+ ldx(dst, MemOperand(kConstantPoolRegister, dst));
+#else
+ lwz(dst, MemOperand(kConstantPoolRegister, 0));
+#endif
+ return;
+ }
+#endif
+
+ if (canOptimize) {
+ if (is_int16(value)) {
+ li(dst, Operand(value));
+ } else {
+ uint16_t u16;
+#if V8_TARGET_ARCH_PPC64
+ if (is_int32(value)) {
+#endif
+ lis(dst, Operand(value >> 16));
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ if (is_int48(value)) {
+ li(dst, Operand(value >> 32));
+ } else {
+ lis(dst, Operand(value >> 48));
+ u16 = ((value >> 32) & 0xffff);
+ if (u16) {
+ ori(dst, dst, Operand(u16));
+ }
+ }
+ sldi(dst, dst, Operand(32));
+ u16 = ((value >> 16) & 0xffff);
+ if (u16) {
+ oris(dst, dst, Operand(u16));
+ }
+ }
+#endif
+ u16 = (value & 0xffff);
+ if (u16) {
+ ori(dst, dst, Operand(u16));
+ }
+ }
+ return;
+ }
+
+ DCHECK(!canOptimize);
+
+ {
+ BlockTrampolinePoolScope block_trampoline_pool(this);
+#if V8_TARGET_ARCH_PPC64
+ int32_t hi_32 = static_cast<int32_t>(value >> 32);
+ int32_t lo_32 = static_cast<int32_t>(value);
+ int hi_word = static_cast<int>(hi_32 >> 16);
+ int lo_word = static_cast<int>(hi_32 & 0xffff);
+ lis(dst, Operand(SIGN_EXT_IMM16(hi_word)));
+ ori(dst, dst, Operand(lo_word));
+ sldi(dst, dst, Operand(32));
+ hi_word = static_cast<int>(((lo_32 >> 16) & 0xffff));
+ lo_word = static_cast<int>(lo_32 & 0xffff);
+ oris(dst, dst, Operand(hi_word));
+ ori(dst, dst, Operand(lo_word));
+#else
+ int hi_word = static_cast<int>(value >> 16);
+ int lo_word = static_cast<int>(value & 0xffff);
+ lis(dst, Operand(SIGN_EXT_IMM16(hi_word)));
+ ori(dst, dst, Operand(lo_word));
+#endif
+ }
+}
+
+
+void Assembler::mov_label_offset(Register dst, Label* label) {
+ if (label->is_bound()) {
+ int target = label->pos();
+ mov(dst, Operand(target + Code::kHeaderSize - kHeapObjectTag));
+ } else {
+ bool is_linked = label->is_linked();
+ // Emit the link to the label in the code stream followed by extra
+ // nop instructions.
+ DCHECK(dst.is(r3)); // target_at_put assumes r3 for now
+ int link = is_linked ? label->pos() - pc_offset() : 0;
+ label->link_to(pc_offset());
+
+ if (!is_linked && !trampoline_emitted_) {
+ unbound_labels_count_++;
+ next_buffer_check_ -= kTrampolineSlotsSize;
+ }
+
+ // When the label is bound, these instructions will be patched
+ // with a 2 instruction mov sequence that will load the
+ // destination register with the position of the label from the
+ // beginning of the code.
+ //
+ // When the label gets bound: target_at extracts the link and
+ // target_at_put patches the instructions.
+ BlockTrampolinePoolScope block_trampoline_pool(this);
+ emit(link);
+ nop();
+ }
+}
+
+
+// Special register instructions
+void Assembler::crxor(int bt, int ba, int bb) {
+ emit(EXT1 | CRXOR | bt * B21 | ba * B16 | bb * B11);
+}
+
+
+void Assembler::creqv(int bt, int ba, int bb) {
+ emit(EXT1 | CREQV | bt * B21 | ba * B16 | bb * B11);
+}
+
+
+void Assembler::mflr(Register dst) {
+ emit(EXT2 | MFSPR | dst.code() * B21 | 256 << 11); // Ignore RC bit
+}
+
+
+void Assembler::mtlr(Register src) {
+ emit(EXT2 | MTSPR | src.code() * B21 | 256 << 11); // Ignore RC bit
+}
+
+
+void Assembler::mtctr(Register src) {
+ emit(EXT2 | MTSPR | src.code() * B21 | 288 << 11); // Ignore RC bit
+}
+
+
+void Assembler::mtxer(Register src) {
+ emit(EXT2 | MTSPR | src.code() * B21 | 32 << 11);
+}
+
+
+void Assembler::mcrfs(int bf, int bfa) {
+ emit(EXT4 | MCRFS | bf * B23 | bfa * B18);
+}
+
+
+void Assembler::mfcr(Register dst) { emit(EXT2 | MFCR | dst.code() * B21); }
+
+
+#if V8_TARGET_ARCH_PPC64
+void Assembler::mffprd(Register dst, DoubleRegister src) {
+ emit(EXT2 | MFVSRD | src.code() * B21 | dst.code() * B16);
+}
+
+
+void Assembler::mffprwz(Register dst, DoubleRegister src) {
+ emit(EXT2 | MFVSRWZ | src.code() * B21 | dst.code() * B16);
+}
+
+
+void Assembler::mtfprd(DoubleRegister dst, Register src) {
+ emit(EXT2 | MTVSRD | dst.code() * B21 | src.code() * B16);
+}
+
+
+void Assembler::mtfprwz(DoubleRegister dst, Register src) {
+ emit(EXT2 | MTVSRWZ | dst.code() * B21 | src.code() * B16);
+}
+
+
+void Assembler::mtfprwa(DoubleRegister dst, Register src) {
+ emit(EXT2 | MTVSRWA | dst.code() * B21 | src.code() * B16);
+}
+#endif
+
+
+// Exception-generating instructions and debugging support.
+// Stops with a non-negative code less than kNumOfWatchedStops support
+// enabling/disabling and a counter feature. See simulator-ppc.h .
+void Assembler::stop(const char* msg, Condition cond, int32_t code,
+ CRegister cr) {
+ if (cond != al) {
+ Label skip;
+ b(NegateCondition(cond), &skip, cr);
+ bkpt(0);
+ bind(&skip);
+ } else {
+ bkpt(0);
+ }
+}
+
+
+void Assembler::bkpt(uint32_t imm16) { emit(0x7d821008); }
+
+
+void Assembler::info(const char* msg, Condition cond, int32_t code,
+ CRegister cr) {
+ if (::v8::internal::FLAG_trace_sim_stubs) {
+ emit(0x7d9ff808);
+#if V8_TARGET_ARCH_PPC64
+ uint64_t value = reinterpret_cast<uint64_t>(msg);
+ emit(static_cast<uint32_t>(value >> 32));
+ emit(static_cast<uint32_t>(value & 0xFFFFFFFF));
+#else
+ emit(reinterpret_cast<Instr>(msg));
+#endif
+ }
+}
+
+
+void Assembler::dcbf(Register ra, Register rb) {
+ emit(EXT2 | DCBF | ra.code() * B16 | rb.code() * B11);
+}
+
+
+void Assembler::sync() { emit(EXT2 | SYNC); }
+
+
+void Assembler::lwsync() { emit(EXT2 | SYNC | 1 * B21); }
+
+
+void Assembler::icbi(Register ra, Register rb) {
+ emit(EXT2 | ICBI | ra.code() * B16 | rb.code() * B11);
+}
+
+
+void Assembler::isync() { emit(EXT1 | ISYNC); }
+
+
+// Floating point support
+
+void Assembler::lfd(const DoubleRegister frt, const MemOperand& src) {
+ int offset = src.offset();
+ Register ra = src.ra();
+ DCHECK(is_int16(offset));
+ int imm16 = offset & kImm16Mask;
+ // could be x_form instruction with some casting magic
+ emit(LFD | frt.code() * B21 | ra.code() * B16 | imm16);
+}
+
+
+void Assembler::lfdu(const DoubleRegister frt, const MemOperand& src) {
+ int offset = src.offset();
+ Register ra = src.ra();
+ DCHECK(is_int16(offset));
+ int imm16 = offset & kImm16Mask;
+ // could be x_form instruction with some casting magic
+ emit(LFDU | frt.code() * B21 | ra.code() * B16 | imm16);
+}
+
+
+void Assembler::lfdx(const DoubleRegister frt, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | LFDX | frt.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::lfdux(const DoubleRegister frt, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | LFDUX | frt.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::lfs(const DoubleRegister frt, const MemOperand& src) {
+ int offset = src.offset();
+ Register ra = src.ra();
+ DCHECK(is_int16(offset));
+ DCHECK(!ra.is(r0));
+ int imm16 = offset & kImm16Mask;
+ // could be x_form instruction with some casting magic
+ emit(LFS | frt.code() * B21 | ra.code() * B16 | imm16);
+}
+
+
+void Assembler::lfsu(const DoubleRegister frt, const MemOperand& src) {
+ int offset = src.offset();
+ Register ra = src.ra();
+ DCHECK(is_int16(offset));
+ DCHECK(!ra.is(r0));
+ int imm16 = offset & kImm16Mask;
+ // could be x_form instruction with some casting magic
+ emit(LFSU | frt.code() * B21 | ra.code() * B16 | imm16);
+}
+
+
+void Assembler::lfsx(const DoubleRegister frt, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | LFSX | frt.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::lfsux(const DoubleRegister frt, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | LFSUX | frt.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::stfd(const DoubleRegister frs, const MemOperand& src) {
+ int offset = src.offset();
+ Register ra = src.ra();
+ DCHECK(is_int16(offset));
+ DCHECK(!ra.is(r0));
+ int imm16 = offset & kImm16Mask;
+ // could be x_form instruction with some casting magic
+ emit(STFD | frs.code() * B21 | ra.code() * B16 | imm16);
+}
+
+
+void Assembler::stfdu(const DoubleRegister frs, const MemOperand& src) {
+ int offset = src.offset();
+ Register ra = src.ra();
+ DCHECK(is_int16(offset));
+ DCHECK(!ra.is(r0));
+ int imm16 = offset & kImm16Mask;
+ // could be x_form instruction with some casting magic
+ emit(STFDU | frs.code() * B21 | ra.code() * B16 | imm16);
+}
+
+
+void Assembler::stfdx(const DoubleRegister frs, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | STFDX | frs.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::stfdux(const DoubleRegister frs, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | STFDUX | frs.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::stfs(const DoubleRegister frs, const MemOperand& src) {
+ int offset = src.offset();
+ Register ra = src.ra();
+ DCHECK(is_int16(offset));
+ DCHECK(!ra.is(r0));
+ int imm16 = offset & kImm16Mask;
+ // could be x_form instruction with some casting magic
+ emit(STFS | frs.code() * B21 | ra.code() * B16 | imm16);
+}
+
+
+void Assembler::stfsu(const DoubleRegister frs, const MemOperand& src) {
+ int offset = src.offset();
+ Register ra = src.ra();
+ DCHECK(is_int16(offset));
+ DCHECK(!ra.is(r0));
+ int imm16 = offset & kImm16Mask;
+ // could be x_form instruction with some casting magic
+ emit(STFSU | frs.code() * B21 | ra.code() * B16 | imm16);
+}
+
+
+void Assembler::stfsx(const DoubleRegister frs, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | STFSX | frs.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::stfsux(const DoubleRegister frs, const MemOperand& src) {
+ Register ra = src.ra();
+ Register rb = src.rb();
+ DCHECK(!ra.is(r0));
+ emit(EXT2 | STFSUX | frs.code() * B21 | ra.code() * B16 | rb.code() * B11 |
+ LeaveRC);
+}
+
+
+void Assembler::fsub(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frb, RCBit rc) {
+ a_form(EXT4 | FSUB, frt, fra, frb, rc);
+}
+
+
+void Assembler::fadd(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frb, RCBit rc) {
+ a_form(EXT4 | FADD, frt, fra, frb, rc);
+}
+
+
+void Assembler::fmul(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frc, RCBit rc) {
+ emit(EXT4 | FMUL | frt.code() * B21 | fra.code() * B16 | frc.code() * B6 |
+ rc);
+}
+
+
+void Assembler::fdiv(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frb, RCBit rc) {
+ a_form(EXT4 | FDIV, frt, fra, frb, rc);
+}
+
+
+void Assembler::fcmpu(const DoubleRegister fra, const DoubleRegister frb,
+ CRegister cr) {
+ DCHECK(cr.code() >= 0 && cr.code() <= 7);
+ emit(EXT4 | FCMPU | cr.code() * B23 | fra.code() * B16 | frb.code() * B11);
+}
+
+
+void Assembler::fmr(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc) {
+ emit(EXT4 | FMR | frt.code() * B21 | frb.code() * B11 | rc);
+}
+
+
+void Assembler::fctiwz(const DoubleRegister frt, const DoubleRegister frb) {
+ emit(EXT4 | FCTIWZ | frt.code() * B21 | frb.code() * B11);
+}
+
+
+void Assembler::fctiw(const DoubleRegister frt, const DoubleRegister frb) {
+ emit(EXT4 | FCTIW | frt.code() * B21 | frb.code() * B11);
+}
+
+
+void Assembler::frim(const DoubleRegister frt, const DoubleRegister frb) {
+ emit(EXT4 | FRIM | frt.code() * B21 | frb.code() * B11);
+}
+
+
+void Assembler::frsp(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc) {
+ emit(EXT4 | FRSP | frt.code() * B21 | frb.code() * B11 | rc);
+}
+
+
+void Assembler::fcfid(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc) {
+ emit(EXT4 | FCFID | frt.code() * B21 | frb.code() * B11 | rc);
+}
+
+
+void Assembler::fctid(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc) {
+ emit(EXT4 | FCTID | frt.code() * B21 | frb.code() * B11 | rc);
+}
+
+
+void Assembler::fctidz(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc) {
+ emit(EXT4 | FCTIDZ | frt.code() * B21 | frb.code() * B11 | rc);
+}
+
+
+void Assembler::fsel(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frc, const DoubleRegister frb,
+ RCBit rc) {
+ emit(EXT4 | FSEL | frt.code() * B21 | fra.code() * B16 | frb.code() * B11 |
+ frc.code() * B6 | rc);
+}
+
+
+void Assembler::fneg(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc) {
+ emit(EXT4 | FNEG | frt.code() * B21 | frb.code() * B11 | rc);
+}
+
+
+void Assembler::mtfsfi(int bf, int immediate, RCBit rc) {
+ emit(EXT4 | MTFSFI | bf * B23 | immediate * B12 | rc);
+}
+
+
+void Assembler::mffs(const DoubleRegister frt, RCBit rc) {
+ emit(EXT4 | MFFS | frt.code() * B21 | rc);
+}
+
+
+void Assembler::mtfsf(const DoubleRegister frb, bool L, int FLM, bool W,
+ RCBit rc) {
+ emit(EXT4 | MTFSF | frb.code() * B11 | W * B16 | FLM * B17 | L * B25 | rc);
+}
+
+
+void Assembler::fsqrt(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc) {
+ emit(EXT4 | FSQRT | frt.code() * B21 | frb.code() * B11 | rc);
+}
+
+
+void Assembler::fabs(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc) {
+ emit(EXT4 | FABS | frt.code() * B21 | frb.code() * B11 | rc);
+}
+
+
+void Assembler::fmadd(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frc, const DoubleRegister frb,
+ RCBit rc) {
+ emit(EXT4 | FMADD | frt.code() * B21 | fra.code() * B16 | frb.code() * B11 |
+ frc.code() * B6 | rc);
+}
+
+
+void Assembler::fmsub(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frc, const DoubleRegister frb,
+ RCBit rc) {
+ emit(EXT4 | FMSUB | frt.code() * B21 | fra.code() * B16 | frb.code() * B11 |
+ frc.code() * B6 | rc);
+}
+
+
+// Pseudo instructions.
+void Assembler::nop(int type) {
+ Register reg = r0;
+ switch (type) {
+ case NON_MARKING_NOP:
+ reg = r0;
+ break;
+ case GROUP_ENDING_NOP:
+ reg = r2;
+ break;
+ case DEBUG_BREAK_NOP:
+ reg = r3;
+ break;
+ default:
+ UNIMPLEMENTED();
+ }
+
+ ori(reg, reg, Operand::Zero());
+}
+
+
+bool Assembler::IsNop(Instr instr, int type) {
+ int reg = 0;
+ switch (type) {
+ case NON_MARKING_NOP:
+ reg = 0;
+ break;
+ case GROUP_ENDING_NOP:
+ reg = 2;
+ break;
+ case DEBUG_BREAK_NOP:
+ reg = 3;
+ break;
+ default:
+ UNIMPLEMENTED();
+ }
+ return instr == (ORI | reg * B21 | reg * B16);
+}
+
+
+// Debugging.
+void Assembler::RecordJSReturn() {
+ positions_recorder()->WriteRecordedPositions();
+ CheckBuffer();
+ RecordRelocInfo(RelocInfo::JS_RETURN);
+}
+
+
+void Assembler::RecordDebugBreakSlot() {
+ positions_recorder()->WriteRecordedPositions();
+ CheckBuffer();
+ RecordRelocInfo(RelocInfo::DEBUG_BREAK_SLOT);
+}
+
+
+void Assembler::RecordComment(const char* msg) {
+ if (FLAG_code_comments) {
+ CheckBuffer();
+ RecordRelocInfo(RelocInfo::COMMENT, reinterpret_cast<intptr_t>(msg));
+ }
+}
+
+
+void Assembler::GrowBuffer() {
+ if (!own_buffer_) FATAL("external code buffer is too small");
+
+ // Compute new buffer size.
+ CodeDesc desc; // the new buffer
+ if (buffer_size_ < 4 * KB) {
+ desc.buffer_size = 4 * KB;
+ } else if (buffer_size_ < 1 * MB) {
+ desc.buffer_size = 2 * buffer_size_;
+ } else {
+ desc.buffer_size = buffer_size_ + 1 * MB;
+ }
+ CHECK_GT(desc.buffer_size, 0); // no overflow
+
+ // Set up new buffer.
+ desc.buffer = NewArray<byte>(desc.buffer_size);
+
+ desc.instr_size = pc_offset();
+ desc.reloc_size = (buffer_ + buffer_size_) - reloc_info_writer.pos();
+
+ // Copy the data.
+ intptr_t pc_delta = desc.buffer - buffer_;
+ intptr_t rc_delta =
+ (desc.buffer + desc.buffer_size) - (buffer_ + buffer_size_);
+ memmove(desc.buffer, buffer_, desc.instr_size);
+ memmove(reloc_info_writer.pos() + rc_delta, reloc_info_writer.pos(),
+ desc.reloc_size);
+
+ // Switch buffers.
+ DeleteArray(buffer_);
+ buffer_ = desc.buffer;
+ buffer_size_ = desc.buffer_size;
+ pc_ += pc_delta;
+ reloc_info_writer.Reposition(reloc_info_writer.pos() + rc_delta,
+ reloc_info_writer.last_pc() + pc_delta);
+
+// None of our relocation types are pc relative pointing outside the code
+// buffer nor pc absolute pointing inside the code buffer, so there is no need
+// to relocate any emitted relocation entries.
+
+#if ABI_USES_FUNCTION_DESCRIPTORS || V8_OOL_CONSTANT_POOL
+ // Relocate runtime entries.
+ for (RelocIterator it(desc); !it.done(); it.next()) {
+ RelocInfo::Mode rmode = it.rinfo()->rmode();
+ if (rmode == RelocInfo::INTERNAL_REFERENCE) {
+ RelocateInternalReference(it.rinfo()->pc(), pc_delta, 0);
+ }
+ }
+#if V8_OOL_CONSTANT_POOL
+ constant_pool_builder_.Relocate(pc_delta);
+#endif
+#endif
+}
+
+
+void Assembler::db(uint8_t data) {
+ CheckBuffer();
+ *reinterpret_cast<uint8_t*>(pc_) = data;
+ pc_ += sizeof(uint8_t);
+}
+
+
+void Assembler::dd(uint32_t data) {
+ CheckBuffer();
+ *reinterpret_cast<uint32_t*>(pc_) = data;
+ pc_ += sizeof(uint32_t);
+}
+
+
+void Assembler::emit_ptr(uintptr_t data) {
+ CheckBuffer();
+ *reinterpret_cast<uintptr_t*>(pc_) = data;
+ pc_ += sizeof(uintptr_t);
+}
+
+
+void Assembler::RecordRelocInfo(RelocInfo::Mode rmode, intptr_t data) {
+ RelocInfo rinfo(pc_, rmode, data, NULL);
+ RecordRelocInfo(rinfo);
+}
+
+
+void Assembler::RecordRelocInfo(const RelocInfo& rinfo) {
+ if (rinfo.rmode() >= RelocInfo::JS_RETURN &&
+ rinfo.rmode() <= RelocInfo::DEBUG_BREAK_SLOT) {
+ // Adjust code for new modes.
+ DCHECK(RelocInfo::IsDebugBreakSlot(rinfo.rmode()) ||
+ RelocInfo::IsJSReturn(rinfo.rmode()) ||
+ RelocInfo::IsComment(rinfo.rmode()) ||
+ RelocInfo::IsPosition(rinfo.rmode()));
+ }
+ if (!RelocInfo::IsNone(rinfo.rmode())) {
+ // Don't record external references unless the heap will be serialized.
+ if (rinfo.rmode() == RelocInfo::EXTERNAL_REFERENCE) {
+ if (!serializer_enabled() && !emit_debug_code()) {
+ return;
+ }
+ }
+ DCHECK(buffer_space() >= kMaxRelocSize); // too late to grow buffer here
+ if (rinfo.rmode() == RelocInfo::CODE_TARGET_WITH_ID) {
+ RelocInfo reloc_info_with_ast_id(rinfo.pc(), rinfo.rmode(),
+ RecordedAstId().ToInt(), NULL);
+ ClearRecordedAstId();
+ reloc_info_writer.Write(&reloc_info_with_ast_id);
+ } else {
+ reloc_info_writer.Write(&rinfo);
+ }
+ }
+}
+
+
+void Assembler::BlockTrampolinePoolFor(int instructions) {
+ BlockTrampolinePoolBefore(pc_offset() + instructions * kInstrSize);
+}
+
+
+void Assembler::CheckTrampolinePool() {
+ // Some small sequences of instructions must not be broken up by the
+ // insertion of a trampoline pool; such sequences are protected by setting
+ // either trampoline_pool_blocked_nesting_ or no_trampoline_pool_before_,
+ // which are both checked here. Also, recursive calls to CheckTrampolinePool
+ // are blocked by trampoline_pool_blocked_nesting_.
+ if ((trampoline_pool_blocked_nesting_ > 0) ||
+ (pc_offset() < no_trampoline_pool_before_)) {
+ // Emission is currently blocked; make sure we try again as soon as
+ // possible.
+ if (trampoline_pool_blocked_nesting_ > 0) {
+ next_buffer_check_ = pc_offset() + kInstrSize;
+ } else {
+ next_buffer_check_ = no_trampoline_pool_before_;
+ }
+ return;
+ }
+
+ DCHECK(!trampoline_emitted_);
+ DCHECK(unbound_labels_count_ >= 0);
+ if (unbound_labels_count_ > 0) {
+ // First we emit jump, then we emit trampoline pool.
+ {
+ BlockTrampolinePoolScope block_trampoline_pool(this);
+ Label after_pool;
+ b(&after_pool);
+
+ int pool_start = pc_offset();
+ for (int i = 0; i < unbound_labels_count_; i++) {
+ b(&after_pool);
+ }
+ bind(&after_pool);
+ trampoline_ = Trampoline(pool_start, unbound_labels_count_);
+
+ trampoline_emitted_ = true;
+ // As we are only going to emit trampoline once, we need to prevent any
+ // further emission.
+ next_buffer_check_ = kMaxInt;
+ }
+ } else {
+ // Number of branches to unbound label at this point is zero, so we can
+ // move next buffer check to maximum.
+ next_buffer_check_ =
+ pc_offset() + kMaxCondBranchReach - kMaxBlockTrampolineSectionSize;
+ }
+ return;
+}
+
+
+Handle<ConstantPoolArray> Assembler::NewConstantPool(Isolate* isolate) {
+#if V8_OOL_CONSTANT_POOL
+ return constant_pool_builder_.New(isolate);
+#else
+ // No out-of-line constant pool support.
+ DCHECK(!FLAG_enable_ool_constant_pool);
+ return isolate->factory()->empty_constant_pool_array();
+#endif
+}
+
+
+void Assembler::PopulateConstantPool(ConstantPoolArray* constant_pool) {
+#if V8_OOL_CONSTANT_POOL
+ constant_pool_builder_.Populate(this, constant_pool);
+#else
+ // No out-of-line constant pool support.
+ DCHECK(!FLAG_enable_ool_constant_pool);
+#endif
+}
+
+
+#if V8_OOL_CONSTANT_POOL
+ConstantPoolBuilder::ConstantPoolBuilder()
+ : size_(0),
+ entries_(),
+ current_section_(ConstantPoolArray::SMALL_SECTION) {}
+
+
+bool ConstantPoolBuilder::IsEmpty() { return entries_.size() == 0; }
+
+
+ConstantPoolArray::Type ConstantPoolBuilder::GetConstantPoolType(
+ RelocInfo::Mode rmode) {
+#if V8_TARGET_ARCH_PPC64
+ // We don't support 32-bit entries at this time.
+ if (!RelocInfo::IsGCRelocMode(rmode)) {
+ return ConstantPoolArray::INT64;
+#else
+ if (rmode == RelocInfo::NONE64) {
+ return ConstantPoolArray::INT64;
+ } else if (!RelocInfo::IsGCRelocMode(rmode)) {
+ return ConstantPoolArray::INT32;
+#endif
+ } else if (RelocInfo::IsCodeTarget(rmode)) {
+ return ConstantPoolArray::CODE_PTR;
+ } else {
+ DCHECK(RelocInfo::IsGCRelocMode(rmode) && !RelocInfo::IsCodeTarget(rmode));
+ return ConstantPoolArray::HEAP_PTR;
+ }
+}
+
+
+ConstantPoolArray::LayoutSection ConstantPoolBuilder::AddEntry(
+ Assembler* assm, const RelocInfo& rinfo) {
+ RelocInfo::Mode rmode = rinfo.rmode();
+ DCHECK(rmode != RelocInfo::COMMENT && rmode != RelocInfo::POSITION &&
+ rmode != RelocInfo::STATEMENT_POSITION &&
+ rmode != RelocInfo::CONST_POOL);
+
+ // Try to merge entries which won't be patched.
+ int merged_index = -1;
+ ConstantPoolArray::LayoutSection entry_section = current_section_;
+ if (RelocInfo::IsNone(rmode) ||
+ (!assm->serializer_enabled() && (rmode >= RelocInfo::CELL))) {
+ size_t i;
+ std::vector<ConstantPoolEntry>::const_iterator it;
+ for (it = entries_.begin(), i = 0; it != entries_.end(); it++, i++) {
+ if (RelocInfo::IsEqual(rinfo, it->rinfo_)) {
+ // Merge with found entry.
+ merged_index = i;
+ entry_section = entries_[i].section_;
+ break;
+ }
+ }
+ }
+ DCHECK(entry_section <= current_section_);
+ entries_.push_back(ConstantPoolEntry(rinfo, entry_section, merged_index));
+
+ if (merged_index == -1) {
+ // Not merged, so update the appropriate count.
+ number_of_entries_[entry_section].increment(GetConstantPoolType(rmode));
+ }
+
+ // Check if we still have room for another entry in the small section
+ // given the limitations of the header's layout fields.
+ if (current_section_ == ConstantPoolArray::SMALL_SECTION) {
+ size_ = ConstantPoolArray::SizeFor(*small_entries());
+ if (!is_uint12(size_)) {
+ current_section_ = ConstantPoolArray::EXTENDED_SECTION;
+ }
+ } else {
+ size_ = ConstantPoolArray::SizeForExtended(*small_entries(),
+ *extended_entries());
+ }
+
+ return entry_section;
+}
+
+
+void ConstantPoolBuilder::Relocate(intptr_t pc_delta) {
+ for (std::vector<ConstantPoolEntry>::iterator entry = entries_.begin();
+ entry != entries_.end(); entry++) {
+ DCHECK(entry->rinfo_.rmode() != RelocInfo::JS_RETURN);
+ entry->rinfo_.set_pc(entry->rinfo_.pc() + pc_delta);
+ }
+}
+
+
+Handle<ConstantPoolArray> ConstantPoolBuilder::New(Isolate* isolate) {
+ if (IsEmpty()) {
+ return isolate->factory()->empty_constant_pool_array();
+ } else if (extended_entries()->is_empty()) {
+ return isolate->factory()->NewConstantPoolArray(*small_entries());
+ } else {
+ DCHECK(current_section_ == ConstantPoolArray::EXTENDED_SECTION);
+ return isolate->factory()->NewExtendedConstantPoolArray(
+ *small_entries(), *extended_entries());
+ }
+}
+
+
+void ConstantPoolBuilder::Populate(Assembler* assm,
+ ConstantPoolArray* constant_pool) {
+ DCHECK_EQ(extended_entries()->is_empty(),
+ !constant_pool->is_extended_layout());
+ DCHECK(small_entries()->equals(ConstantPoolArray::NumberOfEntries(
+ constant_pool, ConstantPoolArray::SMALL_SECTION)));
+ if (constant_pool->is_extended_layout()) {
+ DCHECK(extended_entries()->equals(ConstantPoolArray::NumberOfEntries(
+ constant_pool, ConstantPoolArray::EXTENDED_SECTION)));
+ }
+
+ // Set up initial offsets.
+ int offsets[ConstantPoolArray::NUMBER_OF_LAYOUT_SECTIONS]
+ [ConstantPoolArray::NUMBER_OF_TYPES];
+ for (int section = 0; section <= constant_pool->final_section(); section++) {
+ int section_start = (section == ConstantPoolArray::EXTENDED_SECTION)
+ ? small_entries()->total_count()
+ : 0;
+ for (int i = 0; i < ConstantPoolArray::NUMBER_OF_TYPES; i++) {
+ ConstantPoolArray::Type type = static_cast<ConstantPoolArray::Type>(i);
+ if (number_of_entries_[section].count_of(type) != 0) {
+ offsets[section][type] = constant_pool->OffsetOfElementAt(
+ number_of_entries_[section].base_of(type) + section_start);
+ }
+ }
+ }
+
+ for (std::vector<ConstantPoolEntry>::iterator entry = entries_.begin();
+ entry != entries_.end(); entry++) {
+ RelocInfo rinfo = entry->rinfo_;
+ RelocInfo::Mode rmode = entry->rinfo_.rmode();
+ ConstantPoolArray::Type type = GetConstantPoolType(rmode);
+
+ // Update constant pool if necessary and get the entry's offset.
+ int offset;
+ if (entry->merged_index_ == -1) {
+ offset = offsets[entry->section_][type];
+ offsets[entry->section_][type] += ConstantPoolArray::entry_size(type);
+ if (type == ConstantPoolArray::INT64) {
+#if V8_TARGET_ARCH_PPC64
+ constant_pool->set_at_offset(offset, rinfo.data());
+#else
+ constant_pool->set_at_offset(offset, rinfo.data64());
+ } else if (type == ConstantPoolArray::INT32) {
+ constant_pool->set_at_offset(offset,
+ static_cast<int32_t>(rinfo.data()));
+#endif
+ } else if (type == ConstantPoolArray::CODE_PTR) {
+ constant_pool->set_at_offset(offset,
+ reinterpret_cast<Address>(rinfo.data()));
+ } else {
+ DCHECK(type == ConstantPoolArray::HEAP_PTR);
+ constant_pool->set_at_offset(offset,
+ reinterpret_cast<Object*>(rinfo.data()));
+ }
+ offset -= kHeapObjectTag;
+ entry->merged_index_ = offset; // Stash offset for merged entries.
+ } else {
+ DCHECK(entry->merged_index_ < (entry - entries_.begin()));
+ offset = entries_[entry->merged_index_].merged_index_;
+ }
+
+ // Patch load instruction with correct offset.
+ Assembler::SetConstantPoolOffset(rinfo.pc(), offset);
+ }
+}
+#endif
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright (c) 1994-2006 Sun Microsystems Inc.
+// All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// - Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// - Redistribution in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the
+// distribution.
+//
+// - Neither the name of Sun Microsystems or the names of contributors may
+// be used to endorse or promote products derived from this software without
+// specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The original source code covered by the above license above has been
+// modified significantly by Google Inc.
+// Copyright 2014 the V8 project authors. All rights reserved.
+
+// A light-weight PPC Assembler
+// Generates user mode instructions for the PPC architecture up
+
+#ifndef V8_PPC_ASSEMBLER_PPC_H_
+#define V8_PPC_ASSEMBLER_PPC_H_
+
+#include <stdio.h>
+#include <vector>
+
+#include "src/assembler.h"
+#include "src/ppc/constants-ppc.h"
+#include "src/serialize.h"
+
+#define ABI_USES_FUNCTION_DESCRIPTORS \
+ (V8_HOST_ARCH_PPC && (V8_OS_AIX || \
+ (V8_TARGET_ARCH_PPC64 && V8_TARGET_BIG_ENDIAN)))
+
+#define ABI_PASSES_HANDLES_IN_REGS \
+ (!V8_HOST_ARCH_PPC || V8_OS_AIX || V8_TARGET_ARCH_PPC64)
+
+#define ABI_RETURNS_HANDLES_IN_REGS \
+ (!V8_HOST_ARCH_PPC || V8_TARGET_LITTLE_ENDIAN)
+
+#define ABI_RETURNS_OBJECT_PAIRS_IN_REGS \
+ (!V8_HOST_ARCH_PPC || V8_TARGET_LITTLE_ENDIAN)
+
+#define ABI_TOC_ADDRESSABILITY_VIA_IP \
+ (V8_HOST_ARCH_PPC && V8_TARGET_ARCH_PPC64 && V8_TARGET_LITTLE_ENDIAN)
+
+#if !V8_HOST_ARCH_PPC || V8_OS_AIX || V8_TARGET_ARCH_PPC64
+#define ABI_TOC_REGISTER kRegister_r2_Code
+#else
+#define ABI_TOC_REGISTER kRegister_r13_Code
+#endif
+
+#define INSTR_AND_DATA_CACHE_COHERENCY LWSYNC
+
+namespace v8 {
+namespace internal {
+
+// CPU Registers.
+//
+// 1) We would prefer to use an enum, but enum values are assignment-
+// compatible with int, which has caused code-generation bugs.
+//
+// 2) We would prefer to use a class instead of a struct but we don't like
+// the register initialization to depend on the particular initialization
+// order (which appears to be different on OS X, Linux, and Windows for the
+// installed versions of C++ we tried). Using a struct permits C-style
+// "initialization". Also, the Register objects cannot be const as this
+// forces initialization stubs in MSVC, making us dependent on initialization
+// order.
+//
+// 3) By not using an enum, we are possibly preventing the compiler from
+// doing certain constant folds, which may significantly reduce the
+// code generated for some assembly instructions (because they boil down
+// to a few constants). If this is a problem, we could change the code
+// such that we use an enum in optimized mode, and the struct in debug
+// mode. This way we get the compile-time error checking in debug mode
+// and best performance in optimized code.
+
+// Core register
+struct Register {
+ static const int kNumRegisters = 32;
+ static const int kSizeInBytes = kPointerSize;
+
+#if V8_TARGET_LITTLE_ENDIAN
+ static const int kMantissaOffset = 0;
+ static const int kExponentOffset = 4;
+#else
+ static const int kMantissaOffset = 4;
+ static const int kExponentOffset = 0;
+#endif
+
+ static const int kAllocatableLowRangeBegin = 3;
+ static const int kAllocatableLowRangeEnd = 10;
+ static const int kAllocatableHighRangeBegin = 14;
+#if V8_OOL_CONSTANT_POOL
+ static const int kAllocatableHighRangeEnd = 27;
+#else
+ static const int kAllocatableHighRangeEnd = 28;
+#endif
+ static const int kAllocatableContext = 30;
+
+ static const int kNumAllocatableLow =
+ kAllocatableLowRangeEnd - kAllocatableLowRangeBegin + 1;
+ static const int kNumAllocatableHigh =
+ kAllocatableHighRangeEnd - kAllocatableHighRangeBegin + 1;
+ static const int kMaxNumAllocatableRegisters =
+ kNumAllocatableLow + kNumAllocatableHigh + 1; // cp
+
+ static int NumAllocatableRegisters() { return kMaxNumAllocatableRegisters; }
+
+ static int ToAllocationIndex(Register reg) {
+ int index;
+ int code = reg.code();
+ if (code == kAllocatableContext) {
+ // Context is the last index
+ index = NumAllocatableRegisters() - 1;
+ } else if (code <= kAllocatableLowRangeEnd) {
+ // low range
+ index = code - kAllocatableLowRangeBegin;
+ } else {
+ // high range
+ index = code - kAllocatableHighRangeBegin + kNumAllocatableLow;
+ }
+ DCHECK(index >= 0 && index < kMaxNumAllocatableRegisters);
+ return index;
+ }
+
+ static Register FromAllocationIndex(int index) {
+ DCHECK(index >= 0 && index < kMaxNumAllocatableRegisters);
+ // Last index is always the 'cp' register.
+ if (index == kMaxNumAllocatableRegisters - 1) {
+ return from_code(kAllocatableContext);
+ }
+ return (index < kNumAllocatableLow)
+ ? from_code(index + kAllocatableLowRangeBegin)
+ : from_code(index - kNumAllocatableLow +
+ kAllocatableHighRangeBegin);
+ }
+
+ static const char* AllocationIndexToString(int index) {
+ DCHECK(index >= 0 && index < kMaxNumAllocatableRegisters);
+ const char* const names[] = {
+ "r3",
+ "r4",
+ "r5",
+ "r6",
+ "r7",
+ "r8",
+ "r9",
+ "r10",
+ "r14",
+ "r15",
+ "r16",
+ "r17",
+ "r18",
+ "r19",
+ "r20",
+ "r21",
+ "r22",
+ "r23",
+ "r24",
+ "r25",
+ "r26",
+ "r27",
+#if !V8_OOL_CONSTANT_POOL
+ "r28",
+#endif
+ "cp",
+ };
+ return names[index];
+ }
+
+ static Register from_code(int code) {
+ Register r = {code};
+ return r;
+ }
+
+ bool is_valid() const { return 0 <= code_ && code_ < kNumRegisters; }
+ bool is(Register reg) const { return code_ == reg.code_; }
+ int code() const {
+ DCHECK(is_valid());
+ return code_;
+ }
+ int bit() const {
+ DCHECK(is_valid());
+ return 1 << code_;
+ }
+
+ void set_code(int code) {
+ code_ = code;
+ DCHECK(is_valid());
+ }
+
+ // Unfortunately we can't make this private in a struct.
+ int code_;
+};
+
+// These constants are used in several locations, including static initializers
+const int kRegister_no_reg_Code = -1;
+const int kRegister_r0_Code = 0; // general scratch
+const int kRegister_sp_Code = 1; // stack pointer
+const int kRegister_r2_Code = 2; // special on PowerPC
+const int kRegister_r3_Code = 3;
+const int kRegister_r4_Code = 4;
+const int kRegister_r5_Code = 5;
+const int kRegister_r6_Code = 6;
+const int kRegister_r7_Code = 7;
+const int kRegister_r8_Code = 8;
+const int kRegister_r9_Code = 9;
+const int kRegister_r10_Code = 10;
+const int kRegister_r11_Code = 11; // lithium scratch
+const int kRegister_ip_Code = 12; // ip (general scratch)
+const int kRegister_r13_Code = 13; // special on PowerPC
+const int kRegister_r14_Code = 14;
+const int kRegister_r15_Code = 15;
+
+const int kRegister_r16_Code = 16;
+const int kRegister_r17_Code = 17;
+const int kRegister_r18_Code = 18;
+const int kRegister_r19_Code = 19;
+const int kRegister_r20_Code = 20;
+const int kRegister_r21_Code = 21;
+const int kRegister_r22_Code = 22;
+const int kRegister_r23_Code = 23;
+const int kRegister_r24_Code = 24;
+const int kRegister_r25_Code = 25;
+const int kRegister_r26_Code = 26;
+const int kRegister_r27_Code = 27;
+const int kRegister_r28_Code = 28; // constant pool pointer
+const int kRegister_r29_Code = 29; // roots array pointer
+const int kRegister_r30_Code = 30; // context pointer
+const int kRegister_fp_Code = 31; // frame pointer
+
+const Register no_reg = {kRegister_no_reg_Code};
+
+const Register r0 = {kRegister_r0_Code};
+const Register sp = {kRegister_sp_Code};
+const Register r2 = {kRegister_r2_Code};
+const Register r3 = {kRegister_r3_Code};
+const Register r4 = {kRegister_r4_Code};
+const Register r5 = {kRegister_r5_Code};
+const Register r6 = {kRegister_r6_Code};
+const Register r7 = {kRegister_r7_Code};
+const Register r8 = {kRegister_r8_Code};
+const Register r9 = {kRegister_r9_Code};
+const Register r10 = {kRegister_r10_Code};
+const Register r11 = {kRegister_r11_Code};
+const Register ip = {kRegister_ip_Code};
+const Register r13 = {kRegister_r13_Code};
+const Register r14 = {kRegister_r14_Code};
+const Register r15 = {kRegister_r15_Code};
+
+const Register r16 = {kRegister_r16_Code};
+const Register r17 = {kRegister_r17_Code};
+const Register r18 = {kRegister_r18_Code};
+const Register r19 = {kRegister_r19_Code};
+const Register r20 = {kRegister_r20_Code};
+const Register r21 = {kRegister_r21_Code};
+const Register r22 = {kRegister_r22_Code};
+const Register r23 = {kRegister_r23_Code};
+const Register r24 = {kRegister_r24_Code};
+const Register r25 = {kRegister_r25_Code};
+const Register r26 = {kRegister_r26_Code};
+const Register r27 = {kRegister_r27_Code};
+const Register r28 = {kRegister_r28_Code};
+const Register r29 = {kRegister_r29_Code};
+const Register r30 = {kRegister_r30_Code};
+const Register fp = {kRegister_fp_Code};
+
+// Give alias names to registers
+const Register cp = {kRegister_r30_Code}; // JavaScript context pointer
+const Register kRootRegister = {kRegister_r29_Code}; // Roots array pointer.
+#if V8_OOL_CONSTANT_POOL
+const Register kConstantPoolRegister = {kRegister_r28_Code}; // Constant pool
+#endif
+
+// Double word FP register.
+struct DoubleRegister {
+ static const int kNumRegisters = 32;
+ static const int kMaxNumRegisters = kNumRegisters;
+ static const int kNumVolatileRegisters = 14; // d0-d13
+ static const int kSizeInBytes = 8;
+
+ static const int kAllocatableLowRangeBegin = 1;
+ static const int kAllocatableLowRangeEnd = 12;
+ static const int kAllocatableHighRangeBegin = 15;
+ static const int kAllocatableHighRangeEnd = 31;
+
+ static const int kNumAllocatableLow =
+ kAllocatableLowRangeEnd - kAllocatableLowRangeBegin + 1;
+ static const int kNumAllocatableHigh =
+ kAllocatableHighRangeEnd - kAllocatableHighRangeBegin + 1;
+ static const int kMaxNumAllocatableRegisters =
+ kNumAllocatableLow + kNumAllocatableHigh;
+ static int NumAllocatableRegisters() { return kMaxNumAllocatableRegisters; }
+
+ // TODO(turbofan)
+ inline static int NumAllocatableAliasedRegisters() {
+ return NumAllocatableRegisters();
+ }
+
+ static int ToAllocationIndex(DoubleRegister reg) {
+ int code = reg.code();
+ int index = (code <= kAllocatableLowRangeEnd)
+ ? code - kAllocatableLowRangeBegin
+ : code - kAllocatableHighRangeBegin + kNumAllocatableLow;
+ DCHECK(index < kMaxNumAllocatableRegisters);
+ return index;
+ }
+
+ static DoubleRegister FromAllocationIndex(int index) {
+ DCHECK(index >= 0 && index < kMaxNumAllocatableRegisters);
+ return (index < kNumAllocatableLow)
+ ? from_code(index + kAllocatableLowRangeBegin)
+ : from_code(index - kNumAllocatableLow +
+ kAllocatableHighRangeBegin);
+ }
+
+ static const char* AllocationIndexToString(int index);
+
+ static DoubleRegister from_code(int code) {
+ DoubleRegister r = {code};
+ return r;
+ }
+
+ bool is_valid() const { return 0 <= code_ && code_ < kMaxNumRegisters; }
+ bool is(DoubleRegister reg) const { return code_ == reg.code_; }
+
+ int code() const {
+ DCHECK(is_valid());
+ return code_;
+ }
+ int bit() const {
+ DCHECK(is_valid());
+ return 1 << code_;
+ }
+ void split_code(int* vm, int* m) const {
+ DCHECK(is_valid());
+ *m = (code_ & 0x10) >> 4;
+ *vm = code_ & 0x0F;
+ }
+
+ int code_;
+};
+
+
+const DoubleRegister no_dreg = {-1};
+const DoubleRegister d0 = {0};
+const DoubleRegister d1 = {1};
+const DoubleRegister d2 = {2};
+const DoubleRegister d3 = {3};
+const DoubleRegister d4 = {4};
+const DoubleRegister d5 = {5};
+const DoubleRegister d6 = {6};
+const DoubleRegister d7 = {7};
+const DoubleRegister d8 = {8};
+const DoubleRegister d9 = {9};
+const DoubleRegister d10 = {10};
+const DoubleRegister d11 = {11};
+const DoubleRegister d12 = {12};
+const DoubleRegister d13 = {13};
+const DoubleRegister d14 = {14};
+const DoubleRegister d15 = {15};
+const DoubleRegister d16 = {16};
+const DoubleRegister d17 = {17};
+const DoubleRegister d18 = {18};
+const DoubleRegister d19 = {19};
+const DoubleRegister d20 = {20};
+const DoubleRegister d21 = {21};
+const DoubleRegister d22 = {22};
+const DoubleRegister d23 = {23};
+const DoubleRegister d24 = {24};
+const DoubleRegister d25 = {25};
+const DoubleRegister d26 = {26};
+const DoubleRegister d27 = {27};
+const DoubleRegister d28 = {28};
+const DoubleRegister d29 = {29};
+const DoubleRegister d30 = {30};
+const DoubleRegister d31 = {31};
+
+// Aliases for double registers. Defined using #define instead of
+// "static const DoubleRegister&" because Clang complains otherwise when a
+// compilation unit that includes this header doesn't use the variables.
+#define kFirstCalleeSavedDoubleReg d14
+#define kLastCalleeSavedDoubleReg d31
+#define kDoubleRegZero d14
+#define kScratchDoubleReg d13
+
+Register ToRegister(int num);
+
+// Coprocessor register
+struct CRegister {
+ bool is_valid() const { return 0 <= code_ && code_ < 16; }
+ bool is(CRegister creg) const { return code_ == creg.code_; }
+ int code() const {
+ DCHECK(is_valid());
+ return code_;
+ }
+ int bit() const {
+ DCHECK(is_valid());
+ return 1 << code_;
+ }
+
+ // Unfortunately we can't make this private in a struct.
+ int code_;
+};
+
+
+const CRegister no_creg = {-1};
+
+const CRegister cr0 = {0};
+const CRegister cr1 = {1};
+const CRegister cr2 = {2};
+const CRegister cr3 = {3};
+const CRegister cr4 = {4};
+const CRegister cr5 = {5};
+const CRegister cr6 = {6};
+const CRegister cr7 = {7};
+const CRegister cr8 = {8};
+const CRegister cr9 = {9};
+const CRegister cr10 = {10};
+const CRegister cr11 = {11};
+const CRegister cr12 = {12};
+const CRegister cr13 = {13};
+const CRegister cr14 = {14};
+const CRegister cr15 = {15};
+
+// -----------------------------------------------------------------------------
+// Machine instruction Operands
+
+#if V8_TARGET_ARCH_PPC64
+const RelocInfo::Mode kRelocInfo_NONEPTR = RelocInfo::NONE64;
+#else
+const RelocInfo::Mode kRelocInfo_NONEPTR = RelocInfo::NONE32;
+#endif
+
+// Class Operand represents a shifter operand in data processing instructions
+class Operand BASE_EMBEDDED {
+ public:
+ // immediate
+ INLINE(explicit Operand(intptr_t immediate,
+ RelocInfo::Mode rmode = kRelocInfo_NONEPTR));
+ INLINE(static Operand Zero()) { return Operand(static_cast<intptr_t>(0)); }
+ INLINE(explicit Operand(const ExternalReference& f));
+ explicit Operand(Handle<Object> handle);
+ INLINE(explicit Operand(Smi* value));
+
+ // rm
+ INLINE(explicit Operand(Register rm));
+
+ // Return true if this is a register operand.
+ INLINE(bool is_reg() const);
+
+ // For mov. Return the number of actual instructions required to
+ // load the operand into a register. This can be anywhere from
+ // one (constant pool small section) to five instructions (full
+ // 64-bit sequence).
+ //
+ // The value returned is only valid as long as no entries are added to the
+ // constant pool between this call and the actual instruction being emitted.
+ bool must_output_reloc_info(const Assembler* assembler) const;
+
+ inline intptr_t immediate() const {
+ DCHECK(!rm_.is_valid());
+ return imm_;
+ }
+
+ Register rm() const { return rm_; }
+
+ private:
+ Register rm_;
+ intptr_t imm_; // valid if rm_ == no_reg
+ RelocInfo::Mode rmode_;
+
+ friend class Assembler;
+ friend class MacroAssembler;
+};
+
+
+// Class MemOperand represents a memory operand in load and store instructions
+// On PowerPC we have base register + 16bit signed value
+// Alternatively we can have a 16bit signed value immediate
+class MemOperand BASE_EMBEDDED {
+ public:
+ explicit MemOperand(Register rn, int32_t offset = 0);
+
+ explicit MemOperand(Register ra, Register rb);
+
+ int32_t offset() const {
+ DCHECK(rb_.is(no_reg));
+ return offset_;
+ }
+
+ // PowerPC - base register
+ Register ra() const {
+ DCHECK(!ra_.is(no_reg));
+ return ra_;
+ }
+
+ Register rb() const {
+ DCHECK(offset_ == 0 && !rb_.is(no_reg));
+ return rb_;
+ }
+
+ private:
+ Register ra_; // base
+ int32_t offset_; // offset
+ Register rb_; // index
+
+ friend class Assembler;
+};
+
+
+#if V8_OOL_CONSTANT_POOL
+// Class used to build a constant pool.
+class ConstantPoolBuilder BASE_EMBEDDED {
+ public:
+ ConstantPoolBuilder();
+ ConstantPoolArray::LayoutSection AddEntry(Assembler* assm,
+ const RelocInfo& rinfo);
+ void Relocate(intptr_t pc_delta);
+ bool IsEmpty();
+ Handle<ConstantPoolArray> New(Isolate* isolate);
+ void Populate(Assembler* assm, ConstantPoolArray* constant_pool);
+
+ inline ConstantPoolArray::LayoutSection current_section() const {
+ return current_section_;
+ }
+
+ // Rather than increasing the capacity of the ConstantPoolArray's
+ // small section to match the longer (16-bit) reach of PPC's load
+ // instruction (at the expense of a larger header to describe the
+ // layout), the PPC implementation utilizes the extended section to
+ // satisfy that reach. I.e. all entries (regardless of their
+ // section) are reachable with a single load instruction.
+ //
+ // This implementation does not support an unlimited constant pool
+ // size (which would require a multi-instruction sequence). [See
+ // ARM commit e27ab337 for a reference on the changes required to
+ // support the longer instruction sequence.] Note, however, that
+ // going down that path will necessarily generate that longer
+ // sequence for all extended section accesses since the placement of
+ // a given entry within the section is not known at the time of
+ // code generation.
+ //
+ // TODO(mbrandy): Determine whether there is a benefit to supporting
+ // the longer sequence given that nops could be used for those
+ // entries which are reachable with a single instruction.
+ inline bool is_full() const { return !is_int16(size_); }
+
+ inline ConstantPoolArray::NumberOfEntries* number_of_entries(
+ ConstantPoolArray::LayoutSection section) {
+ return &number_of_entries_[section];
+ }
+
+ inline ConstantPoolArray::NumberOfEntries* small_entries() {
+ return number_of_entries(ConstantPoolArray::SMALL_SECTION);
+ }
+
+ inline ConstantPoolArray::NumberOfEntries* extended_entries() {
+ return number_of_entries(ConstantPoolArray::EXTENDED_SECTION);
+ }
+
+ private:
+ struct ConstantPoolEntry {
+ ConstantPoolEntry(RelocInfo rinfo, ConstantPoolArray::LayoutSection section,
+ int merged_index)
+ : rinfo_(rinfo), section_(section), merged_index_(merged_index) {}
+
+ RelocInfo rinfo_;
+ ConstantPoolArray::LayoutSection section_;
+ int merged_index_;
+ };
+
+ ConstantPoolArray::Type GetConstantPoolType(RelocInfo::Mode rmode);
+
+ uint32_t size_;
+ std::vector<ConstantPoolEntry> entries_;
+ ConstantPoolArray::LayoutSection current_section_;
+ ConstantPoolArray::NumberOfEntries number_of_entries_[2];
+};
+#endif
+
+
+class Assembler : public AssemblerBase {
+ public:
+ // Create an assembler. Instructions and relocation information are emitted
+ // into a buffer, with the instructions starting from the beginning and the
+ // relocation information starting from the end of the buffer. See CodeDesc
+ // for a detailed comment on the layout (globals.h).
+ //
+ // If the provided buffer is NULL, the assembler allocates and grows its own
+ // buffer, and buffer_size determines the initial buffer size. The buffer is
+ // owned by the assembler and deallocated upon destruction of the assembler.
+ //
+ // If the provided buffer is not NULL, the assembler uses the provided buffer
+ // for code generation and assumes its size to be buffer_size. If the buffer
+ // is too small, a fatal error occurs. No deallocation of the buffer is done
+ // upon destruction of the assembler.
+ Assembler(Isolate* isolate, void* buffer, int buffer_size);
+ virtual ~Assembler() {}
+
+ // GetCode emits any pending (non-emitted) code and fills the descriptor
+ // desc. GetCode() is idempotent; it returns the same result if no other
+ // Assembler functions are invoked in between GetCode() calls.
+ void GetCode(CodeDesc* desc);
+
+ // Label operations & relative jumps (PPUM Appendix D)
+ //
+ // Takes a branch opcode (cc) and a label (L) and generates
+ // either a backward branch or a forward branch and links it
+ // to the label fixup chain. Usage:
+ //
+ // Label L; // unbound label
+ // j(cc, &L); // forward branch to unbound label
+ // bind(&L); // bind label to the current pc
+ // j(cc, &L); // backward branch to bound label
+ // bind(&L); // illegal: a label may be bound only once
+ //
+ // Note: The same Label can be used for forward and backward branches
+ // but it may be bound only once.
+
+ void bind(Label* L); // binds an unbound label L to the current code position
+ // Determines if Label is bound and near enough so that a single
+ // branch instruction can be used to reach it.
+ bool is_near(Label* L, Condition cond);
+
+ // Returns the branch offset to the given label from the current code position
+ // Links the label to the current position if it is still unbound
+ // Manages the jump elimination optimization if the second parameter is true.
+ int branch_offset(Label* L, bool jump_elimination_allowed);
+
+ // Puts a labels target address at the given position.
+ // The high 8 bits are set to zero.
+ void label_at_put(Label* L, int at_offset);
+
+#if V8_OOL_CONSTANT_POOL
+ INLINE(static bool IsConstantPoolLoadStart(Address pc));
+ INLINE(static bool IsConstantPoolLoadEnd(Address pc));
+ INLINE(static int GetConstantPoolOffset(Address pc));
+ INLINE(static void SetConstantPoolOffset(Address pc, int offset));
+
+ // Return the address in the constant pool of the code target address used by
+ // the branch/call instruction at pc, or the object in a mov.
+ INLINE(static Address target_constant_pool_address_at(
+ Address pc, ConstantPoolArray* constant_pool));
+#endif
+
+ // Read/Modify the code target address in the branch/call instruction at pc.
+ INLINE(static Address target_address_at(Address pc,
+ ConstantPoolArray* constant_pool));
+ INLINE(static void set_target_address_at(
+ Address pc, ConstantPoolArray* constant_pool, Address target,
+ ICacheFlushMode icache_flush_mode = FLUSH_ICACHE_IF_NEEDED));
+ INLINE(static Address target_address_at(Address pc, Code* code)) {
+ ConstantPoolArray* constant_pool = code ? code->constant_pool() : NULL;
+ return target_address_at(pc, constant_pool);
+ }
+ INLINE(static void set_target_address_at(
+ Address pc, Code* code, Address target,
+ ICacheFlushMode icache_flush_mode = FLUSH_ICACHE_IF_NEEDED)) {
+ ConstantPoolArray* constant_pool = code ? code->constant_pool() : NULL;
+ set_target_address_at(pc, constant_pool, target, icache_flush_mode);
+ }
+
+ // Return the code target address at a call site from the return address
+ // of that call in the instruction stream.
+ inline static Address target_address_from_return_address(Address pc);
+
+ // Given the address of the beginning of a call, return the address
+ // in the instruction stream that the call will return to.
+ INLINE(static Address return_address_from_call_start(Address pc));
+
+ // Return the code target address of the patch debug break slot
+ INLINE(static Address break_address_from_return_address(Address pc));
+
+ // This sets the branch destination.
+ // This is for calls and branches within generated code.
+ inline static void deserialization_set_special_target_at(
+ Address instruction_payload, Code* code, Address target);
+
+ // Size of an instruction.
+ static const int kInstrSize = sizeof(Instr);
+
+ // Here we are patching the address in the LUI/ORI instruction pair.
+ // These values are used in the serialization process and must be zero for
+ // PPC platform, as Code, Embedded Object or External-reference pointers
+ // are split across two consecutive instructions and don't exist separately
+ // in the code, so the serializer should not step forwards in memory after
+ // a target is resolved and written.
+ static const int kSpecialTargetSize = 0;
+
+// Number of instructions to load an address via a mov sequence.
+#if V8_TARGET_ARCH_PPC64
+ static const int kMovInstructionsConstantPool = 2;
+ static const int kMovInstructionsNoConstantPool = 5;
+#else
+ static const int kMovInstructionsConstantPool = 1;
+ static const int kMovInstructionsNoConstantPool = 2;
+#endif
+#if V8_OOL_CONSTANT_POOL
+ static const int kMovInstructions = kMovInstructionsConstantPool;
+#else
+ static const int kMovInstructions = kMovInstructionsNoConstantPool;
+#endif
+
+ // Distance between the instruction referring to the address of the call
+ // target and the return address.
+
+ // Call sequence is a FIXED_SEQUENCE:
+ // mov r8, @ call address
+ // mtlr r8
+ // blrl
+ // @ return address
+ static const int kCallTargetAddressOffset =
+ (kMovInstructions + 2) * kInstrSize;
+
+ // Distance between start of patched return sequence and the emitted address
+ // to jump to.
+ // Patched return sequence is a FIXED_SEQUENCE:
+ // mov r0, <address>
+ // mtlr r0
+ // blrl
+ static const int kPatchReturnSequenceAddressOffset = 0 * kInstrSize;
+
+ // Distance between start of patched debug break slot and the emitted address
+ // to jump to.
+ // Patched debug break slot code is a FIXED_SEQUENCE:
+ // mov r0, <address>
+ // mtlr r0
+ // blrl
+ static const int kPatchDebugBreakSlotAddressOffset = 0 * kInstrSize;
+
+ // This is the length of the BreakLocationIterator::SetDebugBreakAtReturn()
+ // code patch FIXED_SEQUENCE
+ static const int kJSReturnSequenceInstructions =
+ kMovInstructionsNoConstantPool + 3;
+
+ // This is the length of the code sequence from SetDebugBreakAtSlot()
+ // FIXED_SEQUENCE
+ static const int kDebugBreakSlotInstructions =
+ kMovInstructionsNoConstantPool + 2;
+ static const int kDebugBreakSlotLength =
+ kDebugBreakSlotInstructions * kInstrSize;
+
+ static inline int encode_crbit(const CRegister& cr, enum CRBit crbit) {
+ return ((cr.code() * CRWIDTH) + crbit);
+ }
+
+ // ---------------------------------------------------------------------------
+ // Code generation
+
+ // Insert the smallest number of nop instructions
+ // possible to align the pc offset to a multiple
+ // of m. m must be a power of 2 (>= 4).
+ void Align(int m);
+ // Aligns code to something that's optimal for a jump target for the platform.
+ void CodeTargetAlign();
+
+ // Branch instructions
+ void bclr(BOfield bo, LKBit lk);
+ void blr();
+ void bc(int branch_offset, BOfield bo, int condition_bit, LKBit lk = LeaveLK);
+ void b(int branch_offset, LKBit lk);
+
+ void bcctr(BOfield bo, LKBit lk);
+ void bctr();
+ void bctrl();
+
+ // Convenience branch instructions using labels
+ void b(Label* L, LKBit lk = LeaveLK) { b(branch_offset(L, false), lk); }
+
+ void bc_short(Condition cond, Label* L, CRegister cr = cr7,
+ LKBit lk = LeaveLK) {
+ DCHECK(cond != al);
+ DCHECK(cr.code() >= 0 && cr.code() <= 7);
+
+ int b_offset = branch_offset(L, false);
+
+ switch (cond) {
+ case eq:
+ bc(b_offset, BT, encode_crbit(cr, CR_EQ), lk);
+ break;
+ case ne:
+ bc(b_offset, BF, encode_crbit(cr, CR_EQ), lk);
+ break;
+ case gt:
+ bc(b_offset, BT, encode_crbit(cr, CR_GT), lk);
+ break;
+ case le:
+ bc(b_offset, BF, encode_crbit(cr, CR_GT), lk);
+ break;
+ case lt:
+ bc(b_offset, BT, encode_crbit(cr, CR_LT), lk);
+ break;
+ case ge:
+ bc(b_offset, BF, encode_crbit(cr, CR_LT), lk);
+ break;
+ case unordered:
+ bc(b_offset, BT, encode_crbit(cr, CR_FU), lk);
+ break;
+ case ordered:
+ bc(b_offset, BF, encode_crbit(cr, CR_FU), lk);
+ break;
+ case overflow:
+ bc(b_offset, BT, encode_crbit(cr, CR_SO), lk);
+ break;
+ case nooverflow:
+ bc(b_offset, BF, encode_crbit(cr, CR_SO), lk);
+ break;
+ default:
+ UNIMPLEMENTED();
+ }
+ }
+
+ void b(Condition cond, Label* L, CRegister cr = cr7, LKBit lk = LeaveLK) {
+ if (cond == al) {
+ b(L, lk);
+ return;
+ }
+
+ if ((L->is_bound() && is_near(L, cond)) || !is_trampoline_emitted()) {
+ bc_short(cond, L, cr, lk);
+ return;
+ }
+
+ Label skip;
+ Condition neg_cond = NegateCondition(cond);
+ bc_short(neg_cond, &skip, cr);
+ b(L, lk);
+ bind(&skip);
+ }
+
+ void bne(Label* L, CRegister cr = cr7, LKBit lk = LeaveLK) {
+ b(ne, L, cr, lk);
+ }
+ void beq(Label* L, CRegister cr = cr7, LKBit lk = LeaveLK) {
+ b(eq, L, cr, lk);
+ }
+ void blt(Label* L, CRegister cr = cr7, LKBit lk = LeaveLK) {
+ b(lt, L, cr, lk);
+ }
+ void bge(Label* L, CRegister cr = cr7, LKBit lk = LeaveLK) {
+ b(ge, L, cr, lk);
+ }
+ void ble(Label* L, CRegister cr = cr7, LKBit lk = LeaveLK) {
+ b(le, L, cr, lk);
+ }
+ void bgt(Label* L, CRegister cr = cr7, LKBit lk = LeaveLK) {
+ b(gt, L, cr, lk);
+ }
+ void bunordered(Label* L, CRegister cr = cr7, LKBit lk = LeaveLK) {
+ b(unordered, L, cr, lk);
+ }
+ void bordered(Label* L, CRegister cr = cr7, LKBit lk = LeaveLK) {
+ b(ordered, L, cr, lk);
+ }
+ void boverflow(Label* L, CRegister cr = cr0, LKBit lk = LeaveLK) {
+ b(overflow, L, cr, lk);
+ }
+ void bnooverflow(Label* L, CRegister cr = cr0, LKBit lk = LeaveLK) {
+ b(nooverflow, L, cr, lk);
+ }
+
+ // Decrement CTR; branch if CTR != 0
+ void bdnz(Label* L, LKBit lk = LeaveLK) {
+ bc(branch_offset(L, false), DCBNZ, 0, lk);
+ }
+
+ // Data-processing instructions
+
+ void sub(Register dst, Register src1, Register src2, OEBit s = LeaveOE,
+ RCBit r = LeaveRC);
+
+ void subfic(Register dst, Register src, const Operand& imm);
+
+ void subfc(Register dst, Register src1, Register src2, OEBit s = LeaveOE,
+ RCBit r = LeaveRC);
+
+ void add(Register dst, Register src1, Register src2, OEBit s = LeaveOE,
+ RCBit r = LeaveRC);
+
+ void addc(Register dst, Register src1, Register src2, OEBit o = LeaveOE,
+ RCBit r = LeaveRC);
+
+ void addze(Register dst, Register src1, OEBit o, RCBit r);
+
+ void mullw(Register dst, Register src1, Register src2, OEBit o = LeaveOE,
+ RCBit r = LeaveRC);
+
+ void mulhw(Register dst, Register src1, Register src2, OEBit o = LeaveOE,
+ RCBit r = LeaveRC);
+
+ void divw(Register dst, Register src1, Register src2, OEBit o = LeaveOE,
+ RCBit r = LeaveRC);
+
+ void addi(Register dst, Register src, const Operand& imm);
+ void addis(Register dst, Register src, const Operand& imm);
+ void addic(Register dst, Register src, const Operand& imm);
+
+ void and_(Register dst, Register src1, Register src2, RCBit rc = LeaveRC);
+ void andc(Register dst, Register src1, Register src2, RCBit rc = LeaveRC);
+ void andi(Register ra, Register rs, const Operand& imm);
+ void andis(Register ra, Register rs, const Operand& imm);
+ void nor(Register dst, Register src1, Register src2, RCBit r = LeaveRC);
+ void notx(Register dst, Register src, RCBit r = LeaveRC);
+ void ori(Register dst, Register src, const Operand& imm);
+ void oris(Register dst, Register src, const Operand& imm);
+ void orx(Register dst, Register src1, Register src2, RCBit rc = LeaveRC);
+ void xori(Register dst, Register src, const Operand& imm);
+ void xoris(Register ra, Register rs, const Operand& imm);
+ void xor_(Register dst, Register src1, Register src2, RCBit rc = LeaveRC);
+ void cmpi(Register src1, const Operand& src2, CRegister cr = cr7);
+ void cmpli(Register src1, const Operand& src2, CRegister cr = cr7);
+ void cmpwi(Register src1, const Operand& src2, CRegister cr = cr7);
+ void cmplwi(Register src1, const Operand& src2, CRegister cr = cr7);
+ void li(Register dst, const Operand& src);
+ void lis(Register dst, const Operand& imm);
+ void mr(Register dst, Register src);
+
+ void lbz(Register dst, const MemOperand& src);
+ void lbzx(Register dst, const MemOperand& src);
+ void lbzux(Register dst, const MemOperand& src);
+ void lhz(Register dst, const MemOperand& src);
+ void lhzx(Register dst, const MemOperand& src);
+ void lhzux(Register dst, const MemOperand& src);
+ void lwz(Register dst, const MemOperand& src);
+ void lwzu(Register dst, const MemOperand& src);
+ void lwzx(Register dst, const MemOperand& src);
+ void lwzux(Register dst, const MemOperand& src);
+ void lwa(Register dst, const MemOperand& src);
+ void stb(Register dst, const MemOperand& src);
+ void stbx(Register dst, const MemOperand& src);
+ void stbux(Register dst, const MemOperand& src);
+ void sth(Register dst, const MemOperand& src);
+ void sthx(Register dst, const MemOperand& src);
+ void sthux(Register dst, const MemOperand& src);
+ void stw(Register dst, const MemOperand& src);
+ void stwu(Register dst, const MemOperand& src);
+ void stwx(Register rs, const MemOperand& src);
+ void stwux(Register rs, const MemOperand& src);
+
+ void extsb(Register rs, Register ra, RCBit r = LeaveRC);
+ void extsh(Register rs, Register ra, RCBit r = LeaveRC);
+
+ void neg(Register rt, Register ra, OEBit o = LeaveOE, RCBit c = LeaveRC);
+
+#if V8_TARGET_ARCH_PPC64
+ void ld(Register rd, const MemOperand& src);
+ void ldx(Register rd, const MemOperand& src);
+ void ldu(Register rd, const MemOperand& src);
+ void ldux(Register rd, const MemOperand& src);
+ void std(Register rs, const MemOperand& src);
+ void stdx(Register rs, const MemOperand& src);
+ void stdu(Register rs, const MemOperand& src);
+ void stdux(Register rs, const MemOperand& src);
+ void rldic(Register dst, Register src, int sh, int mb, RCBit r = LeaveRC);
+ void rldicl(Register dst, Register src, int sh, int mb, RCBit r = LeaveRC);
+ void rldcl(Register ra, Register rs, Register rb, int mb, RCBit r = LeaveRC);
+ void rldicr(Register dst, Register src, int sh, int me, RCBit r = LeaveRC);
+ void rldimi(Register dst, Register src, int sh, int mb, RCBit r = LeaveRC);
+ void sldi(Register dst, Register src, const Operand& val, RCBit rc = LeaveRC);
+ void srdi(Register dst, Register src, const Operand& val, RCBit rc = LeaveRC);
+ void clrrdi(Register dst, Register src, const Operand& val,
+ RCBit rc = LeaveRC);
+ void clrldi(Register dst, Register src, const Operand& val,
+ RCBit rc = LeaveRC);
+ void sradi(Register ra, Register rs, int sh, RCBit r = LeaveRC);
+ void srd(Register dst, Register src1, Register src2, RCBit r = LeaveRC);
+ void sld(Register dst, Register src1, Register src2, RCBit r = LeaveRC);
+ void srad(Register dst, Register src1, Register src2, RCBit r = LeaveRC);
+ void rotld(Register ra, Register rs, Register rb, RCBit r = LeaveRC);
+ void rotldi(Register ra, Register rs, int sh, RCBit r = LeaveRC);
+ void rotrdi(Register ra, Register rs, int sh, RCBit r = LeaveRC);
+ void cntlzd_(Register dst, Register src, RCBit rc = LeaveRC);
+ void extsw(Register rs, Register ra, RCBit r = LeaveRC);
+ void mulld(Register dst, Register src1, Register src2, OEBit o = LeaveOE,
+ RCBit r = LeaveRC);
+ void divd(Register dst, Register src1, Register src2, OEBit o = LeaveOE,
+ RCBit r = LeaveRC);
+#endif
+
+ void rlwinm(Register ra, Register rs, int sh, int mb, int me,
+ RCBit rc = LeaveRC);
+ void rlwimi(Register ra, Register rs, int sh, int mb, int me,
+ RCBit rc = LeaveRC);
+ void rlwnm(Register ra, Register rs, Register rb, int mb, int me,
+ RCBit rc = LeaveRC);
+ void slwi(Register dst, Register src, const Operand& val, RCBit rc = LeaveRC);
+ void srwi(Register dst, Register src, const Operand& val, RCBit rc = LeaveRC);
+ void clrrwi(Register dst, Register src, const Operand& val,
+ RCBit rc = LeaveRC);
+ void clrlwi(Register dst, Register src, const Operand& val,
+ RCBit rc = LeaveRC);
+ void srawi(Register ra, Register rs, int sh, RCBit r = LeaveRC);
+ void srw(Register dst, Register src1, Register src2, RCBit r = LeaveRC);
+ void slw(Register dst, Register src1, Register src2, RCBit r = LeaveRC);
+ void sraw(Register dst, Register src1, Register src2, RCBit r = LeaveRC);
+ void rotlw(Register ra, Register rs, Register rb, RCBit r = LeaveRC);
+ void rotlwi(Register ra, Register rs, int sh, RCBit r = LeaveRC);
+ void rotrwi(Register ra, Register rs, int sh, RCBit r = LeaveRC);
+
+ void cntlzw_(Register dst, Register src, RCBit rc = LeaveRC);
+
+ void subi(Register dst, Register src1, const Operand& src2);
+
+ void cmp(Register src1, Register src2, CRegister cr = cr7);
+ void cmpl(Register src1, Register src2, CRegister cr = cr7);
+ void cmpw(Register src1, Register src2, CRegister cr = cr7);
+ void cmplw(Register src1, Register src2, CRegister cr = cr7);
+
+ void mov(Register dst, const Operand& src);
+
+ // Load the position of the label relative to the generated code object
+ // pointer in a register.
+ void mov_label_offset(Register dst, Label* label);
+
+ // Multiply instructions
+ void mul(Register dst, Register src1, Register src2, OEBit s = LeaveOE,
+ RCBit r = LeaveRC);
+
+ // Miscellaneous arithmetic instructions
+
+ // Special register access
+ void crxor(int bt, int ba, int bb);
+ void crclr(int bt) { crxor(bt, bt, bt); }
+ void creqv(int bt, int ba, int bb);
+ void crset(int bt) { creqv(bt, bt, bt); }
+ void mflr(Register dst);
+ void mtlr(Register src);
+ void mtctr(Register src);
+ void mtxer(Register src);
+ void mcrfs(int bf, int bfa);
+ void mfcr(Register dst);
+#if V8_TARGET_ARCH_PPC64
+ void mffprd(Register dst, DoubleRegister src);
+ void mffprwz(Register dst, DoubleRegister src);
+ void mtfprd(DoubleRegister dst, Register src);
+ void mtfprwz(DoubleRegister dst, Register src);
+ void mtfprwa(DoubleRegister dst, Register src);
+#endif
+
+ void fake_asm(enum FAKE_OPCODE_T fopcode);
+ void marker_asm(int mcode);
+ void function_descriptor();
+
+ // Exception-generating instructions and debugging support
+ void stop(const char* msg, Condition cond = al,
+ int32_t code = kDefaultStopCode, CRegister cr = cr7);
+
+ void bkpt(uint32_t imm16); // v5 and above
+
+ // Informational messages when simulating
+ void info(const char* msg, Condition cond = al,
+ int32_t code = kDefaultStopCode, CRegister cr = cr7);
+
+ void dcbf(Register ra, Register rb);
+ void sync();
+ void lwsync();
+ void icbi(Register ra, Register rb);
+ void isync();
+
+ // Support for floating point
+ void lfd(const DoubleRegister frt, const MemOperand& src);
+ void lfdu(const DoubleRegister frt, const MemOperand& src);
+ void lfdx(const DoubleRegister frt, const MemOperand& src);
+ void lfdux(const DoubleRegister frt, const MemOperand& src);
+ void lfs(const DoubleRegister frt, const MemOperand& src);
+ void lfsu(const DoubleRegister frt, const MemOperand& src);
+ void lfsx(const DoubleRegister frt, const MemOperand& src);
+ void lfsux(const DoubleRegister frt, const MemOperand& src);
+ void stfd(const DoubleRegister frs, const MemOperand& src);
+ void stfdu(const DoubleRegister frs, const MemOperand& src);
+ void stfdx(const DoubleRegister frs, const MemOperand& src);
+ void stfdux(const DoubleRegister frs, const MemOperand& src);
+ void stfs(const DoubleRegister frs, const MemOperand& src);
+ void stfsu(const DoubleRegister frs, const MemOperand& src);
+ void stfsx(const DoubleRegister frs, const MemOperand& src);
+ void stfsux(const DoubleRegister frs, const MemOperand& src);
+
+ void fadd(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frb, RCBit rc = LeaveRC);
+ void fsub(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frb, RCBit rc = LeaveRC);
+ void fdiv(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frb, RCBit rc = LeaveRC);
+ void fmul(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frc, RCBit rc = LeaveRC);
+ void fcmpu(const DoubleRegister fra, const DoubleRegister frb,
+ CRegister cr = cr7);
+ void fmr(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc = LeaveRC);
+ void fctiwz(const DoubleRegister frt, const DoubleRegister frb);
+ void fctiw(const DoubleRegister frt, const DoubleRegister frb);
+ void frim(const DoubleRegister frt, const DoubleRegister frb);
+ void frsp(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc = LeaveRC);
+ void fcfid(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc = LeaveRC);
+ void fctid(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc = LeaveRC);
+ void fctidz(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc = LeaveRC);
+ void fsel(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frc, const DoubleRegister frb,
+ RCBit rc = LeaveRC);
+ void fneg(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc = LeaveRC);
+ void mtfsfi(int bf, int immediate, RCBit rc = LeaveRC);
+ void mffs(const DoubleRegister frt, RCBit rc = LeaveRC);
+ void mtfsf(const DoubleRegister frb, bool L = 1, int FLM = 0, bool W = 0,
+ RCBit rc = LeaveRC);
+ void fsqrt(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc = LeaveRC);
+ void fabs(const DoubleRegister frt, const DoubleRegister frb,
+ RCBit rc = LeaveRC);
+ void fmadd(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frc, const DoubleRegister frb,
+ RCBit rc = LeaveRC);
+ void fmsub(const DoubleRegister frt, const DoubleRegister fra,
+ const DoubleRegister frc, const DoubleRegister frb,
+ RCBit rc = LeaveRC);
+
+ // Pseudo instructions
+
+ // Different nop operations are used by the code generator to detect certain
+ // states of the generated code.
+ enum NopMarkerTypes {
+ NON_MARKING_NOP = 0,
+ GROUP_ENDING_NOP,
+ DEBUG_BREAK_NOP,
+ // IC markers.
+ PROPERTY_ACCESS_INLINED,
+ PROPERTY_ACCESS_INLINED_CONTEXT,
+ PROPERTY_ACCESS_INLINED_CONTEXT_DONT_DELETE,
+ // Helper values.
+ LAST_CODE_MARKER,
+ FIRST_IC_MARKER = PROPERTY_ACCESS_INLINED
+ };
+
+ void nop(int type = 0); // 0 is the default non-marking type.
+
+ void push(Register src) {
+#if V8_TARGET_ARCH_PPC64
+ stdu(src, MemOperand(sp, -kPointerSize));
+#else
+ stwu(src, MemOperand(sp, -kPointerSize));
+#endif
+ }
+
+ void pop(Register dst) {
+#if V8_TARGET_ARCH_PPC64
+ ld(dst, MemOperand(sp));
+#else
+ lwz(dst, MemOperand(sp));
+#endif
+ addi(sp, sp, Operand(kPointerSize));
+ }
+
+ void pop() { addi(sp, sp, Operand(kPointerSize)); }
+
+ // Jump unconditionally to given label.
+ void jmp(Label* L) { b(L); }
+
+ // Check the code size generated from label to here.
+ int SizeOfCodeGeneratedSince(Label* label) {
+ return pc_offset() - label->pos();
+ }
+
+ // Check the number of instructions generated from label to here.
+ int InstructionsGeneratedSince(Label* label) {
+ return SizeOfCodeGeneratedSince(label) / kInstrSize;
+ }
+
+ // Class for scoping postponing the trampoline pool generation.
+ class BlockTrampolinePoolScope {
+ public:
+ explicit BlockTrampolinePoolScope(Assembler* assem) : assem_(assem) {
+ assem_->StartBlockTrampolinePool();
+ }
+ ~BlockTrampolinePoolScope() { assem_->EndBlockTrampolinePool(); }
+
+ private:
+ Assembler* assem_;
+
+ DISALLOW_IMPLICIT_CONSTRUCTORS(BlockTrampolinePoolScope);
+ };
+
+ // Debugging
+
+ // Mark address of the ExitJSFrame code.
+ void RecordJSReturn();
+
+ // Mark address of a debug break slot.
+ void RecordDebugBreakSlot();
+
+ // Record the AST id of the CallIC being compiled, so that it can be placed
+ // in the relocation information.
+ void SetRecordedAstId(TypeFeedbackId ast_id) {
+ // Causes compiler to fail
+ // DCHECK(recorded_ast_id_.IsNone());
+ recorded_ast_id_ = ast_id;
+ }
+
+ TypeFeedbackId RecordedAstId() {
+ // Causes compiler to fail
+ // DCHECK(!recorded_ast_id_.IsNone());
+ return recorded_ast_id_;
+ }
+
+ void ClearRecordedAstId() { recorded_ast_id_ = TypeFeedbackId::None(); }
+
+ // Record a comment relocation entry that can be used by a disassembler.
+ // Use --code-comments to enable.
+ void RecordComment(const char* msg);
+
+ // Writes a single byte or word of data in the code stream. Used
+ // for inline tables, e.g., jump-tables.
+ void db(uint8_t data);
+ void dd(uint32_t data);
+ void emit_ptr(uintptr_t data);
+
+ PositionsRecorder* positions_recorder() { return &positions_recorder_; }
+
+ // Read/patch instructions
+ Instr instr_at(int pos) { return *reinterpret_cast<Instr*>(buffer_ + pos); }
+ void instr_at_put(int pos, Instr instr) {
+ *reinterpret_cast<Instr*>(buffer_ + pos) = instr;
+ }
+ static Instr instr_at(byte* pc) { return *reinterpret_cast<Instr*>(pc); }
+ static void instr_at_put(byte* pc, Instr instr) {
+ *reinterpret_cast<Instr*>(pc) = instr;
+ }
+ static Condition GetCondition(Instr instr);
+
+ static bool IsLis(Instr instr);
+ static bool IsLi(Instr instr);
+ static bool IsAddic(Instr instr);
+ static bool IsOri(Instr instr);
+
+ static bool IsBranch(Instr instr);
+ static Register GetRA(Instr instr);
+ static Register GetRB(Instr instr);
+#if V8_TARGET_ARCH_PPC64
+ static bool Is64BitLoadIntoR12(Instr instr1, Instr instr2, Instr instr3,
+ Instr instr4, Instr instr5);
+#else
+ static bool Is32BitLoadIntoR12(Instr instr1, Instr instr2);
+#endif
+
+ static bool IsCmpRegister(Instr instr);
+ static bool IsCmpImmediate(Instr instr);
+ static bool IsRlwinm(Instr instr);
+#if V8_TARGET_ARCH_PPC64
+ static bool IsRldicl(Instr instr);
+#endif
+ static bool IsCrSet(Instr instr);
+ static Register GetCmpImmediateRegister(Instr instr);
+ static int GetCmpImmediateRawImmediate(Instr instr);
+ static bool IsNop(Instr instr, int type = NON_MARKING_NOP);
+
+ // Postpone the generation of the trampoline pool for the specified number of
+ // instructions.
+ void BlockTrampolinePoolFor(int instructions);
+ void CheckTrampolinePool();
+
+ int instructions_required_for_mov(const Operand& x) const;
+
+#if V8_OOL_CONSTANT_POOL
+ // Decide between using the constant pool vs. a mov immediate sequence.
+ bool use_constant_pool_for_mov(const Operand& x, bool canOptimize) const;
+
+ // The code currently calls CheckBuffer() too often. This has the side
+ // effect of randomly growing the buffer in the middle of multi-instruction
+ // sequences.
+ // MacroAssembler::LoadConstantPoolPointerRegister() includes a relocation
+ // and multiple instructions. We cannot grow the buffer until the
+ // relocation and all of the instructions are written.
+ //
+ // This function allows outside callers to check and grow the buffer
+ void EnsureSpaceFor(int space_needed);
+#endif
+
+ // Allocate a constant pool of the correct size for the generated code.
+ Handle<ConstantPoolArray> NewConstantPool(Isolate* isolate);
+
+ // Generate the constant pool for the generated code.
+ void PopulateConstantPool(ConstantPoolArray* constant_pool);
+
+#if V8_OOL_CONSTANT_POOL
+ bool is_constant_pool_full() const {
+ return constant_pool_builder_.is_full();
+ }
+
+ bool use_extended_constant_pool() const {
+ return constant_pool_builder_.current_section() ==
+ ConstantPoolArray::EXTENDED_SECTION;
+ }
+#endif
+
+#if ABI_USES_FUNCTION_DESCRIPTORS || V8_OOL_CONSTANT_POOL
+ static void RelocateInternalReference(
+ Address pc, intptr_t delta, Address code_start,
+ ICacheFlushMode icache_flush_mode = FLUSH_ICACHE_IF_NEEDED);
+ static int DecodeInternalReference(Vector<char> buffer, Address pc);
+#endif
+
+ protected:
+ // Relocation for a type-recording IC has the AST id added to it. This
+ // member variable is a way to pass the information from the call site to
+ // the relocation info.
+ TypeFeedbackId recorded_ast_id_;
+
+ int buffer_space() const { return reloc_info_writer.pos() - pc_; }
+
+ // Decode branch instruction at pos and return branch target pos
+ int target_at(int pos);
+
+ // Patch branch instruction at pos to branch to given branch target pos
+ void target_at_put(int pos, int target_pos);
+
+ // Record reloc info for current pc_
+ void RecordRelocInfo(RelocInfo::Mode rmode, intptr_t data = 0);
+ void RecordRelocInfo(const RelocInfo& rinfo);
+#if V8_OOL_CONSTANT_POOL
+ ConstantPoolArray::LayoutSection ConstantPoolAddEntry(
+ const RelocInfo& rinfo) {
+ return constant_pool_builder_.AddEntry(this, rinfo);
+ }
+#endif
+
+ // Block the emission of the trampoline pool before pc_offset.
+ void BlockTrampolinePoolBefore(int pc_offset) {
+ if (no_trampoline_pool_before_ < pc_offset)
+ no_trampoline_pool_before_ = pc_offset;
+ }
+
+ void StartBlockTrampolinePool() { trampoline_pool_blocked_nesting_++; }
+
+ void EndBlockTrampolinePool() { trampoline_pool_blocked_nesting_--; }
+
+ bool is_trampoline_pool_blocked() const {
+ return trampoline_pool_blocked_nesting_ > 0;
+ }
+
+ bool has_exception() const { return internal_trampoline_exception_; }
+
+ bool is_trampoline_emitted() const { return trampoline_emitted_; }
+
+#if V8_OOL_CONSTANT_POOL
+ void set_constant_pool_available(bool available) {
+ constant_pool_available_ = available;
+ }
+#endif
+
+ private:
+ // Code generation
+ // The relocation writer's position is at least kGap bytes below the end of
+ // the generated instructions. This is so that multi-instruction sequences do
+ // not have to check for overflow. The same is true for writes of large
+ // relocation info entries.
+ static const int kGap = 32;
+
+ // Repeated checking whether the trampoline pool should be emitted is rather
+ // expensive. By default we only check again once a number of instructions
+ // has been generated.
+ int next_buffer_check_; // pc offset of next buffer check.
+
+ // Emission of the trampoline pool may be blocked in some code sequences.
+ int trampoline_pool_blocked_nesting_; // Block emission if this is not zero.
+ int no_trampoline_pool_before_; // Block emission before this pc offset.
+
+ // Relocation info generation
+ // Each relocation is encoded as a variable size value
+ static const int kMaxRelocSize = RelocInfoWriter::kMaxSize;
+ RelocInfoWriter reloc_info_writer;
+
+ // The bound position, before this we cannot do instruction elimination.
+ int last_bound_pos_;
+
+#if V8_OOL_CONSTANT_POOL
+ ConstantPoolBuilder constant_pool_builder_;
+#endif
+
+ // Code emission
+ inline void CheckBuffer();
+ void GrowBuffer();
+ inline void emit(Instr x);
+ inline void CheckTrampolinePoolQuick();
+
+ // Instruction generation
+ void a_form(Instr instr, DoubleRegister frt, DoubleRegister fra,
+ DoubleRegister frb, RCBit r);
+ void d_form(Instr instr, Register rt, Register ra, const intptr_t val,
+ bool signed_disp);
+ void x_form(Instr instr, Register ra, Register rs, Register rb, RCBit r);
+ void xo_form(Instr instr, Register rt, Register ra, Register rb, OEBit o,
+ RCBit r);
+ void md_form(Instr instr, Register ra, Register rs, int shift, int maskbit,
+ RCBit r);
+ void mds_form(Instr instr, Register ra, Register rs, Register rb, int maskbit,
+ RCBit r);
+
+ // Labels
+ void print(Label* L);
+ int max_reach_from(int pos);
+ void bind_to(Label* L, int pos);
+ void next(Label* L);
+
+ class Trampoline {
+ public:
+ Trampoline() {
+ next_slot_ = 0;
+ free_slot_count_ = 0;
+ }
+ Trampoline(int start, int slot_count) {
+ next_slot_ = start;
+ free_slot_count_ = slot_count;
+ }
+ int take_slot() {
+ int trampoline_slot = kInvalidSlotPos;
+ if (free_slot_count_ <= 0) {
+ // We have run out of space on trampolines.
+ // Make sure we fail in debug mode, so we become aware of each case
+ // when this happens.
+ DCHECK(0);
+ // Internal exception will be caught.
+ } else {
+ trampoline_slot = next_slot_;
+ free_slot_count_--;
+ next_slot_ += kTrampolineSlotsSize;
+ }
+ return trampoline_slot;
+ }
+
+ private:
+ int next_slot_;
+ int free_slot_count_;
+ };
+
+ int32_t get_trampoline_entry();
+ int unbound_labels_count_;
+ // If trampoline is emitted, generated code is becoming large. As
+ // this is already a slow case which can possibly break our code
+ // generation for the extreme case, we use this information to
+ // trigger different mode of branch instruction generation, where we
+ // no longer use a single branch instruction.
+ bool trampoline_emitted_;
+ static const int kTrampolineSlotsSize = kInstrSize;
+ static const int kMaxCondBranchReach = (1 << (16 - 1)) - 1;
+ static const int kMaxBlockTrampolineSectionSize = 64 * kInstrSize;
+ static const int kInvalidSlotPos = -1;
+
+ Trampoline trampoline_;
+ bool internal_trampoline_exception_;
+
+ friend class RegExpMacroAssemblerPPC;
+ friend class RelocInfo;
+ friend class CodePatcher;
+ friend class BlockTrampolinePoolScope;
+ PositionsRecorder positions_recorder_;
+ friend class PositionsRecorder;
+ friend class EnsureSpace;
+};
+
+
+class EnsureSpace BASE_EMBEDDED {
+ public:
+ explicit EnsureSpace(Assembler* assembler) { assembler->CheckBuffer(); }
+};
+}
+} // namespace v8::internal
+
+#endif // V8_PPC_ASSEMBLER_PPC_H_
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/codegen.h"
+#include "src/debug.h"
+#include "src/deoptimizer.h"
+#include "src/full-codegen.h"
+#include "src/runtime/runtime.h"
+
+namespace v8 {
+namespace internal {
+
+
+#define __ ACCESS_MASM(masm)
+
+
+void Builtins::Generate_Adaptor(MacroAssembler* masm, CFunctionId id,
+ BuiltinExtraArguments extra_args) {
+ // ----------- S t a t e -------------
+ // -- r3 : number of arguments excluding receiver
+ // -- r4 : called function (only guaranteed when
+ // extra_args requires it)
+ // -- cp : context
+ // -- sp[0] : last argument
+ // -- ...
+ // -- sp[4 * (argc - 1)] : first argument (argc == r0)
+ // -- sp[4 * argc] : receiver
+ // -----------------------------------
+
+ // Insert extra arguments.
+ int num_extra_args = 0;
+ if (extra_args == NEEDS_CALLED_FUNCTION) {
+ num_extra_args = 1;
+ __ push(r4);
+ } else {
+ DCHECK(extra_args == NO_EXTRA_ARGUMENTS);
+ }
+
+ // JumpToExternalReference expects r0 to contain the number of arguments
+ // including the receiver and the extra arguments.
+ __ addi(r3, r3, Operand(num_extra_args + 1));
+ __ JumpToExternalReference(ExternalReference(id, masm->isolate()));
+}
+
+
+// Load the built-in InternalArray function from the current context.
+static void GenerateLoadInternalArrayFunction(MacroAssembler* masm,
+ Register result) {
+ // Load the native context.
+
+ __ LoadP(result,
+ MemOperand(cp, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
+ __ LoadP(result, FieldMemOperand(result, GlobalObject::kNativeContextOffset));
+ // Load the InternalArray function from the native context.
+ __ LoadP(result,
+ MemOperand(result, Context::SlotOffset(
+ Context::INTERNAL_ARRAY_FUNCTION_INDEX)));
+}
+
+
+// Load the built-in Array function from the current context.
+static void GenerateLoadArrayFunction(MacroAssembler* masm, Register result) {
+ // Load the native context.
+
+ __ LoadP(result,
+ MemOperand(cp, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
+ __ LoadP(result, FieldMemOperand(result, GlobalObject::kNativeContextOffset));
+ // Load the Array function from the native context.
+ __ LoadP(
+ result,
+ MemOperand(result, Context::SlotOffset(Context::ARRAY_FUNCTION_INDEX)));
+}
+
+
+void Builtins::Generate_InternalArrayCode(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- r3 : number of arguments
+ // -- lr : return address
+ // -- sp[...]: constructor arguments
+ // -----------------------------------
+ Label generic_array_code, one_or_more_arguments, two_or_more_arguments;
+
+ // Get the InternalArray function.
+ GenerateLoadInternalArrayFunction(masm, r4);
+
+ if (FLAG_debug_code) {
+ // Initial map for the builtin InternalArray functions should be maps.
+ __ LoadP(r5, FieldMemOperand(r4, JSFunction::kPrototypeOrInitialMapOffset));
+ __ TestIfSmi(r5, r0);
+ __ Assert(ne, kUnexpectedInitialMapForInternalArrayFunction, cr0);
+ __ CompareObjectType(r5, r6, r7, MAP_TYPE);
+ __ Assert(eq, kUnexpectedInitialMapForInternalArrayFunction);
+ }
+
+ // Run the native code for the InternalArray function called as a normal
+ // function.
+ // tail call a stub
+ InternalArrayConstructorStub stub(masm->isolate());
+ __ TailCallStub(&stub);
+}
+
+
+void Builtins::Generate_ArrayCode(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- r3 : number of arguments
+ // -- lr : return address
+ // -- sp[...]: constructor arguments
+ // -----------------------------------
+ Label generic_array_code, one_or_more_arguments, two_or_more_arguments;
+
+ // Get the Array function.
+ GenerateLoadArrayFunction(masm, r4);
+
+ if (FLAG_debug_code) {
+ // Initial map for the builtin Array functions should be maps.
+ __ LoadP(r5, FieldMemOperand(r4, JSFunction::kPrototypeOrInitialMapOffset));
+ __ TestIfSmi(r5, r0);
+ __ Assert(ne, kUnexpectedInitialMapForArrayFunction, cr0);
+ __ CompareObjectType(r5, r6, r7, MAP_TYPE);
+ __ Assert(eq, kUnexpectedInitialMapForArrayFunction);
+ }
+
+ // Run the native code for the Array function called as a normal function.
+ // tail call a stub
+ __ LoadRoot(r5, Heap::kUndefinedValueRootIndex);
+ ArrayConstructorStub stub(masm->isolate());
+ __ TailCallStub(&stub);
+}
+
+
+void Builtins::Generate_StringConstructCode(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- r3 : number of arguments
+ // -- r4 : constructor function
+ // -- lr : return address
+ // -- sp[(argc - n - 1) * 4] : arg[n] (zero based)
+ // -- sp[argc * 4] : receiver
+ // -----------------------------------
+ Counters* counters = masm->isolate()->counters();
+ __ IncrementCounter(counters->string_ctor_calls(), 1, r5, r6);
+
+ Register function = r4;
+ if (FLAG_debug_code) {
+ __ LoadGlobalFunction(Context::STRING_FUNCTION_INDEX, r5);
+ __ cmp(function, r5);
+ __ Assert(eq, kUnexpectedStringFunction);
+ }
+
+ // Load the first arguments in r3 and get rid of the rest.
+ Label no_arguments;
+ __ cmpi(r3, Operand::Zero());
+ __ beq(&no_arguments);
+ // First args = sp[(argc - 1) * 4].
+ __ subi(r3, r3, Operand(1));
+ __ ShiftLeftImm(r3, r3, Operand(kPointerSizeLog2));
+ __ add(sp, sp, r3);
+ __ LoadP(r3, MemOperand(sp));
+ // sp now point to args[0], drop args[0] + receiver.
+ __ Drop(2);
+
+ Register argument = r5;
+ Label not_cached, argument_is_string;
+ __ LookupNumberStringCache(r3, // Input.
+ argument, // Result.
+ r6, // Scratch.
+ r7, // Scratch.
+ r8, // Scratch.
+ ¬_cached);
+ __ IncrementCounter(counters->string_ctor_cached_number(), 1, r6, r7);
+ __ bind(&argument_is_string);
+
+ // ----------- S t a t e -------------
+ // -- r5 : argument converted to string
+ // -- r4 : constructor function
+ // -- lr : return address
+ // -----------------------------------
+
+ Label gc_required;
+ __ Allocate(JSValue::kSize,
+ r3, // Result.
+ r6, // Scratch.
+ r7, // Scratch.
+ &gc_required, TAG_OBJECT);
+
+ // Initialising the String Object.
+ Register map = r6;
+ __ LoadGlobalFunctionInitialMap(function, map, r7);
+ if (FLAG_debug_code) {
+ __ lbz(r7, FieldMemOperand(map, Map::kInstanceSizeOffset));
+ __ cmpi(r7, Operand(JSValue::kSize >> kPointerSizeLog2));
+ __ Assert(eq, kUnexpectedStringWrapperInstanceSize);
+ __ lbz(r7, FieldMemOperand(map, Map::kUnusedPropertyFieldsOffset));
+ __ cmpi(r7, Operand::Zero());
+ __ Assert(eq, kUnexpectedUnusedPropertiesOfStringWrapper);
+ }
+ __ StoreP(map, FieldMemOperand(r3, HeapObject::kMapOffset), r0);
+
+ __ LoadRoot(r6, Heap::kEmptyFixedArrayRootIndex);
+ __ StoreP(r6, FieldMemOperand(r3, JSObject::kPropertiesOffset), r0);
+ __ StoreP(r6, FieldMemOperand(r3, JSObject::kElementsOffset), r0);
+
+ __ StoreP(argument, FieldMemOperand(r3, JSValue::kValueOffset), r0);
+
+ // Ensure the object is fully initialized.
+ STATIC_ASSERT(JSValue::kSize == 4 * kPointerSize);
+
+ __ Ret();
+
+ // The argument was not found in the number to string cache. Check
+ // if it's a string already before calling the conversion builtin.
+ Label convert_argument;
+ __ bind(¬_cached);
+ __ JumpIfSmi(r3, &convert_argument);
+
+ // Is it a String?
+ __ LoadP(r5, FieldMemOperand(r3, HeapObject::kMapOffset));
+ __ lbz(r6, FieldMemOperand(r5, Map::kInstanceTypeOffset));
+ STATIC_ASSERT(kNotStringTag != 0);
+ __ andi(r0, r6, Operand(kIsNotStringMask));
+ __ bne(&convert_argument, cr0);
+ __ mr(argument, r3);
+ __ IncrementCounter(counters->string_ctor_conversions(), 1, r6, r7);
+ __ b(&argument_is_string);
+
+ // Invoke the conversion builtin and put the result into r5.
+ __ bind(&convert_argument);
+ __ push(function); // Preserve the function.
+ __ IncrementCounter(counters->string_ctor_conversions(), 1, r6, r7);
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+ __ push(r3);
+ __ InvokeBuiltin(Builtins::TO_STRING, CALL_FUNCTION);
+ }
+ __ pop(function);
+ __ mr(argument, r3);
+ __ b(&argument_is_string);
+
+ // Load the empty string into r5, remove the receiver from the
+ // stack, and jump back to the case where the argument is a string.
+ __ bind(&no_arguments);
+ __ LoadRoot(argument, Heap::kempty_stringRootIndex);
+ __ Drop(1);
+ __ b(&argument_is_string);
+
+ // At this point the argument is already a string. Call runtime to
+ // create a string wrapper.
+ __ bind(&gc_required);
+ __ IncrementCounter(counters->string_ctor_gc_required(), 1, r6, r7);
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+ __ push(argument);
+ __ CallRuntime(Runtime::kNewStringWrapper, 1);
+ }
+ __ Ret();
+}
+
+
+static void CallRuntimePassFunction(MacroAssembler* masm,
+ Runtime::FunctionId function_id) {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+ // Push a copy of the function onto the stack.
+ // Push function as parameter to the runtime call.
+ __ Push(r4, r4);
+
+ __ CallRuntime(function_id, 1);
+ // Restore reciever.
+ __ Pop(r4);
+}
+
+
+static void GenerateTailCallToSharedCode(MacroAssembler* masm) {
+ __ LoadP(ip, FieldMemOperand(r4, JSFunction::kSharedFunctionInfoOffset));
+ __ LoadP(ip, FieldMemOperand(ip, SharedFunctionInfo::kCodeOffset));
+ __ addi(ip, ip, Operand(Code::kHeaderSize - kHeapObjectTag));
+ __ JumpToJSEntry(ip);
+}
+
+
+static void GenerateTailCallToReturnedCode(MacroAssembler* masm) {
+ __ addi(ip, r3, Operand(Code::kHeaderSize - kHeapObjectTag));
+ __ JumpToJSEntry(ip);
+}
+
+
+void Builtins::Generate_InOptimizationQueue(MacroAssembler* masm) {
+ // Checking whether the queued function is ready for install is optional,
+ // since we come across interrupts and stack checks elsewhere. However,
+ // not checking may delay installing ready functions, and always checking
+ // would be quite expensive. A good compromise is to first check against
+ // stack limit as a cue for an interrupt signal.
+ Label ok;
+ __ LoadRoot(ip, Heap::kStackLimitRootIndex);
+ __ cmpl(sp, ip);
+ __ bge(&ok);
+
+ CallRuntimePassFunction(masm, Runtime::kTryInstallOptimizedCode);
+ GenerateTailCallToReturnedCode(masm);
+
+ __ bind(&ok);
+ GenerateTailCallToSharedCode(masm);
+}
+
+
+static void Generate_JSConstructStubHelper(MacroAssembler* masm,
+ bool is_api_function,
+ bool create_memento) {
+ // ----------- S t a t e -------------
+ // -- r3 : number of arguments
+ // -- r4 : constructor function
+ // -- r5 : allocation site or undefined
+ // -- lr : return address
+ // -- sp[...]: constructor arguments
+ // -----------------------------------
+
+ // Should never create mementos for api functions.
+ DCHECK(!is_api_function || !create_memento);
+
+ Isolate* isolate = masm->isolate();
+
+ // Enter a construct frame.
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::CONSTRUCT);
+
+ if (create_memento) {
+ __ AssertUndefinedOrAllocationSite(r5, r6);
+ __ push(r5);
+ }
+
+ // Preserve the two incoming parameters on the stack.
+ __ SmiTag(r3);
+ __ push(r3); // Smi-tagged arguments count.
+ __ push(r4); // Constructor function.
+
+ // Try to allocate the object without transitioning into C code. If any of
+ // the preconditions is not met, the code bails out to the runtime call.
+ Label rt_call, allocated;
+ if (FLAG_inline_new) {
+ Label undo_allocation;
+ ExternalReference debug_step_in_fp =
+ ExternalReference::debug_step_in_fp_address(isolate);
+ __ mov(r5, Operand(debug_step_in_fp));
+ __ LoadP(r5, MemOperand(r5));
+ __ cmpi(r5, Operand::Zero());
+ __ bne(&rt_call);
+
+ // Load the initial map and verify that it is in fact a map.
+ // r4: constructor function
+ __ LoadP(r5,
+ FieldMemOperand(r4, JSFunction::kPrototypeOrInitialMapOffset));
+ __ JumpIfSmi(r5, &rt_call);
+ __ CompareObjectType(r5, r6, r7, MAP_TYPE);
+ __ bne(&rt_call);
+
+ // Check that the constructor is not constructing a JSFunction (see
+ // comments in Runtime_NewObject in runtime.cc). In which case the
+ // initial map's instance type would be JS_FUNCTION_TYPE.
+ // r4: constructor function
+ // r5: initial map
+ __ CompareInstanceType(r5, r6, JS_FUNCTION_TYPE);
+ __ beq(&rt_call);
+
+ if (!is_api_function) {
+ Label allocate;
+ MemOperand bit_field3 = FieldMemOperand(r5, Map::kBitField3Offset);
+ // Check if slack tracking is enabled.
+ __ lwz(r7, bit_field3);
+ __ DecodeField<Map::ConstructionCount>(r11, r7);
+ STATIC_ASSERT(JSFunction::kNoSlackTracking == 0);
+ __ cmpi(r11, Operand::Zero()); // JSFunction::kNoSlackTracking
+ __ beq(&allocate);
+ // Decrease generous allocation count.
+ __ Add(r7, r7, -(1 << Map::ConstructionCount::kShift), r0);
+ __ stw(r7, bit_field3);
+ __ cmpi(r11, Operand(JSFunction::kFinishSlackTracking));
+ __ bne(&allocate);
+
+ __ push(r4);
+
+ __ Push(r5, r4); // r4 = constructor
+ __ CallRuntime(Runtime::kFinalizeInstanceSize, 1);
+
+ __ Pop(r4, r5);
+
+ __ bind(&allocate);
+ }
+
+ // Now allocate the JSObject on the heap.
+ // r4: constructor function
+ // r5: initial map
+ __ lbz(r6, FieldMemOperand(r5, Map::kInstanceSizeOffset));
+ if (create_memento) {
+ __ addi(r6, r6, Operand(AllocationMemento::kSize / kPointerSize));
+ }
+
+ __ Allocate(r6, r7, r8, r9, &rt_call, SIZE_IN_WORDS);
+
+ // Allocated the JSObject, now initialize the fields. Map is set to
+ // initial map and properties and elements are set to empty fixed array.
+ // r4: constructor function
+ // r5: initial map
+ // r6: object size (not including memento if create_memento)
+ // r7: JSObject (not tagged)
+ __ LoadRoot(r9, Heap::kEmptyFixedArrayRootIndex);
+ __ mr(r8, r7);
+ __ StoreP(r5, MemOperand(r8, JSObject::kMapOffset));
+ __ StoreP(r9, MemOperand(r8, JSObject::kPropertiesOffset));
+ __ StoreP(r9, MemOperand(r8, JSObject::kElementsOffset));
+ __ addi(r8, r8, Operand(JSObject::kElementsOffset + kPointerSize));
+
+ __ ShiftLeftImm(r9, r6, Operand(kPointerSizeLog2));
+ __ add(r9, r7, r9); // End of object.
+
+ // Fill all the in-object properties with the appropriate filler.
+ // r4: constructor function
+ // r5: initial map
+ // r6: object size (in words, including memento if create_memento)
+ // r7: JSObject (not tagged)
+ // r8: First in-object property of JSObject (not tagged)
+ // r9: End of object
+ DCHECK_EQ(3 * kPointerSize, JSObject::kHeaderSize);
+ __ LoadRoot(r10, Heap::kUndefinedValueRootIndex);
+
+ if (!is_api_function) {
+ Label no_inobject_slack_tracking;
+
+ // Check if slack tracking is enabled.
+ STATIC_ASSERT(JSFunction::kNoSlackTracking == 0);
+ __ cmpi(r11, Operand::Zero()); // JSFunction::kNoSlackTracking
+ __ beq(&no_inobject_slack_tracking);
+
+ // Allocate object with a slack.
+ __ lbz(r3, FieldMemOperand(r5, Map::kPreAllocatedPropertyFieldsOffset));
+ if (FLAG_debug_code) {
+ __ ShiftLeftImm(r0, r3, Operand(kPointerSizeLog2));
+ __ add(r0, r8, r0);
+ // r0: offset of first field after pre-allocated fields
+ __ cmp(r0, r9);
+ __ Assert(le, kUnexpectedNumberOfPreAllocatedPropertyFields);
+ }
+ {
+ Label done;
+ __ cmpi(r3, Operand::Zero());
+ __ beq(&done);
+ __ InitializeNFieldsWithFiller(r8, r3, r10);
+ __ bind(&done);
+ }
+ // To allow for truncation.
+ __ LoadRoot(r10, Heap::kOnePointerFillerMapRootIndex);
+ // Fill the remaining fields with one pointer filler map.
+
+ __ bind(&no_inobject_slack_tracking);
+ }
+
+ if (create_memento) {
+ __ subi(r3, r9, Operand(AllocationMemento::kSize));
+ __ InitializeFieldsWithFiller(r8, r3, r10);
+
+ // Fill in memento fields.
+ // r8: points to the allocated but uninitialized memento.
+ __ LoadRoot(r10, Heap::kAllocationMementoMapRootIndex);
+ __ StoreP(r10, MemOperand(r8, AllocationMemento::kMapOffset));
+ // Load the AllocationSite
+ __ LoadP(r10, MemOperand(sp, 2 * kPointerSize));
+ __ StoreP(r10,
+ MemOperand(r8, AllocationMemento::kAllocationSiteOffset));
+ __ addi(r8, r8, Operand(AllocationMemento::kAllocationSiteOffset +
+ kPointerSize));
+ } else {
+ __ InitializeFieldsWithFiller(r8, r9, r10);
+ }
+
+ // Add the object tag to make the JSObject real, so that we can continue
+ // and jump into the continuation code at any time from now on. Any
+ // failures need to undo the allocation, so that the heap is in a
+ // consistent state and verifiable.
+ __ addi(r7, r7, Operand(kHeapObjectTag));
+
+ // Check if a non-empty properties array is needed. Continue with
+ // allocated object if not fall through to runtime call if it is.
+ // r4: constructor function
+ // r7: JSObject
+ // r8: start of next object (not tagged)
+ __ lbz(r6, FieldMemOperand(r5, Map::kUnusedPropertyFieldsOffset));
+ // The field instance sizes contains both pre-allocated property fields
+ // and in-object properties.
+ __ lbz(r0, FieldMemOperand(r5, Map::kPreAllocatedPropertyFieldsOffset));
+ __ add(r6, r6, r0);
+ __ lbz(r0, FieldMemOperand(r5, Map::kInObjectPropertiesOffset));
+ __ sub(r6, r6, r0, LeaveOE, SetRC);
+
+ // Done if no extra properties are to be allocated.
+ __ beq(&allocated, cr0);
+ __ Assert(ge, kPropertyAllocationCountFailed, cr0);
+
+ // Scale the number of elements by pointer size and add the header for
+ // FixedArrays to the start of the next object calculation from above.
+ // r4: constructor
+ // r6: number of elements in properties array
+ // r7: JSObject
+ // r8: start of next object
+ __ addi(r3, r6, Operand(FixedArray::kHeaderSize / kPointerSize));
+ __ Allocate(
+ r3, r8, r9, r5, &undo_allocation,
+ static_cast<AllocationFlags>(RESULT_CONTAINS_TOP | SIZE_IN_WORDS));
+
+ // Initialize the FixedArray.
+ // r4: constructor
+ // r6: number of elements in properties array
+ // r7: JSObject
+ // r8: FixedArray (not tagged)
+ __ LoadRoot(r9, Heap::kFixedArrayMapRootIndex);
+ __ mr(r5, r8);
+ DCHECK_EQ(0 * kPointerSize, JSObject::kMapOffset);
+ __ StoreP(r9, MemOperand(r5));
+ DCHECK_EQ(1 * kPointerSize, FixedArray::kLengthOffset);
+ __ SmiTag(r3, r6);
+ __ StoreP(r3, MemOperand(r5, kPointerSize));
+ __ addi(r5, r5, Operand(2 * kPointerSize));
+
+ // Initialize the fields to undefined.
+ // r4: constructor function
+ // r5: First element of FixedArray (not tagged)
+ // r6: number of elements in properties array
+ // r7: JSObject
+ // r8: FixedArray (not tagged)
+ DCHECK_EQ(2 * kPointerSize, FixedArray::kHeaderSize);
+ {
+ Label done;
+ __ cmpi(r6, Operand::Zero());
+ __ beq(&done);
+ if (!is_api_function || create_memento) {
+ __ LoadRoot(r10, Heap::kUndefinedValueRootIndex);
+ } else if (FLAG_debug_code) {
+ __ LoadRoot(r11, Heap::kUndefinedValueRootIndex);
+ __ cmp(r10, r11);
+ __ Assert(eq, kUndefinedValueNotLoaded);
+ }
+ __ InitializeNFieldsWithFiller(r5, r6, r10);
+ __ bind(&done);
+ }
+
+ // Store the initialized FixedArray into the properties field of
+ // the JSObject
+ // r4: constructor function
+ // r7: JSObject
+ // r8: FixedArray (not tagged)
+ __ addi(r8, r8, Operand(kHeapObjectTag)); // Add the heap tag.
+ __ StoreP(r8, FieldMemOperand(r7, JSObject::kPropertiesOffset), r0);
+
+ // Continue with JSObject being successfully allocated
+ // r4: constructor function
+ // r7: JSObject
+ __ b(&allocated);
+
+ // Undo the setting of the new top so that the heap is verifiable. For
+ // example, the map's unused properties potentially do not match the
+ // allocated objects unused properties.
+ // r7: JSObject (previous new top)
+ __ bind(&undo_allocation);
+ __ UndoAllocationInNewSpace(r7, r8);
+ }
+
+ // Allocate the new receiver object using the runtime call.
+ // r4: constructor function
+ __ bind(&rt_call);
+ if (create_memento) {
+ // Get the cell or allocation site.
+ __ LoadP(r5, MemOperand(sp, 2 * kPointerSize));
+ __ push(r5);
+ }
+
+ __ push(r4); // argument for Runtime_NewObject
+ if (create_memento) {
+ __ CallRuntime(Runtime::kNewObjectWithAllocationSite, 2);
+ } else {
+ __ CallRuntime(Runtime::kNewObject, 1);
+ }
+ __ mr(r7, r3);
+
+ // If we ended up using the runtime, and we want a memento, then the
+ // runtime call made it for us, and we shouldn't do create count
+ // increment.
+ Label count_incremented;
+ if (create_memento) {
+ __ b(&count_incremented);
+ }
+
+ // Receiver for constructor call allocated.
+ // r7: JSObject
+ __ bind(&allocated);
+
+ if (create_memento) {
+ __ LoadP(r5, MemOperand(sp, kPointerSize * 2));
+ __ LoadRoot(r8, Heap::kUndefinedValueRootIndex);
+ __ cmp(r5, r8);
+ __ beq(&count_incremented);
+ // r5 is an AllocationSite. We are creating a memento from it, so we
+ // need to increment the memento create count.
+ __ LoadP(
+ r6, FieldMemOperand(r5, AllocationSite::kPretenureCreateCountOffset));
+ __ AddSmiLiteral(r6, r6, Smi::FromInt(1), r0);
+ __ StoreP(
+ r6, FieldMemOperand(r5, AllocationSite::kPretenureCreateCountOffset),
+ r0);
+ __ bind(&count_incremented);
+ }
+
+ __ Push(r7, r7);
+
+ // Reload the number of arguments and the constructor from the stack.
+ // sp[0]: receiver
+ // sp[1]: receiver
+ // sp[2]: constructor function
+ // sp[3]: number of arguments (smi-tagged)
+ __ LoadP(r4, MemOperand(sp, 2 * kPointerSize));
+ __ LoadP(r6, MemOperand(sp, 3 * kPointerSize));
+
+ // Set up pointer to last argument.
+ __ addi(r5, fp, Operand(StandardFrameConstants::kCallerSPOffset));
+
+ // Set up number of arguments for function call below
+ __ SmiUntag(r3, r6);
+
+ // Copy arguments and receiver to the expression stack.
+ // r3: number of arguments
+ // r4: constructor function
+ // r5: address of last argument (caller sp)
+ // r6: number of arguments (smi-tagged)
+ // sp[0]: receiver
+ // sp[1]: receiver
+ // sp[2]: constructor function
+ // sp[3]: number of arguments (smi-tagged)
+ Label loop, no_args;
+ __ cmpi(r3, Operand::Zero());
+ __ beq(&no_args);
+ __ ShiftLeftImm(ip, r3, Operand(kPointerSizeLog2));
+ __ mtctr(r3);
+ __ bind(&loop);
+ __ subi(ip, ip, Operand(kPointerSize));
+ __ LoadPX(r0, MemOperand(r5, ip));
+ __ push(r0);
+ __ bdnz(&loop);
+ __ bind(&no_args);
+
+ // Call the function.
+ // r3: number of arguments
+ // r4: constructor function
+ if (is_api_function) {
+ __ LoadP(cp, FieldMemOperand(r4, JSFunction::kContextOffset));
+ Handle<Code> code = masm->isolate()->builtins()->HandleApiCallConstruct();
+ __ Call(code, RelocInfo::CODE_TARGET);
+ } else {
+ ParameterCount actual(r3);
+ __ InvokeFunction(r4, actual, CALL_FUNCTION, NullCallWrapper());
+ }
+
+ // Store offset of return address for deoptimizer.
+ if (!is_api_function) {
+ masm->isolate()->heap()->SetConstructStubDeoptPCOffset(masm->pc_offset());
+ }
+
+ // Restore context from the frame.
+ // r3: result
+ // sp[0]: receiver
+ // sp[1]: constructor function
+ // sp[2]: number of arguments (smi-tagged)
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+
+ // If the result is an object (in the ECMA sense), we should get rid
+ // of the receiver and use the result; see ECMA-262 section 13.2.2-7
+ // on page 74.
+ Label use_receiver, exit;
+
+ // If the result is a smi, it is *not* an object in the ECMA sense.
+ // r3: result
+ // sp[0]: receiver (newly allocated object)
+ // sp[1]: constructor function
+ // sp[2]: number of arguments (smi-tagged)
+ __ JumpIfSmi(r3, &use_receiver);
+
+ // If the type of the result (stored in its map) is less than
+ // FIRST_SPEC_OBJECT_TYPE, it is not an object in the ECMA sense.
+ __ CompareObjectType(r3, r4, r6, FIRST_SPEC_OBJECT_TYPE);
+ __ bge(&exit);
+
+ // Throw away the result of the constructor invocation and use the
+ // on-stack receiver as the result.
+ __ bind(&use_receiver);
+ __ LoadP(r3, MemOperand(sp));
+
+ // Remove receiver from the stack, remove caller arguments, and
+ // return.
+ __ bind(&exit);
+ // r3: result
+ // sp[0]: receiver (newly allocated object)
+ // sp[1]: constructor function
+ // sp[2]: number of arguments (smi-tagged)
+ __ LoadP(r4, MemOperand(sp, 2 * kPointerSize));
+
+ // Leave construct frame.
+ }
+
+ __ SmiToPtrArrayOffset(r4, r4);
+ __ add(sp, sp, r4);
+ __ addi(sp, sp, Operand(kPointerSize));
+ __ IncrementCounter(isolate->counters()->constructed_objects(), 1, r4, r5);
+ __ blr();
+}
+
+
+void Builtins::Generate_JSConstructStubGeneric(MacroAssembler* masm) {
+ Generate_JSConstructStubHelper(masm, false, FLAG_pretenuring_call_new);
+}
+
+
+void Builtins::Generate_JSConstructStubApi(MacroAssembler* masm) {
+ Generate_JSConstructStubHelper(masm, true, false);
+}
+
+
+static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm,
+ bool is_construct) {
+ // Called from Generate_JS_Entry
+ // r3: code entry
+ // r4: function
+ // r5: receiver
+ // r6: argc
+ // r7: argv
+ // r0,r8-r9, cp may be clobbered
+ ProfileEntryHookStub::MaybeCallEntryHook(masm);
+
+ // Clear the context before we push it when entering the internal frame.
+ __ li(cp, Operand::Zero());
+
+ // Enter an internal frame.
+ {
+ FrameScope scope(masm, StackFrame::INTERNAL);
+
+ // Set up the context from the function argument.
+ __ LoadP(cp, FieldMemOperand(r4, JSFunction::kContextOffset));
+
+ __ InitializeRootRegister();
+
+ // Push the function and the receiver onto the stack.
+ __ push(r4);
+ __ push(r5);
+
+ // Copy arguments to the stack in a loop.
+ // r4: function
+ // r6: argc
+ // r7: argv, i.e. points to first arg
+ Label loop, entry;
+ __ ShiftLeftImm(r0, r6, Operand(kPointerSizeLog2));
+ __ add(r5, r7, r0);
+ // r5 points past last arg.
+ __ b(&entry);
+ __ bind(&loop);
+ __ LoadP(r8, MemOperand(r7)); // read next parameter
+ __ addi(r7, r7, Operand(kPointerSize));
+ __ LoadP(r0, MemOperand(r8)); // dereference handle
+ __ push(r0); // push parameter
+ __ bind(&entry);
+ __ cmp(r7, r5);
+ __ bne(&loop);
+
+ // Initialize all JavaScript callee-saved registers, since they will be seen
+ // by the garbage collector as part of handlers.
+ __ LoadRoot(r7, Heap::kUndefinedValueRootIndex);
+ __ mr(r14, r7);
+ __ mr(r15, r7);
+ __ mr(r16, r7);
+ __ mr(r17, r7);
+
+ // Invoke the code and pass argc as r3.
+ __ mr(r3, r6);
+ if (is_construct) {
+ // No type feedback cell is available
+ __ LoadRoot(r5, Heap::kUndefinedValueRootIndex);
+ CallConstructStub stub(masm->isolate(), NO_CALL_CONSTRUCTOR_FLAGS);
+ __ CallStub(&stub);
+ } else {
+ ParameterCount actual(r3);
+ __ InvokeFunction(r4, actual, CALL_FUNCTION, NullCallWrapper());
+ }
+ // Exit the JS frame and remove the parameters (except function), and
+ // return.
+ }
+ __ blr();
+
+ // r3: result
+}
+
+
+void Builtins::Generate_JSEntryTrampoline(MacroAssembler* masm) {
+ Generate_JSEntryTrampolineHelper(masm, false);
+}
+
+
+void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) {
+ Generate_JSEntryTrampolineHelper(masm, true);
+}
+
+
+void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
+ CallRuntimePassFunction(masm, Runtime::kCompileLazy);
+ GenerateTailCallToReturnedCode(masm);
+}
+
+
+static void CallCompileOptimized(MacroAssembler* masm, bool concurrent) {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+ // Push a copy of the function onto the stack.
+ // Push function as parameter to the runtime call.
+ __ Push(r4, r4);
+ // Whether to compile in a background thread.
+ __ Push(masm->isolate()->factory()->ToBoolean(concurrent));
+
+ __ CallRuntime(Runtime::kCompileOptimized, 2);
+ // Restore receiver.
+ __ pop(r4);
+}
+
+
+void Builtins::Generate_CompileOptimized(MacroAssembler* masm) {
+ CallCompileOptimized(masm, false);
+ GenerateTailCallToReturnedCode(masm);
+}
+
+
+void Builtins::Generate_CompileOptimizedConcurrent(MacroAssembler* masm) {
+ CallCompileOptimized(masm, true);
+ GenerateTailCallToReturnedCode(masm);
+}
+
+
+static void GenerateMakeCodeYoungAgainCommon(MacroAssembler* masm) {
+ // For now, we are relying on the fact that make_code_young doesn't do any
+ // garbage collection which allows us to save/restore the registers without
+ // worrying about which of them contain pointers. We also don't build an
+ // internal frame to make the code faster, since we shouldn't have to do stack
+ // crawls in MakeCodeYoung. This seems a bit fragile.
+
+ // Point r3 at the start of the PlatformCodeAge sequence.
+ __ mr(r3, ip);
+
+ // The following registers must be saved and restored when calling through to
+ // the runtime:
+ // r3 - contains return address (beginning of patch sequence)
+ // r4 - isolate
+ // lr - return address
+ FrameScope scope(masm, StackFrame::MANUAL);
+ __ mflr(r0);
+ __ MultiPush(r0.bit() | r3.bit() | r4.bit() | fp.bit());
+ __ PrepareCallCFunction(2, 0, r5);
+ __ mov(r4, Operand(ExternalReference::isolate_address(masm->isolate())));
+ __ CallCFunction(
+ ExternalReference::get_make_code_young_function(masm->isolate()), 2);
+ __ MultiPop(r0.bit() | r3.bit() | r4.bit() | fp.bit());
+ __ mtlr(r0);
+ __ mr(ip, r3);
+ __ Jump(ip);
+}
+
+#define DEFINE_CODE_AGE_BUILTIN_GENERATOR(C) \
+ void Builtins::Generate_Make##C##CodeYoungAgainEvenMarking( \
+ MacroAssembler* masm) { \
+ GenerateMakeCodeYoungAgainCommon(masm); \
+ } \
+ void Builtins::Generate_Make##C##CodeYoungAgainOddMarking( \
+ MacroAssembler* masm) { \
+ GenerateMakeCodeYoungAgainCommon(masm); \
+ }
+CODE_AGE_LIST(DEFINE_CODE_AGE_BUILTIN_GENERATOR)
+#undef DEFINE_CODE_AGE_BUILTIN_GENERATOR
+
+
+void Builtins::Generate_MarkCodeAsExecutedOnce(MacroAssembler* masm) {
+ // For now, we are relying on the fact that make_code_young doesn't do any
+ // garbage collection which allows us to save/restore the registers without
+ // worrying about which of them contain pointers. We also don't build an
+ // internal frame to make the code faster, since we shouldn't have to do stack
+ // crawls in MakeCodeYoung. This seems a bit fragile.
+
+ // Point r3 at the start of the PlatformCodeAge sequence.
+ __ mr(r3, ip);
+
+ // The following registers must be saved and restored when calling through to
+ // the runtime:
+ // r3 - contains return address (beginning of patch sequence)
+ // r4 - isolate
+ // lr - return address
+ FrameScope scope(masm, StackFrame::MANUAL);
+ __ mflr(r0);
+ __ MultiPush(r0.bit() | r3.bit() | r4.bit() | fp.bit());
+ __ PrepareCallCFunction(2, 0, r5);
+ __ mov(r4, Operand(ExternalReference::isolate_address(masm->isolate())));
+ __ CallCFunction(
+ ExternalReference::get_mark_code_as_executed_function(masm->isolate()),
+ 2);
+ __ MultiPop(r0.bit() | r3.bit() | r4.bit() | fp.bit());
+ __ mtlr(r0);
+ __ mr(ip, r3);
+
+ // Perform prologue operations usually performed by the young code stub.
+ __ PushFixedFrame(r4);
+ __ addi(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
+
+ // Jump to point after the code-age stub.
+ __ addi(r3, ip, Operand(kNoCodeAgeSequenceLength));
+ __ Jump(r3);
+}
+
+
+void Builtins::Generate_MarkCodeAsExecutedTwice(MacroAssembler* masm) {
+ GenerateMakeCodeYoungAgainCommon(masm);
+}
+
+
+static void Generate_NotifyStubFailureHelper(MacroAssembler* masm,
+ SaveFPRegsMode save_doubles) {
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+
+ // Preserve registers across notification, this is important for compiled
+ // stubs that tail call the runtime on deopts passing their parameters in
+ // registers.
+ __ MultiPush(kJSCallerSaved | kCalleeSaved);
+ // Pass the function and deoptimization type to the runtime system.
+ __ CallRuntime(Runtime::kNotifyStubFailure, 0, save_doubles);
+ __ MultiPop(kJSCallerSaved | kCalleeSaved);
+ }
+
+ __ addi(sp, sp, Operand(kPointerSize)); // Ignore state
+ __ blr(); // Jump to miss handler
+}
+
+
+void Builtins::Generate_NotifyStubFailure(MacroAssembler* masm) {
+ Generate_NotifyStubFailureHelper(masm, kDontSaveFPRegs);
+}
+
+
+void Builtins::Generate_NotifyStubFailureSaveDoubles(MacroAssembler* masm) {
+ Generate_NotifyStubFailureHelper(masm, kSaveFPRegs);
+}
+
+
+static void Generate_NotifyDeoptimizedHelper(MacroAssembler* masm,
+ Deoptimizer::BailoutType type) {
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+ // Pass the function and deoptimization type to the runtime system.
+ __ LoadSmiLiteral(r3, Smi::FromInt(static_cast<int>(type)));
+ __ push(r3);
+ __ CallRuntime(Runtime::kNotifyDeoptimized, 1);
+ }
+
+ // Get the full codegen state from the stack and untag it -> r9.
+ __ LoadP(r9, MemOperand(sp, 0 * kPointerSize));
+ __ SmiUntag(r9);
+ // Switch on the state.
+ Label with_tos_register, unknown_state;
+ __ cmpi(r9, Operand(FullCodeGenerator::NO_REGISTERS));
+ __ bne(&with_tos_register);
+ __ addi(sp, sp, Operand(1 * kPointerSize)); // Remove state.
+ __ Ret();
+
+ __ bind(&with_tos_register);
+ __ LoadP(r3, MemOperand(sp, 1 * kPointerSize));
+ __ cmpi(r9, Operand(FullCodeGenerator::TOS_REG));
+ __ bne(&unknown_state);
+ __ addi(sp, sp, Operand(2 * kPointerSize)); // Remove state.
+ __ Ret();
+
+ __ bind(&unknown_state);
+ __ stop("no cases left");
+}
+
+
+void Builtins::Generate_NotifyDeoptimized(MacroAssembler* masm) {
+ Generate_NotifyDeoptimizedHelper(masm, Deoptimizer::EAGER);
+}
+
+
+void Builtins::Generate_NotifySoftDeoptimized(MacroAssembler* masm) {
+ Generate_NotifyDeoptimizedHelper(masm, Deoptimizer::SOFT);
+}
+
+
+void Builtins::Generate_NotifyLazyDeoptimized(MacroAssembler* masm) {
+ Generate_NotifyDeoptimizedHelper(masm, Deoptimizer::LAZY);
+}
+
+
+void Builtins::Generate_OnStackReplacement(MacroAssembler* masm) {
+ // Lookup the function in the JavaScript frame.
+ __ LoadP(r3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+ // Pass function as argument.
+ __ push(r3);
+ __ CallRuntime(Runtime::kCompileForOnStackReplacement, 1);
+ }
+
+ // If the code object is null, just return to the unoptimized code.
+ Label skip;
+ __ CmpSmiLiteral(r3, Smi::FromInt(0), r0);
+ __ bne(&skip);
+ __ Ret();
+
+ __ bind(&skip);
+
+ // Load deoptimization data from the code object.
+ // <deopt_data> = <code>[#deoptimization_data_offset]
+ __ LoadP(r4, FieldMemOperand(r3, Code::kDeoptimizationDataOffset));
+
+#if V8_OOL_CONSTANT_POOL
+ {
+ ConstantPoolUnavailableScope constant_pool_unavailable(masm);
+ __ LoadP(kConstantPoolRegister,
+ FieldMemOperand(r3, Code::kConstantPoolOffset));
+#endif
+
+ // Load the OSR entrypoint offset from the deoptimization data.
+ // <osr_offset> = <deopt_data>[#header_size + #osr_pc_offset]
+ __ LoadP(r4, FieldMemOperand(
+ r4, FixedArray::OffsetOfElementAt(
+ DeoptimizationInputData::kOsrPcOffsetIndex)));
+ __ SmiUntag(r4);
+
+ // Compute the target address = code_obj + header_size + osr_offset
+ // <entry_addr> = <code_obj> + #header_size + <osr_offset>
+ __ add(r3, r3, r4);
+ __ addi(r0, r3, Operand(Code::kHeaderSize - kHeapObjectTag));
+ __ mtlr(r0);
+
+ // And "return" to the OSR entry point of the function.
+ __ Ret();
+#if V8_OOL_CONSTANT_POOL
+ }
+#endif
+}
+
+
+void Builtins::Generate_OsrAfterStackCheck(MacroAssembler* masm) {
+ // We check the stack limit as indicator that recompilation might be done.
+ Label ok;
+ __ LoadRoot(ip, Heap::kStackLimitRootIndex);
+ __ cmpl(sp, ip);
+ __ bge(&ok);
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+ __ CallRuntime(Runtime::kStackGuard, 0);
+ }
+ __ Jump(masm->isolate()->builtins()->OnStackReplacement(),
+ RelocInfo::CODE_TARGET);
+
+ __ bind(&ok);
+ __ Ret();
+}
+
+
+void Builtins::Generate_FunctionCall(MacroAssembler* masm) {
+ // 1. Make sure we have at least one argument.
+ // r3: actual number of arguments
+ {
+ Label done;
+ __ cmpi(r3, Operand::Zero());
+ __ bne(&done);
+ __ LoadRoot(r5, Heap::kUndefinedValueRootIndex);
+ __ push(r5);
+ __ addi(r3, r3, Operand(1));
+ __ bind(&done);
+ }
+
+ // 2. Get the function to call (passed as receiver) from the stack, check
+ // if it is a function.
+ // r3: actual number of arguments
+ Label slow, non_function;
+ __ ShiftLeftImm(r4, r3, Operand(kPointerSizeLog2));
+ __ add(r4, sp, r4);
+ __ LoadP(r4, MemOperand(r4));
+ __ JumpIfSmi(r4, &non_function);
+ __ CompareObjectType(r4, r5, r5, JS_FUNCTION_TYPE);
+ __ bne(&slow);
+
+ // 3a. Patch the first argument if necessary when calling a function.
+ // r3: actual number of arguments
+ // r4: function
+ Label shift_arguments;
+ __ li(r7, Operand::Zero()); // indicate regular JS_FUNCTION
+ {
+ Label convert_to_object, use_global_proxy, patch_receiver;
+ // Change context eagerly in case we need the global receiver.
+ __ LoadP(cp, FieldMemOperand(r4, JSFunction::kContextOffset));
+
+ // Do not transform the receiver for strict mode functions.
+ __ LoadP(r5, FieldMemOperand(r4, JSFunction::kSharedFunctionInfoOffset));
+ __ lwz(r6, FieldMemOperand(r5, SharedFunctionInfo::kCompilerHintsOffset));
+ __ TestBit(r6,
+#if V8_TARGET_ARCH_PPC64
+ SharedFunctionInfo::kStrictModeFunction,
+#else
+ SharedFunctionInfo::kStrictModeFunction + kSmiTagSize,
+#endif
+ r0);
+ __ bne(&shift_arguments, cr0);
+
+ // Do not transform the receiver for native (Compilerhints already in r6).
+ __ TestBit(r6,
+#if V8_TARGET_ARCH_PPC64
+ SharedFunctionInfo::kNative,
+#else
+ SharedFunctionInfo::kNative + kSmiTagSize,
+#endif
+ r0);
+ __ bne(&shift_arguments, cr0);
+
+ // Compute the receiver in sloppy mode.
+ __ ShiftLeftImm(ip, r3, Operand(kPointerSizeLog2));
+ __ add(r5, sp, ip);
+ __ LoadP(r5, MemOperand(r5, -kPointerSize));
+ // r3: actual number of arguments
+ // r4: function
+ // r5: first argument
+ __ JumpIfSmi(r5, &convert_to_object);
+
+ __ LoadRoot(r6, Heap::kUndefinedValueRootIndex);
+ __ cmp(r5, r6);
+ __ beq(&use_global_proxy);
+ __ LoadRoot(r6, Heap::kNullValueRootIndex);
+ __ cmp(r5, r6);
+ __ beq(&use_global_proxy);
+
+ STATIC_ASSERT(LAST_SPEC_OBJECT_TYPE == LAST_TYPE);
+ __ CompareObjectType(r5, r6, r6, FIRST_SPEC_OBJECT_TYPE);
+ __ bge(&shift_arguments);
+
+ __ bind(&convert_to_object);
+
+ {
+ // Enter an internal frame in order to preserve argument count.
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+ __ SmiTag(r3);
+ __ Push(r3, r5);
+ __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
+ __ mr(r5, r3);
+
+ __ pop(r3);
+ __ SmiUntag(r3);
+
+ // Exit the internal frame.
+ }
+
+ // Restore the function to r4, and the flag to r7.
+ __ ShiftLeftImm(r7, r3, Operand(kPointerSizeLog2));
+ __ add(r7, sp, r7);
+ __ LoadP(r4, MemOperand(r7));
+ __ li(r7, Operand::Zero());
+ __ b(&patch_receiver);
+
+ __ bind(&use_global_proxy);
+ __ LoadP(r5, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
+ __ LoadP(r5, FieldMemOperand(r5, GlobalObject::kGlobalProxyOffset));
+
+ __ bind(&patch_receiver);
+ __ ShiftLeftImm(ip, r3, Operand(kPointerSizeLog2));
+ __ add(r6, sp, ip);
+ __ StoreP(r5, MemOperand(r6, -kPointerSize));
+
+ __ b(&shift_arguments);
+ }
+
+ // 3b. Check for function proxy.
+ __ bind(&slow);
+ __ li(r7, Operand(1, RelocInfo::NONE32)); // indicate function proxy
+ __ cmpi(r5, Operand(JS_FUNCTION_PROXY_TYPE));
+ __ beq(&shift_arguments);
+ __ bind(&non_function);
+ __ li(r7, Operand(2, RelocInfo::NONE32)); // indicate non-function
+
+ // 3c. Patch the first argument when calling a non-function. The
+ // CALL_NON_FUNCTION builtin expects the non-function callee as
+ // receiver, so overwrite the first argument which will ultimately
+ // become the receiver.
+ // r3: actual number of arguments
+ // r4: function
+ // r7: call type (0: JS function, 1: function proxy, 2: non-function)
+ __ ShiftLeftImm(ip, r3, Operand(kPointerSizeLog2));
+ __ add(r5, sp, ip);
+ __ StoreP(r4, MemOperand(r5, -kPointerSize));
+
+ // 4. Shift arguments and return address one slot down on the stack
+ // (overwriting the original receiver). Adjust argument count to make
+ // the original first argument the new receiver.
+ // r3: actual number of arguments
+ // r4: function
+ // r7: call type (0: JS function, 1: function proxy, 2: non-function)
+ __ bind(&shift_arguments);
+ {
+ Label loop;
+ // Calculate the copy start address (destination). Copy end address is sp.
+ __ ShiftLeftImm(ip, r3, Operand(kPointerSizeLog2));
+ __ add(r5, sp, ip);
+
+ __ bind(&loop);
+ __ LoadP(ip, MemOperand(r5, -kPointerSize));
+ __ StoreP(ip, MemOperand(r5));
+ __ subi(r5, r5, Operand(kPointerSize));
+ __ cmp(r5, sp);
+ __ bne(&loop);
+ // Adjust the actual number of arguments and remove the top element
+ // (which is a copy of the last argument).
+ __ subi(r3, r3, Operand(1));
+ __ pop();
+ }
+
+ // 5a. Call non-function via tail call to CALL_NON_FUNCTION builtin,
+ // or a function proxy via CALL_FUNCTION_PROXY.
+ // r3: actual number of arguments
+ // r4: function
+ // r7: call type (0: JS function, 1: function proxy, 2: non-function)
+ {
+ Label function, non_proxy;
+ __ cmpi(r7, Operand::Zero());
+ __ beq(&function);
+ // Expected number of arguments is 0 for CALL_NON_FUNCTION.
+ __ li(r5, Operand::Zero());
+ __ cmpi(r7, Operand(1));
+ __ bne(&non_proxy);
+
+ __ push(r4); // re-add proxy object as additional argument
+ __ addi(r3, r3, Operand(1));
+ __ GetBuiltinFunction(r4, Builtins::CALL_FUNCTION_PROXY);
+ __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
+ RelocInfo::CODE_TARGET);
+
+ __ bind(&non_proxy);
+ __ GetBuiltinFunction(r4, Builtins::CALL_NON_FUNCTION);
+ __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
+ RelocInfo::CODE_TARGET);
+ __ bind(&function);
+ }
+
+ // 5b. Get the code to call from the function and check that the number of
+ // expected arguments matches what we're providing. If so, jump
+ // (tail-call) to the code in register edx without checking arguments.
+ // r3: actual number of arguments
+ // r4: function
+ __ LoadP(r6, FieldMemOperand(r4, JSFunction::kSharedFunctionInfoOffset));
+ __ LoadWordArith(
+ r5, FieldMemOperand(r6, SharedFunctionInfo::kFormalParameterCountOffset));
+#if !V8_TARGET_ARCH_PPC64
+ __ SmiUntag(r5);
+#endif
+ __ cmp(r5, r3); // Check formal and actual parameter counts.
+ __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
+ RelocInfo::CODE_TARGET, ne);
+
+ __ LoadP(ip, FieldMemOperand(r4, JSFunction::kCodeEntryOffset));
+ ParameterCount expected(0);
+ __ InvokeCode(ip, expected, expected, JUMP_FUNCTION, NullCallWrapper());
+}
+
+
+void Builtins::Generate_FunctionApply(MacroAssembler* masm) {
+ const int kIndexOffset =
+ StandardFrameConstants::kExpressionsOffset - (2 * kPointerSize);
+ const int kLimitOffset =
+ StandardFrameConstants::kExpressionsOffset - (1 * kPointerSize);
+ const int kArgsOffset = 2 * kPointerSize;
+ const int kRecvOffset = 3 * kPointerSize;
+ const int kFunctionOffset = 4 * kPointerSize;
+
+ {
+ FrameAndConstantPoolScope frame_scope(masm, StackFrame::INTERNAL);
+
+ __ LoadP(r3, MemOperand(fp, kFunctionOffset)); // get the function
+ __ push(r3);
+ __ LoadP(r3, MemOperand(fp, kArgsOffset)); // get the args array
+ __ push(r3);
+ __ InvokeBuiltin(Builtins::APPLY_PREPARE, CALL_FUNCTION);
+
+ // Check the stack for overflow. We are not trying to catch
+ // interruptions (e.g. debug break and preemption) here, so the "real stack
+ // limit" is checked.
+ Label okay;
+ __ LoadRoot(r5, Heap::kRealStackLimitRootIndex);
+ // Make r5 the space we have left. The stack might already be overflowed
+ // here which will cause r5 to become negative.
+ __ sub(r5, sp, r5);
+ // Check if the arguments will overflow the stack.
+ __ SmiToPtrArrayOffset(r0, r3);
+ __ cmp(r5, r0);
+ __ bgt(&okay); // Signed comparison.
+
+ // Out of stack space.
+ __ LoadP(r4, MemOperand(fp, kFunctionOffset));
+ __ Push(r4, r3);
+ __ InvokeBuiltin(Builtins::STACK_OVERFLOW, CALL_FUNCTION);
+ // End of stack check.
+
+ // Push current limit and index.
+ __ bind(&okay);
+ __ li(r4, Operand::Zero());
+ __ Push(r3, r4); // limit and initial index.
+
+ // Get the receiver.
+ __ LoadP(r3, MemOperand(fp, kRecvOffset));
+
+ // Check that the function is a JS function (otherwise it must be a proxy).
+ Label push_receiver;
+ __ LoadP(r4, MemOperand(fp, kFunctionOffset));
+ __ CompareObjectType(r4, r5, r5, JS_FUNCTION_TYPE);
+ __ bne(&push_receiver);
+
+ // Change context eagerly to get the right global object if necessary.
+ __ LoadP(cp, FieldMemOperand(r4, JSFunction::kContextOffset));
+ // Load the shared function info while the function is still in r4.
+ __ LoadP(r5, FieldMemOperand(r4, JSFunction::kSharedFunctionInfoOffset));
+
+ // Compute the receiver.
+ // Do not transform the receiver for strict mode functions.
+ Label call_to_object, use_global_proxy;
+ __ lwz(r5, FieldMemOperand(r5, SharedFunctionInfo::kCompilerHintsOffset));
+ __ TestBit(r5,
+#if V8_TARGET_ARCH_PPC64
+ SharedFunctionInfo::kStrictModeFunction,
+#else
+ SharedFunctionInfo::kStrictModeFunction + kSmiTagSize,
+#endif
+ r0);
+ __ bne(&push_receiver, cr0);
+
+ // Do not transform the receiver for strict mode functions.
+ __ TestBit(r5,
+#if V8_TARGET_ARCH_PPC64
+ SharedFunctionInfo::kNative,
+#else
+ SharedFunctionInfo::kNative + kSmiTagSize,
+#endif
+ r0);
+ __ bne(&push_receiver, cr0);
+
+ // Compute the receiver in sloppy mode.
+ __ JumpIfSmi(r3, &call_to_object);
+ __ LoadRoot(r4, Heap::kNullValueRootIndex);
+ __ cmp(r3, r4);
+ __ beq(&use_global_proxy);
+ __ LoadRoot(r4, Heap::kUndefinedValueRootIndex);
+ __ cmp(r3, r4);
+ __ beq(&use_global_proxy);
+
+ // Check if the receiver is already a JavaScript object.
+ // r3: receiver
+ STATIC_ASSERT(LAST_SPEC_OBJECT_TYPE == LAST_TYPE);
+ __ CompareObjectType(r3, r4, r4, FIRST_SPEC_OBJECT_TYPE);
+ __ bge(&push_receiver);
+
+ // Convert the receiver to a regular object.
+ // r3: receiver
+ __ bind(&call_to_object);
+ __ push(r3);
+ __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
+ __ b(&push_receiver);
+
+ __ bind(&use_global_proxy);
+ __ LoadP(r3, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
+ __ LoadP(r3, FieldMemOperand(r3, GlobalObject::kGlobalProxyOffset));
+
+ // Push the receiver.
+ // r3: receiver
+ __ bind(&push_receiver);
+ __ push(r3);
+
+ // Copy all arguments from the array to the stack.
+ Label entry, loop;
+ __ LoadP(r3, MemOperand(fp, kIndexOffset));
+ __ b(&entry);
+
+ // Load the current argument from the arguments array and push it to the
+ // stack.
+ // r3: current argument index
+ __ bind(&loop);
+ __ LoadP(r4, MemOperand(fp, kArgsOffset));
+ __ Push(r4, r3);
+
+ // Call the runtime to access the property in the arguments array.
+ __ CallRuntime(Runtime::kGetProperty, 2);
+ __ push(r3);
+
+ // Use inline caching to access the arguments.
+ __ LoadP(r3, MemOperand(fp, kIndexOffset));
+ __ AddSmiLiteral(r3, r3, Smi::FromInt(1), r0);
+ __ StoreP(r3, MemOperand(fp, kIndexOffset));
+
+ // Test if the copy loop has finished copying all the elements from the
+ // arguments object.
+ __ bind(&entry);
+ __ LoadP(r4, MemOperand(fp, kLimitOffset));
+ __ cmp(r3, r4);
+ __ bne(&loop);
+
+ // Call the function.
+ Label call_proxy;
+ ParameterCount actual(r3);
+ __ SmiUntag(r3);
+ __ LoadP(r4, MemOperand(fp, kFunctionOffset));
+ __ CompareObjectType(r4, r5, r5, JS_FUNCTION_TYPE);
+ __ bne(&call_proxy);
+ __ InvokeFunction(r4, actual, CALL_FUNCTION, NullCallWrapper());
+
+ __ LeaveFrame(StackFrame::INTERNAL, 3 * kPointerSize);
+ __ blr();
+
+ // Call the function proxy.
+ __ bind(&call_proxy);
+ __ push(r4); // add function proxy as last argument
+ __ addi(r3, r3, Operand(1));
+ __ li(r5, Operand::Zero());
+ __ GetBuiltinFunction(r4, Builtins::CALL_FUNCTION_PROXY);
+ __ Call(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
+ RelocInfo::CODE_TARGET);
+
+ // Tear down the internal frame and remove function, receiver and args.
+ }
+ __ addi(sp, sp, Operand(3 * kPointerSize));
+ __ blr();
+}
+
+
+static void ArgumentAdaptorStackCheck(MacroAssembler* masm,
+ Label* stack_overflow) {
+ // ----------- S t a t e -------------
+ // -- r3 : actual number of arguments
+ // -- r4 : function (passed through to callee)
+ // -- r5 : expected number of arguments
+ // -----------------------------------
+ // Check the stack for overflow. We are not trying to catch
+ // interruptions (e.g. debug break and preemption) here, so the "real stack
+ // limit" is checked.
+ __ LoadRoot(r8, Heap::kRealStackLimitRootIndex);
+ // Make r8 the space we have left. The stack might already be overflowed
+ // here which will cause r8 to become negative.
+ __ sub(r8, sp, r8);
+ // Check if the arguments will overflow the stack.
+ __ ShiftLeftImm(r0, r5, Operand(kPointerSizeLog2));
+ __ cmp(r8, r0);
+ __ ble(stack_overflow); // Signed comparison.
+}
+
+
+static void EnterArgumentsAdaptorFrame(MacroAssembler* masm) {
+ __ SmiTag(r3);
+ __ LoadSmiLiteral(r7, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
+ __ mflr(r0);
+ __ push(r0);
+#if V8_OOL_CONSTANT_POOL
+ __ Push(fp, kConstantPoolRegister, r7, r4, r3);
+#else
+ __ Push(fp, r7, r4, r3);
+#endif
+ __ addi(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp +
+ kPointerSize));
+}
+
+
+static void LeaveArgumentsAdaptorFrame(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- r3 : result being passed through
+ // -----------------------------------
+ // Get the number of arguments passed (as a smi), tear down the frame and
+ // then tear down the parameters.
+ __ LoadP(r4, MemOperand(fp, -(StandardFrameConstants::kFixedFrameSizeFromFp +
+ kPointerSize)));
+ int stack_adjustment = kPointerSize; // adjust for receiver
+ __ LeaveFrame(StackFrame::ARGUMENTS_ADAPTOR, stack_adjustment);
+ __ SmiToPtrArrayOffset(r0, r4);
+ __ add(sp, sp, r0);
+}
+
+
+void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- r3 : actual number of arguments
+ // -- r4 : function (passed through to callee)
+ // -- r5 : expected number of arguments
+ // -----------------------------------
+
+ Label stack_overflow;
+ ArgumentAdaptorStackCheck(masm, &stack_overflow);
+ Label invoke, dont_adapt_arguments;
+
+ Label enough, too_few;
+ __ LoadP(ip, FieldMemOperand(r4, JSFunction::kCodeEntryOffset));
+ __ cmp(r3, r5);
+ __ blt(&too_few);
+ __ cmpi(r5, Operand(SharedFunctionInfo::kDontAdaptArgumentsSentinel));
+ __ beq(&dont_adapt_arguments);
+
+ { // Enough parameters: actual >= expected
+ __ bind(&enough);
+ EnterArgumentsAdaptorFrame(masm);
+
+ // Calculate copy start address into r3 and copy end address into r5.
+ // r3: actual number of arguments as a smi
+ // r4: function
+ // r5: expected number of arguments
+ // ip: code entry to call
+ __ SmiToPtrArrayOffset(r3, r3);
+ __ add(r3, r3, fp);
+ // adjust for return address and receiver
+ __ addi(r3, r3, Operand(2 * kPointerSize));
+ __ ShiftLeftImm(r5, r5, Operand(kPointerSizeLog2));
+ __ sub(r5, r3, r5);
+
+ // Copy the arguments (including the receiver) to the new stack frame.
+ // r3: copy start address
+ // r4: function
+ // r5: copy end address
+ // ip: code entry to call
+
+ Label copy;
+ __ bind(©);
+ __ LoadP(r0, MemOperand(r3, 0));
+ __ push(r0);
+ __ cmp(r3, r5); // Compare before moving to next argument.
+ __ subi(r3, r3, Operand(kPointerSize));
+ __ bne(©);
+
+ __ b(&invoke);
+ }
+
+ { // Too few parameters: Actual < expected
+ __ bind(&too_few);
+ EnterArgumentsAdaptorFrame(masm);
+
+ // Calculate copy start address into r0 and copy end address is fp.
+ // r3: actual number of arguments as a smi
+ // r4: function
+ // r5: expected number of arguments
+ // ip: code entry to call
+ __ SmiToPtrArrayOffset(r3, r3);
+ __ add(r3, r3, fp);
+
+ // Copy the arguments (including the receiver) to the new stack frame.
+ // r3: copy start address
+ // r4: function
+ // r5: expected number of arguments
+ // ip: code entry to call
+ Label copy;
+ __ bind(©);
+ // Adjust load for return address and receiver.
+ __ LoadP(r0, MemOperand(r3, 2 * kPointerSize));
+ __ push(r0);
+ __ cmp(r3, fp); // Compare before moving to next argument.
+ __ subi(r3, r3, Operand(kPointerSize));
+ __ bne(©);
+
+ // Fill the remaining expected arguments with undefined.
+ // r4: function
+ // r5: expected number of arguments
+ // ip: code entry to call
+ __ LoadRoot(r0, Heap::kUndefinedValueRootIndex);
+ __ ShiftLeftImm(r5, r5, Operand(kPointerSizeLog2));
+ __ sub(r5, fp, r5);
+ // Adjust for frame.
+ __ subi(r5, r5, Operand(StandardFrameConstants::kFixedFrameSizeFromFp +
+ 2 * kPointerSize));
+
+ Label fill;
+ __ bind(&fill);
+ __ push(r0);
+ __ cmp(sp, r5);
+ __ bne(&fill);
+ }
+
+ // Call the entry point.
+ __ bind(&invoke);
+ __ CallJSEntry(ip);
+
+ // Store offset of return address for deoptimizer.
+ masm->isolate()->heap()->SetArgumentsAdaptorDeoptPCOffset(masm->pc_offset());
+
+ // Exit frame and return.
+ LeaveArgumentsAdaptorFrame(masm);
+ __ blr();
+
+
+ // -------------------------------------------
+ // Dont adapt arguments.
+ // -------------------------------------------
+ __ bind(&dont_adapt_arguments);
+ __ JumpToJSEntry(ip);
+
+ __ bind(&stack_overflow);
+ {
+ FrameScope frame(masm, StackFrame::MANUAL);
+ EnterArgumentsAdaptorFrame(masm);
+ __ InvokeBuiltin(Builtins::STACK_OVERFLOW, CALL_FUNCTION);
+ __ bkpt(0);
+ }
+}
+
+
+#undef __
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/base/bits.h"
+#include "src/bootstrapper.h"
+#include "src/code-stubs.h"
+#include "src/codegen.h"
+#include "src/ic/handler-compiler.h"
+#include "src/ic/ic.h"
+#include "src/isolate.h"
+#include "src/jsregexp.h"
+#include "src/regexp-macro-assembler.h"
+#include "src/runtime/runtime.h"
+
+namespace v8 {
+namespace internal {
+
+
+static void InitializeArrayConstructorDescriptor(
+ Isolate* isolate, CodeStubDescriptor* descriptor,
+ int constant_stack_parameter_count) {
+ Address deopt_handler =
+ Runtime::FunctionForId(Runtime::kArrayConstructor)->entry;
+
+ if (constant_stack_parameter_count == 0) {
+ descriptor->Initialize(deopt_handler, constant_stack_parameter_count,
+ JS_FUNCTION_STUB_MODE);
+ } else {
+ descriptor->Initialize(r3, deopt_handler, constant_stack_parameter_count,
+ JS_FUNCTION_STUB_MODE, PASS_ARGUMENTS);
+ }
+}
+
+
+static void InitializeInternalArrayConstructorDescriptor(
+ Isolate* isolate, CodeStubDescriptor* descriptor,
+ int constant_stack_parameter_count) {
+ Address deopt_handler =
+ Runtime::FunctionForId(Runtime::kInternalArrayConstructor)->entry;
+
+ if (constant_stack_parameter_count == 0) {
+ descriptor->Initialize(deopt_handler, constant_stack_parameter_count,
+ JS_FUNCTION_STUB_MODE);
+ } else {
+ descriptor->Initialize(r3, deopt_handler, constant_stack_parameter_count,
+ JS_FUNCTION_STUB_MODE, PASS_ARGUMENTS);
+ }
+}
+
+
+void ArrayNoArgumentConstructorStub::InitializeDescriptor(
+ CodeStubDescriptor* descriptor) {
+ InitializeArrayConstructorDescriptor(isolate(), descriptor, 0);
+}
+
+
+void ArraySingleArgumentConstructorStub::InitializeDescriptor(
+ CodeStubDescriptor* descriptor) {
+ InitializeArrayConstructorDescriptor(isolate(), descriptor, 1);
+}
+
+
+void ArrayNArgumentsConstructorStub::InitializeDescriptor(
+ CodeStubDescriptor* descriptor) {
+ InitializeArrayConstructorDescriptor(isolate(), descriptor, -1);
+}
+
+
+void InternalArrayNoArgumentConstructorStub::InitializeDescriptor(
+ CodeStubDescriptor* descriptor) {
+ InitializeInternalArrayConstructorDescriptor(isolate(), descriptor, 0);
+}
+
+
+void InternalArraySingleArgumentConstructorStub::InitializeDescriptor(
+ CodeStubDescriptor* descriptor) {
+ InitializeInternalArrayConstructorDescriptor(isolate(), descriptor, 1);
+}
+
+
+void InternalArrayNArgumentsConstructorStub::InitializeDescriptor(
+ CodeStubDescriptor* descriptor) {
+ InitializeInternalArrayConstructorDescriptor(isolate(), descriptor, -1);
+}
+
+
+#define __ ACCESS_MASM(masm)
+
+
+static void EmitIdenticalObjectComparison(MacroAssembler* masm, Label* slow,
+ Condition cond);
+static void EmitSmiNonsmiComparison(MacroAssembler* masm, Register lhs,
+ Register rhs, Label* lhs_not_nan,
+ Label* slow, bool strict);
+static void EmitStrictTwoHeapObjectCompare(MacroAssembler* masm, Register lhs,
+ Register rhs);
+
+
+void HydrogenCodeStub::GenerateLightweightMiss(MacroAssembler* masm,
+ ExternalReference miss) {
+ // Update the static counter each time a new code stub is generated.
+ isolate()->counters()->code_stubs()->Increment();
+
+ CallInterfaceDescriptor descriptor = GetCallInterfaceDescriptor();
+ int param_count = descriptor.GetEnvironmentParameterCount();
+ {
+ // Call the runtime system in a fresh internal frame.
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+ DCHECK(param_count == 0 ||
+ r3.is(descriptor.GetEnvironmentParameterRegister(param_count - 1)));
+ // Push arguments
+ for (int i = 0; i < param_count; ++i) {
+ __ push(descriptor.GetEnvironmentParameterRegister(i));
+ }
+ __ CallExternalReference(miss, param_count);
+ }
+
+ __ Ret();
+}
+
+
+void DoubleToIStub::Generate(MacroAssembler* masm) {
+ Label out_of_range, only_low, negate, done, fastpath_done;
+ Register input_reg = source();
+ Register result_reg = destination();
+ DCHECK(is_truncating());
+
+ int double_offset = offset();
+
+ // Immediate values for this stub fit in instructions, so it's safe to use ip.
+ Register scratch = GetRegisterThatIsNotOneOf(input_reg, result_reg);
+ Register scratch_low =
+ GetRegisterThatIsNotOneOf(input_reg, result_reg, scratch);
+ Register scratch_high =
+ GetRegisterThatIsNotOneOf(input_reg, result_reg, scratch, scratch_low);
+ DoubleRegister double_scratch = kScratchDoubleReg;
+
+ __ push(scratch);
+ // Account for saved regs if input is sp.
+ if (input_reg.is(sp)) double_offset += kPointerSize;
+
+ if (!skip_fastpath()) {
+ // Load double input.
+ __ lfd(double_scratch, MemOperand(input_reg, double_offset));
+
+ // Do fast-path convert from double to int.
+ __ ConvertDoubleToInt64(double_scratch,
+#if !V8_TARGET_ARCH_PPC64
+ scratch,
+#endif
+ result_reg, d0);
+
+// Test for overflow
+#if V8_TARGET_ARCH_PPC64
+ __ TestIfInt32(result_reg, scratch, r0);
+#else
+ __ TestIfInt32(scratch, result_reg, r0);
+#endif
+ __ beq(&fastpath_done);
+ }
+
+ __ Push(scratch_high, scratch_low);
+ // Account for saved regs if input is sp.
+ if (input_reg.is(sp)) double_offset += 2 * kPointerSize;
+
+ __ lwz(scratch_high,
+ MemOperand(input_reg, double_offset + Register::kExponentOffset));
+ __ lwz(scratch_low,
+ MemOperand(input_reg, double_offset + Register::kMantissaOffset));
+
+ __ ExtractBitMask(scratch, scratch_high, HeapNumber::kExponentMask);
+ // Load scratch with exponent - 1. This is faster than loading
+ // with exponent because Bias + 1 = 1024 which is a *PPC* immediate value.
+ STATIC_ASSERT(HeapNumber::kExponentBias + 1 == 1024);
+ __ subi(scratch, scratch, Operand(HeapNumber::kExponentBias + 1));
+ // If exponent is greater than or equal to 84, the 32 less significant
+ // bits are 0s (2^84 = 1, 52 significant bits, 32 uncoded bits),
+ // the result is 0.
+ // Compare exponent with 84 (compare exponent - 1 with 83).
+ __ cmpi(scratch, Operand(83));
+ __ bge(&out_of_range);
+
+ // If we reach this code, 31 <= exponent <= 83.
+ // So, we don't have to handle cases where 0 <= exponent <= 20 for
+ // which we would need to shift right the high part of the mantissa.
+ // Scratch contains exponent - 1.
+ // Load scratch with 52 - exponent (load with 51 - (exponent - 1)).
+ __ subfic(scratch, scratch, Operand(51));
+ __ cmpi(scratch, Operand::Zero());
+ __ ble(&only_low);
+ // 21 <= exponent <= 51, shift scratch_low and scratch_high
+ // to generate the result.
+ __ srw(scratch_low, scratch_low, scratch);
+ // Scratch contains: 52 - exponent.
+ // We needs: exponent - 20.
+ // So we use: 32 - scratch = 32 - 52 + exponent = exponent - 20.
+ __ subfic(scratch, scratch, Operand(32));
+ __ ExtractBitMask(result_reg, scratch_high, HeapNumber::kMantissaMask);
+ // Set the implicit 1 before the mantissa part in scratch_high.
+ STATIC_ASSERT(HeapNumber::kMantissaBitsInTopWord >= 16);
+ __ oris(result_reg, result_reg,
+ Operand(1 << ((HeapNumber::kMantissaBitsInTopWord) - 16)));
+ __ slw(r0, result_reg, scratch);
+ __ orx(result_reg, scratch_low, r0);
+ __ b(&negate);
+
+ __ bind(&out_of_range);
+ __ mov(result_reg, Operand::Zero());
+ __ b(&done);
+
+ __ bind(&only_low);
+ // 52 <= exponent <= 83, shift only scratch_low.
+ // On entry, scratch contains: 52 - exponent.
+ __ neg(scratch, scratch);
+ __ slw(result_reg, scratch_low, scratch);
+
+ __ bind(&negate);
+ // If input was positive, scratch_high ASR 31 equals 0 and
+ // scratch_high LSR 31 equals zero.
+ // New result = (result eor 0) + 0 = result.
+ // If the input was negative, we have to negate the result.
+ // Input_high ASR 31 equals 0xffffffff and scratch_high LSR 31 equals 1.
+ // New result = (result eor 0xffffffff) + 1 = 0 - result.
+ __ srawi(r0, scratch_high, 31);
+#if V8_TARGET_ARCH_PPC64
+ __ srdi(r0, r0, Operand(32));
+#endif
+ __ xor_(result_reg, result_reg, r0);
+ __ srwi(r0, scratch_high, Operand(31));
+ __ add(result_reg, result_reg, r0);
+
+ __ bind(&done);
+ __ Pop(scratch_high, scratch_low);
+
+ __ bind(&fastpath_done);
+ __ pop(scratch);
+
+ __ Ret();
+}
+
+
+// Handle the case where the lhs and rhs are the same object.
+// Equality is almost reflexive (everything but NaN), so this is a test
+// for "identity and not NaN".
+static void EmitIdenticalObjectComparison(MacroAssembler* masm, Label* slow,
+ Condition cond) {
+ Label not_identical;
+ Label heap_number, return_equal;
+ __ cmp(r3, r4);
+ __ bne(¬_identical);
+
+ // Test for NaN. Sadly, we can't just compare to Factory::nan_value(),
+ // so we do the second best thing - test it ourselves.
+ // They are both equal and they are not both Smis so both of them are not
+ // Smis. If it's not a heap number, then return equal.
+ if (cond == lt || cond == gt) {
+ __ CompareObjectType(r3, r7, r7, FIRST_SPEC_OBJECT_TYPE);
+ __ bge(slow);
+ } else {
+ __ CompareObjectType(r3, r7, r7, HEAP_NUMBER_TYPE);
+ __ beq(&heap_number);
+ // Comparing JS objects with <=, >= is complicated.
+ if (cond != eq) {
+ __ cmpi(r7, Operand(FIRST_SPEC_OBJECT_TYPE));
+ __ bge(slow);
+ // Normally here we fall through to return_equal, but undefined is
+ // special: (undefined == undefined) == true, but
+ // (undefined <= undefined) == false! See ECMAScript 11.8.5.
+ if (cond == le || cond == ge) {
+ __ cmpi(r7, Operand(ODDBALL_TYPE));
+ __ bne(&return_equal);
+ __ LoadRoot(r5, Heap::kUndefinedValueRootIndex);
+ __ cmp(r3, r5);
+ __ bne(&return_equal);
+ if (cond == le) {
+ // undefined <= undefined should fail.
+ __ li(r3, Operand(GREATER));
+ } else {
+ // undefined >= undefined should fail.
+ __ li(r3, Operand(LESS));
+ }
+ __ Ret();
+ }
+ }
+ }
+
+ __ bind(&return_equal);
+ if (cond == lt) {
+ __ li(r3, Operand(GREATER)); // Things aren't less than themselves.
+ } else if (cond == gt) {
+ __ li(r3, Operand(LESS)); // Things aren't greater than themselves.
+ } else {
+ __ li(r3, Operand(EQUAL)); // Things are <=, >=, ==, === themselves.
+ }
+ __ Ret();
+
+ // For less and greater we don't have to check for NaN since the result of
+ // x < x is false regardless. For the others here is some code to check
+ // for NaN.
+ if (cond != lt && cond != gt) {
+ __ bind(&heap_number);
+ // It is a heap number, so return non-equal if it's NaN and equal if it's
+ // not NaN.
+
+ // The representation of NaN values has all exponent bits (52..62) set,
+ // and not all mantissa bits (0..51) clear.
+ // Read top bits of double representation (second word of value).
+ __ lwz(r5, FieldMemOperand(r3, HeapNumber::kExponentOffset));
+ // Test that exponent bits are all set.
+ STATIC_ASSERT(HeapNumber::kExponentMask == 0x7ff00000u);
+ __ ExtractBitMask(r6, r5, HeapNumber::kExponentMask);
+ __ cmpli(r6, Operand(0x7ff));
+ __ bne(&return_equal);
+
+ // Shift out flag and all exponent bits, retaining only mantissa.
+ __ slwi(r5, r5, Operand(HeapNumber::kNonMantissaBitsInTopWord));
+ // Or with all low-bits of mantissa.
+ __ lwz(r6, FieldMemOperand(r3, HeapNumber::kMantissaOffset));
+ __ orx(r3, r6, r5);
+ __ cmpi(r3, Operand::Zero());
+ // For equal we already have the right value in r3: Return zero (equal)
+ // if all bits in mantissa are zero (it's an Infinity) and non-zero if
+ // not (it's a NaN). For <= and >= we need to load r0 with the failing
+ // value if it's a NaN.
+ if (cond != eq) {
+ Label not_equal;
+ __ bne(¬_equal);
+ // All-zero means Infinity means equal.
+ __ Ret();
+ __ bind(¬_equal);
+ if (cond == le) {
+ __ li(r3, Operand(GREATER)); // NaN <= NaN should fail.
+ } else {
+ __ li(r3, Operand(LESS)); // NaN >= NaN should fail.
+ }
+ }
+ __ Ret();
+ }
+ // No fall through here.
+
+ __ bind(¬_identical);
+}
+
+
+// See comment at call site.
+static void EmitSmiNonsmiComparison(MacroAssembler* masm, Register lhs,
+ Register rhs, Label* lhs_not_nan,
+ Label* slow, bool strict) {
+ DCHECK((lhs.is(r3) && rhs.is(r4)) || (lhs.is(r4) && rhs.is(r3)));
+
+ Label rhs_is_smi;
+ __ JumpIfSmi(rhs, &rhs_is_smi);
+
+ // Lhs is a Smi. Check whether the rhs is a heap number.
+ __ CompareObjectType(rhs, r6, r7, HEAP_NUMBER_TYPE);
+ if (strict) {
+ // If rhs is not a number and lhs is a Smi then strict equality cannot
+ // succeed. Return non-equal
+ // If rhs is r3 then there is already a non zero value in it.
+ Label skip;
+ __ beq(&skip);
+ if (!rhs.is(r3)) {
+ __ mov(r3, Operand(NOT_EQUAL));
+ }
+ __ Ret();
+ __ bind(&skip);
+ } else {
+ // Smi compared non-strictly with a non-Smi non-heap-number. Call
+ // the runtime.
+ __ bne(slow);
+ }
+
+ // Lhs is a smi, rhs is a number.
+ // Convert lhs to a double in d7.
+ __ SmiToDouble(d7, lhs);
+ // Load the double from rhs, tagged HeapNumber r3, to d6.
+ __ lfd(d6, FieldMemOperand(rhs, HeapNumber::kValueOffset));
+
+ // We now have both loaded as doubles but we can skip the lhs nan check
+ // since it's a smi.
+ __ b(lhs_not_nan);
+
+ __ bind(&rhs_is_smi);
+ // Rhs is a smi. Check whether the non-smi lhs is a heap number.
+ __ CompareObjectType(lhs, r7, r7, HEAP_NUMBER_TYPE);
+ if (strict) {
+ // If lhs is not a number and rhs is a smi then strict equality cannot
+ // succeed. Return non-equal.
+ // If lhs is r3 then there is already a non zero value in it.
+ Label skip;
+ __ beq(&skip);
+ if (!lhs.is(r3)) {
+ __ mov(r3, Operand(NOT_EQUAL));
+ }
+ __ Ret();
+ __ bind(&skip);
+ } else {
+ // Smi compared non-strictly with a non-smi non-heap-number. Call
+ // the runtime.
+ __ bne(slow);
+ }
+
+ // Rhs is a smi, lhs is a heap number.
+ // Load the double from lhs, tagged HeapNumber r4, to d7.
+ __ lfd(d7, FieldMemOperand(lhs, HeapNumber::kValueOffset));
+ // Convert rhs to a double in d6.
+ __ SmiToDouble(d6, rhs);
+ // Fall through to both_loaded_as_doubles.
+}
+
+
+// See comment at call site.
+static void EmitStrictTwoHeapObjectCompare(MacroAssembler* masm, Register lhs,
+ Register rhs) {
+ DCHECK((lhs.is(r3) && rhs.is(r4)) || (lhs.is(r4) && rhs.is(r3)));
+
+ // If either operand is a JS object or an oddball value, then they are
+ // not equal since their pointers are different.
+ // There is no test for undetectability in strict equality.
+ STATIC_ASSERT(LAST_TYPE == LAST_SPEC_OBJECT_TYPE);
+ Label first_non_object;
+ // Get the type of the first operand into r5 and compare it with
+ // FIRST_SPEC_OBJECT_TYPE.
+ __ CompareObjectType(rhs, r5, r5, FIRST_SPEC_OBJECT_TYPE);
+ __ blt(&first_non_object);
+
+ // Return non-zero (r3 is not zero)
+ Label return_not_equal;
+ __ bind(&return_not_equal);
+ __ Ret();
+
+ __ bind(&first_non_object);
+ // Check for oddballs: true, false, null, undefined.
+ __ cmpi(r5, Operand(ODDBALL_TYPE));
+ __ beq(&return_not_equal);
+
+ __ CompareObjectType(lhs, r6, r6, FIRST_SPEC_OBJECT_TYPE);
+ __ bge(&return_not_equal);
+
+ // Check for oddballs: true, false, null, undefined.
+ __ cmpi(r6, Operand(ODDBALL_TYPE));
+ __ beq(&return_not_equal);
+
+ // Now that we have the types we might as well check for
+ // internalized-internalized.
+ STATIC_ASSERT(kInternalizedTag == 0 && kStringTag == 0);
+ __ orx(r5, r5, r6);
+ __ andi(r0, r5, Operand(kIsNotStringMask | kIsNotInternalizedMask));
+ __ beq(&return_not_equal, cr0);
+}
+
+
+// See comment at call site.
+static void EmitCheckForTwoHeapNumbers(MacroAssembler* masm, Register lhs,
+ Register rhs,
+ Label* both_loaded_as_doubles,
+ Label* not_heap_numbers, Label* slow) {
+ DCHECK((lhs.is(r3) && rhs.is(r4)) || (lhs.is(r4) && rhs.is(r3)));
+
+ __ CompareObjectType(rhs, r6, r5, HEAP_NUMBER_TYPE);
+ __ bne(not_heap_numbers);
+ __ LoadP(r5, FieldMemOperand(lhs, HeapObject::kMapOffset));
+ __ cmp(r5, r6);
+ __ bne(slow); // First was a heap number, second wasn't. Go slow case.
+
+ // Both are heap numbers. Load them up then jump to the code we have
+ // for that.
+ __ lfd(d6, FieldMemOperand(rhs, HeapNumber::kValueOffset));
+ __ lfd(d7, FieldMemOperand(lhs, HeapNumber::kValueOffset));
+
+ __ b(both_loaded_as_doubles);
+}
+
+
+// Fast negative check for internalized-to-internalized equality.
+static void EmitCheckForInternalizedStringsOrObjects(MacroAssembler* masm,
+ Register lhs, Register rhs,
+ Label* possible_strings,
+ Label* not_both_strings) {
+ DCHECK((lhs.is(r3) && rhs.is(r4)) || (lhs.is(r4) && rhs.is(r3)));
+
+ // r5 is object type of rhs.
+ Label object_test;
+ STATIC_ASSERT(kInternalizedTag == 0 && kStringTag == 0);
+ __ andi(r0, r5, Operand(kIsNotStringMask));
+ __ bne(&object_test, cr0);
+ __ andi(r0, r5, Operand(kIsNotInternalizedMask));
+ __ bne(possible_strings, cr0);
+ __ CompareObjectType(lhs, r6, r6, FIRST_NONSTRING_TYPE);
+ __ bge(not_both_strings);
+ __ andi(r0, r6, Operand(kIsNotInternalizedMask));
+ __ bne(possible_strings, cr0);
+
+ // Both are internalized. We already checked they weren't the same pointer
+ // so they are not equal.
+ __ li(r3, Operand(NOT_EQUAL));
+ __ Ret();
+
+ __ bind(&object_test);
+ __ cmpi(r5, Operand(FIRST_SPEC_OBJECT_TYPE));
+ __ blt(not_both_strings);
+ __ CompareObjectType(lhs, r5, r6, FIRST_SPEC_OBJECT_TYPE);
+ __ blt(not_both_strings);
+ // If both objects are undetectable, they are equal. Otherwise, they
+ // are not equal, since they are different objects and an object is not
+ // equal to undefined.
+ __ LoadP(r6, FieldMemOperand(rhs, HeapObject::kMapOffset));
+ __ lbz(r5, FieldMemOperand(r5, Map::kBitFieldOffset));
+ __ lbz(r6, FieldMemOperand(r6, Map::kBitFieldOffset));
+ __ and_(r3, r5, r6);
+ __ andi(r3, r3, Operand(1 << Map::kIsUndetectable));
+ __ xori(r3, r3, Operand(1 << Map::kIsUndetectable));
+ __ Ret();
+}
+
+
+static void CompareICStub_CheckInputType(MacroAssembler* masm, Register input,
+ Register scratch,
+ CompareICState::State expected,
+ Label* fail) {
+ Label ok;
+ if (expected == CompareICState::SMI) {
+ __ JumpIfNotSmi(input, fail);
+ } else if (expected == CompareICState::NUMBER) {
+ __ JumpIfSmi(input, &ok);
+ __ CheckMap(input, scratch, Heap::kHeapNumberMapRootIndex, fail,
+ DONT_DO_SMI_CHECK);
+ }
+ // We could be strict about internalized/non-internalized here, but as long as
+ // hydrogen doesn't care, the stub doesn't have to care either.
+ __ bind(&ok);
+}
+
+
+// On entry r4 and r5 are the values to be compared.
+// On exit r3 is 0, positive or negative to indicate the result of
+// the comparison.
+void CompareICStub::GenerateGeneric(MacroAssembler* masm) {
+ Register lhs = r4;
+ Register rhs = r3;
+ Condition cc = GetCondition();
+
+ Label miss;
+ CompareICStub_CheckInputType(masm, lhs, r5, left(), &miss);
+ CompareICStub_CheckInputType(masm, rhs, r6, right(), &miss);
+
+ Label slow; // Call builtin.
+ Label not_smis, both_loaded_as_doubles, lhs_not_nan;
+
+ Label not_two_smis, smi_done;
+ __ orx(r5, r4, r3);
+ __ JumpIfNotSmi(r5, ¬_two_smis);
+ __ SmiUntag(r4);
+ __ SmiUntag(r3);
+ __ sub(r3, r4, r3);
+ __ Ret();
+ __ bind(¬_two_smis);
+
+ // NOTICE! This code is only reached after a smi-fast-case check, so
+ // it is certain that at least one operand isn't a smi.
+
+ // Handle the case where the objects are identical. Either returns the answer
+ // or goes to slow. Only falls through if the objects were not identical.
+ EmitIdenticalObjectComparison(masm, &slow, cc);
+
+ // If either is a Smi (we know that not both are), then they can only
+ // be strictly equal if the other is a HeapNumber.
+ STATIC_ASSERT(kSmiTag == 0);
+ DCHECK_EQ(0, Smi::FromInt(0));
+ __ and_(r5, lhs, rhs);
+ __ JumpIfNotSmi(r5, ¬_smis);
+ // One operand is a smi. EmitSmiNonsmiComparison generates code that can:
+ // 1) Return the answer.
+ // 2) Go to slow.
+ // 3) Fall through to both_loaded_as_doubles.
+ // 4) Jump to lhs_not_nan.
+ // In cases 3 and 4 we have found out we were dealing with a number-number
+ // comparison. The double values of the numbers have been loaded
+ // into d7 and d6.
+ EmitSmiNonsmiComparison(masm, lhs, rhs, &lhs_not_nan, &slow, strict());
+
+ __ bind(&both_loaded_as_doubles);
+ // The arguments have been converted to doubles and stored in d6 and d7
+ __ bind(&lhs_not_nan);
+ Label no_nan;
+ __ fcmpu(d7, d6);
+
+ Label nan, equal, less_than;
+ __ bunordered(&nan);
+ __ beq(&equal);
+ __ blt(&less_than);
+ __ li(r3, Operand(GREATER));
+ __ Ret();
+ __ bind(&equal);
+ __ li(r3, Operand(EQUAL));
+ __ Ret();
+ __ bind(&less_than);
+ __ li(r3, Operand(LESS));
+ __ Ret();
+
+ __ bind(&nan);
+ // If one of the sides was a NaN then the v flag is set. Load r3 with
+ // whatever it takes to make the comparison fail, since comparisons with NaN
+ // always fail.
+ if (cc == lt || cc == le) {
+ __ li(r3, Operand(GREATER));
+ } else {
+ __ li(r3, Operand(LESS));
+ }
+ __ Ret();
+
+ __ bind(¬_smis);
+ // At this point we know we are dealing with two different objects,
+ // and neither of them is a Smi. The objects are in rhs_ and lhs_.
+ if (strict()) {
+ // This returns non-equal for some object types, or falls through if it
+ // was not lucky.
+ EmitStrictTwoHeapObjectCompare(masm, lhs, rhs);
+ }
+
+ Label check_for_internalized_strings;
+ Label flat_string_check;
+ // Check for heap-number-heap-number comparison. Can jump to slow case,
+ // or load both doubles into r3, r4, r5, r6 and jump to the code that handles
+ // that case. If the inputs are not doubles then jumps to
+ // check_for_internalized_strings.
+ // In this case r5 will contain the type of rhs_. Never falls through.
+ EmitCheckForTwoHeapNumbers(masm, lhs, rhs, &both_loaded_as_doubles,
+ &check_for_internalized_strings,
+ &flat_string_check);
+
+ __ bind(&check_for_internalized_strings);
+ // In the strict case the EmitStrictTwoHeapObjectCompare already took care of
+ // internalized strings.
+ if (cc == eq && !strict()) {
+ // Returns an answer for two internalized strings or two detectable objects.
+ // Otherwise jumps to string case or not both strings case.
+ // Assumes that r5 is the type of rhs_ on entry.
+ EmitCheckForInternalizedStringsOrObjects(masm, lhs, rhs, &flat_string_check,
+ &slow);
+ }
+
+ // Check for both being sequential one-byte strings,
+ // and inline if that is the case.
+ __ bind(&flat_string_check);
+
+ __ JumpIfNonSmisNotBothSequentialOneByteStrings(lhs, rhs, r5, r6, &slow);
+
+ __ IncrementCounter(isolate()->counters()->string_compare_native(), 1, r5,
+ r6);
+ if (cc == eq) {
+ StringHelper::GenerateFlatOneByteStringEquals(masm, lhs, rhs, r5, r6);
+ } else {
+ StringHelper::GenerateCompareFlatOneByteStrings(masm, lhs, rhs, r5, r6, r7);
+ }
+ // Never falls through to here.
+
+ __ bind(&slow);
+
+ __ Push(lhs, rhs);
+ // Figure out which native to call and setup the arguments.
+ Builtins::JavaScript native;
+ if (cc == eq) {
+ native = strict() ? Builtins::STRICT_EQUALS : Builtins::EQUALS;
+ } else {
+ native = Builtins::COMPARE;
+ int ncr; // NaN compare result
+ if (cc == lt || cc == le) {
+ ncr = GREATER;
+ } else {
+ DCHECK(cc == gt || cc == ge); // remaining cases
+ ncr = LESS;
+ }
+ __ LoadSmiLiteral(r3, Smi::FromInt(ncr));
+ __ push(r3);
+ }
+
+ // Call the native; it returns -1 (less), 0 (equal), or 1 (greater)
+ // tagged as a small integer.
+ __ InvokeBuiltin(native, JUMP_FUNCTION);
+
+ __ bind(&miss);
+ GenerateMiss(masm);
+}
+
+
+void StoreBufferOverflowStub::Generate(MacroAssembler* masm) {
+ // We don't allow a GC during a store buffer overflow so there is no need to
+ // store the registers in any particular way, but we do have to store and
+ // restore them.
+ __ mflr(r0);
+ __ MultiPush(kJSCallerSaved | r0.bit());
+ if (save_doubles()) {
+ __ SaveFPRegs(sp, 0, DoubleRegister::kNumVolatileRegisters);
+ }
+ const int argument_count = 1;
+ const int fp_argument_count = 0;
+ const Register scratch = r4;
+
+ AllowExternalCallThatCantCauseGC scope(masm);
+ __ PrepareCallCFunction(argument_count, fp_argument_count, scratch);
+ __ mov(r3, Operand(ExternalReference::isolate_address(isolate())));
+ __ CallCFunction(ExternalReference::store_buffer_overflow_function(isolate()),
+ argument_count);
+ if (save_doubles()) {
+ __ RestoreFPRegs(sp, 0, DoubleRegister::kNumVolatileRegisters);
+ }
+ __ MultiPop(kJSCallerSaved | r0.bit());
+ __ mtlr(r0);
+ __ Ret();
+}
+
+
+void StoreRegistersStateStub::Generate(MacroAssembler* masm) {
+ __ PushSafepointRegisters();
+ __ blr();
+}
+
+
+void RestoreRegistersStateStub::Generate(MacroAssembler* masm) {
+ __ PopSafepointRegisters();
+ __ blr();
+}
+
+
+void MathPowStub::Generate(MacroAssembler* masm) {
+ const Register base = r4;
+ const Register exponent = MathPowTaggedDescriptor::exponent();
+ DCHECK(exponent.is(r5));
+ const Register heapnumbermap = r8;
+ const Register heapnumber = r3;
+ const DoubleRegister double_base = d1;
+ const DoubleRegister double_exponent = d2;
+ const DoubleRegister double_result = d3;
+ const DoubleRegister double_scratch = d0;
+ const Register scratch = r11;
+ const Register scratch2 = r10;
+
+ Label call_runtime, done, int_exponent;
+ if (exponent_type() == ON_STACK) {
+ Label base_is_smi, unpack_exponent;
+ // The exponent and base are supplied as arguments on the stack.
+ // This can only happen if the stub is called from non-optimized code.
+ // Load input parameters from stack to double registers.
+ __ LoadP(base, MemOperand(sp, 1 * kPointerSize));
+ __ LoadP(exponent, MemOperand(sp, 0 * kPointerSize));
+
+ __ LoadRoot(heapnumbermap, Heap::kHeapNumberMapRootIndex);
+
+ __ UntagAndJumpIfSmi(scratch, base, &base_is_smi);
+ __ LoadP(scratch, FieldMemOperand(base, JSObject::kMapOffset));
+ __ cmp(scratch, heapnumbermap);
+ __ bne(&call_runtime);
+
+ __ lfd(double_base, FieldMemOperand(base, HeapNumber::kValueOffset));
+ __ b(&unpack_exponent);
+
+ __ bind(&base_is_smi);
+ __ ConvertIntToDouble(scratch, double_base);
+ __ bind(&unpack_exponent);
+
+ __ UntagAndJumpIfSmi(scratch, exponent, &int_exponent);
+ __ LoadP(scratch, FieldMemOperand(exponent, JSObject::kMapOffset));
+ __ cmp(scratch, heapnumbermap);
+ __ bne(&call_runtime);
+
+ __ lfd(double_exponent,
+ FieldMemOperand(exponent, HeapNumber::kValueOffset));
+ } else if (exponent_type() == TAGGED) {
+ // Base is already in double_base.
+ __ UntagAndJumpIfSmi(scratch, exponent, &int_exponent);
+
+ __ lfd(double_exponent,
+ FieldMemOperand(exponent, HeapNumber::kValueOffset));
+ }
+
+ if (exponent_type() != INTEGER) {
+ // Detect integer exponents stored as double.
+ __ TryDoubleToInt32Exact(scratch, double_exponent, scratch2,
+ double_scratch);
+ __ beq(&int_exponent);
+
+ if (exponent_type() == ON_STACK) {
+ // Detect square root case. Crankshaft detects constant +/-0.5 at
+ // compile time and uses DoMathPowHalf instead. We then skip this check
+ // for non-constant cases of +/-0.5 as these hardly occur.
+ Label not_plus_half, not_minus_inf1, not_minus_inf2;
+
+ // Test for 0.5.
+ __ LoadDoubleLiteral(double_scratch, 0.5, scratch);
+ __ fcmpu(double_exponent, double_scratch);
+ __ bne(¬_plus_half);
+
+ // Calculates square root of base. Check for the special case of
+ // Math.pow(-Infinity, 0.5) == Infinity (ECMA spec, 15.8.2.13).
+ __ LoadDoubleLiteral(double_scratch, -V8_INFINITY, scratch);
+ __ fcmpu(double_base, double_scratch);
+ __ bne(¬_minus_inf1);
+ __ fneg(double_result, double_scratch);
+ __ b(&done);
+ __ bind(¬_minus_inf1);
+
+ // Add +0 to convert -0 to +0.
+ __ fadd(double_scratch, double_base, kDoubleRegZero);
+ __ fsqrt(double_result, double_scratch);
+ __ b(&done);
+
+ __ bind(¬_plus_half);
+ __ LoadDoubleLiteral(double_scratch, -0.5, scratch);
+ __ fcmpu(double_exponent, double_scratch);
+ __ bne(&call_runtime);
+
+ // Calculates square root of base. Check for the special case of
+ // Math.pow(-Infinity, -0.5) == 0 (ECMA spec, 15.8.2.13).
+ __ LoadDoubleLiteral(double_scratch, -V8_INFINITY, scratch);
+ __ fcmpu(double_base, double_scratch);
+ __ bne(¬_minus_inf2);
+ __ fmr(double_result, kDoubleRegZero);
+ __ b(&done);
+ __ bind(¬_minus_inf2);
+
+ // Add +0 to convert -0 to +0.
+ __ fadd(double_scratch, double_base, kDoubleRegZero);
+ __ LoadDoubleLiteral(double_result, 1.0, scratch);
+ __ fsqrt(double_scratch, double_scratch);
+ __ fdiv(double_result, double_result, double_scratch);
+ __ b(&done);
+ }
+
+ __ mflr(r0);
+ __ push(r0);
+ {
+ AllowExternalCallThatCantCauseGC scope(masm);
+ __ PrepareCallCFunction(0, 2, scratch);
+ __ MovToFloatParameters(double_base, double_exponent);
+ __ CallCFunction(
+ ExternalReference::power_double_double_function(isolate()), 0, 2);
+ }
+ __ pop(r0);
+ __ mtlr(r0);
+ __ MovFromFloatResult(double_result);
+ __ b(&done);
+ }
+
+ // Calculate power with integer exponent.
+ __ bind(&int_exponent);
+
+ // Get two copies of exponent in the registers scratch and exponent.
+ if (exponent_type() == INTEGER) {
+ __ mr(scratch, exponent);
+ } else {
+ // Exponent has previously been stored into scratch as untagged integer.
+ __ mr(exponent, scratch);
+ }
+ __ fmr(double_scratch, double_base); // Back up base.
+ __ li(scratch2, Operand(1));
+ __ ConvertIntToDouble(scratch2, double_result);
+
+ // Get absolute value of exponent.
+ Label positive_exponent;
+ __ cmpi(scratch, Operand::Zero());
+ __ bge(&positive_exponent);
+ __ neg(scratch, scratch);
+ __ bind(&positive_exponent);
+
+ Label while_true, no_carry, loop_end;
+ __ bind(&while_true);
+ __ andi(scratch2, scratch, Operand(1));
+ __ beq(&no_carry, cr0);
+ __ fmul(double_result, double_result, double_scratch);
+ __ bind(&no_carry);
+ __ ShiftRightArithImm(scratch, scratch, 1, SetRC);
+ __ beq(&loop_end, cr0);
+ __ fmul(double_scratch, double_scratch, double_scratch);
+ __ b(&while_true);
+ __ bind(&loop_end);
+
+ __ cmpi(exponent, Operand::Zero());
+ __ bge(&done);
+
+ __ li(scratch2, Operand(1));
+ __ ConvertIntToDouble(scratch2, double_scratch);
+ __ fdiv(double_result, double_scratch, double_result);
+ // Test whether result is zero. Bail out to check for subnormal result.
+ // Due to subnormals, x^-y == (1/x)^y does not hold in all cases.
+ __ fcmpu(double_result, kDoubleRegZero);
+ __ bne(&done);
+ // double_exponent may not containe the exponent value if the input was a
+ // smi. We set it with exponent value before bailing out.
+ __ ConvertIntToDouble(exponent, double_exponent);
+
+ // Returning or bailing out.
+ Counters* counters = isolate()->counters();
+ if (exponent_type() == ON_STACK) {
+ // The arguments are still on the stack.
+ __ bind(&call_runtime);
+ __ TailCallRuntime(Runtime::kMathPowRT, 2, 1);
+
+ // The stub is called from non-optimized code, which expects the result
+ // as heap number in exponent.
+ __ bind(&done);
+ __ AllocateHeapNumber(heapnumber, scratch, scratch2, heapnumbermap,
+ &call_runtime);
+ __ stfd(double_result,
+ FieldMemOperand(heapnumber, HeapNumber::kValueOffset));
+ DCHECK(heapnumber.is(r3));
+ __ IncrementCounter(counters->math_pow(), 1, scratch, scratch2);
+ __ Ret(2);
+ } else {
+ __ mflr(r0);
+ __ push(r0);
+ {
+ AllowExternalCallThatCantCauseGC scope(masm);
+ __ PrepareCallCFunction(0, 2, scratch);
+ __ MovToFloatParameters(double_base, double_exponent);
+ __ CallCFunction(
+ ExternalReference::power_double_double_function(isolate()), 0, 2);
+ }
+ __ pop(r0);
+ __ mtlr(r0);
+ __ MovFromFloatResult(double_result);
+
+ __ bind(&done);
+ __ IncrementCounter(counters->math_pow(), 1, scratch, scratch2);
+ __ Ret();
+ }
+}
+
+
+bool CEntryStub::NeedsImmovableCode() { return true; }
+
+
+void CodeStub::GenerateStubsAheadOfTime(Isolate* isolate) {
+ CEntryStub::GenerateAheadOfTime(isolate);
+ // WriteInt32ToHeapNumberStub::GenerateFixedRegStubsAheadOfTime(isolate);
+ StoreBufferOverflowStub::GenerateFixedRegStubsAheadOfTime(isolate);
+ StubFailureTrampolineStub::GenerateAheadOfTime(isolate);
+ ArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
+ CreateAllocationSiteStub::GenerateAheadOfTime(isolate);
+ BinaryOpICStub::GenerateAheadOfTime(isolate);
+ StoreRegistersStateStub::GenerateAheadOfTime(isolate);
+ RestoreRegistersStateStub::GenerateAheadOfTime(isolate);
+ BinaryOpICWithAllocationSiteStub::GenerateAheadOfTime(isolate);
+}
+
+
+void StoreRegistersStateStub::GenerateAheadOfTime(Isolate* isolate) {
+ StoreRegistersStateStub stub(isolate);
+ stub.GetCode();
+}
+
+
+void RestoreRegistersStateStub::GenerateAheadOfTime(Isolate* isolate) {
+ RestoreRegistersStateStub stub(isolate);
+ stub.GetCode();
+}
+
+
+void CodeStub::GenerateFPStubs(Isolate* isolate) {
+ // Generate if not already in cache.
+ SaveFPRegsMode mode = kSaveFPRegs;
+ CEntryStub(isolate, 1, mode).GetCode();
+ StoreBufferOverflowStub(isolate, mode).GetCode();
+ isolate->set_fp_stubs_generated(true);
+}
+
+
+void CEntryStub::GenerateAheadOfTime(Isolate* isolate) {
+ CEntryStub stub(isolate, 1, kDontSaveFPRegs);
+ stub.GetCode();
+}
+
+
+void CEntryStub::Generate(MacroAssembler* masm) {
+ // Called from JavaScript; parameters are on stack as if calling JS function.
+ // r3: number of arguments including receiver
+ // r4: pointer to builtin function
+ // fp: frame pointer (restored after C call)
+ // sp: stack pointer (restored as callee's sp after C call)
+ // cp: current context (C callee-saved)
+
+ ProfileEntryHookStub::MaybeCallEntryHook(masm);
+
+ __ mr(r15, r4);
+
+ // Compute the argv pointer.
+ __ ShiftLeftImm(r4, r3, Operand(kPointerSizeLog2));
+ __ add(r4, r4, sp);
+ __ subi(r4, r4, Operand(kPointerSize));
+
+ // Enter the exit frame that transitions from JavaScript to C++.
+ FrameScope scope(masm, StackFrame::MANUAL);
+
+ // Need at least one extra slot for return address location.
+ int arg_stack_space = 1;
+
+// PPC LINUX ABI:
+#if V8_TARGET_ARCH_PPC64 && !ABI_RETURNS_OBJECT_PAIRS_IN_REGS
+ // Pass buffer for return value on stack if necessary
+ if (result_size() > 1) {
+ DCHECK_EQ(2, result_size());
+ arg_stack_space += 2;
+ }
+#endif
+
+ __ EnterExitFrame(save_doubles(), arg_stack_space);
+
+ // Store a copy of argc in callee-saved registers for later.
+ __ mr(r14, r3);
+
+ // r3, r14: number of arguments including receiver (C callee-saved)
+ // r4: pointer to the first argument
+ // r15: pointer to builtin function (C callee-saved)
+
+ // Result returned in registers or stack, depending on result size and ABI.
+
+ Register isolate_reg = r5;
+#if V8_TARGET_ARCH_PPC64 && !ABI_RETURNS_OBJECT_PAIRS_IN_REGS
+ if (result_size() > 1) {
+ // The return value is 16-byte non-scalar value.
+ // Use frame storage reserved by calling function to pass return
+ // buffer as implicit first argument.
+ __ mr(r5, r4);
+ __ mr(r4, r3);
+ __ addi(r3, sp, Operand((kStackFrameExtraParamSlot + 1) * kPointerSize));
+ isolate_reg = r6;
+ }
+#endif
+
+ // Call C built-in.
+ __ mov(isolate_reg, Operand(ExternalReference::isolate_address(isolate())));
+
+#if ABI_USES_FUNCTION_DESCRIPTORS && !defined(USE_SIMULATOR)
+ // Native AIX/PPC64 Linux use a function descriptor.
+ __ LoadP(ToRegister(ABI_TOC_REGISTER), MemOperand(r15, kPointerSize));
+ __ LoadP(ip, MemOperand(r15, 0)); // Instruction address
+ Register target = ip;
+#elif ABI_TOC_ADDRESSABILITY_VIA_IP
+ __ Move(ip, r15);
+ Register target = ip;
+#else
+ Register target = r15;
+#endif
+
+ // To let the GC traverse the return address of the exit frames, we need to
+ // know where the return address is. The CEntryStub is unmovable, so
+ // we can store the address on the stack to be able to find it again and
+ // we never have to restore it, because it will not change.
+ // Compute the return address in lr to return to after the jump below. Pc is
+ // already at '+ 8' from the current instruction but return is after three
+ // instructions so add another 4 to pc to get the return address.
+ {
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm);
+ Label here;
+ __ b(&here, SetLK);
+ __ bind(&here);
+ __ mflr(r8);
+
+ // Constant used below is dependent on size of Call() macro instructions
+ __ addi(r0, r8, Operand(20));
+
+ __ StoreP(r0, MemOperand(sp, kStackFrameExtraParamSlot * kPointerSize));
+ __ Call(target);
+ }
+
+#if V8_TARGET_ARCH_PPC64 && !ABI_RETURNS_OBJECT_PAIRS_IN_REGS
+ // If return value is on the stack, pop it to registers.
+ if (result_size() > 1) {
+ __ LoadP(r4, MemOperand(r3, kPointerSize));
+ __ LoadP(r3, MemOperand(r3));
+ }
+#endif
+
+ // Runtime functions should not return 'the hole'. Allowing it to escape may
+ // lead to crashes in the IC code later.
+ if (FLAG_debug_code) {
+ Label okay;
+ __ CompareRoot(r3, Heap::kTheHoleValueRootIndex);
+ __ bne(&okay);
+ __ stop("The hole escaped");
+ __ bind(&okay);
+ }
+
+ // Check result for exception sentinel.
+ Label exception_returned;
+ __ CompareRoot(r3, Heap::kExceptionRootIndex);
+ __ beq(&exception_returned);
+
+ ExternalReference pending_exception_address(Isolate::kPendingExceptionAddress,
+ isolate());
+
+ // Check that there is no pending exception, otherwise we
+ // should have returned the exception sentinel.
+ if (FLAG_debug_code) {
+ Label okay;
+ __ mov(r5, Operand(pending_exception_address));
+ __ LoadP(r5, MemOperand(r5));
+ __ CompareRoot(r5, Heap::kTheHoleValueRootIndex);
+ // Cannot use check here as it attempts to generate call into runtime.
+ __ beq(&okay);
+ __ stop("Unexpected pending exception");
+ __ bind(&okay);
+ }
+
+ // Exit C frame and return.
+ // r3:r4: result
+ // sp: stack pointer
+ // fp: frame pointer
+ // r14: still holds argc (callee-saved).
+ __ LeaveExitFrame(save_doubles(), r14, true);
+ __ blr();
+
+ // Handling of exception.
+ __ bind(&exception_returned);
+
+ // Retrieve the pending exception.
+ __ mov(r5, Operand(pending_exception_address));
+ __ LoadP(r3, MemOperand(r5));
+
+ // Clear the pending exception.
+ __ LoadRoot(r6, Heap::kTheHoleValueRootIndex);
+ __ StoreP(r6, MemOperand(r5));
+
+ // Special handling of termination exceptions which are uncatchable
+ // by javascript code.
+ Label throw_termination_exception;
+ __ CompareRoot(r3, Heap::kTerminationExceptionRootIndex);
+ __ beq(&throw_termination_exception);
+
+ // Handle normal exception.
+ __ Throw(r3);
+
+ __ bind(&throw_termination_exception);
+ __ ThrowUncatchable(r3);
+}
+
+
+void JSEntryStub::Generate(MacroAssembler* masm) {
+ // r3: code entry
+ // r4: function
+ // r5: receiver
+ // r6: argc
+ // [sp+0]: argv
+
+ Label invoke, handler_entry, exit;
+
+// Called from C
+#if ABI_USES_FUNCTION_DESCRIPTORS
+ __ function_descriptor();
+#endif
+
+ ProfileEntryHookStub::MaybeCallEntryHook(masm);
+
+ // PPC LINUX ABI:
+ // preserve LR in pre-reserved slot in caller's frame
+ __ mflr(r0);
+ __ StoreP(r0, MemOperand(sp, kStackFrameLRSlot * kPointerSize));
+
+ // Save callee saved registers on the stack.
+ __ MultiPush(kCalleeSaved);
+
+ // Floating point regs FPR0 - FRP13 are volatile
+ // FPR14-FPR31 are non-volatile, but sub-calls will save them for us
+
+ // int offset_to_argv = kPointerSize * 22; // matches (22*4) above
+ // __ lwz(r7, MemOperand(sp, offset_to_argv));
+
+ // Push a frame with special values setup to mark it as an entry frame.
+ // r3: code entry
+ // r4: function
+ // r5: receiver
+ // r6: argc
+ // r7: argv
+ __ li(r0, Operand(-1)); // Push a bad frame pointer to fail if it is used.
+ __ push(r0);
+#if V8_OOL_CONSTANT_POOL
+ __ mov(kConstantPoolRegister,
+ Operand(isolate()->factory()->empty_constant_pool_array()));
+ __ push(kConstantPoolRegister);
+#endif
+ int marker = type();
+ __ LoadSmiLiteral(r0, Smi::FromInt(marker));
+ __ push(r0);
+ __ push(r0);
+ // Save copies of the top frame descriptor on the stack.
+ __ mov(r8, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate())));
+ __ LoadP(r0, MemOperand(r8));
+ __ push(r0);
+
+ // Set up frame pointer for the frame to be pushed.
+ __ addi(fp, sp, Operand(-EntryFrameConstants::kCallerFPOffset));
+
+ // If this is the outermost JS call, set js_entry_sp value.
+ Label non_outermost_js;
+ ExternalReference js_entry_sp(Isolate::kJSEntrySPAddress, isolate());
+ __ mov(r8, Operand(ExternalReference(js_entry_sp)));
+ __ LoadP(r9, MemOperand(r8));
+ __ cmpi(r9, Operand::Zero());
+ __ bne(&non_outermost_js);
+ __ StoreP(fp, MemOperand(r8));
+ __ LoadSmiLiteral(ip, Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
+ Label cont;
+ __ b(&cont);
+ __ bind(&non_outermost_js);
+ __ LoadSmiLiteral(ip, Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME));
+ __ bind(&cont);
+ __ push(ip); // frame-type
+
+ // Jump to a faked try block that does the invoke, with a faked catch
+ // block that sets the pending exception.
+ __ b(&invoke);
+
+ __ bind(&handler_entry);
+ handler_offset_ = handler_entry.pos();
+ // Caught exception: Store result (exception) in the pending exception
+ // field in the JSEnv and return a failure sentinel. Coming in here the
+ // fp will be invalid because the PushTryHandler below sets it to 0 to
+ // signal the existence of the JSEntry frame.
+ __ mov(ip, Operand(ExternalReference(Isolate::kPendingExceptionAddress,
+ isolate())));
+
+ __ StoreP(r3, MemOperand(ip));
+ __ LoadRoot(r3, Heap::kExceptionRootIndex);
+ __ b(&exit);
+
+ // Invoke: Link this frame into the handler chain. There's only one
+ // handler block in this code object, so its index is 0.
+ __ bind(&invoke);
+ // Must preserve r0-r4, r5-r7 are available. (needs update for PPC)
+ __ PushTryHandler(StackHandler::JS_ENTRY, 0);
+ // If an exception not caught by another handler occurs, this handler
+ // returns control to the code after the b(&invoke) above, which
+ // restores all kCalleeSaved registers (including cp and fp) to their
+ // saved values before returning a failure to C.
+
+ // Clear any pending exceptions.
+ __ mov(r8, Operand(isolate()->factory()->the_hole_value()));
+ __ mov(ip, Operand(ExternalReference(Isolate::kPendingExceptionAddress,
+ isolate())));
+ __ StoreP(r8, MemOperand(ip));
+
+ // Invoke the function by calling through JS entry trampoline builtin.
+ // Notice that we cannot store a reference to the trampoline code directly in
+ // this stub, because runtime stubs are not traversed when doing GC.
+
+ // Expected registers by Builtins::JSEntryTrampoline
+ // r3: code entry
+ // r4: function
+ // r5: receiver
+ // r6: argc
+ // r7: argv
+ if (type() == StackFrame::ENTRY_CONSTRUCT) {
+ ExternalReference construct_entry(Builtins::kJSConstructEntryTrampoline,
+ isolate());
+ __ mov(ip, Operand(construct_entry));
+ } else {
+ ExternalReference entry(Builtins::kJSEntryTrampoline, isolate());
+ __ mov(ip, Operand(entry));
+ }
+ __ LoadP(ip, MemOperand(ip)); // deref address
+
+ // Branch and link to JSEntryTrampoline.
+ // the address points to the start of the code object, skip the header
+ __ addi(ip, ip, Operand(Code::kHeaderSize - kHeapObjectTag));
+ __ mtctr(ip);
+ __ bctrl(); // make the call
+
+ // Unlink this frame from the handler chain.
+ __ PopTryHandler();
+
+ __ bind(&exit); // r3 holds result
+ // Check if the current stack frame is marked as the outermost JS frame.
+ Label non_outermost_js_2;
+ __ pop(r8);
+ __ CmpSmiLiteral(r8, Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME), r0);
+ __ bne(&non_outermost_js_2);
+ __ mov(r9, Operand::Zero());
+ __ mov(r8, Operand(ExternalReference(js_entry_sp)));
+ __ StoreP(r9, MemOperand(r8));
+ __ bind(&non_outermost_js_2);
+
+ // Restore the top frame descriptors from the stack.
+ __ pop(r6);
+ __ mov(ip, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate())));
+ __ StoreP(r6, MemOperand(ip));
+
+ // Reset the stack to the callee saved registers.
+ __ addi(sp, sp, Operand(-EntryFrameConstants::kCallerFPOffset));
+
+// Restore callee-saved registers and return.
+#ifdef DEBUG
+ if (FLAG_debug_code) {
+ Label here;
+ __ b(&here, SetLK);
+ __ bind(&here);
+ }
+#endif
+
+ __ MultiPop(kCalleeSaved);
+
+ __ LoadP(r0, MemOperand(sp, kStackFrameLRSlot * kPointerSize));
+ __ mtctr(r0);
+ __ bctr();
+}
+
+
+// Uses registers r3 to r7.
+// Expected input (depending on whether args are in registers or on the stack):
+// * object: r3 or at sp + 1 * kPointerSize.
+// * function: r4 or at sp.
+//
+// An inlined call site may have been generated before calling this stub.
+// In this case the offset to the inline site to patch is passed in r8.
+// (See LCodeGen::DoInstanceOfKnownGlobal)
+void InstanceofStub::Generate(MacroAssembler* masm) {
+ // Call site inlining and patching implies arguments in registers.
+ DCHECK(HasArgsInRegisters() || !HasCallSiteInlineCheck());
+
+ // Fixed register usage throughout the stub:
+ const Register object = r3; // Object (lhs).
+ Register map = r6; // Map of the object.
+ const Register function = r4; // Function (rhs).
+ const Register prototype = r7; // Prototype of the function.
+ const Register inline_site = r9;
+ const Register scratch = r5;
+ Register scratch3 = no_reg;
+
+// delta = mov + unaligned LoadP + cmp + bne
+#if V8_TARGET_ARCH_PPC64
+ const int32_t kDeltaToLoadBoolResult =
+ (Assembler::kMovInstructions + 4) * Assembler::kInstrSize;
+#else
+ const int32_t kDeltaToLoadBoolResult =
+ (Assembler::kMovInstructions + 3) * Assembler::kInstrSize;
+#endif
+
+ Label slow, loop, is_instance, is_not_instance, not_js_object;
+
+ if (!HasArgsInRegisters()) {
+ __ LoadP(object, MemOperand(sp, 1 * kPointerSize));
+ __ LoadP(function, MemOperand(sp, 0));
+ }
+
+ // Check that the left hand is a JS object and load map.
+ __ JumpIfSmi(object, ¬_js_object);
+ __ IsObjectJSObjectType(object, map, scratch, ¬_js_object);
+
+ // If there is a call site cache don't look in the global cache, but do the
+ // real lookup and update the call site cache.
+ if (!HasCallSiteInlineCheck() && !ReturnTrueFalseObject()) {
+ Label miss;
+ __ CompareRoot(function, Heap::kInstanceofCacheFunctionRootIndex);
+ __ bne(&miss);
+ __ CompareRoot(map, Heap::kInstanceofCacheMapRootIndex);
+ __ bne(&miss);
+ __ LoadRoot(r3, Heap::kInstanceofCacheAnswerRootIndex);
+ __ Ret(HasArgsInRegisters() ? 0 : 2);
+
+ __ bind(&miss);
+ }
+
+ // Get the prototype of the function.
+ __ TryGetFunctionPrototype(function, prototype, scratch, &slow, true);
+
+ // Check that the function prototype is a JS object.
+ __ JumpIfSmi(prototype, &slow);
+ __ IsObjectJSObjectType(prototype, scratch, scratch, &slow);
+
+ // Update the global instanceof or call site inlined cache with the current
+ // map and function. The cached answer will be set when it is known below.
+ if (!HasCallSiteInlineCheck()) {
+ __ StoreRoot(function, Heap::kInstanceofCacheFunctionRootIndex);
+ __ StoreRoot(map, Heap::kInstanceofCacheMapRootIndex);
+ } else {
+ DCHECK(HasArgsInRegisters());
+ // Patch the (relocated) inlined map check.
+
+ // The offset was stored in r8
+ // (See LCodeGen::DoDeferredLInstanceOfKnownGlobal).
+ const Register offset = r8;
+ __ mflr(inline_site);
+ __ sub(inline_site, inline_site, offset);
+ // Get the map location in r8 and patch it.
+ __ GetRelocatedValue(inline_site, offset, scratch);
+ __ StoreP(map, FieldMemOperand(offset, Cell::kValueOffset), r0);
+ }
+
+ // Register mapping: r6 is object map and r7 is function prototype.
+ // Get prototype of object into r5.
+ __ LoadP(scratch, FieldMemOperand(map, Map::kPrototypeOffset));
+
+ // We don't need map any more. Use it as a scratch register.
+ scratch3 = map;
+ map = no_reg;
+
+ // Loop through the prototype chain looking for the function prototype.
+ __ LoadRoot(scratch3, Heap::kNullValueRootIndex);
+ __ bind(&loop);
+ __ cmp(scratch, prototype);
+ __ beq(&is_instance);
+ __ cmp(scratch, scratch3);
+ __ beq(&is_not_instance);
+ __ LoadP(scratch, FieldMemOperand(scratch, HeapObject::kMapOffset));
+ __ LoadP(scratch, FieldMemOperand(scratch, Map::kPrototypeOffset));
+ __ b(&loop);
+ Factory* factory = isolate()->factory();
+
+ __ bind(&is_instance);
+ if (!HasCallSiteInlineCheck()) {
+ __ LoadSmiLiteral(r3, Smi::FromInt(0));
+ __ StoreRoot(r3, Heap::kInstanceofCacheAnswerRootIndex);
+ if (ReturnTrueFalseObject()) {
+ __ Move(r3, factory->true_value());
+ }
+ } else {
+ // Patch the call site to return true.
+ __ LoadRoot(r3, Heap::kTrueValueRootIndex);
+ __ addi(inline_site, inline_site, Operand(kDeltaToLoadBoolResult));
+ // Get the boolean result location in scratch and patch it.
+ __ SetRelocatedValue(inline_site, scratch, r3);
+
+ if (!ReturnTrueFalseObject()) {
+ __ LoadSmiLiteral(r3, Smi::FromInt(0));
+ }
+ }
+ __ Ret(HasArgsInRegisters() ? 0 : 2);
+
+ __ bind(&is_not_instance);
+ if (!HasCallSiteInlineCheck()) {
+ __ LoadSmiLiteral(r3, Smi::FromInt(1));
+ __ StoreRoot(r3, Heap::kInstanceofCacheAnswerRootIndex);
+ if (ReturnTrueFalseObject()) {
+ __ Move(r3, factory->false_value());
+ }
+ } else {
+ // Patch the call site to return false.
+ __ LoadRoot(r3, Heap::kFalseValueRootIndex);
+ __ addi(inline_site, inline_site, Operand(kDeltaToLoadBoolResult));
+ // Get the boolean result location in scratch and patch it.
+ __ SetRelocatedValue(inline_site, scratch, r3);
+
+ if (!ReturnTrueFalseObject()) {
+ __ LoadSmiLiteral(r3, Smi::FromInt(1));
+ }
+ }
+ __ Ret(HasArgsInRegisters() ? 0 : 2);
+
+ Label object_not_null, object_not_null_or_smi;
+ __ bind(¬_js_object);
+ // Before null, smi and string value checks, check that the rhs is a function
+ // as for a non-function rhs an exception needs to be thrown.
+ __ JumpIfSmi(function, &slow);
+ __ CompareObjectType(function, scratch3, scratch, JS_FUNCTION_TYPE);
+ __ bne(&slow);
+
+ // Null is not instance of anything.
+ __ Cmpi(object, Operand(isolate()->factory()->null_value()), r0);
+ __ bne(&object_not_null);
+ if (ReturnTrueFalseObject()) {
+ __ Move(r3, factory->false_value());
+ } else {
+ __ LoadSmiLiteral(r3, Smi::FromInt(1));
+ }
+ __ Ret(HasArgsInRegisters() ? 0 : 2);
+
+ __ bind(&object_not_null);
+ // Smi values are not instances of anything.
+ __ JumpIfNotSmi(object, &object_not_null_or_smi);
+ if (ReturnTrueFalseObject()) {
+ __ Move(r3, factory->false_value());
+ } else {
+ __ LoadSmiLiteral(r3, Smi::FromInt(1));
+ }
+ __ Ret(HasArgsInRegisters() ? 0 : 2);
+
+ __ bind(&object_not_null_or_smi);
+ // String values are not instances of anything.
+ __ IsObjectJSStringType(object, scratch, &slow);
+ if (ReturnTrueFalseObject()) {
+ __ Move(r3, factory->false_value());
+ } else {
+ __ LoadSmiLiteral(r3, Smi::FromInt(1));
+ }
+ __ Ret(HasArgsInRegisters() ? 0 : 2);
+
+ // Slow-case. Tail call builtin.
+ __ bind(&slow);
+ if (!ReturnTrueFalseObject()) {
+ if (HasArgsInRegisters()) {
+ __ Push(r3, r4);
+ }
+ __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
+ } else {
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+ __ Push(r3, r4);
+ __ InvokeBuiltin(Builtins::INSTANCE_OF, CALL_FUNCTION);
+ }
+ Label true_value, done;
+ __ cmpi(r3, Operand::Zero());
+ __ beq(&true_value);
+
+ __ LoadRoot(r3, Heap::kFalseValueRootIndex);
+ __ b(&done);
+
+ __ bind(&true_value);
+ __ LoadRoot(r3, Heap::kTrueValueRootIndex);
+
+ __ bind(&done);
+ __ Ret(HasArgsInRegisters() ? 0 : 2);
+ }
+}
+
+
+void FunctionPrototypeStub::Generate(MacroAssembler* masm) {
+ Label miss;
+ Register receiver = LoadDescriptor::ReceiverRegister();
+
+ NamedLoadHandlerCompiler::GenerateLoadFunctionPrototype(masm, receiver, r6,
+ r7, &miss);
+ __ bind(&miss);
+ PropertyAccessCompiler::TailCallBuiltin(
+ masm, PropertyAccessCompiler::MissBuiltin(Code::LOAD_IC));
+}
+
+
+void LoadIndexedStringStub::Generate(MacroAssembler* masm) {
+ // Return address is in lr.
+ Label miss;
+
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ Register index = LoadDescriptor::NameRegister();
+ Register scratch = r6;
+ Register result = r3;
+ DCHECK(!scratch.is(receiver) && !scratch.is(index));
+
+ StringCharAtGenerator char_at_generator(receiver, index, scratch, result,
+ &miss, // When not a string.
+ &miss, // When not a number.
+ &miss, // When index out of range.
+ STRING_INDEX_IS_ARRAY_INDEX,
+ RECEIVER_IS_STRING);
+ char_at_generator.GenerateFast(masm);
+ __ Ret();
+
+ StubRuntimeCallHelper call_helper;
+ char_at_generator.GenerateSlow(masm, call_helper);
+
+ __ bind(&miss);
+ PropertyAccessCompiler::TailCallBuiltin(
+ masm, PropertyAccessCompiler::MissBuiltin(Code::KEYED_LOAD_IC));
+}
+
+
+void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) {
+ // The displacement is the offset of the last parameter (if any)
+ // relative to the frame pointer.
+ const int kDisplacement =
+ StandardFrameConstants::kCallerSPOffset - kPointerSize;
+ DCHECK(r4.is(ArgumentsAccessReadDescriptor::index()));
+ DCHECK(r3.is(ArgumentsAccessReadDescriptor::parameter_count()));
+
+ // Check that the key is a smi.
+ Label slow;
+ __ JumpIfNotSmi(r4, &slow);
+
+ // Check if the calling frame is an arguments adaptor frame.
+ Label adaptor;
+ __ LoadP(r5, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+ __ LoadP(r6, MemOperand(r5, StandardFrameConstants::kContextOffset));
+ STATIC_ASSERT(StackFrame::ARGUMENTS_ADAPTOR < 0x3fffu);
+ __ CmpSmiLiteral(r6, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
+ __ beq(&adaptor);
+
+ // Check index against formal parameters count limit passed in
+ // through register r3. Use unsigned comparison to get negative
+ // check for free.
+ __ cmpl(r4, r3);
+ __ bge(&slow);
+
+ // Read the argument from the stack and return it.
+ __ sub(r6, r3, r4);
+ __ SmiToPtrArrayOffset(r6, r6);
+ __ add(r6, fp, r6);
+ __ LoadP(r3, MemOperand(r6, kDisplacement));
+ __ blr();
+
+ // Arguments adaptor case: Check index against actual arguments
+ // limit found in the arguments adaptor frame. Use unsigned
+ // comparison to get negative check for free.
+ __ bind(&adaptor);
+ __ LoadP(r3, MemOperand(r5, ArgumentsAdaptorFrameConstants::kLengthOffset));
+ __ cmpl(r4, r3);
+ __ bge(&slow);
+
+ // Read the argument from the adaptor frame and return it.
+ __ sub(r6, r3, r4);
+ __ SmiToPtrArrayOffset(r6, r6);
+ __ add(r6, r5, r6);
+ __ LoadP(r3, MemOperand(r6, kDisplacement));
+ __ blr();
+
+ // Slow-case: Handle non-smi or out-of-bounds access to arguments
+ // by calling the runtime system.
+ __ bind(&slow);
+ __ push(r4);
+ __ TailCallRuntime(Runtime::kGetArgumentsProperty, 1, 1);
+}
+
+
+void ArgumentsAccessStub::GenerateNewSloppySlow(MacroAssembler* masm) {
+ // sp[0] : number of parameters
+ // sp[1] : receiver displacement
+ // sp[2] : function
+
+ // Check if the calling frame is an arguments adaptor frame.
+ Label runtime;
+ __ LoadP(r6, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+ __ LoadP(r5, MemOperand(r6, StandardFrameConstants::kContextOffset));
+ STATIC_ASSERT(StackFrame::ARGUMENTS_ADAPTOR < 0x3fffu);
+ __ CmpSmiLiteral(r5, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
+ __ bne(&runtime);
+
+ // Patch the arguments.length and the parameters pointer in the current frame.
+ __ LoadP(r5, MemOperand(r6, ArgumentsAdaptorFrameConstants::kLengthOffset));
+ __ StoreP(r5, MemOperand(sp, 0 * kPointerSize));
+ __ SmiToPtrArrayOffset(r5, r5);
+ __ add(r6, r6, r5);
+ __ addi(r6, r6, Operand(StandardFrameConstants::kCallerSPOffset));
+ __ StoreP(r6, MemOperand(sp, 1 * kPointerSize));
+
+ __ bind(&runtime);
+ __ TailCallRuntime(Runtime::kNewSloppyArguments, 3, 1);
+}
+
+
+void ArgumentsAccessStub::GenerateNewSloppyFast(MacroAssembler* masm) {
+ // Stack layout:
+ // sp[0] : number of parameters (tagged)
+ // sp[1] : address of receiver argument
+ // sp[2] : function
+ // Registers used over whole function:
+ // r9 : allocated object (tagged)
+ // r11 : mapped parameter count (tagged)
+
+ __ LoadP(r4, MemOperand(sp, 0 * kPointerSize));
+ // r4 = parameter count (tagged)
+
+ // Check if the calling frame is an arguments adaptor frame.
+ Label runtime;
+ Label adaptor_frame, try_allocate;
+ __ LoadP(r6, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+ __ LoadP(r5, MemOperand(r6, StandardFrameConstants::kContextOffset));
+ STATIC_ASSERT(StackFrame::ARGUMENTS_ADAPTOR < 0x3fffu);
+ __ CmpSmiLiteral(r5, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
+ __ beq(&adaptor_frame);
+
+ // No adaptor, parameter count = argument count.
+ __ mr(r5, r4);
+ __ b(&try_allocate);
+
+ // We have an adaptor frame. Patch the parameters pointer.
+ __ bind(&adaptor_frame);
+ __ LoadP(r5, MemOperand(r6, ArgumentsAdaptorFrameConstants::kLengthOffset));
+ __ SmiToPtrArrayOffset(r7, r5);
+ __ add(r6, r6, r7);
+ __ addi(r6, r6, Operand(StandardFrameConstants::kCallerSPOffset));
+ __ StoreP(r6, MemOperand(sp, 1 * kPointerSize));
+
+ // r4 = parameter count (tagged)
+ // r5 = argument count (tagged)
+ // Compute the mapped parameter count = min(r4, r5) in r4.
+ Label skip;
+ __ cmp(r4, r5);
+ __ blt(&skip);
+ __ mr(r4, r5);
+ __ bind(&skip);
+
+ __ bind(&try_allocate);
+
+ // Compute the sizes of backing store, parameter map, and arguments object.
+ // 1. Parameter map, has 2 extra words containing context and backing store.
+ const int kParameterMapHeaderSize =
+ FixedArray::kHeaderSize + 2 * kPointerSize;
+ // If there are no mapped parameters, we do not need the parameter_map.
+ Label skip2, skip3;
+ __ CmpSmiLiteral(r4, Smi::FromInt(0), r0);
+ __ bne(&skip2);
+ __ li(r11, Operand::Zero());
+ __ b(&skip3);
+ __ bind(&skip2);
+ __ SmiToPtrArrayOffset(r11, r4);
+ __ addi(r11, r11, Operand(kParameterMapHeaderSize));
+ __ bind(&skip3);
+
+ // 2. Backing store.
+ __ SmiToPtrArrayOffset(r7, r5);
+ __ add(r11, r11, r7);
+ __ addi(r11, r11, Operand(FixedArray::kHeaderSize));
+
+ // 3. Arguments object.
+ __ addi(r11, r11, Operand(Heap::kSloppyArgumentsObjectSize));
+
+ // Do the allocation of all three objects in one go.
+ __ Allocate(r11, r3, r6, r7, &runtime, TAG_OBJECT);
+
+ // r3 = address of new object(s) (tagged)
+ // r5 = argument count (smi-tagged)
+ // Get the arguments boilerplate from the current native context into r4.
+ const int kNormalOffset =
+ Context::SlotOffset(Context::SLOPPY_ARGUMENTS_MAP_INDEX);
+ const int kAliasedOffset =
+ Context::SlotOffset(Context::ALIASED_ARGUMENTS_MAP_INDEX);
+
+ __ LoadP(r7,
+ MemOperand(cp, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
+ __ LoadP(r7, FieldMemOperand(r7, GlobalObject::kNativeContextOffset));
+ Label skip4, skip5;
+ __ cmpi(r4, Operand::Zero());
+ __ bne(&skip4);
+ __ LoadP(r7, MemOperand(r7, kNormalOffset));
+ __ b(&skip5);
+ __ bind(&skip4);
+ __ LoadP(r7, MemOperand(r7, kAliasedOffset));
+ __ bind(&skip5);
+
+ // r3 = address of new object (tagged)
+ // r4 = mapped parameter count (tagged)
+ // r5 = argument count (smi-tagged)
+ // r7 = address of arguments map (tagged)
+ __ StoreP(r7, FieldMemOperand(r3, JSObject::kMapOffset), r0);
+ __ LoadRoot(r6, Heap::kEmptyFixedArrayRootIndex);
+ __ StoreP(r6, FieldMemOperand(r3, JSObject::kPropertiesOffset), r0);
+ __ StoreP(r6, FieldMemOperand(r3, JSObject::kElementsOffset), r0);
+
+ // Set up the callee in-object property.
+ STATIC_ASSERT(Heap::kArgumentsCalleeIndex == 1);
+ __ LoadP(r6, MemOperand(sp, 2 * kPointerSize));
+ __ AssertNotSmi(r6);
+ const int kCalleeOffset =
+ JSObject::kHeaderSize + Heap::kArgumentsCalleeIndex * kPointerSize;
+ __ StoreP(r6, FieldMemOperand(r3, kCalleeOffset), r0);
+
+ // Use the length (smi tagged) and set that as an in-object property too.
+ __ AssertSmi(r5);
+ STATIC_ASSERT(Heap::kArgumentsLengthIndex == 0);
+ const int kLengthOffset =
+ JSObject::kHeaderSize + Heap::kArgumentsLengthIndex * kPointerSize;
+ __ StoreP(r5, FieldMemOperand(r3, kLengthOffset), r0);
+
+ // Set up the elements pointer in the allocated arguments object.
+ // If we allocated a parameter map, r7 will point there, otherwise
+ // it will point to the backing store.
+ __ addi(r7, r3, Operand(Heap::kSloppyArgumentsObjectSize));
+ __ StoreP(r7, FieldMemOperand(r3, JSObject::kElementsOffset), r0);
+
+ // r3 = address of new object (tagged)
+ // r4 = mapped parameter count (tagged)
+ // r5 = argument count (tagged)
+ // r7 = address of parameter map or backing store (tagged)
+ // Initialize parameter map. If there are no mapped arguments, we're done.
+ Label skip_parameter_map, skip6;
+ __ CmpSmiLiteral(r4, Smi::FromInt(0), r0);
+ __ bne(&skip6);
+ // Move backing store address to r6, because it is
+ // expected there when filling in the unmapped arguments.
+ __ mr(r6, r7);
+ __ b(&skip_parameter_map);
+ __ bind(&skip6);
+
+ __ LoadRoot(r9, Heap::kSloppyArgumentsElementsMapRootIndex);
+ __ StoreP(r9, FieldMemOperand(r7, FixedArray::kMapOffset), r0);
+ __ AddSmiLiteral(r9, r4, Smi::FromInt(2), r0);
+ __ StoreP(r9, FieldMemOperand(r7, FixedArray::kLengthOffset), r0);
+ __ StoreP(cp, FieldMemOperand(r7, FixedArray::kHeaderSize + 0 * kPointerSize),
+ r0);
+ __ SmiToPtrArrayOffset(r9, r4);
+ __ add(r9, r7, r9);
+ __ addi(r9, r9, Operand(kParameterMapHeaderSize));
+ __ StoreP(r9, FieldMemOperand(r7, FixedArray::kHeaderSize + 1 * kPointerSize),
+ r0);
+
+ // Copy the parameter slots and the holes in the arguments.
+ // We need to fill in mapped_parameter_count slots. They index the context,
+ // where parameters are stored in reverse order, at
+ // MIN_CONTEXT_SLOTS .. MIN_CONTEXT_SLOTS+parameter_count-1
+ // The mapped parameter thus need to get indices
+ // MIN_CONTEXT_SLOTS+parameter_count-1 ..
+ // MIN_CONTEXT_SLOTS+parameter_count-mapped_parameter_count
+ // We loop from right to left.
+ Label parameters_loop, parameters_test;
+ __ mr(r9, r4);
+ __ LoadP(r11, MemOperand(sp, 0 * kPointerSize));
+ __ AddSmiLiteral(r11, r11, Smi::FromInt(Context::MIN_CONTEXT_SLOTS), r0);
+ __ sub(r11, r11, r4);
+ __ LoadRoot(r10, Heap::kTheHoleValueRootIndex);
+ __ SmiToPtrArrayOffset(r6, r9);
+ __ add(r6, r7, r6);
+ __ addi(r6, r6, Operand(kParameterMapHeaderSize));
+
+ // r9 = loop variable (tagged)
+ // r4 = mapping index (tagged)
+ // r6 = address of backing store (tagged)
+ // r7 = address of parameter map (tagged)
+ // r8 = temporary scratch (a.o., for address calculation)
+ // r10 = the hole value
+ __ b(¶meters_test);
+
+ __ bind(¶meters_loop);
+ __ SubSmiLiteral(r9, r9, Smi::FromInt(1), r0);
+ __ SmiToPtrArrayOffset(r8, r9);
+ __ addi(r8, r8, Operand(kParameterMapHeaderSize - kHeapObjectTag));
+ __ StorePX(r11, MemOperand(r8, r7));
+ __ subi(r8, r8, Operand(kParameterMapHeaderSize - FixedArray::kHeaderSize));
+ __ StorePX(r10, MemOperand(r8, r6));
+ __ AddSmiLiteral(r11, r11, Smi::FromInt(1), r0);
+ __ bind(¶meters_test);
+ __ CmpSmiLiteral(r9, Smi::FromInt(0), r0);
+ __ bne(¶meters_loop);
+
+ __ bind(&skip_parameter_map);
+ // r5 = argument count (tagged)
+ // r6 = address of backing store (tagged)
+ // r8 = scratch
+ // Copy arguments header and remaining slots (if there are any).
+ __ LoadRoot(r8, Heap::kFixedArrayMapRootIndex);
+ __ StoreP(r8, FieldMemOperand(r6, FixedArray::kMapOffset), r0);
+ __ StoreP(r5, FieldMemOperand(r6, FixedArray::kLengthOffset), r0);
+
+ Label arguments_loop, arguments_test;
+ __ mr(r11, r4);
+ __ LoadP(r7, MemOperand(sp, 1 * kPointerSize));
+ __ SmiToPtrArrayOffset(r8, r11);
+ __ sub(r7, r7, r8);
+ __ b(&arguments_test);
+
+ __ bind(&arguments_loop);
+ __ subi(r7, r7, Operand(kPointerSize));
+ __ LoadP(r9, MemOperand(r7, 0));
+ __ SmiToPtrArrayOffset(r8, r11);
+ __ add(r8, r6, r8);
+ __ StoreP(r9, FieldMemOperand(r8, FixedArray::kHeaderSize), r0);
+ __ AddSmiLiteral(r11, r11, Smi::FromInt(1), r0);
+
+ __ bind(&arguments_test);
+ __ cmp(r11, r5);
+ __ blt(&arguments_loop);
+
+ // Return and remove the on-stack parameters.
+ __ addi(sp, sp, Operand(3 * kPointerSize));
+ __ Ret();
+
+ // Do the runtime call to allocate the arguments object.
+ // r5 = argument count (tagged)
+ __ bind(&runtime);
+ __ StoreP(r5, MemOperand(sp, 0 * kPointerSize)); // Patch argument count.
+ __ TailCallRuntime(Runtime::kNewSloppyArguments, 3, 1);
+}
+
+
+void LoadIndexedInterceptorStub::Generate(MacroAssembler* masm) {
+ // Return address is in lr.
+ Label slow;
+
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ Register key = LoadDescriptor::NameRegister();
+
+ // Check that the key is an array index, that is Uint32.
+ __ TestIfPositiveSmi(key, r0);
+ __ bne(&slow, cr0);
+
+ // Everything is fine, call runtime.
+ __ Push(receiver, key); // Receiver, key.
+
+ // Perform tail call to the entry.
+ __ TailCallExternalReference(
+ ExternalReference(IC_Utility(IC::kLoadElementWithInterceptor),
+ masm->isolate()),
+ 2, 1);
+
+ __ bind(&slow);
+ PropertyAccessCompiler::TailCallBuiltin(
+ masm, PropertyAccessCompiler::MissBuiltin(Code::KEYED_LOAD_IC));
+}
+
+
+void ArgumentsAccessStub::GenerateNewStrict(MacroAssembler* masm) {
+ // sp[0] : number of parameters
+ // sp[4] : receiver displacement
+ // sp[8] : function
+ // Check if the calling frame is an arguments adaptor frame.
+ Label adaptor_frame, try_allocate, runtime;
+ __ LoadP(r5, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+ __ LoadP(r6, MemOperand(r5, StandardFrameConstants::kContextOffset));
+ STATIC_ASSERT(StackFrame::ARGUMENTS_ADAPTOR < 0x3fffu);
+ __ CmpSmiLiteral(r6, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
+ __ beq(&adaptor_frame);
+
+ // Get the length from the frame.
+ __ LoadP(r4, MemOperand(sp, 0));
+ __ b(&try_allocate);
+
+ // Patch the arguments.length and the parameters pointer.
+ __ bind(&adaptor_frame);
+ __ LoadP(r4, MemOperand(r5, ArgumentsAdaptorFrameConstants::kLengthOffset));
+ __ StoreP(r4, MemOperand(sp, 0));
+ __ SmiToPtrArrayOffset(r6, r4);
+ __ add(r6, r5, r6);
+ __ addi(r6, r6, Operand(StandardFrameConstants::kCallerSPOffset));
+ __ StoreP(r6, MemOperand(sp, 1 * kPointerSize));
+
+ // Try the new space allocation. Start out with computing the size
+ // of the arguments object and the elements array in words.
+ Label add_arguments_object;
+ __ bind(&try_allocate);
+ __ cmpi(r4, Operand::Zero());
+ __ beq(&add_arguments_object);
+ __ SmiUntag(r4);
+ __ addi(r4, r4, Operand(FixedArray::kHeaderSize / kPointerSize));
+ __ bind(&add_arguments_object);
+ __ addi(r4, r4, Operand(Heap::kStrictArgumentsObjectSize / kPointerSize));
+
+ // Do the allocation of both objects in one go.
+ __ Allocate(r4, r3, r5, r6, &runtime,
+ static_cast<AllocationFlags>(TAG_OBJECT | SIZE_IN_WORDS));
+
+ // Get the arguments boilerplate from the current native context.
+ __ LoadP(r7,
+ MemOperand(cp, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
+ __ LoadP(r7, FieldMemOperand(r7, GlobalObject::kNativeContextOffset));
+ __ LoadP(
+ r7,
+ MemOperand(r7, Context::SlotOffset(Context::STRICT_ARGUMENTS_MAP_INDEX)));
+
+ __ StoreP(r7, FieldMemOperand(r3, JSObject::kMapOffset), r0);
+ __ LoadRoot(r6, Heap::kEmptyFixedArrayRootIndex);
+ __ StoreP(r6, FieldMemOperand(r3, JSObject::kPropertiesOffset), r0);
+ __ StoreP(r6, FieldMemOperand(r3, JSObject::kElementsOffset), r0);
+
+ // Get the length (smi tagged) and set that as an in-object property too.
+ STATIC_ASSERT(Heap::kArgumentsLengthIndex == 0);
+ __ LoadP(r4, MemOperand(sp, 0 * kPointerSize));
+ __ AssertSmi(r4);
+ __ StoreP(r4,
+ FieldMemOperand(r3, JSObject::kHeaderSize +
+ Heap::kArgumentsLengthIndex * kPointerSize),
+ r0);
+
+ // If there are no actual arguments, we're done.
+ Label done;
+ __ cmpi(r4, Operand::Zero());
+ __ beq(&done);
+
+ // Get the parameters pointer from the stack.
+ __ LoadP(r5, MemOperand(sp, 1 * kPointerSize));
+
+ // Set up the elements pointer in the allocated arguments object and
+ // initialize the header in the elements fixed array.
+ __ addi(r7, r3, Operand(Heap::kStrictArgumentsObjectSize));
+ __ StoreP(r7, FieldMemOperand(r3, JSObject::kElementsOffset), r0);
+ __ LoadRoot(r6, Heap::kFixedArrayMapRootIndex);
+ __ StoreP(r6, FieldMemOperand(r7, FixedArray::kMapOffset), r0);
+ __ StoreP(r4, FieldMemOperand(r7, FixedArray::kLengthOffset), r0);
+ // Untag the length for the loop.
+ __ SmiUntag(r4);
+
+ // Copy the fixed array slots.
+ Label loop;
+ // Set up r7 to point just prior to the first array slot.
+ __ addi(r7, r7,
+ Operand(FixedArray::kHeaderSize - kHeapObjectTag - kPointerSize));
+ __ mtctr(r4);
+ __ bind(&loop);
+ // Pre-decrement r5 with kPointerSize on each iteration.
+ // Pre-decrement in order to skip receiver.
+ __ LoadPU(r6, MemOperand(r5, -kPointerSize));
+ // Pre-increment r7 with kPointerSize on each iteration.
+ __ StorePU(r6, MemOperand(r7, kPointerSize));
+ __ bdnz(&loop);
+
+ // Return and remove the on-stack parameters.
+ __ bind(&done);
+ __ addi(sp, sp, Operand(3 * kPointerSize));
+ __ Ret();
+
+ // Do the runtime call to allocate the arguments object.
+ __ bind(&runtime);
+ __ TailCallRuntime(Runtime::kNewStrictArguments, 3, 1);
+}
+
+
+void RegExpExecStub::Generate(MacroAssembler* masm) {
+// Just jump directly to runtime if native RegExp is not selected at compile
+// time or if regexp entry in generated code is turned off runtime switch or
+// at compilation.
+#ifdef V8_INTERPRETED_REGEXP
+ __ TailCallRuntime(Runtime::kRegExpExecRT, 4, 1);
+#else // V8_INTERPRETED_REGEXP
+
+ // Stack frame on entry.
+ // sp[0]: last_match_info (expected JSArray)
+ // sp[4]: previous index
+ // sp[8]: subject string
+ // sp[12]: JSRegExp object
+
+ const int kLastMatchInfoOffset = 0 * kPointerSize;
+ const int kPreviousIndexOffset = 1 * kPointerSize;
+ const int kSubjectOffset = 2 * kPointerSize;
+ const int kJSRegExpOffset = 3 * kPointerSize;
+
+ Label runtime, br_over, encoding_type_UC16;
+
+ // Allocation of registers for this function. These are in callee save
+ // registers and will be preserved by the call to the native RegExp code, as
+ // this code is called using the normal C calling convention. When calling
+ // directly from generated code the native RegExp code will not do a GC and
+ // therefore the content of these registers are safe to use after the call.
+ Register subject = r14;
+ Register regexp_data = r15;
+ Register last_match_info_elements = r16;
+ Register code = r17;
+
+ // Ensure register assigments are consistent with callee save masks
+ DCHECK(subject.bit() & kCalleeSaved);
+ DCHECK(regexp_data.bit() & kCalleeSaved);
+ DCHECK(last_match_info_elements.bit() & kCalleeSaved);
+ DCHECK(code.bit() & kCalleeSaved);
+
+ // Ensure that a RegExp stack is allocated.
+ ExternalReference address_of_regexp_stack_memory_address =
+ ExternalReference::address_of_regexp_stack_memory_address(isolate());
+ ExternalReference address_of_regexp_stack_memory_size =
+ ExternalReference::address_of_regexp_stack_memory_size(isolate());
+ __ mov(r3, Operand(address_of_regexp_stack_memory_size));
+ __ LoadP(r3, MemOperand(r3, 0));
+ __ cmpi(r3, Operand::Zero());
+ __ beq(&runtime);
+
+ // Check that the first argument is a JSRegExp object.
+ __ LoadP(r3, MemOperand(sp, kJSRegExpOffset));
+ __ JumpIfSmi(r3, &runtime);
+ __ CompareObjectType(r3, r4, r4, JS_REGEXP_TYPE);
+ __ bne(&runtime);
+
+ // Check that the RegExp has been compiled (data contains a fixed array).
+ __ LoadP(regexp_data, FieldMemOperand(r3, JSRegExp::kDataOffset));
+ if (FLAG_debug_code) {
+ __ TestIfSmi(regexp_data, r0);
+ __ Check(ne, kUnexpectedTypeForRegExpDataFixedArrayExpected, cr0);
+ __ CompareObjectType(regexp_data, r3, r3, FIXED_ARRAY_TYPE);
+ __ Check(eq, kUnexpectedTypeForRegExpDataFixedArrayExpected);
+ }
+
+ // regexp_data: RegExp data (FixedArray)
+ // Check the type of the RegExp. Only continue if type is JSRegExp::IRREGEXP.
+ __ LoadP(r3, FieldMemOperand(regexp_data, JSRegExp::kDataTagOffset));
+ // DCHECK(Smi::FromInt(JSRegExp::IRREGEXP) < (char *)0xffffu);
+ __ CmpSmiLiteral(r3, Smi::FromInt(JSRegExp::IRREGEXP), r0);
+ __ bne(&runtime);
+
+ // regexp_data: RegExp data (FixedArray)
+ // Check that the number of captures fit in the static offsets vector buffer.
+ __ LoadP(r5,
+ FieldMemOperand(regexp_data, JSRegExp::kIrregexpCaptureCountOffset));
+ // Check (number_of_captures + 1) * 2 <= offsets vector size
+ // Or number_of_captures * 2 <= offsets vector size - 2
+ // SmiToShortArrayOffset accomplishes the multiplication by 2 and
+ // SmiUntag (which is a nop for 32-bit).
+ __ SmiToShortArrayOffset(r5, r5);
+ STATIC_ASSERT(Isolate::kJSRegexpStaticOffsetsVectorSize >= 2);
+ __ cmpli(r5, Operand(Isolate::kJSRegexpStaticOffsetsVectorSize - 2));
+ __ bgt(&runtime);
+
+ // Reset offset for possibly sliced string.
+ __ li(r11, Operand::Zero());
+ __ LoadP(subject, MemOperand(sp, kSubjectOffset));
+ __ JumpIfSmi(subject, &runtime);
+ __ mr(r6, subject); // Make a copy of the original subject string.
+ __ LoadP(r3, FieldMemOperand(subject, HeapObject::kMapOffset));
+ __ lbz(r3, FieldMemOperand(r3, Map::kInstanceTypeOffset));
+ // subject: subject string
+ // r6: subject string
+ // r3: subject string instance type
+ // regexp_data: RegExp data (FixedArray)
+ // Handle subject string according to its encoding and representation:
+ // (1) Sequential string? If yes, go to (5).
+ // (2) Anything but sequential or cons? If yes, go to (6).
+ // (3) Cons string. If the string is flat, replace subject with first string.
+ // Otherwise bailout.
+ // (4) Is subject external? If yes, go to (7).
+ // (5) Sequential string. Load regexp code according to encoding.
+ // (E) Carry on.
+ /// [...]
+
+ // Deferred code at the end of the stub:
+ // (6) Not a long external string? If yes, go to (8).
+ // (7) External string. Make it, offset-wise, look like a sequential string.
+ // Go to (5).
+ // (8) Short external string or not a string? If yes, bail out to runtime.
+ // (9) Sliced string. Replace subject with parent. Go to (4).
+
+ Label seq_string /* 5 */, external_string /* 7 */, check_underlying /* 4 */,
+ not_seq_nor_cons /* 6 */, not_long_external /* 8 */;
+
+ // (1) Sequential string? If yes, go to (5).
+ STATIC_ASSERT((kIsNotStringMask | kStringRepresentationMask |
+ kShortExternalStringMask) == 0x93);
+ __ andi(r4, r3, Operand(kIsNotStringMask | kStringRepresentationMask |
+ kShortExternalStringMask));
+ STATIC_ASSERT((kStringTag | kSeqStringTag) == 0);
+ __ beq(&seq_string, cr0); // Go to (5).
+
+ // (2) Anything but sequential or cons? If yes, go to (6).
+ STATIC_ASSERT(kConsStringTag < kExternalStringTag);
+ STATIC_ASSERT(kSlicedStringTag > kExternalStringTag);
+ STATIC_ASSERT(kIsNotStringMask > kExternalStringTag);
+ STATIC_ASSERT(kShortExternalStringTag > kExternalStringTag);
+ STATIC_ASSERT(kExternalStringTag < 0xffffu);
+ __ cmpi(r4, Operand(kExternalStringTag));
+ __ bge(¬_seq_nor_cons); // Go to (6).
+
+ // (3) Cons string. Check that it's flat.
+ // Replace subject with first string and reload instance type.
+ __ LoadP(r3, FieldMemOperand(subject, ConsString::kSecondOffset));
+ __ CompareRoot(r3, Heap::kempty_stringRootIndex);
+ __ bne(&runtime);
+ __ LoadP(subject, FieldMemOperand(subject, ConsString::kFirstOffset));
+
+ // (4) Is subject external? If yes, go to (7).
+ __ bind(&check_underlying);
+ __ LoadP(r3, FieldMemOperand(subject, HeapObject::kMapOffset));
+ __ lbz(r3, FieldMemOperand(r3, Map::kInstanceTypeOffset));
+ STATIC_ASSERT(kSeqStringTag == 0);
+ STATIC_ASSERT(kStringRepresentationMask == 3);
+ __ andi(r0, r3, Operand(kStringRepresentationMask));
+ // The underlying external string is never a short external string.
+ STATIC_ASSERT(ExternalString::kMaxShortLength < ConsString::kMinLength);
+ STATIC_ASSERT(ExternalString::kMaxShortLength < SlicedString::kMinLength);
+ __ bne(&external_string, cr0); // Go to (7).
+
+ // (5) Sequential string. Load regexp code according to encoding.
+ __ bind(&seq_string);
+ // subject: sequential subject string (or look-alike, external string)
+ // r6: original subject string
+ // Load previous index and check range before r6 is overwritten. We have to
+ // use r6 instead of subject here because subject might have been only made
+ // to look like a sequential string when it actually is an external string.
+ __ LoadP(r4, MemOperand(sp, kPreviousIndexOffset));
+ __ JumpIfNotSmi(r4, &runtime);
+ __ LoadP(r6, FieldMemOperand(r6, String::kLengthOffset));
+ __ cmpl(r6, r4);
+ __ ble(&runtime);
+ __ SmiUntag(r4);
+
+ STATIC_ASSERT(4 == kOneByteStringTag);
+ STATIC_ASSERT(kTwoByteStringTag == 0);
+ STATIC_ASSERT(kStringEncodingMask == 4);
+ __ ExtractBitMask(r6, r3, kStringEncodingMask, SetRC);
+ __ beq(&encoding_type_UC16, cr0);
+ __ LoadP(code,
+ FieldMemOperand(regexp_data, JSRegExp::kDataOneByteCodeOffset));
+ __ b(&br_over);
+ __ bind(&encoding_type_UC16);
+ __ LoadP(code, FieldMemOperand(regexp_data, JSRegExp::kDataUC16CodeOffset));
+ __ bind(&br_over);
+
+ // (E) Carry on. String handling is done.
+ // code: irregexp code
+ // Check that the irregexp code has been generated for the actual string
+ // encoding. If it has, the field contains a code object otherwise it contains
+ // a smi (code flushing support).
+ __ JumpIfSmi(code, &runtime);
+
+ // r4: previous index
+ // r6: encoding of subject string (1 if one_byte, 0 if two_byte);
+ // code: Address of generated regexp code
+ // subject: Subject string
+ // regexp_data: RegExp data (FixedArray)
+ // All checks done. Now push arguments for native regexp code.
+ __ IncrementCounter(isolate()->counters()->regexp_entry_native(), 1, r3, r5);
+
+ // Isolates: note we add an additional parameter here (isolate pointer).
+ const int kRegExpExecuteArguments = 10;
+ const int kParameterRegisters = 8;
+ __ EnterExitFrame(false, kRegExpExecuteArguments - kParameterRegisters);
+
+ // Stack pointer now points to cell where return address is to be written.
+ // Arguments are before that on the stack or in registers.
+
+ // Argument 10 (in stack parameter area): Pass current isolate address.
+ __ mov(r3, Operand(ExternalReference::isolate_address(isolate())));
+ __ StoreP(r3, MemOperand(sp, (kStackFrameExtraParamSlot + 1) * kPointerSize));
+
+ // Argument 9 is a dummy that reserves the space used for
+ // the return address added by the ExitFrame in native calls.
+
+ // Argument 8 (r10): Indicate that this is a direct call from JavaScript.
+ __ li(r10, Operand(1));
+
+ // Argument 7 (r9): Start (high end) of backtracking stack memory area.
+ __ mov(r3, Operand(address_of_regexp_stack_memory_address));
+ __ LoadP(r3, MemOperand(r3, 0));
+ __ mov(r5, Operand(address_of_regexp_stack_memory_size));
+ __ LoadP(r5, MemOperand(r5, 0));
+ __ add(r9, r3, r5);
+
+ // Argument 6 (r8): Set the number of capture registers to zero to force
+ // global egexps to behave as non-global. This does not affect non-global
+ // regexps.
+ __ li(r8, Operand::Zero());
+
+ // Argument 5 (r7): static offsets vector buffer.
+ __ mov(
+ r7,
+ Operand(ExternalReference::address_of_static_offsets_vector(isolate())));
+
+ // For arguments 4 (r6) and 3 (r5) get string length, calculate start of data
+ // and calculate the shift of the index (0 for one-byte and 1 for two-byte).
+ __ addi(r18, subject, Operand(SeqString::kHeaderSize - kHeapObjectTag));
+ __ xori(r6, r6, Operand(1));
+ // Load the length from the original subject string from the previous stack
+ // frame. Therefore we have to use fp, which points exactly to two pointer
+ // sizes below the previous sp. (Because creating a new stack frame pushes
+ // the previous fp onto the stack and moves up sp by 2 * kPointerSize.)
+ __ LoadP(subject, MemOperand(fp, kSubjectOffset + 2 * kPointerSize));
+ // If slice offset is not 0, load the length from the original sliced string.
+ // Argument 4, r6: End of string data
+ // Argument 3, r5: Start of string data
+ // Prepare start and end index of the input.
+ __ ShiftLeft_(r11, r11, r6);
+ __ add(r11, r18, r11);
+ __ ShiftLeft_(r5, r4, r6);
+ __ add(r5, r11, r5);
+
+ __ LoadP(r18, FieldMemOperand(subject, String::kLengthOffset));
+ __ SmiUntag(r18);
+ __ ShiftLeft_(r6, r18, r6);
+ __ add(r6, r11, r6);
+
+ // Argument 2 (r4): Previous index.
+ // Already there
+
+ // Argument 1 (r3): Subject string.
+ __ mr(r3, subject);
+
+ // Locate the code entry and call it.
+ __ addi(code, code, Operand(Code::kHeaderSize - kHeapObjectTag));
+
+
+#if ABI_USES_FUNCTION_DESCRIPTORS && defined(USE_SIMULATOR)
+ // Even Simulated AIX/PPC64 Linux uses a function descriptor for the
+ // RegExp routine. Extract the instruction address here since
+ // DirectCEntryStub::GenerateCall will not do it for calls out to
+ // what it thinks is C code compiled for the simulator/host
+ // platform.
+ __ LoadP(code, MemOperand(code, 0)); // Instruction address
+#endif
+
+ DirectCEntryStub stub(isolate());
+ stub.GenerateCall(masm, code);
+
+ __ LeaveExitFrame(false, no_reg, true);
+
+ // r3: result
+ // subject: subject string (callee saved)
+ // regexp_data: RegExp data (callee saved)
+ // last_match_info_elements: Last match info elements (callee saved)
+ // Check the result.
+ Label success;
+ __ cmpi(r3, Operand(1));
+ // We expect exactly one result since we force the called regexp to behave
+ // as non-global.
+ __ beq(&success);
+ Label failure;
+ __ cmpi(r3, Operand(NativeRegExpMacroAssembler::FAILURE));
+ __ beq(&failure);
+ __ cmpi(r3, Operand(NativeRegExpMacroAssembler::EXCEPTION));
+ // If not exception it can only be retry. Handle that in the runtime system.
+ __ bne(&runtime);
+ // Result must now be exception. If there is no pending exception already a
+ // stack overflow (on the backtrack stack) was detected in RegExp code but
+ // haven't created the exception yet. Handle that in the runtime system.
+ // TODO(592): Rerunning the RegExp to get the stack overflow exception.
+ __ mov(r4, Operand(isolate()->factory()->the_hole_value()));
+ __ mov(r5, Operand(ExternalReference(Isolate::kPendingExceptionAddress,
+ isolate())));
+ __ LoadP(r3, MemOperand(r5, 0));
+ __ cmp(r3, r4);
+ __ beq(&runtime);
+
+ __ StoreP(r4, MemOperand(r5, 0)); // Clear pending exception.
+
+ // Check if the exception is a termination. If so, throw as uncatchable.
+ __ CompareRoot(r3, Heap::kTerminationExceptionRootIndex);
+
+ Label termination_exception;
+ __ beq(&termination_exception);
+
+ __ Throw(r3);
+
+ __ bind(&termination_exception);
+ __ ThrowUncatchable(r3);
+
+ __ bind(&failure);
+ // For failure and exception return null.
+ __ mov(r3, Operand(isolate()->factory()->null_value()));
+ __ addi(sp, sp, Operand(4 * kPointerSize));
+ __ Ret();
+
+ // Process the result from the native regexp code.
+ __ bind(&success);
+ __ LoadP(r4,
+ FieldMemOperand(regexp_data, JSRegExp::kIrregexpCaptureCountOffset));
+ // Calculate number of capture registers (number_of_captures + 1) * 2.
+ // SmiToShortArrayOffset accomplishes the multiplication by 2 and
+ // SmiUntag (which is a nop for 32-bit).
+ __ SmiToShortArrayOffset(r4, r4);
+ __ addi(r4, r4, Operand(2));
+
+ __ LoadP(r3, MemOperand(sp, kLastMatchInfoOffset));
+ __ JumpIfSmi(r3, &runtime);
+ __ CompareObjectType(r3, r5, r5, JS_ARRAY_TYPE);
+ __ bne(&runtime);
+ // Check that the JSArray is in fast case.
+ __ LoadP(last_match_info_elements,
+ FieldMemOperand(r3, JSArray::kElementsOffset));
+ __ LoadP(r3,
+ FieldMemOperand(last_match_info_elements, HeapObject::kMapOffset));
+ __ CompareRoot(r3, Heap::kFixedArrayMapRootIndex);
+ __ bne(&runtime);
+ // Check that the last match info has space for the capture registers and the
+ // additional information.
+ __ LoadP(
+ r3, FieldMemOperand(last_match_info_elements, FixedArray::kLengthOffset));
+ __ addi(r5, r4, Operand(RegExpImpl::kLastMatchOverhead));
+ __ SmiUntag(r0, r3);
+ __ cmp(r5, r0);
+ __ bgt(&runtime);
+
+ // r4: number of capture registers
+ // subject: subject string
+ // Store the capture count.
+ __ SmiTag(r5, r4);
+ __ StoreP(r5, FieldMemOperand(last_match_info_elements,
+ RegExpImpl::kLastCaptureCountOffset),
+ r0);
+ // Store last subject and last input.
+ __ StoreP(subject, FieldMemOperand(last_match_info_elements,
+ RegExpImpl::kLastSubjectOffset),
+ r0);
+ __ mr(r5, subject);
+ __ RecordWriteField(last_match_info_elements, RegExpImpl::kLastSubjectOffset,
+ subject, r10, kLRHasNotBeenSaved, kDontSaveFPRegs);
+ __ mr(subject, r5);
+ __ StoreP(subject, FieldMemOperand(last_match_info_elements,
+ RegExpImpl::kLastInputOffset),
+ r0);
+ __ RecordWriteField(last_match_info_elements, RegExpImpl::kLastInputOffset,
+ subject, r10, kLRHasNotBeenSaved, kDontSaveFPRegs);
+
+ // Get the static offsets vector filled by the native regexp code.
+ ExternalReference address_of_static_offsets_vector =
+ ExternalReference::address_of_static_offsets_vector(isolate());
+ __ mov(r5, Operand(address_of_static_offsets_vector));
+
+ // r4: number of capture registers
+ // r5: offsets vector
+ Label next_capture;
+ // Capture register counter starts from number of capture registers and
+ // counts down until wraping after zero.
+ __ addi(
+ r3, last_match_info_elements,
+ Operand(RegExpImpl::kFirstCaptureOffset - kHeapObjectTag - kPointerSize));
+ __ addi(r5, r5, Operand(-kIntSize)); // bias down for lwzu
+ __ mtctr(r4);
+ __ bind(&next_capture);
+ // Read the value from the static offsets vector buffer.
+ __ lwzu(r6, MemOperand(r5, kIntSize));
+ // Store the smi value in the last match info.
+ __ SmiTag(r6);
+ __ StorePU(r6, MemOperand(r3, kPointerSize));
+ __ bdnz(&next_capture);
+
+ // Return last match info.
+ __ LoadP(r3, MemOperand(sp, kLastMatchInfoOffset));
+ __ addi(sp, sp, Operand(4 * kPointerSize));
+ __ Ret();
+
+ // Do the runtime call to execute the regexp.
+ __ bind(&runtime);
+ __ TailCallRuntime(Runtime::kRegExpExecRT, 4, 1);
+
+ // Deferred code for string handling.
+ // (6) Not a long external string? If yes, go to (8).
+ __ bind(¬_seq_nor_cons);
+ // Compare flags are still set.
+ __ bgt(¬_long_external); // Go to (8).
+
+ // (7) External string. Make it, offset-wise, look like a sequential string.
+ __ bind(&external_string);
+ __ LoadP(r3, FieldMemOperand(subject, HeapObject::kMapOffset));
+ __ lbz(r3, FieldMemOperand(r3, Map::kInstanceTypeOffset));
+ if (FLAG_debug_code) {
+ // Assert that we do not have a cons or slice (indirect strings) here.
+ // Sequential strings have already been ruled out.
+ STATIC_ASSERT(kIsIndirectStringMask == 1);
+ __ andi(r0, r3, Operand(kIsIndirectStringMask));
+ __ Assert(eq, kExternalStringExpectedButNotFound, cr0);
+ }
+ __ LoadP(subject,
+ FieldMemOperand(subject, ExternalString::kResourceDataOffset));
+ // Move the pointer so that offset-wise, it looks like a sequential string.
+ STATIC_ASSERT(SeqTwoByteString::kHeaderSize == SeqOneByteString::kHeaderSize);
+ __ subi(subject, subject,
+ Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
+ __ b(&seq_string); // Go to (5).
+
+ // (8) Short external string or not a string? If yes, bail out to runtime.
+ __ bind(¬_long_external);
+ STATIC_ASSERT(kNotStringTag != 0 && kShortExternalStringTag != 0);
+ __ andi(r0, r4, Operand(kIsNotStringMask | kShortExternalStringMask));
+ __ bne(&runtime, cr0);
+
+ // (9) Sliced string. Replace subject with parent. Go to (4).
+ // Load offset into r11 and replace subject string with parent.
+ __ LoadP(r11, FieldMemOperand(subject, SlicedString::kOffsetOffset));
+ __ SmiUntag(r11);
+ __ LoadP(subject, FieldMemOperand(subject, SlicedString::kParentOffset));
+ __ b(&check_underlying); // Go to (4).
+#endif // V8_INTERPRETED_REGEXP
+}
+
+
+static void GenerateRecordCallTarget(MacroAssembler* masm) {
+ // Cache the called function in a feedback vector slot. Cache states
+ // are uninitialized, monomorphic (indicated by a JSFunction), and
+ // megamorphic.
+ // r3 : number of arguments to the construct function
+ // r4 : the function to call
+ // r5 : Feedback vector
+ // r6 : slot in feedback vector (Smi)
+ Label initialize, done, miss, megamorphic, not_array_function;
+
+ DCHECK_EQ(*TypeFeedbackVector::MegamorphicSentinel(masm->isolate()),
+ masm->isolate()->heap()->megamorphic_symbol());
+ DCHECK_EQ(*TypeFeedbackVector::UninitializedSentinel(masm->isolate()),
+ masm->isolate()->heap()->uninitialized_symbol());
+
+ // Load the cache state into r7.
+ __ SmiToPtrArrayOffset(r7, r6);
+ __ add(r7, r5, r7);
+ __ LoadP(r7, FieldMemOperand(r7, FixedArray::kHeaderSize));
+
+ // A monomorphic cache hit or an already megamorphic state: invoke the
+ // function without changing the state.
+ __ cmp(r7, r4);
+ __ b(eq, &done);
+
+ if (!FLAG_pretenuring_call_new) {
+ // If we came here, we need to see if we are the array function.
+ // If we didn't have a matching function, and we didn't find the megamorph
+ // sentinel, then we have in the slot either some other function or an
+ // AllocationSite. Do a map check on the object in ecx.
+ __ LoadP(r8, FieldMemOperand(r7, 0));
+ __ CompareRoot(r8, Heap::kAllocationSiteMapRootIndex);
+ __ bne(&miss);
+
+ // Make sure the function is the Array() function
+ __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, r7);
+ __ cmp(r4, r7);
+ __ bne(&megamorphic);
+ __ b(&done);
+ }
+
+ __ bind(&miss);
+
+ // A monomorphic miss (i.e, here the cache is not uninitialized) goes
+ // megamorphic.
+ __ CompareRoot(r7, Heap::kuninitialized_symbolRootIndex);
+ __ beq(&initialize);
+ // MegamorphicSentinel is an immortal immovable object (undefined) so no
+ // write-barrier is needed.
+ __ bind(&megamorphic);
+ __ SmiToPtrArrayOffset(r7, r6);
+ __ add(r7, r5, r7);
+ __ LoadRoot(ip, Heap::kmegamorphic_symbolRootIndex);
+ __ StoreP(ip, FieldMemOperand(r7, FixedArray::kHeaderSize), r0);
+ __ jmp(&done);
+
+ // An uninitialized cache is patched with the function
+ __ bind(&initialize);
+
+ if (!FLAG_pretenuring_call_new) {
+ // Make sure the function is the Array() function.
+ __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, r7);
+ __ cmp(r4, r7);
+ __ bne(¬_array_function);
+
+ // The target function is the Array constructor,
+ // Create an AllocationSite if we don't already have it, store it in the
+ // slot.
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+
+ // Arguments register must be smi-tagged to call out.
+ __ SmiTag(r3);
+ __ Push(r6, r5, r4, r3);
+
+ CreateAllocationSiteStub create_stub(masm->isolate());
+ __ CallStub(&create_stub);
+
+ __ Pop(r6, r5, r4, r3);
+ __ SmiUntag(r3);
+ }
+ __ b(&done);
+
+ __ bind(¬_array_function);
+ }
+
+ __ SmiToPtrArrayOffset(r7, r6);
+ __ add(r7, r5, r7);
+ __ addi(r7, r7, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ __ StoreP(r4, MemOperand(r7, 0));
+
+ __ Push(r7, r5, r4);
+ __ RecordWrite(r5, r7, r4, kLRHasNotBeenSaved, kDontSaveFPRegs,
+ EMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
+ __ Pop(r7, r5, r4);
+
+ __ bind(&done);
+}
+
+
+static void EmitContinueIfStrictOrNative(MacroAssembler* masm, Label* cont) {
+ // Do not transform the receiver for strict mode functions and natives.
+ __ LoadP(r6, FieldMemOperand(r4, JSFunction::kSharedFunctionInfoOffset));
+ __ lwz(r7, FieldMemOperand(r6, SharedFunctionInfo::kCompilerHintsOffset));
+ __ TestBit(r7,
+#if V8_TARGET_ARCH_PPC64
+ SharedFunctionInfo::kStrictModeFunction,
+#else
+ SharedFunctionInfo::kStrictModeFunction + kSmiTagSize,
+#endif
+ r0);
+ __ bne(cont, cr0);
+
+ // Do not transform the receiver for native.
+ __ TestBit(r7,
+#if V8_TARGET_ARCH_PPC64
+ SharedFunctionInfo::kNative,
+#else
+ SharedFunctionInfo::kNative + kSmiTagSize,
+#endif
+ r0);
+ __ bne(cont, cr0);
+}
+
+
+static void EmitSlowCase(MacroAssembler* masm, int argc, Label* non_function) {
+ // Check for function proxy.
+ STATIC_ASSERT(JS_FUNCTION_PROXY_TYPE < 0xffffu);
+ __ cmpi(r7, Operand(JS_FUNCTION_PROXY_TYPE));
+ __ bne(non_function);
+ __ push(r4); // put proxy as additional argument
+ __ li(r3, Operand(argc + 1));
+ __ li(r5, Operand::Zero());
+ __ GetBuiltinFunction(r4, Builtins::CALL_FUNCTION_PROXY);
+ {
+ Handle<Code> adaptor =
+ masm->isolate()->builtins()->ArgumentsAdaptorTrampoline();
+ __ Jump(adaptor, RelocInfo::CODE_TARGET);
+ }
+
+ // CALL_NON_FUNCTION expects the non-function callee as receiver (instead
+ // of the original receiver from the call site).
+ __ bind(non_function);
+ __ StoreP(r4, MemOperand(sp, argc * kPointerSize), r0);
+ __ li(r3, Operand(argc)); // Set up the number of arguments.
+ __ li(r5, Operand::Zero());
+ __ GetBuiltinFunction(r4, Builtins::CALL_NON_FUNCTION);
+ __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
+ RelocInfo::CODE_TARGET);
+}
+
+
+static void EmitWrapCase(MacroAssembler* masm, int argc, Label* cont) {
+ // Wrap the receiver and patch it back onto the stack.
+ {
+ FrameAndConstantPoolScope frame_scope(masm, StackFrame::INTERNAL);
+ __ Push(r4, r6);
+ __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
+ __ pop(r4);
+ }
+ __ StoreP(r3, MemOperand(sp, argc * kPointerSize), r0);
+ __ b(cont);
+}
+
+
+static void CallFunctionNoFeedback(MacroAssembler* masm, int argc,
+ bool needs_checks, bool call_as_method) {
+ // r4 : the function to call
+ Label slow, non_function, wrap, cont;
+
+ if (needs_checks) {
+ // Check that the function is really a JavaScript function.
+ // r4: pushed function (to be verified)
+ __ JumpIfSmi(r4, &non_function);
+
+ // Goto slow case if we do not have a function.
+ __ CompareObjectType(r4, r7, r7, JS_FUNCTION_TYPE);
+ __ bne(&slow);
+ }
+
+ // Fast-case: Invoke the function now.
+ // r4: pushed function
+ ParameterCount actual(argc);
+
+ if (call_as_method) {
+ if (needs_checks) {
+ EmitContinueIfStrictOrNative(masm, &cont);
+ }
+
+ // Compute the receiver in sloppy mode.
+ __ LoadP(r6, MemOperand(sp, argc * kPointerSize), r0);
+
+ if (needs_checks) {
+ __ JumpIfSmi(r6, &wrap);
+ __ CompareObjectType(r6, r7, r7, FIRST_SPEC_OBJECT_TYPE);
+ __ blt(&wrap);
+ } else {
+ __ b(&wrap);
+ }
+
+ __ bind(&cont);
+ }
+
+ __ InvokeFunction(r4, actual, JUMP_FUNCTION, NullCallWrapper());
+
+ if (needs_checks) {
+ // Slow-case: Non-function called.
+ __ bind(&slow);
+ EmitSlowCase(masm, argc, &non_function);
+ }
+
+ if (call_as_method) {
+ __ bind(&wrap);
+ EmitWrapCase(masm, argc, &cont);
+ }
+}
+
+
+void CallFunctionStub::Generate(MacroAssembler* masm) {
+ CallFunctionNoFeedback(masm, argc(), NeedsChecks(), CallAsMethod());
+}
+
+
+void CallConstructStub::Generate(MacroAssembler* masm) {
+ // r3 : number of arguments
+ // r4 : the function to call
+ // r5 : feedback vector
+ // r6 : (only if r5 is not the megamorphic symbol) slot in feedback
+ // vector (Smi)
+ Label slow, non_function_call;
+
+ // Check that the function is not a smi.
+ __ JumpIfSmi(r4, &non_function_call);
+ // Check that the function is a JSFunction.
+ __ CompareObjectType(r4, r7, r7, JS_FUNCTION_TYPE);
+ __ bne(&slow);
+
+ if (RecordCallTarget()) {
+ GenerateRecordCallTarget(masm);
+
+ __ SmiToPtrArrayOffset(r8, r6);
+ __ add(r8, r5, r8);
+ if (FLAG_pretenuring_call_new) {
+ // Put the AllocationSite from the feedback vector into r5.
+ // By adding kPointerSize we encode that we know the AllocationSite
+ // entry is at the feedback vector slot given by r6 + 1.
+ __ LoadP(r5, FieldMemOperand(r8, FixedArray::kHeaderSize + kPointerSize));
+ } else {
+ Label feedback_register_initialized;
+ // Put the AllocationSite from the feedback vector into r5, or undefined.
+ __ LoadP(r5, FieldMemOperand(r8, FixedArray::kHeaderSize));
+ __ LoadP(r8, FieldMemOperand(r5, AllocationSite::kMapOffset));
+ __ CompareRoot(r8, Heap::kAllocationSiteMapRootIndex);
+ __ beq(&feedback_register_initialized);
+ __ LoadRoot(r5, Heap::kUndefinedValueRootIndex);
+ __ bind(&feedback_register_initialized);
+ }
+
+ __ AssertUndefinedOrAllocationSite(r5, r8);
+ }
+
+ // Jump to the function-specific construct stub.
+ Register jmp_reg = r7;
+ __ LoadP(jmp_reg, FieldMemOperand(r4, JSFunction::kSharedFunctionInfoOffset));
+ __ LoadP(jmp_reg,
+ FieldMemOperand(jmp_reg, SharedFunctionInfo::kConstructStubOffset));
+ __ addi(ip, jmp_reg, Operand(Code::kHeaderSize - kHeapObjectTag));
+ __ JumpToJSEntry(ip);
+
+ // r3: number of arguments
+ // r4: called object
+ // r7: object type
+ Label do_call;
+ __ bind(&slow);
+ STATIC_ASSERT(JS_FUNCTION_PROXY_TYPE < 0xffffu);
+ __ cmpi(r7, Operand(JS_FUNCTION_PROXY_TYPE));
+ __ bne(&non_function_call);
+ __ GetBuiltinFunction(r4, Builtins::CALL_FUNCTION_PROXY_AS_CONSTRUCTOR);
+ __ b(&do_call);
+
+ __ bind(&non_function_call);
+ __ GetBuiltinFunction(r4, Builtins::CALL_NON_FUNCTION_AS_CONSTRUCTOR);
+ __ bind(&do_call);
+ // Set expected number of arguments to zero (not changing r3).
+ __ li(r5, Operand::Zero());
+ __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
+ RelocInfo::CODE_TARGET);
+}
+
+
+static void EmitLoadTypeFeedbackVector(MacroAssembler* masm, Register vector) {
+ __ LoadP(vector, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ __ LoadP(vector,
+ FieldMemOperand(vector, JSFunction::kSharedFunctionInfoOffset));
+ __ LoadP(vector,
+ FieldMemOperand(vector, SharedFunctionInfo::kFeedbackVectorOffset));
+}
+
+
+void CallIC_ArrayStub::Generate(MacroAssembler* masm) {
+ // r4 - function
+ // r6 - slot id
+ Label miss;
+ int argc = arg_count();
+ ParameterCount actual(argc);
+
+ EmitLoadTypeFeedbackVector(masm, r5);
+
+ __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, r7);
+ __ cmp(r4, r7);
+ __ bne(&miss);
+
+ __ mov(r3, Operand(arg_count()));
+ __ SmiToPtrArrayOffset(r7, r6);
+ __ add(r7, r5, r7);
+ __ LoadP(r7, FieldMemOperand(r7, FixedArray::kHeaderSize));
+
+ // Verify that r7 contains an AllocationSite
+ __ LoadP(r8, FieldMemOperand(r7, HeapObject::kMapOffset));
+ __ CompareRoot(r8, Heap::kAllocationSiteMapRootIndex);
+ __ bne(&miss);
+
+ __ mr(r5, r7);
+ ArrayConstructorStub stub(masm->isolate(), arg_count());
+ __ TailCallStub(&stub);
+
+ __ bind(&miss);
+ GenerateMiss(masm);
+
+ // The slow case, we need this no matter what to complete a call after a miss.
+ CallFunctionNoFeedback(masm, arg_count(), true, CallAsMethod());
+
+ // Unreachable.
+ __ stop("Unexpected code address");
+}
+
+
+void CallICStub::Generate(MacroAssembler* masm) {
+ // r4 - function
+ // r6 - slot id (Smi)
+ Label extra_checks_or_miss, slow_start;
+ Label slow, non_function, wrap, cont;
+ Label have_js_function;
+ int argc = arg_count();
+ ParameterCount actual(argc);
+
+ EmitLoadTypeFeedbackVector(masm, r5);
+
+ // The checks. First, does r4 match the recorded monomorphic target?
+ __ SmiToPtrArrayOffset(r7, r6);
+ __ add(r7, r5, r7);
+ __ LoadP(r7, FieldMemOperand(r7, FixedArray::kHeaderSize));
+ __ cmp(r4, r7);
+ __ bne(&extra_checks_or_miss);
+
+ __ bind(&have_js_function);
+ if (CallAsMethod()) {
+ EmitContinueIfStrictOrNative(masm, &cont);
+ // Compute the receiver in sloppy mode.
+ __ LoadP(r6, MemOperand(sp, argc * kPointerSize), r0);
+
+ __ JumpIfSmi(r6, &wrap);
+ __ CompareObjectType(r6, r7, r7, FIRST_SPEC_OBJECT_TYPE);
+ __ blt(&wrap);
+
+ __ bind(&cont);
+ }
+
+ __ InvokeFunction(r4, actual, JUMP_FUNCTION, NullCallWrapper());
+
+ __ bind(&slow);
+ EmitSlowCase(masm, argc, &non_function);
+
+ if (CallAsMethod()) {
+ __ bind(&wrap);
+ EmitWrapCase(masm, argc, &cont);
+ }
+
+ __ bind(&extra_checks_or_miss);
+ Label miss;
+
+ __ CompareRoot(r7, Heap::kmegamorphic_symbolRootIndex);
+ __ beq(&slow_start);
+ __ CompareRoot(r7, Heap::kuninitialized_symbolRootIndex);
+ __ beq(&miss);
+
+ if (!FLAG_trace_ic) {
+ // We are going megamorphic. If the feedback is a JSFunction, it is fine
+ // to handle it here. More complex cases are dealt with in the runtime.
+ __ AssertNotSmi(r7);
+ __ CompareObjectType(r7, r8, r8, JS_FUNCTION_TYPE);
+ __ bne(&miss);
+ __ SmiToPtrArrayOffset(r7, r6);
+ __ add(r7, r5, r7);
+ __ LoadRoot(ip, Heap::kmegamorphic_symbolRootIndex);
+ __ StoreP(ip, FieldMemOperand(r7, FixedArray::kHeaderSize), r0);
+ // We have to update statistics for runtime profiling.
+ const int with_types_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kWithTypesIndex);
+ __ LoadP(r7, FieldMemOperand(r5, with_types_offset));
+ __ SubSmiLiteral(r7, r7, Smi::FromInt(1), r0);
+ __ StoreP(r7, FieldMemOperand(r5, with_types_offset), r0);
+ const int generic_offset =
+ FixedArray::OffsetOfElementAt(TypeFeedbackVector::kGenericCountIndex);
+ __ LoadP(r7, FieldMemOperand(r5, generic_offset));
+ __ AddSmiLiteral(r7, r7, Smi::FromInt(1), r0);
+ __ StoreP(r7, FieldMemOperand(r5, generic_offset), r0);
+ __ jmp(&slow_start);
+ }
+
+ // We are here because tracing is on or we are going monomorphic.
+ __ bind(&miss);
+ GenerateMiss(masm);
+
+ // the slow case
+ __ bind(&slow_start);
+ // Check that the function is really a JavaScript function.
+ // r4: pushed function (to be verified)
+ __ JumpIfSmi(r4, &non_function);
+
+ // Goto slow case if we do not have a function.
+ __ CompareObjectType(r4, r7, r7, JS_FUNCTION_TYPE);
+ __ bne(&slow);
+ __ b(&have_js_function);
+}
+
+
+void CallICStub::GenerateMiss(MacroAssembler* masm) {
+ // Get the receiver of the function from the stack; 1 ~ return address.
+ __ LoadP(r7, MemOperand(sp, (arg_count() + 1) * kPointerSize), r0);
+
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+
+ // Push the receiver and the function and feedback info.
+ __ Push(r7, r4, r5, r6);
+
+ // Call the entry.
+ IC::UtilityId id = GetICState() == DEFAULT ? IC::kCallIC_Miss
+ : IC::kCallIC_Customization_Miss;
+
+ ExternalReference miss = ExternalReference(IC_Utility(id), masm->isolate());
+ __ CallExternalReference(miss, 4);
+
+ // Move result to r4 and exit the internal frame.
+ __ mr(r4, r3);
+ }
+}
+
+
+// StringCharCodeAtGenerator
+void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) {
+ // If the receiver is a smi trigger the non-string case.
+ if (check_mode_ == RECEIVER_IS_UNKNOWN) {
+ __ JumpIfSmi(object_, receiver_not_string_);
+
+ // Fetch the instance type of the receiver into result register.
+ __ LoadP(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
+ __ lbz(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
+ // If the receiver is not a string trigger the non-string case.
+ __ andi(r0, result_, Operand(kIsNotStringMask));
+ __ bne(receiver_not_string_, cr0);
+ }
+
+ // If the index is non-smi trigger the non-smi case.
+ __ JumpIfNotSmi(index_, &index_not_smi_);
+ __ bind(&got_smi_index_);
+
+ // Check for index out of range.
+ __ LoadP(ip, FieldMemOperand(object_, String::kLengthOffset));
+ __ cmpl(ip, index_);
+ __ ble(index_out_of_range_);
+
+ __ SmiUntag(index_);
+
+ StringCharLoadGenerator::Generate(masm, object_, index_, result_,
+ &call_runtime_);
+
+ __ SmiTag(result_);
+ __ bind(&exit_);
+}
+
+
+void StringCharCodeAtGenerator::GenerateSlow(
+ MacroAssembler* masm, const RuntimeCallHelper& call_helper) {
+ __ Abort(kUnexpectedFallthroughToCharCodeAtSlowCase);
+
+ // Index is not a smi.
+ __ bind(&index_not_smi_);
+ // If index is a heap number, try converting it to an integer.
+ __ CheckMap(index_, result_, Heap::kHeapNumberMapRootIndex, index_not_number_,
+ DONT_DO_SMI_CHECK);
+ call_helper.BeforeCall(masm);
+ __ push(object_);
+ __ push(index_); // Consumed by runtime conversion function.
+ if (index_flags_ == STRING_INDEX_IS_NUMBER) {
+ __ CallRuntime(Runtime::kNumberToIntegerMapMinusZero, 1);
+ } else {
+ DCHECK(index_flags_ == STRING_INDEX_IS_ARRAY_INDEX);
+ // NumberToSmi discards numbers that are not exact integers.
+ __ CallRuntime(Runtime::kNumberToSmi, 1);
+ }
+ // Save the conversion result before the pop instructions below
+ // have a chance to overwrite it.
+ __ Move(index_, r3);
+ __ pop(object_);
+ // Reload the instance type.
+ __ LoadP(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
+ __ lbz(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
+ call_helper.AfterCall(masm);
+ // If index is still not a smi, it must be out of range.
+ __ JumpIfNotSmi(index_, index_out_of_range_);
+ // Otherwise, return to the fast path.
+ __ b(&got_smi_index_);
+
+ // Call runtime. We get here when the receiver is a string and the
+ // index is a number, but the code of getting the actual character
+ // is too complex (e.g., when the string needs to be flattened).
+ __ bind(&call_runtime_);
+ call_helper.BeforeCall(masm);
+ __ SmiTag(index_);
+ __ Push(object_, index_);
+ __ CallRuntime(Runtime::kStringCharCodeAtRT, 2);
+ __ Move(result_, r3);
+ call_helper.AfterCall(masm);
+ __ b(&exit_);
+
+ __ Abort(kUnexpectedFallthroughFromCharCodeAtSlowCase);
+}
+
+
+// -------------------------------------------------------------------------
+// StringCharFromCodeGenerator
+
+void StringCharFromCodeGenerator::GenerateFast(MacroAssembler* masm) {
+ // Fast case of Heap::LookupSingleCharacterStringFromCode.
+ DCHECK(base::bits::IsPowerOfTwo32(String::kMaxOneByteCharCode + 1));
+ __ LoadSmiLiteral(r0, Smi::FromInt(~String::kMaxOneByteCharCode));
+ __ ori(r0, r0, Operand(kSmiTagMask));
+ __ and_(r0, code_, r0);
+ __ cmpi(r0, Operand::Zero());
+ __ bne(&slow_case_);
+
+ __ LoadRoot(result_, Heap::kSingleCharacterStringCacheRootIndex);
+ // At this point code register contains smi tagged one-byte char code.
+ __ mr(r0, code_);
+ __ SmiToPtrArrayOffset(code_, code_);
+ __ add(result_, result_, code_);
+ __ mr(code_, r0);
+ __ LoadP(result_, FieldMemOperand(result_, FixedArray::kHeaderSize));
+ __ CompareRoot(result_, Heap::kUndefinedValueRootIndex);
+ __ beq(&slow_case_);
+ __ bind(&exit_);
+}
+
+
+void StringCharFromCodeGenerator::GenerateSlow(
+ MacroAssembler* masm, const RuntimeCallHelper& call_helper) {
+ __ Abort(kUnexpectedFallthroughToCharFromCodeSlowCase);
+
+ __ bind(&slow_case_);
+ call_helper.BeforeCall(masm);
+ __ push(code_);
+ __ CallRuntime(Runtime::kCharFromCode, 1);
+ __ Move(result_, r3);
+ call_helper.AfterCall(masm);
+ __ b(&exit_);
+
+ __ Abort(kUnexpectedFallthroughFromCharFromCodeSlowCase);
+}
+
+
+enum CopyCharactersFlags { COPY_ONE_BYTE = 1, DEST_ALWAYS_ALIGNED = 2 };
+
+
+void StringHelper::GenerateCopyCharacters(MacroAssembler* masm, Register dest,
+ Register src, Register count,
+ Register scratch,
+ String::Encoding encoding) {
+ if (FLAG_debug_code) {
+ // Check that destination is word aligned.
+ __ andi(r0, dest, Operand(kPointerAlignmentMask));
+ __ Check(eq, kDestinationOfCopyNotAligned, cr0);
+ }
+
+ // Nothing to do for zero characters.
+ Label done;
+ if (encoding == String::TWO_BYTE_ENCODING) {
+ // double the length
+ __ add(count, count, count, LeaveOE, SetRC);
+ __ beq(&done, cr0);
+ } else {
+ __ cmpi(count, Operand::Zero());
+ __ beq(&done);
+ }
+
+ // Copy count bytes from src to dst.
+ Label byte_loop;
+ __ mtctr(count);
+ __ bind(&byte_loop);
+ __ lbz(scratch, MemOperand(src));
+ __ addi(src, src, Operand(1));
+ __ stb(scratch, MemOperand(dest));
+ __ addi(dest, dest, Operand(1));
+ __ bdnz(&byte_loop);
+
+ __ bind(&done);
+}
+
+
+void SubStringStub::Generate(MacroAssembler* masm) {
+ Label runtime;
+
+ // Stack frame on entry.
+ // lr: return address
+ // sp[0]: to
+ // sp[4]: from
+ // sp[8]: string
+
+ // This stub is called from the native-call %_SubString(...), so
+ // nothing can be assumed about the arguments. It is tested that:
+ // "string" is a sequential string,
+ // both "from" and "to" are smis, and
+ // 0 <= from <= to <= string.length.
+ // If any of these assumptions fail, we call the runtime system.
+
+ const int kToOffset = 0 * kPointerSize;
+ const int kFromOffset = 1 * kPointerSize;
+ const int kStringOffset = 2 * kPointerSize;
+
+ __ LoadP(r5, MemOperand(sp, kToOffset));
+ __ LoadP(r6, MemOperand(sp, kFromOffset));
+
+ // If either to or from had the smi tag bit set, then fail to generic runtime
+ __ JumpIfNotSmi(r5, &runtime);
+ __ JumpIfNotSmi(r6, &runtime);
+ __ SmiUntag(r5);
+ __ SmiUntag(r6, SetRC);
+ // Both r5 and r6 are untagged integers.
+
+ // We want to bailout to runtime here if From is negative.
+ __ blt(&runtime, cr0); // From < 0.
+
+ __ cmpl(r6, r5);
+ __ bgt(&runtime); // Fail if from > to.
+ __ sub(r5, r5, r6);
+
+ // Make sure first argument is a string.
+ __ LoadP(r3, MemOperand(sp, kStringOffset));
+ __ JumpIfSmi(r3, &runtime);
+ Condition is_string = masm->IsObjectStringType(r3, r4);
+ __ b(NegateCondition(is_string), &runtime, cr0);
+
+ Label single_char;
+ __ cmpi(r5, Operand(1));
+ __ b(eq, &single_char);
+
+ // Short-cut for the case of trivial substring.
+ Label return_r3;
+ // r3: original string
+ // r5: result string length
+ __ LoadP(r7, FieldMemOperand(r3, String::kLengthOffset));
+ __ SmiUntag(r0, r7);
+ __ cmpl(r5, r0);
+ // Return original string.
+ __ beq(&return_r3);
+ // Longer than original string's length or negative: unsafe arguments.
+ __ bgt(&runtime);
+ // Shorter than original string's length: an actual substring.
+
+ // Deal with different string types: update the index if necessary
+ // and put the underlying string into r8.
+ // r3: original string
+ // r4: instance type
+ // r5: length
+ // r6: from index (untagged)
+ Label underlying_unpacked, sliced_string, seq_or_external_string;
+ // If the string is not indirect, it can only be sequential or external.
+ STATIC_ASSERT(kIsIndirectStringMask == (kSlicedStringTag & kConsStringTag));
+ STATIC_ASSERT(kIsIndirectStringMask != 0);
+ __ andi(r0, r4, Operand(kIsIndirectStringMask));
+ __ beq(&seq_or_external_string, cr0);
+
+ __ andi(r0, r4, Operand(kSlicedNotConsMask));
+ __ bne(&sliced_string, cr0);
+ // Cons string. Check whether it is flat, then fetch first part.
+ __ LoadP(r8, FieldMemOperand(r3, ConsString::kSecondOffset));
+ __ CompareRoot(r8, Heap::kempty_stringRootIndex);
+ __ bne(&runtime);
+ __ LoadP(r8, FieldMemOperand(r3, ConsString::kFirstOffset));
+ // Update instance type.
+ __ LoadP(r4, FieldMemOperand(r8, HeapObject::kMapOffset));
+ __ lbz(r4, FieldMemOperand(r4, Map::kInstanceTypeOffset));
+ __ b(&underlying_unpacked);
+
+ __ bind(&sliced_string);
+ // Sliced string. Fetch parent and correct start index by offset.
+ __ LoadP(r8, FieldMemOperand(r3, SlicedString::kParentOffset));
+ __ LoadP(r7, FieldMemOperand(r3, SlicedString::kOffsetOffset));
+ __ SmiUntag(r4, r7);
+ __ add(r6, r6, r4); // Add offset to index.
+ // Update instance type.
+ __ LoadP(r4, FieldMemOperand(r8, HeapObject::kMapOffset));
+ __ lbz(r4, FieldMemOperand(r4, Map::kInstanceTypeOffset));
+ __ b(&underlying_unpacked);
+
+ __ bind(&seq_or_external_string);
+ // Sequential or external string. Just move string to the expected register.
+ __ mr(r8, r3);
+
+ __ bind(&underlying_unpacked);
+
+ if (FLAG_string_slices) {
+ Label copy_routine;
+ // r8: underlying subject string
+ // r4: instance type of underlying subject string
+ // r5: length
+ // r6: adjusted start index (untagged)
+ __ cmpi(r5, Operand(SlicedString::kMinLength));
+ // Short slice. Copy instead of slicing.
+ __ blt(©_routine);
+ // Allocate new sliced string. At this point we do not reload the instance
+ // type including the string encoding because we simply rely on the info
+ // provided by the original string. It does not matter if the original
+ // string's encoding is wrong because we always have to recheck encoding of
+ // the newly created string's parent anyways due to externalized strings.
+ Label two_byte_slice, set_slice_header;
+ STATIC_ASSERT((kStringEncodingMask & kOneByteStringTag) != 0);
+ STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0);
+ __ andi(r0, r4, Operand(kStringEncodingMask));
+ __ beq(&two_byte_slice, cr0);
+ __ AllocateOneByteSlicedString(r3, r5, r9, r10, &runtime);
+ __ b(&set_slice_header);
+ __ bind(&two_byte_slice);
+ __ AllocateTwoByteSlicedString(r3, r5, r9, r10, &runtime);
+ __ bind(&set_slice_header);
+ __ SmiTag(r6);
+ __ StoreP(r8, FieldMemOperand(r3, SlicedString::kParentOffset), r0);
+ __ StoreP(r6, FieldMemOperand(r3, SlicedString::kOffsetOffset), r0);
+ __ b(&return_r3);
+
+ __ bind(©_routine);
+ }
+
+ // r8: underlying subject string
+ // r4: instance type of underlying subject string
+ // r5: length
+ // r6: adjusted start index (untagged)
+ Label two_byte_sequential, sequential_string, allocate_result;
+ STATIC_ASSERT(kExternalStringTag != 0);
+ STATIC_ASSERT(kSeqStringTag == 0);
+ __ andi(r0, r4, Operand(kExternalStringTag));
+ __ beq(&sequential_string, cr0);
+
+ // Handle external string.
+ // Rule out short external strings.
+ STATIC_ASSERT(kShortExternalStringTag != 0);
+ __ andi(r0, r4, Operand(kShortExternalStringTag));
+ __ bne(&runtime, cr0);
+ __ LoadP(r8, FieldMemOperand(r8, ExternalString::kResourceDataOffset));
+ // r8 already points to the first character of underlying string.
+ __ b(&allocate_result);
+
+ __ bind(&sequential_string);
+ // Locate first character of underlying subject string.
+ STATIC_ASSERT(SeqTwoByteString::kHeaderSize == SeqOneByteString::kHeaderSize);
+ __ addi(r8, r8, Operand(SeqOneByteString::kHeaderSize - kHeapObjectTag));
+
+ __ bind(&allocate_result);
+ // Sequential acii string. Allocate the result.
+ STATIC_ASSERT((kOneByteStringTag & kStringEncodingMask) != 0);
+ __ andi(r0, r4, Operand(kStringEncodingMask));
+ __ beq(&two_byte_sequential, cr0);
+
+ // Allocate and copy the resulting one-byte string.
+ __ AllocateOneByteString(r3, r5, r7, r9, r10, &runtime);
+
+ // Locate first character of substring to copy.
+ __ add(r8, r8, r6);
+ // Locate first character of result.
+ __ addi(r4, r3, Operand(SeqOneByteString::kHeaderSize - kHeapObjectTag));
+
+ // r3: result string
+ // r4: first character of result string
+ // r5: result string length
+ // r8: first character of substring to copy
+ STATIC_ASSERT((SeqOneByteString::kHeaderSize & kObjectAlignmentMask) == 0);
+ StringHelper::GenerateCopyCharacters(masm, r4, r8, r5, r6,
+ String::ONE_BYTE_ENCODING);
+ __ b(&return_r3);
+
+ // Allocate and copy the resulting two-byte string.
+ __ bind(&two_byte_sequential);
+ __ AllocateTwoByteString(r3, r5, r7, r9, r10, &runtime);
+
+ // Locate first character of substring to copy.
+ __ ShiftLeftImm(r4, r6, Operand(1));
+ __ add(r8, r8, r4);
+ // Locate first character of result.
+ __ addi(r4, r3, Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
+
+ // r3: result string.
+ // r4: first character of result.
+ // r5: result length.
+ // r8: first character of substring to copy.
+ STATIC_ASSERT((SeqTwoByteString::kHeaderSize & kObjectAlignmentMask) == 0);
+ StringHelper::GenerateCopyCharacters(masm, r4, r8, r5, r6,
+ String::TWO_BYTE_ENCODING);
+
+ __ bind(&return_r3);
+ Counters* counters = isolate()->counters();
+ __ IncrementCounter(counters->sub_string_native(), 1, r6, r7);
+ __ Drop(3);
+ __ Ret();
+
+ // Just jump to runtime to create the sub string.
+ __ bind(&runtime);
+ __ TailCallRuntime(Runtime::kSubString, 3, 1);
+
+ __ bind(&single_char);
+ // r3: original string
+ // r4: instance type
+ // r5: length
+ // r6: from index (untagged)
+ __ SmiTag(r6, r6);
+ StringCharAtGenerator generator(r3, r6, r5, r3, &runtime, &runtime, &runtime,
+ STRING_INDEX_IS_NUMBER, RECEIVER_IS_STRING);
+ generator.GenerateFast(masm);
+ __ Drop(3);
+ __ Ret();
+ generator.SkipSlow(masm, &runtime);
+}
+
+
+void StringHelper::GenerateFlatOneByteStringEquals(MacroAssembler* masm,
+ Register left,
+ Register right,
+ Register scratch1,
+ Register scratch2) {
+ Register length = scratch1;
+
+ // Compare lengths.
+ Label strings_not_equal, check_zero_length;
+ __ LoadP(length, FieldMemOperand(left, String::kLengthOffset));
+ __ LoadP(scratch2, FieldMemOperand(right, String::kLengthOffset));
+ __ cmp(length, scratch2);
+ __ beq(&check_zero_length);
+ __ bind(&strings_not_equal);
+ __ LoadSmiLiteral(r3, Smi::FromInt(NOT_EQUAL));
+ __ Ret();
+
+ // Check if the length is zero.
+ Label compare_chars;
+ __ bind(&check_zero_length);
+ STATIC_ASSERT(kSmiTag == 0);
+ __ cmpi(length, Operand::Zero());
+ __ bne(&compare_chars);
+ __ LoadSmiLiteral(r3, Smi::FromInt(EQUAL));
+ __ Ret();
+
+ // Compare characters.
+ __ bind(&compare_chars);
+ GenerateOneByteCharsCompareLoop(masm, left, right, length, scratch2,
+ &strings_not_equal);
+
+ // Characters are equal.
+ __ LoadSmiLiteral(r3, Smi::FromInt(EQUAL));
+ __ Ret();
+}
+
+
+void StringHelper::GenerateCompareFlatOneByteStrings(
+ MacroAssembler* masm, Register left, Register right, Register scratch1,
+ Register scratch2, Register scratch3) {
+ Label skip, result_not_equal, compare_lengths;
+ // Find minimum length and length difference.
+ __ LoadP(scratch1, FieldMemOperand(left, String::kLengthOffset));
+ __ LoadP(scratch2, FieldMemOperand(right, String::kLengthOffset));
+ __ sub(scratch3, scratch1, scratch2, LeaveOE, SetRC);
+ Register length_delta = scratch3;
+ __ ble(&skip, cr0);
+ __ mr(scratch1, scratch2);
+ __ bind(&skip);
+ Register min_length = scratch1;
+ STATIC_ASSERT(kSmiTag == 0);
+ __ cmpi(min_length, Operand::Zero());
+ __ beq(&compare_lengths);
+
+ // Compare loop.
+ GenerateOneByteCharsCompareLoop(masm, left, right, min_length, scratch2,
+ &result_not_equal);
+
+ // Compare lengths - strings up to min-length are equal.
+ __ bind(&compare_lengths);
+ DCHECK(Smi::FromInt(EQUAL) == static_cast<Smi*>(0));
+ // Use length_delta as result if it's zero.
+ __ mr(r3, length_delta);
+ __ cmpi(r3, Operand::Zero());
+ __ bind(&result_not_equal);
+ // Conditionally update the result based either on length_delta or
+ // the last comparion performed in the loop above.
+ Label less_equal, equal;
+ __ ble(&less_equal);
+ __ LoadSmiLiteral(r3, Smi::FromInt(GREATER));
+ __ Ret();
+ __ bind(&less_equal);
+ __ beq(&equal);
+ __ LoadSmiLiteral(r3, Smi::FromInt(LESS));
+ __ bind(&equal);
+ __ Ret();
+}
+
+
+void StringHelper::GenerateOneByteCharsCompareLoop(
+ MacroAssembler* masm, Register left, Register right, Register length,
+ Register scratch1, Label* chars_not_equal) {
+ // Change index to run from -length to -1 by adding length to string
+ // start. This means that loop ends when index reaches zero, which
+ // doesn't need an additional compare.
+ __ SmiUntag(length);
+ __ addi(scratch1, length,
+ Operand(SeqOneByteString::kHeaderSize - kHeapObjectTag));
+ __ add(left, left, scratch1);
+ __ add(right, right, scratch1);
+ __ subfic(length, length, Operand::Zero());
+ Register index = length; // index = -length;
+
+ // Compare loop.
+ Label loop;
+ __ bind(&loop);
+ __ lbzx(scratch1, MemOperand(left, index));
+ __ lbzx(r0, MemOperand(right, index));
+ __ cmp(scratch1, r0);
+ __ bne(chars_not_equal);
+ __ addi(index, index, Operand(1));
+ __ cmpi(index, Operand::Zero());
+ __ bne(&loop);
+}
+
+
+void StringCompareStub::Generate(MacroAssembler* masm) {
+ Label runtime;
+
+ Counters* counters = isolate()->counters();
+
+ // Stack frame on entry.
+ // sp[0]: right string
+ // sp[4]: left string
+ __ LoadP(r3, MemOperand(sp)); // Load right in r3, left in r4.
+ __ LoadP(r4, MemOperand(sp, kPointerSize));
+
+ Label not_same;
+ __ cmp(r3, r4);
+ __ bne(¬_same);
+ STATIC_ASSERT(EQUAL == 0);
+ STATIC_ASSERT(kSmiTag == 0);
+ __ LoadSmiLiteral(r3, Smi::FromInt(EQUAL));
+ __ IncrementCounter(counters->string_compare_native(), 1, r4, r5);
+ __ addi(sp, sp, Operand(2 * kPointerSize));
+ __ Ret();
+
+ __ bind(¬_same);
+
+ // Check that both objects are sequential one-byte strings.
+ __ JumpIfNotBothSequentialOneByteStrings(r4, r3, r5, r6, &runtime);
+
+ // Compare flat one-byte strings natively. Remove arguments from stack first.
+ __ IncrementCounter(counters->string_compare_native(), 1, r5, r6);
+ __ addi(sp, sp, Operand(2 * kPointerSize));
+ StringHelper::GenerateCompareFlatOneByteStrings(masm, r4, r3, r5, r6, r7);
+
+ // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
+ // tagged as a small integer.
+ __ bind(&runtime);
+ __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
+}
+
+
+void BinaryOpICWithAllocationSiteStub::Generate(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- r4 : left
+ // -- r3 : right
+ // -- lr : return address
+ // -----------------------------------
+
+ // Load r5 with the allocation site. We stick an undefined dummy value here
+ // and replace it with the real allocation site later when we instantiate this
+ // stub in BinaryOpICWithAllocationSiteStub::GetCodeCopyFromTemplate().
+ __ Move(r5, handle(isolate()->heap()->undefined_value()));
+
+ // Make sure that we actually patched the allocation site.
+ if (FLAG_debug_code) {
+ __ TestIfSmi(r5, r0);
+ __ Assert(ne, kExpectedAllocationSite, cr0);
+ __ push(r5);
+ __ LoadP(r5, FieldMemOperand(r5, HeapObject::kMapOffset));
+ __ LoadRoot(ip, Heap::kAllocationSiteMapRootIndex);
+ __ cmp(r5, ip);
+ __ pop(r5);
+ __ Assert(eq, kExpectedAllocationSite);
+ }
+
+ // Tail call into the stub that handles binary operations with allocation
+ // sites.
+ BinaryOpWithAllocationSiteStub stub(isolate(), state());
+ __ TailCallStub(&stub);
+}
+
+
+void CompareICStub::GenerateSmis(MacroAssembler* masm) {
+ DCHECK(state() == CompareICState::SMI);
+ Label miss;
+ __ orx(r5, r4, r3);
+ __ JumpIfNotSmi(r5, &miss);
+
+ if (GetCondition() == eq) {
+ // For equality we do not care about the sign of the result.
+ // __ sub(r3, r3, r4, SetCC);
+ __ sub(r3, r3, r4);
+ } else {
+ // Untag before subtracting to avoid handling overflow.
+ __ SmiUntag(r4);
+ __ SmiUntag(r3);
+ __ sub(r3, r4, r3);
+ }
+ __ Ret();
+
+ __ bind(&miss);
+ GenerateMiss(masm);
+}
+
+
+void CompareICStub::GenerateNumbers(MacroAssembler* masm) {
+ DCHECK(state() == CompareICState::NUMBER);
+
+ Label generic_stub;
+ Label unordered, maybe_undefined1, maybe_undefined2;
+ Label miss;
+ Label equal, less_than;
+
+ if (left() == CompareICState::SMI) {
+ __ JumpIfNotSmi(r4, &miss);
+ }
+ if (right() == CompareICState::SMI) {
+ __ JumpIfNotSmi(r3, &miss);
+ }
+
+ // Inlining the double comparison and falling back to the general compare
+ // stub if NaN is involved.
+ // Load left and right operand.
+ Label done, left, left_smi, right_smi;
+ __ JumpIfSmi(r3, &right_smi);
+ __ CheckMap(r3, r5, Heap::kHeapNumberMapRootIndex, &maybe_undefined1,
+ DONT_DO_SMI_CHECK);
+ __ lfd(d1, FieldMemOperand(r3, HeapNumber::kValueOffset));
+ __ b(&left);
+ __ bind(&right_smi);
+ __ SmiToDouble(d1, r3);
+
+ __ bind(&left);
+ __ JumpIfSmi(r4, &left_smi);
+ __ CheckMap(r4, r5, Heap::kHeapNumberMapRootIndex, &maybe_undefined2,
+ DONT_DO_SMI_CHECK);
+ __ lfd(d0, FieldMemOperand(r4, HeapNumber::kValueOffset));
+ __ b(&done);
+ __ bind(&left_smi);
+ __ SmiToDouble(d0, r4);
+
+ __ bind(&done);
+
+ // Compare operands
+ __ fcmpu(d0, d1);
+
+ // Don't base result on status bits when a NaN is involved.
+ __ bunordered(&unordered);
+
+ // Return a result of -1, 0, or 1, based on status bits.
+ __ beq(&equal);
+ __ blt(&less_than);
+ // assume greater than
+ __ li(r3, Operand(GREATER));
+ __ Ret();
+ __ bind(&equal);
+ __ li(r3, Operand(EQUAL));
+ __ Ret();
+ __ bind(&less_than);
+ __ li(r3, Operand(LESS));
+ __ Ret();
+
+ __ bind(&unordered);
+ __ bind(&generic_stub);
+ CompareICStub stub(isolate(), op(), CompareICState::GENERIC,
+ CompareICState::GENERIC, CompareICState::GENERIC);
+ __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET);
+
+ __ bind(&maybe_undefined1);
+ if (Token::IsOrderedRelationalCompareOp(op())) {
+ __ CompareRoot(r3, Heap::kUndefinedValueRootIndex);
+ __ bne(&miss);
+ __ JumpIfSmi(r4, &unordered);
+ __ CompareObjectType(r4, r5, r5, HEAP_NUMBER_TYPE);
+ __ bne(&maybe_undefined2);
+ __ b(&unordered);
+ }
+
+ __ bind(&maybe_undefined2);
+ if (Token::IsOrderedRelationalCompareOp(op())) {
+ __ CompareRoot(r4, Heap::kUndefinedValueRootIndex);
+ __ beq(&unordered);
+ }
+
+ __ bind(&miss);
+ GenerateMiss(masm);
+}
+
+
+void CompareICStub::GenerateInternalizedStrings(MacroAssembler* masm) {
+ DCHECK(state() == CompareICState::INTERNALIZED_STRING);
+ Label miss, not_equal;
+
+ // Registers containing left and right operands respectively.
+ Register left = r4;
+ Register right = r3;
+ Register tmp1 = r5;
+ Register tmp2 = r6;
+
+ // Check that both operands are heap objects.
+ __ JumpIfEitherSmi(left, right, &miss);
+
+ // Check that both operands are symbols.
+ __ LoadP(tmp1, FieldMemOperand(left, HeapObject::kMapOffset));
+ __ LoadP(tmp2, FieldMemOperand(right, HeapObject::kMapOffset));
+ __ lbz(tmp1, FieldMemOperand(tmp1, Map::kInstanceTypeOffset));
+ __ lbz(tmp2, FieldMemOperand(tmp2, Map::kInstanceTypeOffset));
+ STATIC_ASSERT(kInternalizedTag == 0 && kStringTag == 0);
+ __ orx(tmp1, tmp1, tmp2);
+ __ andi(r0, tmp1, Operand(kIsNotStringMask | kIsNotInternalizedMask));
+ __ bne(&miss, cr0);
+
+ // Internalized strings are compared by identity.
+ __ cmp(left, right);
+ __ bne(¬_equal);
+ // Make sure r3 is non-zero. At this point input operands are
+ // guaranteed to be non-zero.
+ DCHECK(right.is(r3));
+ STATIC_ASSERT(EQUAL == 0);
+ STATIC_ASSERT(kSmiTag == 0);
+ __ LoadSmiLiteral(r3, Smi::FromInt(EQUAL));
+ __ bind(¬_equal);
+ __ Ret();
+
+ __ bind(&miss);
+ GenerateMiss(masm);
+}
+
+
+void CompareICStub::GenerateUniqueNames(MacroAssembler* masm) {
+ DCHECK(state() == CompareICState::UNIQUE_NAME);
+ DCHECK(GetCondition() == eq);
+ Label miss;
+
+ // Registers containing left and right operands respectively.
+ Register left = r4;
+ Register right = r3;
+ Register tmp1 = r5;
+ Register tmp2 = r6;
+
+ // Check that both operands are heap objects.
+ __ JumpIfEitherSmi(left, right, &miss);
+
+ // Check that both operands are unique names. This leaves the instance
+ // types loaded in tmp1 and tmp2.
+ __ LoadP(tmp1, FieldMemOperand(left, HeapObject::kMapOffset));
+ __ LoadP(tmp2, FieldMemOperand(right, HeapObject::kMapOffset));
+ __ lbz(tmp1, FieldMemOperand(tmp1, Map::kInstanceTypeOffset));
+ __ lbz(tmp2, FieldMemOperand(tmp2, Map::kInstanceTypeOffset));
+
+ __ JumpIfNotUniqueNameInstanceType(tmp1, &miss);
+ __ JumpIfNotUniqueNameInstanceType(tmp2, &miss);
+
+ // Unique names are compared by identity.
+ __ cmp(left, right);
+ __ bne(&miss);
+ // Make sure r3 is non-zero. At this point input operands are
+ // guaranteed to be non-zero.
+ DCHECK(right.is(r3));
+ STATIC_ASSERT(EQUAL == 0);
+ STATIC_ASSERT(kSmiTag == 0);
+ __ LoadSmiLiteral(r3, Smi::FromInt(EQUAL));
+ __ Ret();
+
+ __ bind(&miss);
+ GenerateMiss(masm);
+}
+
+
+void CompareICStub::GenerateStrings(MacroAssembler* masm) {
+ DCHECK(state() == CompareICState::STRING);
+ Label miss, not_identical, is_symbol;
+
+ bool equality = Token::IsEqualityOp(op());
+
+ // Registers containing left and right operands respectively.
+ Register left = r4;
+ Register right = r3;
+ Register tmp1 = r5;
+ Register tmp2 = r6;
+ Register tmp3 = r7;
+ Register tmp4 = r8;
+
+ // Check that both operands are heap objects.
+ __ JumpIfEitherSmi(left, right, &miss);
+
+ // Check that both operands are strings. This leaves the instance
+ // types loaded in tmp1 and tmp2.
+ __ LoadP(tmp1, FieldMemOperand(left, HeapObject::kMapOffset));
+ __ LoadP(tmp2, FieldMemOperand(right, HeapObject::kMapOffset));
+ __ lbz(tmp1, FieldMemOperand(tmp1, Map::kInstanceTypeOffset));
+ __ lbz(tmp2, FieldMemOperand(tmp2, Map::kInstanceTypeOffset));
+ STATIC_ASSERT(kNotStringTag != 0);
+ __ orx(tmp3, tmp1, tmp2);
+ __ andi(r0, tmp3, Operand(kIsNotStringMask));
+ __ bne(&miss, cr0);
+
+ // Fast check for identical strings.
+ __ cmp(left, right);
+ STATIC_ASSERT(EQUAL == 0);
+ STATIC_ASSERT(kSmiTag == 0);
+ __ bne(¬_identical);
+ __ LoadSmiLiteral(r3, Smi::FromInt(EQUAL));
+ __ Ret();
+ __ bind(¬_identical);
+
+ // Handle not identical strings.
+
+ // Check that both strings are internalized strings. If they are, we're done
+ // because we already know they are not identical. We know they are both
+ // strings.
+ if (equality) {
+ DCHECK(GetCondition() == eq);
+ STATIC_ASSERT(kInternalizedTag == 0);
+ __ orx(tmp3, tmp1, tmp2);
+ __ andi(r0, tmp3, Operand(kIsNotInternalizedMask));
+ __ bne(&is_symbol, cr0);
+ // Make sure r3 is non-zero. At this point input operands are
+ // guaranteed to be non-zero.
+ DCHECK(right.is(r3));
+ __ Ret();
+ __ bind(&is_symbol);
+ }
+
+ // Check that both strings are sequential one-byte.
+ Label runtime;
+ __ JumpIfBothInstanceTypesAreNotSequentialOneByte(tmp1, tmp2, tmp3, tmp4,
+ &runtime);
+
+ // Compare flat one-byte strings. Returns when done.
+ if (equality) {
+ StringHelper::GenerateFlatOneByteStringEquals(masm, left, right, tmp1,
+ tmp2);
+ } else {
+ StringHelper::GenerateCompareFlatOneByteStrings(masm, left, right, tmp1,
+ tmp2, tmp3);
+ }
+
+ // Handle more complex cases in runtime.
+ __ bind(&runtime);
+ __ Push(left, right);
+ if (equality) {
+ __ TailCallRuntime(Runtime::kStringEquals, 2, 1);
+ } else {
+ __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
+ }
+
+ __ bind(&miss);
+ GenerateMiss(masm);
+}
+
+
+void CompareICStub::GenerateObjects(MacroAssembler* masm) {
+ DCHECK(state() == CompareICState::OBJECT);
+ Label miss;
+ __ and_(r5, r4, r3);
+ __ JumpIfSmi(r5, &miss);
+
+ __ CompareObjectType(r3, r5, r5, JS_OBJECT_TYPE);
+ __ bne(&miss);
+ __ CompareObjectType(r4, r5, r5, JS_OBJECT_TYPE);
+ __ bne(&miss);
+
+ DCHECK(GetCondition() == eq);
+ __ sub(r3, r3, r4);
+ __ Ret();
+
+ __ bind(&miss);
+ GenerateMiss(masm);
+}
+
+
+void CompareICStub::GenerateKnownObjects(MacroAssembler* masm) {
+ Label miss;
+ __ and_(r5, r4, r3);
+ __ JumpIfSmi(r5, &miss);
+ __ LoadP(r5, FieldMemOperand(r3, HeapObject::kMapOffset));
+ __ LoadP(r6, FieldMemOperand(r4, HeapObject::kMapOffset));
+ __ Cmpi(r5, Operand(known_map_), r0);
+ __ bne(&miss);
+ __ Cmpi(r6, Operand(known_map_), r0);
+ __ bne(&miss);
+
+ __ sub(r3, r3, r4);
+ __ Ret();
+
+ __ bind(&miss);
+ GenerateMiss(masm);
+}
+
+
+void CompareICStub::GenerateMiss(MacroAssembler* masm) {
+ {
+ // Call the runtime system in a fresh internal frame.
+ ExternalReference miss =
+ ExternalReference(IC_Utility(IC::kCompareIC_Miss), isolate());
+
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+ __ Push(r4, r3);
+ __ Push(r4, r3);
+ __ LoadSmiLiteral(r0, Smi::FromInt(op()));
+ __ push(r0);
+ __ CallExternalReference(miss, 3);
+ // Compute the entry point of the rewritten stub.
+ __ addi(r5, r3, Operand(Code::kHeaderSize - kHeapObjectTag));
+ // Restore registers.
+ __ Pop(r4, r3);
+ }
+
+ __ JumpToJSEntry(r5);
+}
+
+
+// This stub is paired with DirectCEntryStub::GenerateCall
+void DirectCEntryStub::Generate(MacroAssembler* masm) {
+ // Place the return address on the stack, making the call
+ // GC safe. The RegExp backend also relies on this.
+ __ mflr(r0);
+ __ StoreP(r0, MemOperand(sp, kStackFrameExtraParamSlot * kPointerSize));
+ __ Call(ip); // Call the C++ function.
+ __ LoadP(r0, MemOperand(sp, kStackFrameExtraParamSlot * kPointerSize));
+ __ mtlr(r0);
+ __ blr();
+}
+
+
+void DirectCEntryStub::GenerateCall(MacroAssembler* masm, Register target) {
+#if ABI_USES_FUNCTION_DESCRIPTORS && !defined(USE_SIMULATOR)
+ // Native AIX/PPC64 Linux use a function descriptor.
+ __ LoadP(ToRegister(ABI_TOC_REGISTER), MemOperand(target, kPointerSize));
+ __ LoadP(ip, MemOperand(target, 0)); // Instruction address
+#else
+ // ip needs to be set for DirectCEentryStub::Generate, and also
+ // for ABI_TOC_ADDRESSABILITY_VIA_IP.
+ __ Move(ip, target);
+#endif
+
+ intptr_t code = reinterpret_cast<intptr_t>(GetCode().location());
+ __ mov(r0, Operand(code, RelocInfo::CODE_TARGET));
+ __ Call(r0); // Call the stub.
+}
+
+
+void NameDictionaryLookupStub::GenerateNegativeLookup(
+ MacroAssembler* masm, Label* miss, Label* done, Register receiver,
+ Register properties, Handle<Name> name, Register scratch0) {
+ DCHECK(name->IsUniqueName());
+ // If names of slots in range from 1 to kProbes - 1 for the hash value are
+ // not equal to the name and kProbes-th slot is not used (its name is the
+ // undefined value), it guarantees the hash table doesn't contain the
+ // property. It's true even if some slots represent deleted properties
+ // (their names are the hole value).
+ for (int i = 0; i < kInlinedProbes; i++) {
+ // scratch0 points to properties hash.
+ // Compute the masked index: (hash + i + i * i) & mask.
+ Register index = scratch0;
+ // Capacity is smi 2^n.
+ __ LoadP(index, FieldMemOperand(properties, kCapacityOffset));
+ __ subi(index, index, Operand(1));
+ __ LoadSmiLiteral(
+ ip, Smi::FromInt(name->Hash() + NameDictionary::GetProbeOffset(i)));
+ __ and_(index, index, ip);
+
+ // Scale the index by multiplying by the entry size.
+ DCHECK(NameDictionary::kEntrySize == 3);
+ __ ShiftLeftImm(ip, index, Operand(1));
+ __ add(index, index, ip); // index *= 3.
+
+ Register entity_name = scratch0;
+ // Having undefined at this place means the name is not contained.
+ Register tmp = properties;
+ __ SmiToPtrArrayOffset(ip, index);
+ __ add(tmp, properties, ip);
+ __ LoadP(entity_name, FieldMemOperand(tmp, kElementsStartOffset));
+
+ DCHECK(!tmp.is(entity_name));
+ __ LoadRoot(tmp, Heap::kUndefinedValueRootIndex);
+ __ cmp(entity_name, tmp);
+ __ beq(done);
+
+ // Load the hole ready for use below:
+ __ LoadRoot(tmp, Heap::kTheHoleValueRootIndex);
+
+ // Stop if found the property.
+ __ Cmpi(entity_name, Operand(Handle<Name>(name)), r0);
+ __ beq(miss);
+
+ Label good;
+ __ cmp(entity_name, tmp);
+ __ beq(&good);
+
+ // Check if the entry name is not a unique name.
+ __ LoadP(entity_name, FieldMemOperand(entity_name, HeapObject::kMapOffset));
+ __ lbz(entity_name, FieldMemOperand(entity_name, Map::kInstanceTypeOffset));
+ __ JumpIfNotUniqueNameInstanceType(entity_name, miss);
+ __ bind(&good);
+
+ // Restore the properties.
+ __ LoadP(properties,
+ FieldMemOperand(receiver, JSObject::kPropertiesOffset));
+ }
+
+ const int spill_mask = (r0.bit() | r9.bit() | r8.bit() | r7.bit() | r6.bit() |
+ r5.bit() | r4.bit() | r3.bit());
+
+ __ mflr(r0);
+ __ MultiPush(spill_mask);
+
+ __ LoadP(r3, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
+ __ mov(r4, Operand(Handle<Name>(name)));
+ NameDictionaryLookupStub stub(masm->isolate(), NEGATIVE_LOOKUP);
+ __ CallStub(&stub);
+ __ cmpi(r3, Operand::Zero());
+
+ __ MultiPop(spill_mask); // MultiPop does not touch condition flags
+ __ mtlr(r0);
+
+ __ beq(done);
+ __ bne(miss);
+}
+
+
+// Probe the name dictionary in the |elements| register. Jump to the
+// |done| label if a property with the given name is found. Jump to
+// the |miss| label otherwise.
+// If lookup was successful |scratch2| will be equal to elements + 4 * index.
+void NameDictionaryLookupStub::GeneratePositiveLookup(
+ MacroAssembler* masm, Label* miss, Label* done, Register elements,
+ Register name, Register scratch1, Register scratch2) {
+ DCHECK(!elements.is(scratch1));
+ DCHECK(!elements.is(scratch2));
+ DCHECK(!name.is(scratch1));
+ DCHECK(!name.is(scratch2));
+
+ __ AssertName(name);
+
+ // Compute the capacity mask.
+ __ LoadP(scratch1, FieldMemOperand(elements, kCapacityOffset));
+ __ SmiUntag(scratch1); // convert smi to int
+ __ subi(scratch1, scratch1, Operand(1));
+
+ // Generate an unrolled loop that performs a few probes before
+ // giving up. Measurements done on Gmail indicate that 2 probes
+ // cover ~93% of loads from dictionaries.
+ for (int i = 0; i < kInlinedProbes; i++) {
+ // Compute the masked index: (hash + i + i * i) & mask.
+ __ lwz(scratch2, FieldMemOperand(name, Name::kHashFieldOffset));
+ if (i > 0) {
+ // Add the probe offset (i + i * i) left shifted to avoid right shifting
+ // the hash in a separate instruction. The value hash + i + i * i is right
+ // shifted in the following and instruction.
+ DCHECK(NameDictionary::GetProbeOffset(i) <
+ 1 << (32 - Name::kHashFieldOffset));
+ __ addi(scratch2, scratch2,
+ Operand(NameDictionary::GetProbeOffset(i) << Name::kHashShift));
+ }
+ __ srwi(scratch2, scratch2, Operand(Name::kHashShift));
+ __ and_(scratch2, scratch1, scratch2);
+
+ // Scale the index by multiplying by the element size.
+ DCHECK(NameDictionary::kEntrySize == 3);
+ // scratch2 = scratch2 * 3.
+ __ ShiftLeftImm(ip, scratch2, Operand(1));
+ __ add(scratch2, scratch2, ip);
+
+ // Check if the key is identical to the name.
+ __ ShiftLeftImm(ip, scratch2, Operand(kPointerSizeLog2));
+ __ add(scratch2, elements, ip);
+ __ LoadP(ip, FieldMemOperand(scratch2, kElementsStartOffset));
+ __ cmp(name, ip);
+ __ beq(done);
+ }
+
+ const int spill_mask = (r0.bit() | r9.bit() | r8.bit() | r7.bit() | r6.bit() |
+ r5.bit() | r4.bit() | r3.bit()) &
+ ~(scratch1.bit() | scratch2.bit());
+
+ __ mflr(r0);
+ __ MultiPush(spill_mask);
+ if (name.is(r3)) {
+ DCHECK(!elements.is(r4));
+ __ mr(r4, name);
+ __ mr(r3, elements);
+ } else {
+ __ mr(r3, elements);
+ __ mr(r4, name);
+ }
+ NameDictionaryLookupStub stub(masm->isolate(), POSITIVE_LOOKUP);
+ __ CallStub(&stub);
+ __ cmpi(r3, Operand::Zero());
+ __ mr(scratch2, r5);
+ __ MultiPop(spill_mask);
+ __ mtlr(r0);
+
+ __ bne(done);
+ __ beq(miss);
+}
+
+
+void NameDictionaryLookupStub::Generate(MacroAssembler* masm) {
+ // This stub overrides SometimesSetsUpAFrame() to return false. That means
+ // we cannot call anything that could cause a GC from this stub.
+ // Registers:
+ // result: NameDictionary to probe
+ // r4: key
+ // dictionary: NameDictionary to probe.
+ // index: will hold an index of entry if lookup is successful.
+ // might alias with result_.
+ // Returns:
+ // result_ is zero if lookup failed, non zero otherwise.
+
+ Register result = r3;
+ Register dictionary = r3;
+ Register key = r4;
+ Register index = r5;
+ Register mask = r6;
+ Register hash = r7;
+ Register undefined = r8;
+ Register entry_key = r9;
+ Register scratch = r9;
+
+ Label in_dictionary, maybe_in_dictionary, not_in_dictionary;
+
+ __ LoadP(mask, FieldMemOperand(dictionary, kCapacityOffset));
+ __ SmiUntag(mask);
+ __ subi(mask, mask, Operand(1));
+
+ __ lwz(hash, FieldMemOperand(key, Name::kHashFieldOffset));
+
+ __ LoadRoot(undefined, Heap::kUndefinedValueRootIndex);
+
+ for (int i = kInlinedProbes; i < kTotalProbes; i++) {
+ // Compute the masked index: (hash + i + i * i) & mask.
+ // Capacity is smi 2^n.
+ if (i > 0) {
+ // Add the probe offset (i + i * i) left shifted to avoid right shifting
+ // the hash in a separate instruction. The value hash + i + i * i is right
+ // shifted in the following and instruction.
+ DCHECK(NameDictionary::GetProbeOffset(i) <
+ 1 << (32 - Name::kHashFieldOffset));
+ __ addi(index, hash,
+ Operand(NameDictionary::GetProbeOffset(i) << Name::kHashShift));
+ } else {
+ __ mr(index, hash);
+ }
+ __ srwi(r0, index, Operand(Name::kHashShift));
+ __ and_(index, mask, r0);
+
+ // Scale the index by multiplying by the entry size.
+ DCHECK(NameDictionary::kEntrySize == 3);
+ __ ShiftLeftImm(scratch, index, Operand(1));
+ __ add(index, index, scratch); // index *= 3.
+
+ DCHECK_EQ(kSmiTagSize, 1);
+ __ ShiftLeftImm(scratch, index, Operand(kPointerSizeLog2));
+ __ add(index, dictionary, scratch);
+ __ LoadP(entry_key, FieldMemOperand(index, kElementsStartOffset));
+
+ // Having undefined at this place means the name is not contained.
+ __ cmp(entry_key, undefined);
+ __ beq(¬_in_dictionary);
+
+ // Stop if found the property.
+ __ cmp(entry_key, key);
+ __ beq(&in_dictionary);
+
+ if (i != kTotalProbes - 1 && mode() == NEGATIVE_LOOKUP) {
+ // Check if the entry name is not a unique name.
+ __ LoadP(entry_key, FieldMemOperand(entry_key, HeapObject::kMapOffset));
+ __ lbz(entry_key, FieldMemOperand(entry_key, Map::kInstanceTypeOffset));
+ __ JumpIfNotUniqueNameInstanceType(entry_key, &maybe_in_dictionary);
+ }
+ }
+
+ __ bind(&maybe_in_dictionary);
+ // If we are doing negative lookup then probing failure should be
+ // treated as a lookup success. For positive lookup probing failure
+ // should be treated as lookup failure.
+ if (mode() == POSITIVE_LOOKUP) {
+ __ li(result, Operand::Zero());
+ __ Ret();
+ }
+
+ __ bind(&in_dictionary);
+ __ li(result, Operand(1));
+ __ Ret();
+
+ __ bind(¬_in_dictionary);
+ __ li(result, Operand::Zero());
+ __ Ret();
+}
+
+
+void StoreBufferOverflowStub::GenerateFixedRegStubsAheadOfTime(
+ Isolate* isolate) {
+ StoreBufferOverflowStub stub1(isolate, kDontSaveFPRegs);
+ stub1.GetCode();
+ // Hydrogen code stubs need stub2 at snapshot time.
+ StoreBufferOverflowStub stub2(isolate, kSaveFPRegs);
+ stub2.GetCode();
+}
+
+
+// Takes the input in 3 registers: address_ value_ and object_. A pointer to
+// the value has just been written into the object, now this stub makes sure
+// we keep the GC informed. The word in the object where the value has been
+// written is in the address register.
+void RecordWriteStub::Generate(MacroAssembler* masm) {
+ Label skip_to_incremental_noncompacting;
+ Label skip_to_incremental_compacting;
+
+ // The first two branch instructions are generated with labels so as to
+ // get the offset fixed up correctly by the bind(Label*) call. We patch
+ // it back and forth between branch condition True and False
+ // when we start and stop incremental heap marking.
+ // See RecordWriteStub::Patch for details.
+
+ // Clear the bit, branch on True for NOP action initially
+ __ crclr(Assembler::encode_crbit(cr2, CR_LT));
+ __ blt(&skip_to_incremental_noncompacting, cr2);
+ __ blt(&skip_to_incremental_compacting, cr2);
+
+ if (remembered_set_action() == EMIT_REMEMBERED_SET) {
+ __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(),
+ MacroAssembler::kReturnAtEnd);
+ }
+ __ Ret();
+
+ __ bind(&skip_to_incremental_noncompacting);
+ GenerateIncremental(masm, INCREMENTAL);
+
+ __ bind(&skip_to_incremental_compacting);
+ GenerateIncremental(masm, INCREMENTAL_COMPACTION);
+
+ // Initial mode of the stub is expected to be STORE_BUFFER_ONLY.
+ // Will be checked in IncrementalMarking::ActivateGeneratedStub.
+ // patching not required on PPC as the initial path is effectively NOP
+}
+
+
+void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) {
+ regs_.Save(masm);
+
+ if (remembered_set_action() == EMIT_REMEMBERED_SET) {
+ Label dont_need_remembered_set;
+
+ __ LoadP(regs_.scratch0(), MemOperand(regs_.address(), 0));
+ __ JumpIfNotInNewSpace(regs_.scratch0(), // Value.
+ regs_.scratch0(), &dont_need_remembered_set);
+
+ __ CheckPageFlag(regs_.object(), regs_.scratch0(),
+ 1 << MemoryChunk::SCAN_ON_SCAVENGE, ne,
+ &dont_need_remembered_set);
+
+ // First notify the incremental marker if necessary, then update the
+ // remembered set.
+ CheckNeedsToInformIncrementalMarker(
+ masm, kUpdateRememberedSetOnNoNeedToInformIncrementalMarker, mode);
+ InformIncrementalMarker(masm);
+ regs_.Restore(masm);
+ __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(),
+ MacroAssembler::kReturnAtEnd);
+
+ __ bind(&dont_need_remembered_set);
+ }
+
+ CheckNeedsToInformIncrementalMarker(
+ masm, kReturnOnNoNeedToInformIncrementalMarker, mode);
+ InformIncrementalMarker(masm);
+ regs_.Restore(masm);
+ __ Ret();
+}
+
+
+void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm) {
+ regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode());
+ int argument_count = 3;
+ __ PrepareCallCFunction(argument_count, regs_.scratch0());
+ Register address =
+ r3.is(regs_.address()) ? regs_.scratch0() : regs_.address();
+ DCHECK(!address.is(regs_.object()));
+ DCHECK(!address.is(r3));
+ __ mr(address, regs_.address());
+ __ mr(r3, regs_.object());
+ __ mr(r4, address);
+ __ mov(r5, Operand(ExternalReference::isolate_address(isolate())));
+
+ AllowExternalCallThatCantCauseGC scope(masm);
+ __ CallCFunction(
+ ExternalReference::incremental_marking_record_write_function(isolate()),
+ argument_count);
+ regs_.RestoreCallerSaveRegisters(masm, save_fp_regs_mode());
+}
+
+
+void RecordWriteStub::CheckNeedsToInformIncrementalMarker(
+ MacroAssembler* masm, OnNoNeedToInformIncrementalMarker on_no_need,
+ Mode mode) {
+ Label on_black;
+ Label need_incremental;
+ Label need_incremental_pop_scratch;
+
+ DCHECK((~Page::kPageAlignmentMask & 0xffff) == 0);
+ __ lis(r0, Operand((~Page::kPageAlignmentMask >> 16)));
+ __ and_(regs_.scratch0(), regs_.object(), r0);
+ __ LoadP(
+ regs_.scratch1(),
+ MemOperand(regs_.scratch0(), MemoryChunk::kWriteBarrierCounterOffset));
+ __ subi(regs_.scratch1(), regs_.scratch1(), Operand(1));
+ __ StoreP(
+ regs_.scratch1(),
+ MemOperand(regs_.scratch0(), MemoryChunk::kWriteBarrierCounterOffset));
+ __ cmpi(regs_.scratch1(), Operand::Zero()); // PPC, we could do better here
+ __ blt(&need_incremental);
+
+ // Let's look at the color of the object: If it is not black we don't have
+ // to inform the incremental marker.
+ __ JumpIfBlack(regs_.object(), regs_.scratch0(), regs_.scratch1(), &on_black);
+
+ regs_.Restore(masm);
+ if (on_no_need == kUpdateRememberedSetOnNoNeedToInformIncrementalMarker) {
+ __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(),
+ MacroAssembler::kReturnAtEnd);
+ } else {
+ __ Ret();
+ }
+
+ __ bind(&on_black);
+
+ // Get the value from the slot.
+ __ LoadP(regs_.scratch0(), MemOperand(regs_.address(), 0));
+
+ if (mode == INCREMENTAL_COMPACTION) {
+ Label ensure_not_white;
+
+ __ CheckPageFlag(regs_.scratch0(), // Contains value.
+ regs_.scratch1(), // Scratch.
+ MemoryChunk::kEvacuationCandidateMask, eq,
+ &ensure_not_white);
+
+ __ CheckPageFlag(regs_.object(),
+ regs_.scratch1(), // Scratch.
+ MemoryChunk::kSkipEvacuationSlotsRecordingMask, eq,
+ &need_incremental);
+
+ __ bind(&ensure_not_white);
+ }
+
+ // We need extra registers for this, so we push the object and the address
+ // register temporarily.
+ __ Push(regs_.object(), regs_.address());
+ __ EnsureNotWhite(regs_.scratch0(), // The value.
+ regs_.scratch1(), // Scratch.
+ regs_.object(), // Scratch.
+ regs_.address(), // Scratch.
+ &need_incremental_pop_scratch);
+ __ Pop(regs_.object(), regs_.address());
+
+ regs_.Restore(masm);
+ if (on_no_need == kUpdateRememberedSetOnNoNeedToInformIncrementalMarker) {
+ __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(),
+ MacroAssembler::kReturnAtEnd);
+ } else {
+ __ Ret();
+ }
+
+ __ bind(&need_incremental_pop_scratch);
+ __ Pop(regs_.object(), regs_.address());
+
+ __ bind(&need_incremental);
+
+ // Fall through when we need to inform the incremental marker.
+}
+
+
+void StoreArrayLiteralElementStub::Generate(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- r3 : element value to store
+ // -- r6 : element index as smi
+ // -- sp[0] : array literal index in function as smi
+ // -- sp[4] : array literal
+ // clobbers r3, r5, r7
+ // -----------------------------------
+
+ Label element_done;
+ Label double_elements;
+ Label smi_element;
+ Label slow_elements;
+ Label fast_elements;
+
+ // Get array literal index, array literal and its map.
+ __ LoadP(r7, MemOperand(sp, 0 * kPointerSize));
+ __ LoadP(r4, MemOperand(sp, 1 * kPointerSize));
+ __ LoadP(r5, FieldMemOperand(r4, JSObject::kMapOffset));
+
+ __ CheckFastElements(r5, r8, &double_elements);
+ // FAST_*_SMI_ELEMENTS or FAST_*_ELEMENTS
+ __ JumpIfSmi(r3, &smi_element);
+ __ CheckFastSmiElements(r5, r8, &fast_elements);
+
+ // Store into the array literal requires a elements transition. Call into
+ // the runtime.
+ __ bind(&slow_elements);
+ // call.
+ __ Push(r4, r6, r3);
+ __ LoadP(r8, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ __ LoadP(r8, FieldMemOperand(r8, JSFunction::kLiteralsOffset));
+ __ Push(r8, r7);
+ __ TailCallRuntime(Runtime::kStoreArrayLiteralElement, 5, 1);
+
+ // Array literal has ElementsKind of FAST_*_ELEMENTS and value is an object.
+ __ bind(&fast_elements);
+ __ LoadP(r8, FieldMemOperand(r4, JSObject::kElementsOffset));
+ __ SmiToPtrArrayOffset(r9, r6);
+ __ add(r9, r8, r9);
+#if V8_TARGET_ARCH_PPC64
+ // add due to offset alignment requirements of StorePU
+ __ addi(r9, r9, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ __ StoreP(r3, MemOperand(r9));
+#else
+ __ StorePU(r3, MemOperand(r9, FixedArray::kHeaderSize - kHeapObjectTag));
+#endif
+ // Update the write barrier for the array store.
+ __ RecordWrite(r8, r9, r3, kLRHasNotBeenSaved, kDontSaveFPRegs,
+ EMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
+ __ Ret();
+
+ // Array literal has ElementsKind of FAST_*_SMI_ELEMENTS or FAST_*_ELEMENTS,
+ // and value is Smi.
+ __ bind(&smi_element);
+ __ LoadP(r8, FieldMemOperand(r4, JSObject::kElementsOffset));
+ __ SmiToPtrArrayOffset(r9, r6);
+ __ add(r9, r8, r9);
+ __ StoreP(r3, FieldMemOperand(r9, FixedArray::kHeaderSize), r0);
+ __ Ret();
+
+ // Array literal has ElementsKind of FAST_DOUBLE_ELEMENTS.
+ __ bind(&double_elements);
+ __ LoadP(r8, FieldMemOperand(r4, JSObject::kElementsOffset));
+ __ StoreNumberToDoubleElements(r3, r6, r8, r9, d0, &slow_elements);
+ __ Ret();
+}
+
+
+void StubFailureTrampolineStub::Generate(MacroAssembler* masm) {
+ CEntryStub ces(isolate(), 1, kSaveFPRegs);
+ __ Call(ces.GetCode(), RelocInfo::CODE_TARGET);
+ int parameter_count_offset =
+ StubFailureTrampolineFrame::kCallerStackParameterCountFrameOffset;
+ __ LoadP(r4, MemOperand(fp, parameter_count_offset));
+ if (function_mode() == JS_FUNCTION_STUB_MODE) {
+ __ addi(r4, r4, Operand(1));
+ }
+ masm->LeaveFrame(StackFrame::STUB_FAILURE_TRAMPOLINE);
+ __ slwi(r4, r4, Operand(kPointerSizeLog2));
+ __ add(sp, sp, r4);
+ __ Ret();
+}
+
+
+void LoadICTrampolineStub::Generate(MacroAssembler* masm) {
+ EmitLoadTypeFeedbackVector(masm, VectorLoadICDescriptor::VectorRegister());
+ VectorLoadStub stub(isolate(), state());
+ __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET);
+}
+
+
+void KeyedLoadICTrampolineStub::Generate(MacroAssembler* masm) {
+ EmitLoadTypeFeedbackVector(masm, VectorLoadICDescriptor::VectorRegister());
+ VectorKeyedLoadStub stub(isolate());
+ __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET);
+}
+
+
+void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) {
+ if (masm->isolate()->function_entry_hook() != NULL) {
+ PredictableCodeSizeScope predictable(masm,
+#if V8_TARGET_ARCH_PPC64
+ 14 * Assembler::kInstrSize);
+#else
+ 11 * Assembler::kInstrSize);
+#endif
+ ProfileEntryHookStub stub(masm->isolate());
+ __ mflr(r0);
+ __ Push(r0, ip);
+ __ CallStub(&stub);
+ __ Pop(r0, ip);
+ __ mtlr(r0);
+ }
+}
+
+
+void ProfileEntryHookStub::Generate(MacroAssembler* masm) {
+ // The entry hook is a "push lr, ip" instruction, followed by a call.
+ const int32_t kReturnAddressDistanceFromFunctionStart =
+ Assembler::kCallTargetAddressOffset + 3 * Assembler::kInstrSize;
+
+ // This should contain all kJSCallerSaved registers.
+ const RegList kSavedRegs = kJSCallerSaved | // Caller saved registers.
+ r15.bit(); // Saved stack pointer.
+
+ // We also save lr, so the count here is one higher than the mask indicates.
+ const int32_t kNumSavedRegs = kNumJSCallerSaved + 2;
+
+ // Save all caller-save registers as this may be called from anywhere.
+ __ mflr(ip);
+ __ MultiPush(kSavedRegs | ip.bit());
+
+ // Compute the function's address for the first argument.
+ __ subi(r3, ip, Operand(kReturnAddressDistanceFromFunctionStart));
+
+ // The caller's return address is two slots above the saved temporaries.
+ // Grab that for the second argument to the hook.
+ __ addi(r4, sp, Operand((kNumSavedRegs + 1) * kPointerSize));
+
+ // Align the stack if necessary.
+ int frame_alignment = masm->ActivationFrameAlignment();
+ if (frame_alignment > kPointerSize) {
+ __ mr(r15, sp);
+ DCHECK(base::bits::IsPowerOfTwo32(frame_alignment));
+ __ ClearRightImm(sp, sp, Operand(WhichPowerOf2(frame_alignment)));
+ }
+
+#if !defined(USE_SIMULATOR)
+ uintptr_t entry_hook =
+ reinterpret_cast<uintptr_t>(isolate()->function_entry_hook());
+ __ mov(ip, Operand(entry_hook));
+
+#if ABI_USES_FUNCTION_DESCRIPTORS
+ // Function descriptor
+ __ LoadP(ToRegister(ABI_TOC_REGISTER), MemOperand(ip, kPointerSize));
+ __ LoadP(ip, MemOperand(ip, 0));
+#elif ABI_TOC_ADDRESSABILITY_VIA_IP
+// ip set above, so nothing to do.
+#endif
+
+ // PPC LINUX ABI:
+ __ li(r0, Operand::Zero());
+ __ StorePU(r0, MemOperand(sp, -kNumRequiredStackFrameSlots * kPointerSize));
+#else
+ // Under the simulator we need to indirect the entry hook through a
+ // trampoline function at a known address.
+ // It additionally takes an isolate as a third parameter
+ __ mov(r5, Operand(ExternalReference::isolate_address(isolate())));
+
+ ApiFunction dispatcher(FUNCTION_ADDR(EntryHookTrampoline));
+ __ mov(ip, Operand(ExternalReference(
+ &dispatcher, ExternalReference::BUILTIN_CALL, isolate())));
+#endif
+ __ Call(ip);
+
+#if !defined(USE_SIMULATOR)
+ __ addi(sp, sp, Operand(kNumRequiredStackFrameSlots * kPointerSize));
+#endif
+
+ // Restore the stack pointer if needed.
+ if (frame_alignment > kPointerSize) {
+ __ mr(sp, r15);
+ }
+
+ // Also pop lr to get Ret(0).
+ __ MultiPop(kSavedRegs | ip.bit());
+ __ mtlr(ip);
+ __ Ret();
+}
+
+
+template <class T>
+static void CreateArrayDispatch(MacroAssembler* masm,
+ AllocationSiteOverrideMode mode) {
+ if (mode == DISABLE_ALLOCATION_SITES) {
+ T stub(masm->isolate(), GetInitialFastElementsKind(), mode);
+ __ TailCallStub(&stub);
+ } else if (mode == DONT_OVERRIDE) {
+ int last_index =
+ GetSequenceIndexFromFastElementsKind(TERMINAL_FAST_ELEMENTS_KIND);
+ for (int i = 0; i <= last_index; ++i) {
+ ElementsKind kind = GetFastElementsKindFromSequenceIndex(i);
+ __ Cmpi(r6, Operand(kind), r0);
+ T stub(masm->isolate(), kind);
+ __ TailCallStub(&stub, eq);
+ }
+
+ // If we reached this point there is a problem.
+ __ Abort(kUnexpectedElementsKindInArrayConstructor);
+ } else {
+ UNREACHABLE();
+ }
+}
+
+
+static void CreateArrayDispatchOneArgument(MacroAssembler* masm,
+ AllocationSiteOverrideMode mode) {
+ // r5 - allocation site (if mode != DISABLE_ALLOCATION_SITES)
+ // r6 - kind (if mode != DISABLE_ALLOCATION_SITES)
+ // r3 - number of arguments
+ // r4 - constructor?
+ // sp[0] - last argument
+ Label normal_sequence;
+ if (mode == DONT_OVERRIDE) {
+ DCHECK(FAST_SMI_ELEMENTS == 0);
+ DCHECK(FAST_HOLEY_SMI_ELEMENTS == 1);
+ DCHECK(FAST_ELEMENTS == 2);
+ DCHECK(FAST_HOLEY_ELEMENTS == 3);
+ DCHECK(FAST_DOUBLE_ELEMENTS == 4);
+ DCHECK(FAST_HOLEY_DOUBLE_ELEMENTS == 5);
+
+ // is the low bit set? If so, we are holey and that is good.
+ __ andi(r0, r6, Operand(1));
+ __ bne(&normal_sequence, cr0);
+ }
+
+ // look at the first argument
+ __ LoadP(r8, MemOperand(sp, 0));
+ __ cmpi(r8, Operand::Zero());
+ __ beq(&normal_sequence);
+
+ if (mode == DISABLE_ALLOCATION_SITES) {
+ ElementsKind initial = GetInitialFastElementsKind();
+ ElementsKind holey_initial = GetHoleyElementsKind(initial);
+
+ ArraySingleArgumentConstructorStub stub_holey(
+ masm->isolate(), holey_initial, DISABLE_ALLOCATION_SITES);
+ __ TailCallStub(&stub_holey);
+
+ __ bind(&normal_sequence);
+ ArraySingleArgumentConstructorStub stub(masm->isolate(), initial,
+ DISABLE_ALLOCATION_SITES);
+ __ TailCallStub(&stub);
+ } else if (mode == DONT_OVERRIDE) {
+ // We are going to create a holey array, but our kind is non-holey.
+ // Fix kind and retry (only if we have an allocation site in the slot).
+ __ addi(r6, r6, Operand(1));
+
+ if (FLAG_debug_code) {
+ __ LoadP(r8, FieldMemOperand(r5, 0));
+ __ CompareRoot(r8, Heap::kAllocationSiteMapRootIndex);
+ __ Assert(eq, kExpectedAllocationSite);
+ }
+
+ // Save the resulting elements kind in type info. We can't just store r6
+ // in the AllocationSite::transition_info field because elements kind is
+ // restricted to a portion of the field...upper bits need to be left alone.
+ STATIC_ASSERT(AllocationSite::ElementsKindBits::kShift == 0);
+ __ LoadP(r7, FieldMemOperand(r5, AllocationSite::kTransitionInfoOffset));
+ __ AddSmiLiteral(r7, r7, Smi::FromInt(kFastElementsKindPackedToHoley), r0);
+ __ StoreP(r7, FieldMemOperand(r5, AllocationSite::kTransitionInfoOffset),
+ r0);
+
+ __ bind(&normal_sequence);
+ int last_index =
+ GetSequenceIndexFromFastElementsKind(TERMINAL_FAST_ELEMENTS_KIND);
+ for (int i = 0; i <= last_index; ++i) {
+ ElementsKind kind = GetFastElementsKindFromSequenceIndex(i);
+ __ mov(r0, Operand(kind));
+ __ cmp(r6, r0);
+ ArraySingleArgumentConstructorStub stub(masm->isolate(), kind);
+ __ TailCallStub(&stub, eq);
+ }
+
+ // If we reached this point there is a problem.
+ __ Abort(kUnexpectedElementsKindInArrayConstructor);
+ } else {
+ UNREACHABLE();
+ }
+}
+
+
+template <class T>
+static void ArrayConstructorStubAheadOfTimeHelper(Isolate* isolate) {
+ int to_index =
+ GetSequenceIndexFromFastElementsKind(TERMINAL_FAST_ELEMENTS_KIND);
+ for (int i = 0; i <= to_index; ++i) {
+ ElementsKind kind = GetFastElementsKindFromSequenceIndex(i);
+ T stub(isolate, kind);
+ stub.GetCode();
+ if (AllocationSite::GetMode(kind) != DONT_TRACK_ALLOCATION_SITE) {
+ T stub1(isolate, kind, DISABLE_ALLOCATION_SITES);
+ stub1.GetCode();
+ }
+ }
+}
+
+
+void ArrayConstructorStubBase::GenerateStubsAheadOfTime(Isolate* isolate) {
+ ArrayConstructorStubAheadOfTimeHelper<ArrayNoArgumentConstructorStub>(
+ isolate);
+ ArrayConstructorStubAheadOfTimeHelper<ArraySingleArgumentConstructorStub>(
+ isolate);
+ ArrayConstructorStubAheadOfTimeHelper<ArrayNArgumentsConstructorStub>(
+ isolate);
+}
+
+
+void InternalArrayConstructorStubBase::GenerateStubsAheadOfTime(
+ Isolate* isolate) {
+ ElementsKind kinds[2] = {FAST_ELEMENTS, FAST_HOLEY_ELEMENTS};
+ for (int i = 0; i < 2; i++) {
+ // For internal arrays we only need a few things
+ InternalArrayNoArgumentConstructorStub stubh1(isolate, kinds[i]);
+ stubh1.GetCode();
+ InternalArraySingleArgumentConstructorStub stubh2(isolate, kinds[i]);
+ stubh2.GetCode();
+ InternalArrayNArgumentsConstructorStub stubh3(isolate, kinds[i]);
+ stubh3.GetCode();
+ }
+}
+
+
+void ArrayConstructorStub::GenerateDispatchToArrayStub(
+ MacroAssembler* masm, AllocationSiteOverrideMode mode) {
+ if (argument_count() == ANY) {
+ Label not_zero_case, not_one_case;
+ __ cmpi(r3, Operand::Zero());
+ __ bne(¬_zero_case);
+ CreateArrayDispatch<ArrayNoArgumentConstructorStub>(masm, mode);
+
+ __ bind(¬_zero_case);
+ __ cmpi(r3, Operand(1));
+ __ bgt(¬_one_case);
+ CreateArrayDispatchOneArgument(masm, mode);
+
+ __ bind(¬_one_case);
+ CreateArrayDispatch<ArrayNArgumentsConstructorStub>(masm, mode);
+ } else if (argument_count() == NONE) {
+ CreateArrayDispatch<ArrayNoArgumentConstructorStub>(masm, mode);
+ } else if (argument_count() == ONE) {
+ CreateArrayDispatchOneArgument(masm, mode);
+ } else if (argument_count() == MORE_THAN_ONE) {
+ CreateArrayDispatch<ArrayNArgumentsConstructorStub>(masm, mode);
+ } else {
+ UNREACHABLE();
+ }
+}
+
+
+void ArrayConstructorStub::Generate(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- r3 : argc (only if argument_count() == ANY)
+ // -- r4 : constructor
+ // -- r5 : AllocationSite or undefined
+ // -- sp[0] : return address
+ // -- sp[4] : last argument
+ // -----------------------------------
+
+ if (FLAG_debug_code) {
+ // The array construct code is only set for the global and natives
+ // builtin Array functions which always have maps.
+
+ // Initial map for the builtin Array function should be a map.
+ __ LoadP(r7, FieldMemOperand(r4, JSFunction::kPrototypeOrInitialMapOffset));
+ // Will both indicate a NULL and a Smi.
+ __ TestIfSmi(r7, r0);
+ __ Assert(ne, kUnexpectedInitialMapForArrayFunction, cr0);
+ __ CompareObjectType(r7, r7, r8, MAP_TYPE);
+ __ Assert(eq, kUnexpectedInitialMapForArrayFunction);
+
+ // We should either have undefined in r5 or a valid AllocationSite
+ __ AssertUndefinedOrAllocationSite(r5, r7);
+ }
+
+ Label no_info;
+ // Get the elements kind and case on that.
+ __ CompareRoot(r5, Heap::kUndefinedValueRootIndex);
+ __ beq(&no_info);
+
+ __ LoadP(r6, FieldMemOperand(r5, AllocationSite::kTransitionInfoOffset));
+ __ SmiUntag(r6);
+ STATIC_ASSERT(AllocationSite::ElementsKindBits::kShift == 0);
+ __ And(r6, r6, Operand(AllocationSite::ElementsKindBits::kMask));
+ GenerateDispatchToArrayStub(masm, DONT_OVERRIDE);
+
+ __ bind(&no_info);
+ GenerateDispatchToArrayStub(masm, DISABLE_ALLOCATION_SITES);
+}
+
+
+void InternalArrayConstructorStub::GenerateCase(MacroAssembler* masm,
+ ElementsKind kind) {
+ __ cmpli(r3, Operand(1));
+
+ InternalArrayNoArgumentConstructorStub stub0(isolate(), kind);
+ __ TailCallStub(&stub0, lt);
+
+ InternalArrayNArgumentsConstructorStub stubN(isolate(), kind);
+ __ TailCallStub(&stubN, gt);
+
+ if (IsFastPackedElementsKind(kind)) {
+ // We might need to create a holey array
+ // look at the first argument
+ __ LoadP(r6, MemOperand(sp, 0));
+ __ cmpi(r6, Operand::Zero());
+
+ InternalArraySingleArgumentConstructorStub stub1_holey(
+ isolate(), GetHoleyElementsKind(kind));
+ __ TailCallStub(&stub1_holey, ne);
+ }
+
+ InternalArraySingleArgumentConstructorStub stub1(isolate(), kind);
+ __ TailCallStub(&stub1);
+}
+
+
+void InternalArrayConstructorStub::Generate(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- r3 : argc
+ // -- r4 : constructor
+ // -- sp[0] : return address
+ // -- sp[4] : last argument
+ // -----------------------------------
+
+ if (FLAG_debug_code) {
+ // The array construct code is only set for the global and natives
+ // builtin Array functions which always have maps.
+
+ // Initial map for the builtin Array function should be a map.
+ __ LoadP(r6, FieldMemOperand(r4, JSFunction::kPrototypeOrInitialMapOffset));
+ // Will both indicate a NULL and a Smi.
+ __ TestIfSmi(r6, r0);
+ __ Assert(ne, kUnexpectedInitialMapForArrayFunction, cr0);
+ __ CompareObjectType(r6, r6, r7, MAP_TYPE);
+ __ Assert(eq, kUnexpectedInitialMapForArrayFunction);
+ }
+
+ // Figure out the right elements kind
+ __ LoadP(r6, FieldMemOperand(r4, JSFunction::kPrototypeOrInitialMapOffset));
+ // Load the map's "bit field 2" into |result|.
+ __ lbz(r6, FieldMemOperand(r6, Map::kBitField2Offset));
+ // Retrieve elements_kind from bit field 2.
+ __ DecodeField<Map::ElementsKindBits>(r6);
+
+ if (FLAG_debug_code) {
+ Label done;
+ __ cmpi(r6, Operand(FAST_ELEMENTS));
+ __ beq(&done);
+ __ cmpi(r6, Operand(FAST_HOLEY_ELEMENTS));
+ __ Assert(eq, kInvalidElementsKindForInternalArrayOrInternalPackedArray);
+ __ bind(&done);
+ }
+
+ Label fast_elements_case;
+ __ cmpi(r6, Operand(FAST_ELEMENTS));
+ __ beq(&fast_elements_case);
+ GenerateCase(masm, FAST_HOLEY_ELEMENTS);
+
+ __ bind(&fast_elements_case);
+ GenerateCase(masm, FAST_ELEMENTS);
+}
+
+
+void CallApiFunctionStub::Generate(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- r3 : callee
+ // -- r7 : call_data
+ // -- r5 : holder
+ // -- r4 : api_function_address
+ // -- cp : context
+ // --
+ // -- sp[0] : last argument
+ // -- ...
+ // -- sp[(argc - 1)* 4] : first argument
+ // -- sp[argc * 4] : receiver
+ // -----------------------------------
+
+ Register callee = r3;
+ Register call_data = r7;
+ Register holder = r5;
+ Register api_function_address = r4;
+ Register context = cp;
+
+ int argc = this->argc();
+ bool is_store = this->is_store();
+ bool call_data_undefined = this->call_data_undefined();
+
+ typedef FunctionCallbackArguments FCA;
+
+ STATIC_ASSERT(FCA::kContextSaveIndex == 6);
+ STATIC_ASSERT(FCA::kCalleeIndex == 5);
+ STATIC_ASSERT(FCA::kDataIndex == 4);
+ STATIC_ASSERT(FCA::kReturnValueOffset == 3);
+ STATIC_ASSERT(FCA::kReturnValueDefaultValueIndex == 2);
+ STATIC_ASSERT(FCA::kIsolateIndex == 1);
+ STATIC_ASSERT(FCA::kHolderIndex == 0);
+ STATIC_ASSERT(FCA::kArgsLength == 7);
+
+ // context save
+ __ push(context);
+ // load context from callee
+ __ LoadP(context, FieldMemOperand(callee, JSFunction::kContextOffset));
+
+ // callee
+ __ push(callee);
+
+ // call data
+ __ push(call_data);
+
+ Register scratch = call_data;
+ if (!call_data_undefined) {
+ __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
+ }
+ // return value
+ __ push(scratch);
+ // return value default
+ __ push(scratch);
+ // isolate
+ __ mov(scratch, Operand(ExternalReference::isolate_address(isolate())));
+ __ push(scratch);
+ // holder
+ __ push(holder);
+
+ // Prepare arguments.
+ __ mr(scratch, sp);
+
+ // Allocate the v8::Arguments structure in the arguments' space since
+ // it's not controlled by GC.
+ // PPC LINUX ABI:
+ //
+ // Create 5 extra slots on stack:
+ // [0] space for DirectCEntryStub's LR save
+ // [1-4] FunctionCallbackInfo
+ const int kApiStackSpace = 5;
+
+ FrameScope frame_scope(masm, StackFrame::MANUAL);
+ __ EnterExitFrame(false, kApiStackSpace);
+
+ DCHECK(!api_function_address.is(r3) && !scratch.is(r3));
+ // r3 = FunctionCallbackInfo&
+ // Arguments is after the return address.
+ __ addi(r3, sp, Operand((kStackFrameExtraParamSlot + 1) * kPointerSize));
+ // FunctionCallbackInfo::implicit_args_
+ __ StoreP(scratch, MemOperand(r3, 0 * kPointerSize));
+ // FunctionCallbackInfo::values_
+ __ addi(ip, scratch, Operand((FCA::kArgsLength - 1 + argc) * kPointerSize));
+ __ StoreP(ip, MemOperand(r3, 1 * kPointerSize));
+ // FunctionCallbackInfo::length_ = argc
+ __ li(ip, Operand(argc));
+ __ stw(ip, MemOperand(r3, 2 * kPointerSize));
+ // FunctionCallbackInfo::is_construct_call = 0
+ __ li(ip, Operand::Zero());
+ __ stw(ip, MemOperand(r3, 2 * kPointerSize + kIntSize));
+
+ const int kStackUnwindSpace = argc + FCA::kArgsLength + 1;
+ ExternalReference thunk_ref =
+ ExternalReference::invoke_function_callback(isolate());
+
+ AllowExternalCallThatCantCauseGC scope(masm);
+ MemOperand context_restore_operand(
+ fp, (2 + FCA::kContextSaveIndex) * kPointerSize);
+ // Stores return the first js argument
+ int return_value_offset = 0;
+ if (is_store) {
+ return_value_offset = 2 + FCA::kArgsLength;
+ } else {
+ return_value_offset = 2 + FCA::kReturnValueOffset;
+ }
+ MemOperand return_value_operand(fp, return_value_offset * kPointerSize);
+
+ __ CallApiFunctionAndReturn(api_function_address, thunk_ref,
+ kStackUnwindSpace, return_value_operand,
+ &context_restore_operand);
+}
+
+
+void CallApiGetterStub::Generate(MacroAssembler* masm) {
+ // ----------- S t a t e -------------
+ // -- sp[0] : name
+ // -- sp[4 - kArgsLength*4] : PropertyCallbackArguments object
+ // -- ...
+ // -- r5 : api_function_address
+ // -----------------------------------
+
+ Register api_function_address = ApiGetterDescriptor::function_address();
+ DCHECK(api_function_address.is(r5));
+
+ __ mr(r3, sp); // r0 = Handle<Name>
+ __ addi(r4, r3, Operand(1 * kPointerSize)); // r4 = PCA
+
+// If ABI passes Handles (pointer-sized struct) in a register:
+//
+// Create 2 extra slots on stack:
+// [0] space for DirectCEntryStub's LR save
+// [1] AccessorInfo&
+//
+// Otherwise:
+//
+// Create 3 extra slots on stack:
+// [0] space for DirectCEntryStub's LR save
+// [1] copy of Handle (first arg)
+// [2] AccessorInfo&
+#if ABI_PASSES_HANDLES_IN_REGS
+ const int kAccessorInfoSlot = kStackFrameExtraParamSlot + 1;
+ const int kApiStackSpace = 2;
+#else
+ const int kArg0Slot = kStackFrameExtraParamSlot + 1;
+ const int kAccessorInfoSlot = kArg0Slot + 1;
+ const int kApiStackSpace = 3;
+#endif
+
+ FrameScope frame_scope(masm, StackFrame::MANUAL);
+ __ EnterExitFrame(false, kApiStackSpace);
+
+#if !ABI_PASSES_HANDLES_IN_REGS
+ // pass 1st arg by reference
+ __ StoreP(r3, MemOperand(sp, kArg0Slot * kPointerSize));
+ __ addi(r3, sp, Operand(kArg0Slot * kPointerSize));
+#endif
+
+ // Create PropertyAccessorInfo instance on the stack above the exit frame with
+ // r4 (internal::Object** args_) as the data.
+ __ StoreP(r4, MemOperand(sp, kAccessorInfoSlot * kPointerSize));
+ // r4 = AccessorInfo&
+ __ addi(r4, sp, Operand(kAccessorInfoSlot * kPointerSize));
+
+ const int kStackUnwindSpace = PropertyCallbackArguments::kArgsLength + 1;
+
+ ExternalReference thunk_ref =
+ ExternalReference::invoke_accessor_getter_callback(isolate());
+ __ CallApiFunctionAndReturn(api_function_address, thunk_ref,
+ kStackUnwindSpace,
+ MemOperand(fp, 6 * kPointerSize), NULL);
+}
+
+
+#undef __
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_PPC_CODE_STUBS_PPC_H_
+#define V8_PPC_CODE_STUBS_PPC_H_
+
+namespace v8 {
+namespace internal {
+
+
+void ArrayNativeCode(MacroAssembler* masm, Label* call_generic_code);
+
+
+class StringHelper : public AllStatic {
+ public:
+ // Generate code for copying a large number of characters. This function
+ // is allowed to spend extra time setting up conditions to make copying
+ // faster. Copying of overlapping regions is not supported.
+ // Dest register ends at the position after the last character written.
+ static void GenerateCopyCharacters(MacroAssembler* masm, Register dest,
+ Register src, Register count,
+ Register scratch,
+ String::Encoding encoding);
+
+ // Compares two flat one-byte strings and returns result in r0.
+ static void GenerateCompareFlatOneByteStrings(MacroAssembler* masm,
+ Register left, Register right,
+ Register scratch1,
+ Register scratch2,
+ Register scratch3);
+
+ // Compares two flat one-byte strings for equality and returns result in r0.
+ static void GenerateFlatOneByteStringEquals(MacroAssembler* masm,
+ Register left, Register right,
+ Register scratch1,
+ Register scratch2);
+
+ private:
+ static void GenerateOneByteCharsCompareLoop(MacroAssembler* masm,
+ Register left, Register right,
+ Register length,
+ Register scratch1,
+ Label* chars_not_equal);
+
+ DISALLOW_IMPLICIT_CONSTRUCTORS(StringHelper);
+};
+
+
+class StoreRegistersStateStub : public PlatformCodeStub {
+ public:
+ explicit StoreRegistersStateStub(Isolate* isolate)
+ : PlatformCodeStub(isolate) {}
+
+ static void GenerateAheadOfTime(Isolate* isolate);
+
+ private:
+ DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
+ DEFINE_PLATFORM_CODE_STUB(StoreRegistersState, PlatformCodeStub);
+};
+
+
+class RestoreRegistersStateStub : public PlatformCodeStub {
+ public:
+ explicit RestoreRegistersStateStub(Isolate* isolate)
+ : PlatformCodeStub(isolate) {}
+
+ static void GenerateAheadOfTime(Isolate* isolate);
+
+ private:
+ DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
+ DEFINE_PLATFORM_CODE_STUB(RestoreRegistersState, PlatformCodeStub);
+};
+
+
+class RecordWriteStub : public PlatformCodeStub {
+ public:
+ RecordWriteStub(Isolate* isolate, Register object, Register value,
+ Register address, RememberedSetAction remembered_set_action,
+ SaveFPRegsMode fp_mode)
+ : PlatformCodeStub(isolate),
+ regs_(object, // An input reg.
+ address, // An input reg.
+ value) { // One scratch reg.
+ minor_key_ = ObjectBits::encode(object.code()) |
+ ValueBits::encode(value.code()) |
+ AddressBits::encode(address.code()) |
+ RememberedSetActionBits::encode(remembered_set_action) |
+ SaveFPRegsModeBits::encode(fp_mode);
+ }
+
+ RecordWriteStub(uint32_t key, Isolate* isolate)
+ : PlatformCodeStub(key, isolate), regs_(object(), address(), value()) {}
+
+ enum Mode { STORE_BUFFER_ONLY, INCREMENTAL, INCREMENTAL_COMPACTION };
+
+ virtual bool SometimesSetsUpAFrame() { return false; }
+
+ static void PatchBranchIntoNop(MacroAssembler* masm, int pos) {
+ // Consider adding DCHECK here to catch bad patching
+ masm->instr_at_put(pos, (masm->instr_at(pos) & ~kBOfieldMask) | BT);
+ }
+
+ static void PatchNopIntoBranch(MacroAssembler* masm, int pos) {
+ // Consider adding DCHECK here to catch bad patching
+ masm->instr_at_put(pos, (masm->instr_at(pos) & ~kBOfieldMask) | BF);
+ }
+
+ static Mode GetMode(Code* stub) {
+ Instr first_instruction =
+ Assembler::instr_at(stub->instruction_start() + Assembler::kInstrSize);
+ Instr second_instruction = Assembler::instr_at(stub->instruction_start() +
+ (Assembler::kInstrSize * 2));
+
+ // Consider adding DCHECK here to catch unexpected instruction sequence
+ if (BF == (first_instruction & kBOfieldMask)) {
+ return INCREMENTAL;
+ }
+
+ if (BF == (second_instruction & kBOfieldMask)) {
+ return INCREMENTAL_COMPACTION;
+ }
+
+ return STORE_BUFFER_ONLY;
+ }
+
+ static void Patch(Code* stub, Mode mode) {
+ MacroAssembler masm(NULL, stub->instruction_start(),
+ stub->instruction_size());
+ switch (mode) {
+ case STORE_BUFFER_ONLY:
+ DCHECK(GetMode(stub) == INCREMENTAL ||
+ GetMode(stub) == INCREMENTAL_COMPACTION);
+
+ PatchBranchIntoNop(&masm, Assembler::kInstrSize);
+ PatchBranchIntoNop(&masm, Assembler::kInstrSize * 2);
+ break;
+ case INCREMENTAL:
+ DCHECK(GetMode(stub) == STORE_BUFFER_ONLY);
+ PatchNopIntoBranch(&masm, Assembler::kInstrSize);
+ break;
+ case INCREMENTAL_COMPACTION:
+ DCHECK(GetMode(stub) == STORE_BUFFER_ONLY);
+ PatchNopIntoBranch(&masm, Assembler::kInstrSize * 2);
+ break;
+ }
+ DCHECK(GetMode(stub) == mode);
+ CpuFeatures::FlushICache(stub->instruction_start() + Assembler::kInstrSize,
+ 2 * Assembler::kInstrSize);
+ }
+
+ DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
+
+ private:
+ // This is a helper class for freeing up 3 scratch registers. The input is
+ // two registers that must be preserved and one scratch register provided by
+ // the caller.
+ class RegisterAllocation {
+ public:
+ RegisterAllocation(Register object, Register address, Register scratch0)
+ : object_(object), address_(address), scratch0_(scratch0) {
+ DCHECK(!AreAliased(scratch0, object, address, no_reg));
+ scratch1_ = GetRegisterThatIsNotOneOf(object_, address_, scratch0_);
+ }
+
+ void Save(MacroAssembler* masm) {
+ DCHECK(!AreAliased(object_, address_, scratch1_, scratch0_));
+ // We don't have to save scratch0_ because it was given to us as
+ // a scratch register.
+ masm->push(scratch1_);
+ }
+
+ void Restore(MacroAssembler* masm) { masm->pop(scratch1_); }
+
+ // If we have to call into C then we need to save and restore all caller-
+ // saved registers that were not already preserved. The scratch registers
+ // will be restored by other means so we don't bother pushing them here.
+ void SaveCallerSaveRegisters(MacroAssembler* masm, SaveFPRegsMode mode) {
+ masm->mflr(r0);
+ masm->push(r0);
+ masm->MultiPush(kJSCallerSaved & ~scratch1_.bit());
+ if (mode == kSaveFPRegs) {
+ // Save all volatile FP registers except d0.
+ masm->SaveFPRegs(sp, 1, DoubleRegister::kNumVolatileRegisters - 1);
+ }
+ }
+
+ inline void RestoreCallerSaveRegisters(MacroAssembler* masm,
+ SaveFPRegsMode mode) {
+ if (mode == kSaveFPRegs) {
+ // Restore all volatile FP registers except d0.
+ masm->RestoreFPRegs(sp, 1, DoubleRegister::kNumVolatileRegisters - 1);
+ }
+ masm->MultiPop(kJSCallerSaved & ~scratch1_.bit());
+ masm->pop(r0);
+ masm->mtlr(r0);
+ }
+
+ inline Register object() { return object_; }
+ inline Register address() { return address_; }
+ inline Register scratch0() { return scratch0_; }
+ inline Register scratch1() { return scratch1_; }
+
+ private:
+ Register object_;
+ Register address_;
+ Register scratch0_;
+ Register scratch1_;
+
+ friend class RecordWriteStub;
+ };
+
+ enum OnNoNeedToInformIncrementalMarker {
+ kReturnOnNoNeedToInformIncrementalMarker,
+ kUpdateRememberedSetOnNoNeedToInformIncrementalMarker
+ };
+
+ virtual inline Major MajorKey() const FINAL OVERRIDE { return RecordWrite; }
+
+ virtual void Generate(MacroAssembler* masm) OVERRIDE;
+ void GenerateIncremental(MacroAssembler* masm, Mode mode);
+ void CheckNeedsToInformIncrementalMarker(
+ MacroAssembler* masm, OnNoNeedToInformIncrementalMarker on_no_need,
+ Mode mode);
+ void InformIncrementalMarker(MacroAssembler* masm);
+
+ void Activate(Code* code) {
+ code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code);
+ }
+
+ Register object() const {
+ return Register::from_code(ObjectBits::decode(minor_key_));
+ }
+
+ Register value() const {
+ return Register::from_code(ValueBits::decode(minor_key_));
+ }
+
+ Register address() const {
+ return Register::from_code(AddressBits::decode(minor_key_));
+ }
+
+ RememberedSetAction remembered_set_action() const {
+ return RememberedSetActionBits::decode(minor_key_);
+ }
+
+ SaveFPRegsMode save_fp_regs_mode() const {
+ return SaveFPRegsModeBits::decode(minor_key_);
+ }
+
+ class ObjectBits : public BitField<int, 0, 5> {};
+ class ValueBits : public BitField<int, 5, 5> {};
+ class AddressBits : public BitField<int, 10, 5> {};
+ class RememberedSetActionBits : public BitField<RememberedSetAction, 15, 1> {
+ };
+ class SaveFPRegsModeBits : public BitField<SaveFPRegsMode, 16, 1> {};
+
+ Label slow_;
+ RegisterAllocation regs_;
+
+ DISALLOW_COPY_AND_ASSIGN(RecordWriteStub);
+};
+
+
+// Trampoline stub to call into native code. To call safely into native code
+// in the presence of compacting GC (which can move code objects) we need to
+// keep the code which called into native pinned in the memory. Currently the
+// simplest approach is to generate such stub early enough so it can never be
+// moved by GC
+class DirectCEntryStub : public PlatformCodeStub {
+ public:
+ explicit DirectCEntryStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
+ void GenerateCall(MacroAssembler* masm, Register target);
+
+ private:
+ bool NeedsImmovableCode() { return true; }
+
+ DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
+ DEFINE_PLATFORM_CODE_STUB(DirectCEntry, PlatformCodeStub);
+};
+
+
+class NameDictionaryLookupStub : public PlatformCodeStub {
+ public:
+ enum LookupMode { POSITIVE_LOOKUP, NEGATIVE_LOOKUP };
+
+ NameDictionaryLookupStub(Isolate* isolate, LookupMode mode)
+ : PlatformCodeStub(isolate) {
+ minor_key_ = LookupModeBits::encode(mode);
+ }
+
+ static void GenerateNegativeLookup(MacroAssembler* masm, Label* miss,
+ Label* done, Register receiver,
+ Register properties, Handle<Name> name,
+ Register scratch0);
+
+ static void GeneratePositiveLookup(MacroAssembler* masm, Label* miss,
+ Label* done, Register elements,
+ Register name, Register r0, Register r1);
+
+ virtual bool SometimesSetsUpAFrame() { return false; }
+
+ private:
+ static const int kInlinedProbes = 4;
+ static const int kTotalProbes = 20;
+
+ static const int kCapacityOffset =
+ NameDictionary::kHeaderSize +
+ NameDictionary::kCapacityIndex * kPointerSize;
+
+ static const int kElementsStartOffset =
+ NameDictionary::kHeaderSize +
+ NameDictionary::kElementsStartIndex * kPointerSize;
+
+ LookupMode mode() const { return LookupModeBits::decode(minor_key_); }
+
+ class LookupModeBits : public BitField<LookupMode, 0, 1> {};
+
+ DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
+ DEFINE_PLATFORM_CODE_STUB(NameDictionaryLookup, PlatformCodeStub);
+};
+}
+} // namespace v8::internal
+
+#endif // V8_PPC_CODE_STUBS_PPC_H_
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/codegen.h"
+#include "src/macro-assembler.h"
+#include "src/ppc/simulator-ppc.h"
+
+namespace v8 {
+namespace internal {
+
+
+#define __ masm.
+
+
+#if defined(USE_SIMULATOR)
+byte* fast_exp_ppc_machine_code = NULL;
+double fast_exp_simulator(double x) {
+ return Simulator::current(Isolate::Current())
+ ->CallFPReturnsDouble(fast_exp_ppc_machine_code, x, 0);
+}
+#endif
+
+
+UnaryMathFunction CreateExpFunction() {
+ if (!FLAG_fast_math) return &std::exp;
+ size_t actual_size;
+ byte* buffer =
+ static_cast<byte*>(base::OS::Allocate(1 * KB, &actual_size, true));
+ if (buffer == NULL) return &std::exp;
+ ExternalReference::InitializeMathExpData();
+
+ MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
+
+ {
+ DoubleRegister input = d1;
+ DoubleRegister result = d2;
+ DoubleRegister double_scratch1 = d3;
+ DoubleRegister double_scratch2 = d4;
+ Register temp1 = r7;
+ Register temp2 = r8;
+ Register temp3 = r9;
+
+// Called from C
+#if ABI_USES_FUNCTION_DESCRIPTORS
+ __ function_descriptor();
+#endif
+
+ __ Push(temp3, temp2, temp1);
+ MathExpGenerator::EmitMathExp(&masm, input, result, double_scratch1,
+ double_scratch2, temp1, temp2, temp3);
+ __ Pop(temp3, temp2, temp1);
+ __ fmr(d1, result);
+ __ Ret();
+ }
+
+ CodeDesc desc;
+ masm.GetCode(&desc);
+#if !ABI_USES_FUNCTION_DESCRIPTORS
+ DCHECK(!RelocInfo::RequiresRelocation(desc));
+#endif
+
+ CpuFeatures::FlushICache(buffer, actual_size);
+ base::OS::ProtectCode(buffer, actual_size);
+
+#if !defined(USE_SIMULATOR)
+ return FUNCTION_CAST<UnaryMathFunction>(buffer);
+#else
+ fast_exp_ppc_machine_code = buffer;
+ return &fast_exp_simulator;
+#endif
+}
+
+
+UnaryMathFunction CreateSqrtFunction() {
+#if defined(USE_SIMULATOR)
+ return &std::sqrt;
+#else
+ size_t actual_size;
+ byte* buffer =
+ static_cast<byte*>(base::OS::Allocate(1 * KB, &actual_size, true));
+ if (buffer == NULL) return &std::sqrt;
+
+ MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
+
+// Called from C
+#if ABI_USES_FUNCTION_DESCRIPTORS
+ __ function_descriptor();
+#endif
+
+ __ MovFromFloatParameter(d1);
+ __ fsqrt(d1, d1);
+ __ MovToFloatResult(d1);
+ __ Ret();
+
+ CodeDesc desc;
+ masm.GetCode(&desc);
+#if !ABI_USES_FUNCTION_DESCRIPTORS
+ DCHECK(!RelocInfo::RequiresRelocation(desc));
+#endif
+
+ CpuFeatures::FlushICache(buffer, actual_size);
+ base::OS::ProtectCode(buffer, actual_size);
+ return FUNCTION_CAST<UnaryMathFunction>(buffer);
+#endif
+}
+
+#undef __
+
+
+// -------------------------------------------------------------------------
+// Platform-specific RuntimeCallHelper functions.
+
+void StubRuntimeCallHelper::BeforeCall(MacroAssembler* masm) const {
+ masm->EnterFrame(StackFrame::INTERNAL);
+ DCHECK(!masm->has_frame());
+ masm->set_has_frame(true);
+}
+
+
+void StubRuntimeCallHelper::AfterCall(MacroAssembler* masm) const {
+ masm->LeaveFrame(StackFrame::INTERNAL);
+ DCHECK(masm->has_frame());
+ masm->set_has_frame(false);
+}
+
+
+// -------------------------------------------------------------------------
+// Code generators
+
+#define __ ACCESS_MASM(masm)
+
+void ElementsTransitionGenerator::GenerateMapChangeElementsTransition(
+ MacroAssembler* masm, Register receiver, Register key, Register value,
+ Register target_map, AllocationSiteMode mode,
+ Label* allocation_memento_found) {
+ Register scratch_elements = r7;
+ DCHECK(!AreAliased(receiver, key, value, target_map, scratch_elements));
+
+ if (mode == TRACK_ALLOCATION_SITE) {
+ DCHECK(allocation_memento_found != NULL);
+ __ JumpIfJSArrayHasAllocationMemento(receiver, scratch_elements,
+ allocation_memento_found);
+ }
+
+ // Set transitioned map.
+ __ StoreP(target_map, FieldMemOperand(receiver, HeapObject::kMapOffset), r0);
+ __ RecordWriteField(receiver, HeapObject::kMapOffset, target_map, r11,
+ kLRHasNotBeenSaved, kDontSaveFPRegs, EMIT_REMEMBERED_SET,
+ OMIT_SMI_CHECK);
+}
+
+
+void ElementsTransitionGenerator::GenerateSmiToDouble(
+ MacroAssembler* masm, Register receiver, Register key, Register value,
+ Register target_map, AllocationSiteMode mode, Label* fail) {
+ // lr contains the return address
+ Label loop, entry, convert_hole, gc_required, only_change_map, done;
+ Register elements = r7;
+ Register length = r8;
+ Register array = r9;
+ Register array_end = array;
+
+ // target_map parameter can be clobbered.
+ Register scratch1 = target_map;
+ Register scratch2 = r11;
+
+ // Verify input registers don't conflict with locals.
+ DCHECK(!AreAliased(receiver, key, value, target_map, elements, length, array,
+ scratch2));
+
+ if (mode == TRACK_ALLOCATION_SITE) {
+ __ JumpIfJSArrayHasAllocationMemento(receiver, elements, fail);
+ }
+
+ // Check for empty arrays, which only require a map transition and no changes
+ // to the backing store.
+ __ LoadP(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
+ __ CompareRoot(elements, Heap::kEmptyFixedArrayRootIndex);
+ __ beq(&only_change_map);
+
+ // Preserve lr and use r17 as a temporary register.
+ __ mflr(r0);
+ __ Push(r0);
+
+ __ LoadP(length, FieldMemOperand(elements, FixedArray::kLengthOffset));
+ // length: number of elements (smi-tagged)
+
+ // Allocate new FixedDoubleArray.
+ __ SmiToDoubleArrayOffset(r17, length);
+ __ addi(r17, r17, Operand(FixedDoubleArray::kHeaderSize));
+ __ Allocate(r17, array, r10, scratch2, &gc_required, DOUBLE_ALIGNMENT);
+
+ // Set destination FixedDoubleArray's length and map.
+ __ LoadRoot(scratch2, Heap::kFixedDoubleArrayMapRootIndex);
+ __ StoreP(length, MemOperand(array, FixedDoubleArray::kLengthOffset));
+ // Update receiver's map.
+ __ StoreP(scratch2, MemOperand(array, HeapObject::kMapOffset));
+
+ __ StoreP(target_map, FieldMemOperand(receiver, HeapObject::kMapOffset), r0);
+ __ RecordWriteField(receiver, HeapObject::kMapOffset, target_map, scratch2,
+ kLRHasBeenSaved, kDontSaveFPRegs, OMIT_REMEMBERED_SET,
+ OMIT_SMI_CHECK);
+ // Replace receiver's backing store with newly created FixedDoubleArray.
+ __ addi(scratch1, array, Operand(kHeapObjectTag));
+ __ StoreP(scratch1, FieldMemOperand(receiver, JSObject::kElementsOffset), r0);
+ __ RecordWriteField(receiver, JSObject::kElementsOffset, scratch1, scratch2,
+ kLRHasBeenSaved, kDontSaveFPRegs, EMIT_REMEMBERED_SET,
+ OMIT_SMI_CHECK);
+
+ // Prepare for conversion loop.
+ __ addi(target_map, elements,
+ Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ __ addi(r10, array, Operand(FixedDoubleArray::kHeaderSize));
+ __ SmiToDoubleArrayOffset(array, length);
+ __ add(array_end, r10, array);
+// Repurpose registers no longer in use.
+#if V8_TARGET_ARCH_PPC64
+ Register hole_int64 = elements;
+#else
+ Register hole_lower = elements;
+ Register hole_upper = length;
+#endif
+ // scratch1: begin of source FixedArray element fields, not tagged
+ // hole_lower: kHoleNanLower32 OR hol_int64
+ // hole_upper: kHoleNanUpper32
+ // array_end: end of destination FixedDoubleArray, not tagged
+ // scratch2: begin of FixedDoubleArray element fields, not tagged
+
+ __ b(&entry);
+
+ __ bind(&only_change_map);
+ __ StoreP(target_map, FieldMemOperand(receiver, HeapObject::kMapOffset), r0);
+ __ RecordWriteField(receiver, HeapObject::kMapOffset, target_map, scratch2,
+ kLRHasNotBeenSaved, kDontSaveFPRegs, OMIT_REMEMBERED_SET,
+ OMIT_SMI_CHECK);
+ __ b(&done);
+
+ // Call into runtime if GC is required.
+ __ bind(&gc_required);
+ __ Pop(r0);
+ __ mtlr(r0);
+ __ b(fail);
+
+ // Convert and copy elements.
+ __ bind(&loop);
+ __ LoadP(r11, MemOperand(scratch1));
+ __ addi(scratch1, scratch1, Operand(kPointerSize));
+ // r11: current element
+ __ UntagAndJumpIfNotSmi(r11, r11, &convert_hole);
+
+ // Normal smi, convert to double and store.
+ __ ConvertIntToDouble(r11, d0);
+ __ stfd(d0, MemOperand(scratch2, 0));
+ __ addi(r10, r10, Operand(8));
+
+ __ b(&entry);
+
+ // Hole found, store the-hole NaN.
+ __ bind(&convert_hole);
+ if (FLAG_debug_code) {
+ // Restore a "smi-untagged" heap object.
+ __ LoadP(r11, MemOperand(r6, -kPointerSize));
+ __ CompareRoot(r11, Heap::kTheHoleValueRootIndex);
+ __ Assert(eq, kObjectFoundInSmiOnlyArray);
+ }
+#if V8_TARGET_ARCH_PPC64
+ __ std(hole_int64, MemOperand(r10, 0));
+#else
+ __ stw(hole_upper, MemOperand(r10, Register::kExponentOffset));
+ __ stw(hole_lower, MemOperand(r10, Register::kMantissaOffset));
+#endif
+ __ addi(r10, r10, Operand(8));
+
+ __ bind(&entry);
+ __ cmp(r10, array_end);
+ __ blt(&loop);
+
+ __ Pop(r0);
+ __ mtlr(r0);
+ __ bind(&done);
+}
+
+
+void ElementsTransitionGenerator::GenerateDoubleToObject(
+ MacroAssembler* masm, Register receiver, Register key, Register value,
+ Register target_map, AllocationSiteMode mode, Label* fail) {
+ // Register lr contains the return address.
+ Label entry, loop, convert_hole, gc_required, only_change_map;
+ Register elements = r7;
+ Register array = r9;
+ Register length = r8;
+ Register scratch = r11;
+
+ // Verify input registers don't conflict with locals.
+ DCHECK(!AreAliased(receiver, key, value, target_map, elements, array, length,
+ scratch));
+
+ if (mode == TRACK_ALLOCATION_SITE) {
+ __ JumpIfJSArrayHasAllocationMemento(receiver, elements, fail);
+ }
+
+ // Check for empty arrays, which only require a map transition and no changes
+ // to the backing store.
+ __ LoadP(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
+ __ CompareRoot(elements, Heap::kEmptyFixedArrayRootIndex);
+ __ beq(&only_change_map);
+
+ __ Push(target_map, receiver, key, value);
+ __ LoadP(length, FieldMemOperand(elements, FixedArray::kLengthOffset));
+ // elements: source FixedDoubleArray
+ // length: number of elements (smi-tagged)
+
+ // Allocate new FixedArray.
+ // Re-use value and target_map registers, as they have been saved on the
+ // stack.
+ Register array_size = value;
+ Register allocate_scratch = target_map;
+ __ li(array_size, Operand(FixedDoubleArray::kHeaderSize));
+ __ SmiToPtrArrayOffset(r0, length);
+ __ add(array_size, array_size, r0);
+ __ Allocate(array_size, array, allocate_scratch, scratch, &gc_required,
+ NO_ALLOCATION_FLAGS);
+ // array: destination FixedArray, not tagged as heap object
+ // Set destination FixedDoubleArray's length and map.
+ __ LoadRoot(scratch, Heap::kFixedArrayMapRootIndex);
+ __ StoreP(length, MemOperand(array, FixedDoubleArray::kLengthOffset));
+ __ StoreP(scratch, MemOperand(array, HeapObject::kMapOffset));
+ __ addi(array, array, Operand(kHeapObjectTag));
+
+ // Prepare for conversion loop.
+ Register src_elements = elements;
+ Register dst_elements = target_map;
+ Register dst_end = length;
+ Register heap_number_map = scratch;
+ __ addi(src_elements, elements,
+ Operand(FixedDoubleArray::kHeaderSize - kHeapObjectTag));
+ __ SmiToPtrArrayOffset(length, length);
+ __ LoadRoot(r10, Heap::kTheHoleValueRootIndex);
+
+ Label initialization_loop, loop_done;
+ __ ShiftRightImm(r0, length, Operand(kPointerSizeLog2), SetRC);
+ __ beq(&loop_done, cr0);
+
+ // Allocating heap numbers in the loop below can fail and cause a jump to
+ // gc_required. We can't leave a partly initialized FixedArray behind,
+ // so pessimistically fill it with holes now.
+ __ mtctr(r0);
+ __ addi(dst_elements, array,
+ Operand(FixedArray::kHeaderSize - kHeapObjectTag - kPointerSize));
+ __ bind(&initialization_loop);
+ __ StorePU(r10, MemOperand(dst_elements, kPointerSize));
+ __ bdnz(&initialization_loop);
+
+ __ addi(dst_elements, array,
+ Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ __ add(dst_end, dst_elements, length);
+ __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
+ // Using offsetted addresses in src_elements to fully take advantage of
+ // post-indexing.
+ // dst_elements: begin of destination FixedArray element fields, not tagged
+ // src_elements: begin of source FixedDoubleArray element fields,
+ // not tagged, +4
+ // dst_end: end of destination FixedArray, not tagged
+ // array: destination FixedArray
+ // r10: the-hole pointer
+ // heap_number_map: heap number map
+ __ b(&loop);
+
+ // Call into runtime if GC is required.
+ __ bind(&gc_required);
+ __ Pop(target_map, receiver, key, value);
+ __ b(fail);
+
+ // Replace the-hole NaN with the-hole pointer.
+ __ bind(&convert_hole);
+ __ StoreP(r10, MemOperand(dst_elements));
+ __ addi(dst_elements, dst_elements, Operand(kPointerSize));
+ __ cmpl(dst_elements, dst_end);
+ __ bge(&loop_done);
+
+ __ bind(&loop);
+ Register upper_bits = key;
+ __ lwz(upper_bits, MemOperand(src_elements, Register::kExponentOffset));
+ __ addi(src_elements, src_elements, Operand(kDoubleSize));
+ // upper_bits: current element's upper 32 bit
+ // src_elements: address of next element's upper 32 bit
+ __ Cmpi(upper_bits, Operand(kHoleNanUpper32), r0);
+ __ beq(&convert_hole);
+
+ // Non-hole double, copy value into a heap number.
+ Register heap_number = receiver;
+ Register scratch2 = value;
+ __ AllocateHeapNumber(heap_number, scratch2, r11, heap_number_map,
+ &gc_required);
+ // heap_number: new heap number
+#if V8_TARGET_ARCH_PPC64
+ __ ld(scratch2, MemOperand(src_elements, -kDoubleSize));
+ // subtract tag for std
+ __ addi(upper_bits, heap_number, Operand(-kHeapObjectTag));
+ __ std(scratch2, MemOperand(upper_bits, HeapNumber::kValueOffset));
+#else
+ __ lwz(scratch2,
+ MemOperand(src_elements, Register::kMantissaOffset - kDoubleSize));
+ __ lwz(upper_bits,
+ MemOperand(src_elements, Register::kExponentOffset - kDoubleSize));
+ __ stw(scratch2, FieldMemOperand(heap_number, HeapNumber::kMantissaOffset));
+ __ stw(upper_bits, FieldMemOperand(heap_number, HeapNumber::kExponentOffset));
+#endif
+ __ mr(scratch2, dst_elements);
+ __ StoreP(heap_number, MemOperand(dst_elements));
+ __ addi(dst_elements, dst_elements, Operand(kPointerSize));
+ __ RecordWrite(array, scratch2, heap_number, kLRHasNotBeenSaved,
+ kDontSaveFPRegs, EMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
+ __ b(&entry);
+
+ // Replace the-hole NaN with the-hole pointer.
+ __ bind(&convert_hole);
+ __ StoreP(r10, MemOperand(dst_elements));
+ __ addi(dst_elements, dst_elements, Operand(kPointerSize));
+
+ __ bind(&entry);
+ __ cmpl(dst_elements, dst_end);
+ __ blt(&loop);
+ __ bind(&loop_done);
+
+ __ Pop(target_map, receiver, key, value);
+ // Replace receiver's backing store with newly created and filled FixedArray.
+ __ StoreP(array, FieldMemOperand(receiver, JSObject::kElementsOffset), r0);
+ __ RecordWriteField(receiver, JSObject::kElementsOffset, array, scratch,
+ kLRHasNotBeenSaved, kDontSaveFPRegs, EMIT_REMEMBERED_SET,
+ OMIT_SMI_CHECK);
+
+ __ bind(&only_change_map);
+ // Update receiver's map.
+ __ StoreP(target_map, FieldMemOperand(receiver, HeapObject::kMapOffset), r0);
+ __ RecordWriteField(receiver, HeapObject::kMapOffset, target_map, scratch,
+ kLRHasNotBeenSaved, kDontSaveFPRegs, OMIT_REMEMBERED_SET,
+ OMIT_SMI_CHECK);
+}
+
+
+// assume ip can be used as a scratch register below
+void StringCharLoadGenerator::Generate(MacroAssembler* masm, Register string,
+ Register index, Register result,
+ Label* call_runtime) {
+ // Fetch the instance type of the receiver into result register.
+ __ LoadP(result, FieldMemOperand(string, HeapObject::kMapOffset));
+ __ lbz(result, FieldMemOperand(result, Map::kInstanceTypeOffset));
+
+ // We need special handling for indirect strings.
+ Label check_sequential;
+ __ andi(r0, result, Operand(kIsIndirectStringMask));
+ __ beq(&check_sequential, cr0);
+
+ // Dispatch on the indirect string shape: slice or cons.
+ Label cons_string;
+ __ mov(ip, Operand(kSlicedNotConsMask));
+ __ and_(r0, result, ip, SetRC);
+ __ beq(&cons_string, cr0);
+
+ // Handle slices.
+ Label indirect_string_loaded;
+ __ LoadP(result, FieldMemOperand(string, SlicedString::kOffsetOffset));
+ __ LoadP(string, FieldMemOperand(string, SlicedString::kParentOffset));
+ __ SmiUntag(ip, result);
+ __ add(index, index, ip);
+ __ b(&indirect_string_loaded);
+
+ // Handle cons strings.
+ // Check whether the right hand side is the empty string (i.e. if
+ // this is really a flat string in a cons string). If that is not
+ // the case we would rather go to the runtime system now to flatten
+ // the string.
+ __ bind(&cons_string);
+ __ LoadP(result, FieldMemOperand(string, ConsString::kSecondOffset));
+ __ CompareRoot(result, Heap::kempty_stringRootIndex);
+ __ bne(call_runtime);
+ // Get the first of the two strings and load its instance type.
+ __ LoadP(string, FieldMemOperand(string, ConsString::kFirstOffset));
+
+ __ bind(&indirect_string_loaded);
+ __ LoadP(result, FieldMemOperand(string, HeapObject::kMapOffset));
+ __ lbz(result, FieldMemOperand(result, Map::kInstanceTypeOffset));
+
+ // Distinguish sequential and external strings. Only these two string
+ // representations can reach here (slices and flat cons strings have been
+ // reduced to the underlying sequential or external string).
+ Label external_string, check_encoding;
+ __ bind(&check_sequential);
+ STATIC_ASSERT(kSeqStringTag == 0);
+ __ andi(r0, result, Operand(kStringRepresentationMask));
+ __ bne(&external_string, cr0);
+
+ // Prepare sequential strings
+ STATIC_ASSERT(SeqTwoByteString::kHeaderSize == SeqOneByteString::kHeaderSize);
+ __ addi(string, string,
+ Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
+ __ b(&check_encoding);
+
+ // Handle external strings.
+ __ bind(&external_string);
+ if (FLAG_debug_code) {
+ // Assert that we do not have a cons or slice (indirect strings) here.
+ // Sequential strings have already been ruled out.
+ __ andi(r0, result, Operand(kIsIndirectStringMask));
+ __ Assert(eq, kExternalStringExpectedButNotFound, cr0);
+ }
+ // Rule out short external strings.
+ STATIC_ASSERT(kShortExternalStringTag != 0);
+ __ andi(r0, result, Operand(kShortExternalStringMask));
+ __ bne(call_runtime, cr0);
+ __ LoadP(string,
+ FieldMemOperand(string, ExternalString::kResourceDataOffset));
+
+ Label one_byte, done;
+ __ bind(&check_encoding);
+ STATIC_ASSERT(kTwoByteStringTag == 0);
+ __ andi(r0, result, Operand(kStringEncodingMask));
+ __ bne(&one_byte, cr0);
+ // Two-byte string.
+ __ ShiftLeftImm(result, index, Operand(1));
+ __ lhzx(result, MemOperand(string, result));
+ __ b(&done);
+ __ bind(&one_byte);
+ // One-byte string.
+ __ lbzx(result, MemOperand(string, index));
+ __ bind(&done);
+}
+
+
+static MemOperand ExpConstant(int index, Register base) {
+ return MemOperand(base, index * kDoubleSize);
+}
+
+
+void MathExpGenerator::EmitMathExp(MacroAssembler* masm, DoubleRegister input,
+ DoubleRegister result,
+ DoubleRegister double_scratch1,
+ DoubleRegister double_scratch2,
+ Register temp1, Register temp2,
+ Register temp3) {
+ DCHECK(!input.is(result));
+ DCHECK(!input.is(double_scratch1));
+ DCHECK(!input.is(double_scratch2));
+ DCHECK(!result.is(double_scratch1));
+ DCHECK(!result.is(double_scratch2));
+ DCHECK(!double_scratch1.is(double_scratch2));
+ DCHECK(!temp1.is(temp2));
+ DCHECK(!temp1.is(temp3));
+ DCHECK(!temp2.is(temp3));
+ DCHECK(ExternalReference::math_exp_constants(0).address() != NULL);
+ DCHECK(!masm->serializer_enabled()); // External references not serializable.
+
+ Label zero, infinity, done;
+
+ __ mov(temp3, Operand(ExternalReference::math_exp_constants(0)));
+
+ __ lfd(double_scratch1, ExpConstant(0, temp3));
+ __ fcmpu(double_scratch1, input);
+ __ fmr(result, input);
+ __ bunordered(&done);
+ __ bge(&zero);
+
+ __ lfd(double_scratch2, ExpConstant(1, temp3));
+ __ fcmpu(input, double_scratch2);
+ __ bge(&infinity);
+
+ __ lfd(double_scratch1, ExpConstant(3, temp3));
+ __ lfd(result, ExpConstant(4, temp3));
+ __ fmul(double_scratch1, double_scratch1, input);
+ __ fadd(double_scratch1, double_scratch1, result);
+ __ MovDoubleLowToInt(temp2, double_scratch1);
+ __ fsub(double_scratch1, double_scratch1, result);
+ __ lfd(result, ExpConstant(6, temp3));
+ __ lfd(double_scratch2, ExpConstant(5, temp3));
+ __ fmul(double_scratch1, double_scratch1, double_scratch2);
+ __ fsub(double_scratch1, double_scratch1, input);
+ __ fsub(result, result, double_scratch1);
+ __ fmul(double_scratch2, double_scratch1, double_scratch1);
+ __ fmul(result, result, double_scratch2);
+ __ lfd(double_scratch2, ExpConstant(7, temp3));
+ __ fmul(result, result, double_scratch2);
+ __ fsub(result, result, double_scratch1);
+ __ lfd(double_scratch2, ExpConstant(8, temp3));
+ __ fadd(result, result, double_scratch2);
+ __ srwi(temp1, temp2, Operand(11));
+ __ andi(temp2, temp2, Operand(0x7ff));
+ __ addi(temp1, temp1, Operand(0x3ff));
+
+ // Must not call ExpConstant() after overwriting temp3!
+ __ mov(temp3, Operand(ExternalReference::math_exp_log_table()));
+ __ slwi(temp2, temp2, Operand(3));
+#if V8_TARGET_ARCH_PPC64
+ __ ldx(temp2, MemOperand(temp3, temp2));
+ __ sldi(temp1, temp1, Operand(52));
+ __ orx(temp2, temp1, temp2);
+ __ MovInt64ToDouble(double_scratch1, temp2);
+#else
+ __ add(ip, temp3, temp2);
+ __ lwz(temp3, MemOperand(ip, Register::kExponentOffset));
+ __ lwz(temp2, MemOperand(ip, Register::kMantissaOffset));
+ __ slwi(temp1, temp1, Operand(20));
+ __ orx(temp3, temp1, temp3);
+ __ MovInt64ToDouble(double_scratch1, temp3, temp2);
+#endif
+
+ __ fmul(result, result, double_scratch1);
+ __ b(&done);
+
+ __ bind(&zero);
+ __ fmr(result, kDoubleRegZero);
+ __ b(&done);
+
+ __ bind(&infinity);
+ __ lfd(result, ExpConstant(2, temp3));
+
+ __ bind(&done);
+}
+
+#undef __
+
+CodeAgingHelper::CodeAgingHelper() {
+ DCHECK(young_sequence_.length() == kNoCodeAgeSequenceLength);
+ // Since patcher is a large object, allocate it dynamically when needed,
+ // to avoid overloading the stack in stress conditions.
+ // DONT_FLUSH is used because the CodeAgingHelper is initialized early in
+ // the process, before ARM simulator ICache is setup.
+ SmartPointer<CodePatcher> patcher(new CodePatcher(
+ young_sequence_.start(), young_sequence_.length() / Assembler::kInstrSize,
+ CodePatcher::DONT_FLUSH));
+ PredictableCodeSizeScope scope(patcher->masm(), young_sequence_.length());
+ patcher->masm()->PushFixedFrame(r4);
+ patcher->masm()->addi(fp, sp,
+ Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
+ for (int i = 0; i < kNoCodeAgeSequenceNops; i++) {
+ patcher->masm()->nop();
+ }
+}
+
+
+#ifdef DEBUG
+bool CodeAgingHelper::IsOld(byte* candidate) const {
+ return Assembler::IsNop(Assembler::instr_at(candidate));
+}
+#endif
+
+
+bool Code::IsYoungSequence(Isolate* isolate, byte* sequence) {
+ bool result = isolate->code_aging_helper()->IsYoung(sequence);
+ DCHECK(result || isolate->code_aging_helper()->IsOld(sequence));
+ return result;
+}
+
+
+void Code::GetCodeAgeAndParity(Isolate* isolate, byte* sequence, Age* age,
+ MarkingParity* parity) {
+ if (IsYoungSequence(isolate, sequence)) {
+ *age = kNoAgeCodeAge;
+ *parity = NO_MARKING_PARITY;
+ } else {
+ ConstantPoolArray* constant_pool = NULL;
+ Address target_address = Assembler::target_address_at(
+ sequence + kCodeAgingTargetDelta, constant_pool);
+ Code* stub = GetCodeFromTargetAddress(target_address);
+ GetCodeAgeAndParity(stub, age, parity);
+ }
+}
+
+
+void Code::PatchPlatformCodeAge(Isolate* isolate, byte* sequence, Code::Age age,
+ MarkingParity parity) {
+ uint32_t young_length = isolate->code_aging_helper()->young_sequence_length();
+ if (age == kNoAgeCodeAge) {
+ isolate->code_aging_helper()->CopyYoungSequenceTo(sequence);
+ CpuFeatures::FlushICache(sequence, young_length);
+ } else {
+ // FIXED_SEQUENCE
+ Code* stub = GetCodeAgeStub(isolate, age, parity);
+ CodePatcher patcher(sequence, young_length / Assembler::kInstrSize);
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(patcher.masm());
+ intptr_t target = reinterpret_cast<intptr_t>(stub->instruction_start());
+ // Don't use Call -- we need to preserve ip and lr.
+ // GenerateMakeCodeYoungAgainCommon for the stub code.
+ patcher.masm()->nop(); // marker to detect sequence (see IsOld)
+ patcher.masm()->mov(r3, Operand(target));
+ patcher.masm()->Jump(r3);
+ for (int i = 0; i < kCodeAgingSequenceNops; i++) {
+ patcher.masm()->nop();
+ }
+ }
+}
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_PPC_CODEGEN_PPC_H_
+#define V8_PPC_CODEGEN_PPC_H_
+
+#include "src/ast.h"
+#include "src/macro-assembler.h"
+
+namespace v8 {
+namespace internal {
+
+
+enum TypeofState { INSIDE_TYPEOF, NOT_INSIDE_TYPEOF };
+
+
+class StringCharLoadGenerator : public AllStatic {
+ public:
+ // Generates the code for handling different string types and loading the
+ // indexed character into |result|. We expect |index| as untagged input and
+ // |result| as untagged output.
+ static void Generate(MacroAssembler* masm, Register string, Register index,
+ Register result, Label* call_runtime);
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(StringCharLoadGenerator);
+};
+
+class MathExpGenerator : public AllStatic {
+ public:
+ // Register input isn't modified. All other registers are clobbered.
+ static void EmitMathExp(MacroAssembler* masm, DoubleRegister input,
+ DoubleRegister result, DoubleRegister double_scratch1,
+ DoubleRegister double_scratch2, Register temp1,
+ Register temp2, Register temp3);
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(MathExpGenerator);
+};
+}
+} // namespace v8::internal
+
+#endif // V8_PPC_CODEGEN_PPC_H_
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/ppc/constants-ppc.h"
+
+
+namespace v8 {
+namespace internal {
+
+// These register names are defined in a way to match the native disassembler
+// formatting. See for example the command "objdump -d <binary file>".
+const char* Registers::names_[kNumRegisters] = {
+ "r0", "sp", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",
+ "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", "r20", "r21",
+ "r22", "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", "fp"};
+
+
+// List of alias names which can be used when referring to PPC registers.
+const Registers::RegisterAlias Registers::aliases_[] = {{10, "sl"},
+ {11, "r11"},
+ {12, "r12"},
+ {13, "r13"},
+ {14, "r14"},
+ {15, "r15"},
+ {kNoRegister, NULL}};
+
+
+const char* Registers::Name(int reg) {
+ const char* result;
+ if ((0 <= reg) && (reg < kNumRegisters)) {
+ result = names_[reg];
+ } else {
+ result = "noreg";
+ }
+ return result;
+}
+
+
+const char* FPRegisters::names_[kNumFPRegisters] = {
+ "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10",
+ "d11", "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21",
+ "d22", "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31"};
+
+
+const char* FPRegisters::Name(int reg) {
+ DCHECK((0 <= reg) && (reg < kNumFPRegisters));
+ return names_[reg];
+}
+
+
+int FPRegisters::Number(const char* name) {
+ for (int i = 0; i < kNumFPRegisters; i++) {
+ if (strcmp(names_[i], name) == 0) {
+ return i;
+ }
+ }
+
+ // No register with the requested name found.
+ return kNoRegister;
+}
+
+
+int Registers::Number(const char* name) {
+ // Look through the canonical names.
+ for (int i = 0; i < kNumRegisters; i++) {
+ if (strcmp(names_[i], name) == 0) {
+ return i;
+ }
+ }
+
+ // Look through the alias names.
+ int i = 0;
+ while (aliases_[i].reg != kNoRegister) {
+ if (strcmp(aliases_[i].name, name) == 0) {
+ return aliases_[i].reg;
+ }
+ i++;
+ }
+
+ // No register with the requested name found.
+ return kNoRegister;
+}
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_PPC_CONSTANTS_PPC_H_
+#define V8_PPC_CONSTANTS_PPC_H_
+
+namespace v8 {
+namespace internal {
+
+// Number of registers
+const int kNumRegisters = 32;
+
+// FP support.
+const int kNumFPDoubleRegisters = 32;
+const int kNumFPRegisters = kNumFPDoubleRegisters;
+
+const int kNoRegister = -1;
+
+// sign-extend the least significant 16-bits of value <imm>
+#define SIGN_EXT_IMM16(imm) ((static_cast<int>(imm) << 16) >> 16)
+
+// sign-extend the least significant 26-bits of value <imm>
+#define SIGN_EXT_IMM26(imm) ((static_cast<int>(imm) << 6) >> 6)
+
+// -----------------------------------------------------------------------------
+// Conditions.
+
+// Defines constants and accessor classes to assemble, disassemble and
+// simulate PPC instructions.
+//
+// Section references in the code refer to the "PowerPC Microprocessor
+// Family: The Programmer.s Reference Guide" from 10/95
+// https://www-01.ibm.com/chips/techlib/techlib.nsf/techdocs/852569B20050FF778525699600741775/$file/prg.pdf
+//
+
+// Constants for specific fields are defined in their respective named enums.
+// General constants are in an anonymous enum in class Instr.
+enum Condition {
+ kNoCondition = -1,
+ eq = 0, // Equal.
+ ne = 1, // Not equal.
+ ge = 2, // Greater or equal.
+ lt = 3, // Less than.
+ gt = 4, // Greater than.
+ le = 5, // Less then or equal
+ unordered = 6, // Floating-point unordered
+ ordered = 7,
+ overflow = 8, // Summary overflow
+ nooverflow = 9,
+ al = 10 // Always.
+};
+
+
+inline Condition NegateCondition(Condition cond) {
+ DCHECK(cond != al);
+ return static_cast<Condition>(cond ^ ne);
+}
+
+
+// Commute a condition such that {a cond b == b cond' a}.
+inline Condition CommuteCondition(Condition cond) {
+ switch (cond) {
+ case lt:
+ return gt;
+ case gt:
+ return lt;
+ case ge:
+ return le;
+ case le:
+ return ge;
+ default:
+ return cond;
+ }
+}
+
+// -----------------------------------------------------------------------------
+// Instructions encoding.
+
+// Instr is merely used by the Assembler to distinguish 32bit integers
+// representing instructions from usual 32 bit values.
+// Instruction objects are pointers to 32bit values, and provide methods to
+// access the various ISA fields.
+typedef int32_t Instr;
+
+// Opcodes as defined in section 4.2 table 34 (32bit PowerPC)
+enum Opcode {
+ TWI = 3 << 26, // Trap Word Immediate
+ MULLI = 7 << 26, // Multiply Low Immediate
+ SUBFIC = 8 << 26, // Subtract from Immediate Carrying
+ CMPLI = 10 << 26, // Compare Logical Immediate
+ CMPI = 11 << 26, // Compare Immediate
+ ADDIC = 12 << 26, // Add Immediate Carrying
+ ADDICx = 13 << 26, // Add Immediate Carrying and Record
+ ADDI = 14 << 26, // Add Immediate
+ ADDIS = 15 << 26, // Add Immediate Shifted
+ BCX = 16 << 26, // Branch Conditional
+ SC = 17 << 26, // System Call
+ BX = 18 << 26, // Branch
+ EXT1 = 19 << 26, // Extended code set 1
+ RLWIMIX = 20 << 26, // Rotate Left Word Immediate then Mask Insert
+ RLWINMX = 21 << 26, // Rotate Left Word Immediate then AND with Mask
+ RLWNMX = 23 << 26, // Rotate Left Word then AND with Mask
+ ORI = 24 << 26, // OR Immediate
+ ORIS = 25 << 26, // OR Immediate Shifted
+ XORI = 26 << 26, // XOR Immediate
+ XORIS = 27 << 26, // XOR Immediate Shifted
+ ANDIx = 28 << 26, // AND Immediate
+ ANDISx = 29 << 26, // AND Immediate Shifted
+ EXT5 = 30 << 26, // Extended code set 5 - 64bit only
+ EXT2 = 31 << 26, // Extended code set 2
+ LWZ = 32 << 26, // Load Word and Zero
+ LWZU = 33 << 26, // Load Word with Zero Update
+ LBZ = 34 << 26, // Load Byte and Zero
+ LBZU = 35 << 26, // Load Byte and Zero with Update
+ STW = 36 << 26, // Store
+ STWU = 37 << 26, // Store Word with Update
+ STB = 38 << 26, // Store Byte
+ STBU = 39 << 26, // Store Byte with Update
+ LHZ = 40 << 26, // Load Half and Zero
+ LHZU = 41 << 26, // Load Half and Zero with Update
+ LHA = 42 << 26, // Load Half Algebraic
+ LHAU = 43 << 26, // Load Half Algebraic with Update
+ STH = 44 << 26, // Store Half
+ STHU = 45 << 26, // Store Half with Update
+ LMW = 46 << 26, // Load Multiple Word
+ STMW = 47 << 26, // Store Multiple Word
+ LFS = 48 << 26, // Load Floating-Point Single
+ LFSU = 49 << 26, // Load Floating-Point Single with Update
+ LFD = 50 << 26, // Load Floating-Point Double
+ LFDU = 51 << 26, // Load Floating-Point Double with Update
+ STFS = 52 << 26, // Store Floating-Point Single
+ STFSU = 53 << 26, // Store Floating-Point Single with Update
+ STFD = 54 << 26, // Store Floating-Point Double
+ STFDU = 55 << 26, // Store Floating-Point Double with Update
+ LD = 58 << 26, // Load Double Word
+ EXT3 = 59 << 26, // Extended code set 3
+ STD = 62 << 26, // Store Double Word (optionally with Update)
+ EXT4 = 63 << 26 // Extended code set 4
+};
+
+// Bits 10-1
+enum OpcodeExt1 {
+ MCRF = 0 << 1, // Move Condition Register Field
+ BCLRX = 16 << 1, // Branch Conditional Link Register
+ CRNOR = 33 << 1, // Condition Register NOR)
+ RFI = 50 << 1, // Return from Interrupt
+ CRANDC = 129 << 1, // Condition Register AND with Complement
+ ISYNC = 150 << 1, // Instruction Synchronize
+ CRXOR = 193 << 1, // Condition Register XOR
+ CRNAND = 225 << 1, // Condition Register NAND
+ CRAND = 257 << 1, // Condition Register AND
+ CREQV = 289 << 1, // Condition Register Equivalent
+ CRORC = 417 << 1, // Condition Register OR with Complement
+ CROR = 449 << 1, // Condition Register OR
+ BCCTRX = 528 << 1 // Branch Conditional to Count Register
+};
+
+// Bits 9-1 or 10-1
+enum OpcodeExt2 {
+ CMP = 0 << 1,
+ TW = 4 << 1,
+ SUBFCX = 8 << 1,
+ ADDCX = 10 << 1,
+ MULHWUX = 11 << 1,
+ MFCR = 19 << 1,
+ LWARX = 20 << 1,
+ LDX = 21 << 1,
+ LWZX = 23 << 1, // load word zero w/ x-form
+ SLWX = 24 << 1,
+ CNTLZWX = 26 << 1,
+ SLDX = 27 << 1,
+ ANDX = 28 << 1,
+ CMPL = 32 << 1,
+ SUBFX = 40 << 1,
+ MFVSRD = 51 << 1, // Move From VSR Doubleword
+ LDUX = 53 << 1,
+ DCBST = 54 << 1,
+ LWZUX = 55 << 1, // load word zero w/ update x-form
+ CNTLZDX = 58 << 1,
+ ANDCX = 60 << 1,
+ MULHWX = 75 << 1,
+ DCBF = 86 << 1,
+ LBZX = 87 << 1, // load byte zero w/ x-form
+ NEGX = 104 << 1,
+ MFVSRWZ = 115 << 1, // Move From VSR Word And Zero
+ LBZUX = 119 << 1, // load byte zero w/ update x-form
+ NORX = 124 << 1,
+ SUBFEX = 136 << 1,
+ ADDEX = 138 << 1,
+ STDX = 149 << 1,
+ STWX = 151 << 1, // store word w/ x-form
+ MTVSRD = 179 << 1, // Move To VSR Doubleword
+ STDUX = 181 << 1,
+ STWUX = 183 << 1, // store word w/ update x-form
+ /*
+ MTCRF
+ MTMSR
+ STWCXx
+ SUBFZEX
+ */
+ ADDZEX = 202 << 1, // Add to Zero Extended
+ /*
+ MTSR
+ */
+ MTVSRWA = 211 << 1, // Move To VSR Word Algebraic
+ STBX = 215 << 1, // store byte w/ x-form
+ MULLD = 233 << 1, // Multiply Low Double Word
+ MULLW = 235 << 1, // Multiply Low Word
+ MTVSRWZ = 243 << 1, // Move To VSR Word And Zero
+ STBUX = 247 << 1, // store byte w/ update x-form
+ ADDX = 266 << 1, // Add
+ LHZX = 279 << 1, // load half-word zero w/ x-form
+ LHZUX = 311 << 1, // load half-word zero w/ update x-form
+ LHAX = 343 << 1, // load half-word algebraic w/ x-form
+ LHAUX = 375 << 1, // load half-word algebraic w/ update x-form
+ XORX = 316 << 1, // Exclusive OR
+ MFSPR = 339 << 1, // Move from Special-Purpose-Register
+ STHX = 407 << 1, // store half-word w/ x-form
+ STHUX = 439 << 1, // store half-word w/ update x-form
+ ORX = 444 << 1, // Or
+ MTSPR = 467 << 1, // Move to Special-Purpose-Register
+ DIVD = 489 << 1, // Divide Double Word
+ DIVW = 491 << 1, // Divide Word
+
+ // Below represent bits 10-1 (any value >= 512)
+ LFSX = 535 << 1, // load float-single w/ x-form
+ SRWX = 536 << 1, // Shift Right Word
+ SRDX = 539 << 1, // Shift Right Double Word
+ LFSUX = 567 << 1, // load float-single w/ update x-form
+ SYNC = 598 << 1, // Synchronize
+ LFDX = 599 << 1, // load float-double w/ x-form
+ LFDUX = 631 << 1, // load float-double w/ update X-form
+ STFSX = 663 << 1, // store float-single w/ x-form
+ STFSUX = 695 << 1, // store float-single w/ update x-form
+ STFDX = 727 << 1, // store float-double w/ x-form
+ STFDUX = 759 << 1, // store float-double w/ update x-form
+ SRAW = 792 << 1, // Shift Right Algebraic Word
+ SRAD = 794 << 1, // Shift Right Algebraic Double Word
+ SRAWIX = 824 << 1, // Shift Right Algebraic Word Immediate
+ SRADIX = 413 << 2, // Shift Right Algebraic Double Word Immediate
+ EXTSH = 922 << 1, // Extend Sign Halfword
+ EXTSB = 954 << 1, // Extend Sign Byte
+ ICBI = 982 << 1, // Instruction Cache Block Invalidate
+ EXTSW = 986 << 1 // Extend Sign Word
+};
+
+// Some use Bits 10-1 and other only 5-1 for the opcode
+enum OpcodeExt4 {
+ // Bits 5-1
+ FDIV = 18 << 1, // Floating Divide
+ FSUB = 20 << 1, // Floating Subtract
+ FADD = 21 << 1, // Floating Add
+ FSQRT = 22 << 1, // Floating Square Root
+ FSEL = 23 << 1, // Floating Select
+ FMUL = 25 << 1, // Floating Multiply
+ FMSUB = 28 << 1, // Floating Multiply-Subtract
+ FMADD = 29 << 1, // Floating Multiply-Add
+
+ // Bits 10-1
+ FCMPU = 0 << 1, // Floating Compare Unordered
+ FRSP = 12 << 1, // Floating-Point Rounding
+ FCTIW = 14 << 1, // Floating Convert to Integer Word X-form
+ FCTIWZ = 15 << 1, // Floating Convert to Integer Word with Round to Zero
+ FNEG = 40 << 1, // Floating Negate
+ MCRFS = 64 << 1, // Move to Condition Register from FPSCR
+ FMR = 72 << 1, // Floating Move Register
+ MTFSFI = 134 << 1, // Move to FPSCR Field Immediate
+ FABS = 264 << 1, // Floating Absolute Value
+ FRIM = 488 << 1, // Floating Round to Integer Minus
+ MFFS = 583 << 1, // move from FPSCR x-form
+ MTFSF = 711 << 1, // move to FPSCR fields XFL-form
+ FCFID = 846 << 1, // Floating convert from integer doubleword
+ FCTID = 814 << 1, // Floating convert from integer doubleword
+ FCTIDZ = 815 << 1 // Floating convert from integer doubleword
+};
+
+enum OpcodeExt5 {
+ // Bits 4-2
+ RLDICL = 0 << 1, // Rotate Left Double Word Immediate then Clear Left
+ RLDICR = 2 << 1, // Rotate Left Double Word Immediate then Clear Right
+ RLDIC = 4 << 1, // Rotate Left Double Word Immediate then Clear
+ RLDIMI = 6 << 1, // Rotate Left Double Word Immediate then Mask Insert
+ // Bits 4-1
+ RLDCL = 8 << 1, // Rotate Left Double Word then Clear Left
+ RLDCR = 9 << 1 // Rotate Left Double Word then Clear Right
+};
+
+// Instruction encoding bits and masks.
+enum {
+ // Instruction encoding bit
+ B1 = 1 << 1,
+ B4 = 1 << 4,
+ B5 = 1 << 5,
+ B7 = 1 << 7,
+ B8 = 1 << 8,
+ B9 = 1 << 9,
+ B12 = 1 << 12,
+ B18 = 1 << 18,
+ B19 = 1 << 19,
+ B20 = 1 << 20,
+ B22 = 1 << 22,
+ B23 = 1 << 23,
+ B24 = 1 << 24,
+ B25 = 1 << 25,
+ B26 = 1 << 26,
+ B27 = 1 << 27,
+ B28 = 1 << 28,
+ B6 = 1 << 6,
+ B10 = 1 << 10,
+ B11 = 1 << 11,
+ B16 = 1 << 16,
+ B17 = 1 << 17,
+ B21 = 1 << 21,
+
+ // Instruction bit masks
+ kCondMask = 0x1F << 21,
+ kOff12Mask = (1 << 12) - 1,
+ kImm24Mask = (1 << 24) - 1,
+ kOff16Mask = (1 << 16) - 1,
+ kImm16Mask = (1 << 16) - 1,
+ kImm26Mask = (1 << 26) - 1,
+ kBOfieldMask = 0x1f << 21,
+ kOpcodeMask = 0x3f << 26,
+ kExt1OpcodeMask = 0x3ff << 1,
+ kExt2OpcodeMask = 0x1f << 1,
+ kExt5OpcodeMask = 0x3 << 2,
+ kBOMask = 0x1f << 21,
+ kBIMask = 0x1F << 16,
+ kBDMask = 0x14 << 2,
+ kAAMask = 0x01 << 1,
+ kLKMask = 0x01,
+ kRCMask = 0x01,
+ kTOMask = 0x1f << 21
+};
+
+// the following is to differentiate different faked opcodes for
+// the BOGUS PPC instruction we invented (when bit 25 is 0) or to mark
+// different stub code (when bit 25 is 1)
+// - use primary opcode 1 for undefined instruction
+// - use bit 25 to indicate whether the opcode is for fake-arm
+// instr or stub-marker
+// - use the least significant 6-bit to indicate FAKE_OPCODE_T or
+// MARKER_T
+#define FAKE_OPCODE 1 << 26
+#define MARKER_SUBOPCODE_BIT 25
+#define MARKER_SUBOPCODE 1 << MARKER_SUBOPCODE_BIT
+#define FAKER_SUBOPCODE 0 << MARKER_SUBOPCODE_BIT
+
+enum FAKE_OPCODE_T {
+ fBKPT = 14,
+ fLastFaker // can't be more than 128 (2^^7)
+};
+#define FAKE_OPCODE_HIGH_BIT 7 // fake opcode has to fall into bit 0~7
+#define F_NEXT_AVAILABLE_STUB_MARKER 369 // must be less than 2^^9 (512)
+#define STUB_MARKER_HIGH_BIT 9 // stub marker has to fall into bit 0~9
+// -----------------------------------------------------------------------------
+// Addressing modes and instruction variants.
+
+// Overflow Exception
+enum OEBit {
+ SetOE = 1 << 10, // Set overflow exception
+ LeaveOE = 0 << 10 // No overflow exception
+};
+
+// Record bit
+enum RCBit { // Bit 0
+ SetRC = 1, // LT,GT,EQ,SO
+ LeaveRC = 0 // None
+};
+
+// Link bit
+enum LKBit { // Bit 0
+ SetLK = 1, // Load effective address of next instruction
+ LeaveLK = 0 // No action
+};
+
+enum BOfield { // Bits 25-21
+ DCBNZF = 0 << 21, // Decrement CTR; branch if CTR != 0 and condition false
+ DCBEZF = 2 << 21, // Decrement CTR; branch if CTR == 0 and condition false
+ BF = 4 << 21, // Branch if condition false
+ DCBNZT = 8 << 21, // Decrement CTR; branch if CTR != 0 and condition true
+ DCBEZT = 10 << 21, // Decrement CTR; branch if CTR == 0 and condition true
+ BT = 12 << 21, // Branch if condition true
+ DCBNZ = 16 << 21, // Decrement CTR; branch if CTR != 0
+ DCBEZ = 18 << 21, // Decrement CTR; branch if CTR == 0
+ BA = 20 << 21 // Branch always
+};
+
+#if V8_OS_AIX
+#undef CR_LT
+#undef CR_GT
+#undef CR_EQ
+#undef CR_SO
+#endif
+
+enum CRBit { CR_LT = 0, CR_GT = 1, CR_EQ = 2, CR_SO = 3, CR_FU = 3 };
+
+#define CRWIDTH 4
+
+// -----------------------------------------------------------------------------
+// Supervisor Call (svc) specific support.
+
+// Special Software Interrupt codes when used in the presence of the PPC
+// simulator.
+// svc (formerly swi) provides a 24bit immediate value. Use bits 22:0 for
+// standard SoftwareInterrupCode. Bit 23 is reserved for the stop feature.
+enum SoftwareInterruptCodes {
+ // transition to C code
+ kCallRtRedirected = 0x10,
+ // break point
+ kBreakpoint = 0x821008, // bits23-0 of 0x7d821008 = twge r2, r2
+ // stop
+ kStopCode = 1 << 23,
+ // info
+ kInfo = 0x9ff808 // bits23-0 of 0x7d9ff808 = twge r31, r31
+};
+const uint32_t kStopCodeMask = kStopCode - 1;
+const uint32_t kMaxStopCode = kStopCode - 1;
+const int32_t kDefaultStopCode = -1;
+
+// FP rounding modes.
+enum FPRoundingMode {
+ RN = 0, // Round to Nearest.
+ RZ = 1, // Round towards zero.
+ RP = 2, // Round towards Plus Infinity.
+ RM = 3, // Round towards Minus Infinity.
+
+ // Aliases.
+ kRoundToNearest = RN,
+ kRoundToZero = RZ,
+ kRoundToPlusInf = RP,
+ kRoundToMinusInf = RM
+};
+
+const uint32_t kFPRoundingModeMask = 3;
+
+enum CheckForInexactConversion {
+ kCheckForInexactConversion,
+ kDontCheckForInexactConversion
+};
+
+// -----------------------------------------------------------------------------
+// Specific instructions, constants, and masks.
+// These constants are declared in assembler-arm.cc, as they use named registers
+// and other constants.
+
+
+// add(sp, sp, 4) instruction (aka Pop())
+extern const Instr kPopInstruction;
+
+// str(r, MemOperand(sp, 4, NegPreIndex), al) instruction (aka push(r))
+// register r is not encoded.
+extern const Instr kPushRegPattern;
+
+// ldr(r, MemOperand(sp, 4, PostIndex), al) instruction (aka pop(r))
+// register r is not encoded.
+extern const Instr kPopRegPattern;
+
+// use TWI to indicate redirection call for simulation mode
+const Instr rtCallRedirInstr = TWI;
+
+// -----------------------------------------------------------------------------
+// Instruction abstraction.
+
+// The class Instruction enables access to individual fields defined in the PPC
+// architecture instruction set encoding.
+// Note that the Assembler uses typedef int32_t Instr.
+//
+// Example: Test whether the instruction at ptr does set the condition code
+// bits.
+//
+// bool InstructionSetsConditionCodes(byte* ptr) {
+// Instruction* instr = Instruction::At(ptr);
+// int type = instr->TypeValue();
+// return ((type == 0) || (type == 1)) && instr->HasS();
+// }
+//
+class Instruction {
+ public:
+ enum { kInstrSize = 4, kInstrSizeLog2 = 2, kPCReadOffset = 8 };
+
+// Helper macro to define static accessors.
+// We use the cast to char* trick to bypass the strict anti-aliasing rules.
+#define DECLARE_STATIC_TYPED_ACCESSOR(return_type, Name) \
+ static inline return_type Name(Instr instr) { \
+ char* temp = reinterpret_cast<char*>(&instr); \
+ return reinterpret_cast<Instruction*>(temp)->Name(); \
+ }
+
+#define DECLARE_STATIC_ACCESSOR(Name) DECLARE_STATIC_TYPED_ACCESSOR(int, Name)
+
+ // Get the raw instruction bits.
+ inline Instr InstructionBits() const {
+ return *reinterpret_cast<const Instr*>(this);
+ }
+
+ // Set the raw instruction bits to value.
+ inline void SetInstructionBits(Instr value) {
+ *reinterpret_cast<Instr*>(this) = value;
+ }
+
+ // Read one particular bit out of the instruction bits.
+ inline int Bit(int nr) const { return (InstructionBits() >> nr) & 1; }
+
+ // Read a bit field's value out of the instruction bits.
+ inline int Bits(int hi, int lo) const {
+ return (InstructionBits() >> lo) & ((2 << (hi - lo)) - 1);
+ }
+
+ // Read a bit field out of the instruction bits.
+ inline int BitField(int hi, int lo) const {
+ return InstructionBits() & (((2 << (hi - lo)) - 1) << lo);
+ }
+
+ // Static support.
+
+ // Read one particular bit out of the instruction bits.
+ static inline int Bit(Instr instr, int nr) { return (instr >> nr) & 1; }
+
+ // Read the value of a bit field out of the instruction bits.
+ static inline int Bits(Instr instr, int hi, int lo) {
+ return (instr >> lo) & ((2 << (hi - lo)) - 1);
+ }
+
+
+ // Read a bit field out of the instruction bits.
+ static inline int BitField(Instr instr, int hi, int lo) {
+ return instr & (((2 << (hi - lo)) - 1) << lo);
+ }
+
+ inline int RSValue() const { return Bits(25, 21); }
+ inline int RTValue() const { return Bits(25, 21); }
+ inline int RAValue() const { return Bits(20, 16); }
+ DECLARE_STATIC_ACCESSOR(RAValue);
+ inline int RBValue() const { return Bits(15, 11); }
+ DECLARE_STATIC_ACCESSOR(RBValue);
+ inline int RCValue() const { return Bits(10, 6); }
+ DECLARE_STATIC_ACCESSOR(RCValue);
+
+ inline int OpcodeValue() const { return static_cast<Opcode>(Bits(31, 26)); }
+ inline Opcode OpcodeField() const {
+ return static_cast<Opcode>(BitField(24, 21));
+ }
+
+ // Fields used in Software interrupt instructions
+ inline SoftwareInterruptCodes SvcValue() const {
+ return static_cast<SoftwareInterruptCodes>(Bits(23, 0));
+ }
+
+ // Instructions are read of out a code stream. The only way to get a
+ // reference to an instruction is to convert a pointer. There is no way
+ // to allocate or create instances of class Instruction.
+ // Use the At(pc) function to create references to Instruction.
+ static Instruction* At(byte* pc) {
+ return reinterpret_cast<Instruction*>(pc);
+ }
+
+
+ private:
+ // We need to prevent the creation of instances of class Instruction.
+ DISALLOW_IMPLICIT_CONSTRUCTORS(Instruction);
+};
+
+
+// Helper functions for converting between register numbers and names.
+class Registers {
+ public:
+ // Return the name of the register.
+ static const char* Name(int reg);
+
+ // Lookup the register number for the name provided.
+ static int Number(const char* name);
+
+ struct RegisterAlias {
+ int reg;
+ const char* name;
+ };
+
+ private:
+ static const char* names_[kNumRegisters];
+ static const RegisterAlias aliases_[];
+};
+
+// Helper functions for converting between FP register numbers and names.
+class FPRegisters {
+ public:
+ // Return the name of the register.
+ static const char* Name(int reg);
+
+ // Lookup the register number for the name provided.
+ static int Number(const char* name);
+
+ private:
+ static const char* names_[kNumFPRegisters];
+};
+}
+} // namespace v8::internal
+
+#endif // V8_PPC_CONSTANTS_PPC_H_
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// CPU specific code for ppc independent of OS goes here.
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/assembler.h"
+#include "src/macro-assembler.h"
+#include "src/simulator.h" // for cache flushing.
+
+namespace v8 {
+namespace internal {
+
+void CpuFeatures::FlushICache(void* buffer, size_t size) {
+ // Nothing to do flushing no instructions.
+ if (size == 0) {
+ return;
+ }
+
+#if defined(USE_SIMULATOR)
+ // Not generating PPC instructions for C-code. This means that we are
+ // building an PPC emulator based target. We should notify the simulator
+ // that the Icache was flushed.
+ // None of this code ends up in the snapshot so there are no issues
+ // around whether or not to generate the code when building snapshots.
+ Simulator::FlushICache(Isolate::Current()->simulator_i_cache(), buffer, size);
+#else
+
+ if (CpuFeatures::IsSupported(INSTR_AND_DATA_CACHE_COHERENCY)) {
+ __asm__ __volatile__(
+ "sync \n"
+ "icbi 0, %0 \n"
+ "isync \n"
+ : /* no output */
+ : "r"(buffer)
+ : "memory");
+ return;
+ }
+
+ const int kCacheLineSize = CpuFeatures::cache_line_size();
+ intptr_t mask = kCacheLineSize - 1;
+ byte *start =
+ reinterpret_cast<byte *>(reinterpret_cast<intptr_t>(buffer) & ~mask);
+ byte *end = static_cast<byte *>(buffer) + size;
+ for (byte *pointer = start; pointer < end; pointer += kCacheLineSize) {
+ __asm__(
+ "dcbf 0, %0 \n"
+ "sync \n"
+ "icbi 0, %0 \n"
+ "isync \n"
+ : /* no output */
+ : "r"(pointer));
+ }
+
+#endif // USE_SIMULATOR
+}
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+cscope 15 $HOME/src/v8svn/src/ppc 0001503427
+ @assembler-ppc-inl.h
+
+37 #iâdeà
+V8_PPC_ASSEMBLER_PPC_INL_H_
+
+
+38 \ 1
+ #V8_PPC_ASSEMBLER_PPC_INL_H_
+
+
+ )
+
+40 \ 2
+ ~"¤c/µc/as£mbËr-µc.h
+"
+
+42 \ 2
+ ~"¤c/as£mbËr.h
+"
+
+43 \ 2
+ ~"¤c/debug.h
+"
+
+46
+Çme¥aû
+
+ gv8
+ {
+
+47
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+50
+boÞ
+
+ gCpuF\97tu»s
+::
+SuµÜtsC¿nkshaá
+(è{ \15
+\8cue
+; }
+
+53 \1e
+ gR\96ocInfo
+::
+¶y
+(
+\9a\8d\8c_t
+
+d\96\8f
+,
+ICacheFlushMode
+
+iÿche_æush_mode
+) {
+
+54 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+ ||
+V8_OOL_CONSTANT_POOL
+
+
+55 ià(
+ gR\96ocInfo
+::
+IsIÁ\94ÇlReã»nû
+(
+rmode_
+)) {
+
+57
+As£mbËr
+::
+R\96oÿ\8bIÁ\94ÇlReã»nû
+(
+pc_
+,
+d\96\8f
+, 0,
+iÿche_æush_mode
+);
+
+65
+Add»ss
+
+ gR\96ocInfo
+::
+\8frg\91_add»ss
+() {
+
+66
+DCHECK
+(
+IsCodeT¬g\91
+(
+rmode_
+è||
+IsRuÁimeEÁry
+(rmode_));
+
+67 \15
+ gAs£mbËr
+::
+\8frg\91_add»ss_©
+(
+pc_
+,
+ho¡_
+);
+
+71
+Add»ss
+
+ gR\96ocInfo
+::
+\8frg\91_add»ss_add»ss
+() {
+
+72
+DCHECK
+(
+IsCodeT¬g\91
+(
+rmode_
+è||
+IsRuÁimeEÁry
+(rmode_) ||
+
+73
+rmode_
+ =ð
+EMBEDDED_OBJECT
+ ||\84mode_ =ð
+EXTERNAL_REFERENCE
+);
+
+75 #ià
+V8_OOL_CONSTANT_POOL
+
+
+76 ià(
+ gAs£mbËr
+::
+IsCÚ¡ªtPoÞLßdS\8f¹
+(
+pc_
+)) {
+
+79 \15
+»\9a\8b½»t_ÿ¡
+<
+Add»ss
+>(
+pc_
+);
+
+92 \15
+ g»\9a\8b½»t_ÿ¡
+<
+ gAdd»ss
+>(
+ gpc_
+);
+
+96
+Add»ss
+
+ gR\96ocInfo
+::
+cÚ¡ªt_poÞ_\92\8cy_add»ss
+() {
+
+97 #ià
+V8_OOL_CONSTANT_POOL
+
+
+98 \15
+As£mbËr
+::
+\8frg\91_cÚ¡ªt_poÞ_add»ss_©
+(
+pc_
+,
+
+99
+ho¡_
+->
+cÚ¡ªt_poÞ
+());
+
+101
+UNREACHABLE
+();
+
+102 \15
+ gNULL
+;
+
+107 \12
+ gR\96ocInfo
+::
+\8frg\91_add»ss_size
+(è{ \15
+As£mbËr
+::
+kS³c\9flT¬g\91Size
+; }
+
+110 \1e
+ gR\96ocInfo
+::
+£t_\8frg\91_add»ss
+(
+Add»ss
+
+\8frg\91
+,
+
+111
+Wr\99eB¬r\9brMode
+
+wr\99e_b¬r\9br_mode
+,
+
+112
+ICacheFlushMode
+
+iÿche_æush_mode
+) {
+
+113
+DCHECK
+(
+IsCodeT¬g\91
+(
+rmode_
+è||
+IsRuÁimeEÁry
+(rmode_));
+
+114
+ gAs£mbËr
+::
+£t_\8frg\91_add»ss_©
+(
+pc_
+,
+ho¡_
+,
+\8frg\91
+,
+iÿche_æush_mode
+);
+
+115 ià(
+ gwr\99e_b¬r\9br_mode
+ =ð
+UPDATE_WRITE_BARRIER
+ &&
+ho¡
+(è!ð
+NULL
+ &&
+
+116
+IsCodeT¬g\91
+(
+rmode_
+)) {
+
+117
+Objeù
+*
+\8frg\91_code
+ =
+Code
+::
+G\91CodeFromT¬g\91Add»ss
+(
+\8frg\91
+);
+
+118
+ho¡
+()->
+G\91H\97p
+()->
+\9aüem\92\8fl_m¬k\9ag
+()->
+RecÜdWr\99eIÁoCode
+(
+
+119
+ho¡
+(),
+this
+,
+H\97pObjeù
+::
+ÿ¡
+(
+\8frg\91_code
+));
+
+124
+Add»ss
+
+ gAs£mbËr
+::
+b»ak_add»ss_äom_»tuº_add»ss
+(Add»s
+pc
+) {
+
+125 \15
+\8frg\91_add»ss_äom_»tuº_add»ss
+(
+pc
+);
+
+129
+Add»ss
+
+ gAs£mbËr
+::
+\8frg\91_add»ss_äom_»tuº_add»ss
+(Add»s
+pc
+) {
+
+137 #ià
+V8_OOL_CONSTANT_POOL
+
+
+138 ià(
+IsCÚ¡ªtPoÞLßdEnd
+(
+pc
+ - 3 *
+kIn¡rSize
+)) {
+
+139 \15
+pc
+ - (
+kMovIn¡ruùiÚsCÚ¡ªtPoÞ
+ + 2è*
+kIn¡rSize
+;
+
+142 \15
+ gpc
+ - (
+ gkMovIn¡ruùiÚsNoCÚ¡ªtPoÞ
+ + 2è*
+ gkIn¡rSize
+;
+
+146
+Add»ss
+
+ gAs£mbËr
+::
+»tuº_add»ss_äom_ÿÎ_¡¬t
+(Add»s
+pc
+) {
+
+147 #ià
+V8_OOL_CONSTANT_POOL
+
+
+148
+Add»ss
+
+lßd_add»ss
+ =
+pc
+ + (
+kMovIn¡ruùiÚsCÚ¡ªtPoÞ
+ - 1è*
+kIn¡rSize
+;
+
+149 ià(
+IsCÚ¡ªtPoÞLßdEnd
+(
+lßd_add»ss
+))
+
+150 \15
+ gpc
+ + (
+ gkMovIn¡ruùiÚsCÚ¡ªtPoÞ
+ + 2è*
+ gkIn¡rSize
+;
+
+152 \15
+ gpc
+ + (
+ gkMovIn¡ruùiÚsNoCÚ¡ªtPoÞ
+ + 2è*
+ gkIn¡rSize
+;
+
+156
+Objeù
+*
+ gR\96ocInfo
+::
+\8frg\91_objeù
+() {
+
+157
+DCHECK
+(
+IsCodeT¬g\91
+(
+rmode_
+è||\84mode_ =ð
+EMBEDDED_OBJECT
+);
+
+158 \15
+ g»\9a\8b½»t_ÿ¡
+<
+ gObjeù
+*>(
+ gAs£mbËr
+::
+\8frg\91_add»ss_©
+(
+pc_
+,
+ho¡_
+));
+
+162
+ gHªdË
+<
+ gObjeù
+>
+ gR\96ocInfo
+::
+\8frg\91_objeù_hªdË
+(
+As£mbËr
+*
+Üig\9a
+) {
+
+163
+DCHECK
+(
+IsCodeT¬g\91
+(
+rmode_
+è||\84mode_ =ð
+EMBEDDED_OBJECT
+);
+
+164 \15
+ gHªdË
+<
+ gObjeù
+>(
+
+165
+ g»\9a\8b½»t_ÿ¡
+<
+ gObjeù
+**>(
+ gAs£mbËr
+::
+\8frg\91_add»ss_©
+(
+pc_
+,
+ho¡_
+)));
+
+169 \1e
+ gR\96ocInfo
+::
+£t_\8frg\91_objeù
+(
+Objeù
+*
+\8frg\91
+,
+
+170
+Wr\99eB¬r\9brMode
+
+wr\99e_b¬r\9br_mode
+,
+
+171
+ICacheFlushMode
+
+iÿche_æush_mode
+) {
+
+172
+DCHECK
+(
+IsCodeT¬g\91
+(
+rmode_
+è||\84mode_ =ð
+EMBEDDED_OBJECT
+);
+
+173
+ gAs£mbËr
+::
+£t_\8frg\91_add»ss_©
+(
+
+174
+pc_
+,
+ho¡_
+,
+»\9a\8b½»t_ÿ¡
+<
+Add»ss
+>(
+\8frg\91
+),
+iÿche_æush_mode
+);
+
+175 ià(
+ gwr\99e_b¬r\9br_mode
+ =ð
+UPDATE_WRITE_BARRIER
+ &&
+ho¡
+(è!ð
+NULL
+ &&
+
+176
+\8frg\91
+->
+IsH\97pObjeù
+()) {
+
+177
+ho¡
+()->
+G\91H\97p
+()->
+\9aüem\92\8fl_m¬k\9ag
+()->
+RecÜdWr\99e
+(
+
+178
+ho¡
+(), &
+MemÜy
+::
+Objeù_©
+(
+pc_
+),
+H\97pObjeù
+::
+ÿ¡
+(
+\8frg\91
+));
+
+183
+Add»ss
+
+ gR\96ocInfo
+::
+\8frg\91_»ã»nû
+() {
+
+184
+DCHECK
+(
+rmode_
+ =ð
+EXTERNAL_REFERENCE
+);
+
+185 \15
+ gAs£mbËr
+::
+\8frg\91_add»ss_©
+(
+pc_
+,
+ho¡_
+);
+
+189
+Add»ss
+
+ gR\96ocInfo
+::
+\8frg\91_ruÁime_\92\8cy
+(
+As£mbËr
+*
+Üig\9a
+) {
+
+190
+DCHECK
+(
+IsRuÁimeEÁry
+(
+rmode_
+));
+
+191 \15
+\8frg\91_add»ss
+();
+
+195 \1e
+ gR\96ocInfo
+::
+£t_\8frg\91_ruÁime_\92\8cy
+(
+Add»ss
+
+\8frg\91
+,
+
+196
+Wr\99eB¬r\9brMode
+
+wr\99e_b¬r\9br_mode
+,
+
+197
+ICacheFlushMode
+
+iÿche_æush_mode
+) {
+
+198
+DCHECK
+(
+IsRuÁimeEÁry
+(
+rmode_
+));
+
+199 ià(
+\8frg\91_add»ss
+(è!ð
+\8frg\91
+)
+
+200
+£t_\8frg\91_add»ss
+(
+\8frg\91
+,
+wr\99e_b¬r\9br_mode
+,
+iÿche_æush_mode
+);
+
+204
+ gHªdË
+<
+ gC\96l
+>
+ gR\96ocInfo
+::
+\8frg\91_ûÎ_hªdË
+() {
+
+205
+DCHECK
+(
+rmode_
+ =ð
+R\96ocInfo
+::
+CELL
+);
+
+206
+Add»ss
+
+ gadd»ss
+ =
+MemÜy
+::
+Add»ss_©
+(
+pc_
+);
+
+207 \15
+ gHªdË
+<
+ gC\96l
+>(
+ g»\9a\8b½»t_ÿ¡
+<C\96l**>(
+ gadd»ss
+));
+
+211
+C\96l
+*
+ gR\96ocInfo
+::
+\8frg\91_ûÎ
+() {
+
+212
+DCHECK
+(
+rmode_
+ =ð
+R\96ocInfo
+::
+CELL
+);
+
+213 \15
+ gC\96l
+::
+FromV®ueAdd»ss
+(
+MemÜy
+::
+Add»ss_©
+(
+pc_
+));
+
+217 \1e
+ gR\96ocInfo
+::
+£t_\8frg\91_ûÎ
+(
+C\96l
+*
+ûÎ
+,
+Wr\99eB¬r\9brMode
+
+wr\99e_b¬r\9br_mode
+,
+
+218
+ICacheFlushMode
+
+iÿche_æush_mode
+) {
+
+219
+DCHECK
+(
+rmode_
+ =ð
+R\96ocInfo
+::
+CELL
+);
+
+220
+Add»ss
+
+ gadd»ss
+ =
+ûÎ
+->
+add»ss
+(è+
+C\96l
+::
+kV®ueOff£t
+;
+
+221
+ gMemÜy
+::
+Add»ss_©
+(
+pc_
+èð
+add»ss
+;
+
+222 ià(
+ gwr\99e_b¬r\9br_mode
+ =ð
+UPDATE_WRITE_BARRIER
+ &&
+ho¡
+(è!ð
+NULL
+) {
+
+225
+ho¡
+()->
+G\91H\97p
+()->
+\9aüem\92\8fl_m¬k\9ag
+()->
+RecÜdWr\99e
+(ho¡(),
+NULL
+,
+ûÎ
+);
+
+230 #ià
+V8_OOL_CONSTANT_POOL
+
+
+231 \18cڡ \12
+ gkNoCodeAgeIn¡ruùiÚs
+ = 7;
+
+233 \18cڡ \12
+ gkNoCodeAgeIn¡ruùiÚs
+ = 6;
+
+235 \18cڡ \12
+ gkCodeAg\9agIn¡ruùiÚs
+ =
+
+236
+As£mbËr
+::
+kMovIn¡ruùiÚsNoCÚ¡ªtPoÞ
+ + 3;
+
+237 \18cڡ \12
+ gkNoCodeAgeSequ\92ûIn¡ruùiÚs
+ =
+
+238 ((
+kNoCodeAgeIn¡ruùiÚs
+ >ð
+kCodeAg\9agIn¡ruùiÚs
+)
+
+239 ?
+kNoCodeAgeIn¡ruùiÚs
+
+
+240 :
+kCodeAg\9agIn¡ruùiÚs
+);
+
+241 \18cڡ \12
+ gkNoCodeAgeSequ\92ûNÝs
+ =
+
+242 (
+kNoCodeAgeSequ\92ûIn¡ruùiÚs
+ -
+kNoCodeAgeIn¡ruùiÚs
+);
+
+243 \18cڡ \12
+ gkCodeAg\9agSequ\92ûNÝs
+ =
+
+244 (
+kNoCodeAgeSequ\92ûIn¡ruùiÚs
+ -
+kCodeAg\9agIn¡ruùiÚs
+);
+
+245 \18cڡ \12
+ gkCodeAg\9agT¬g\91D\96\8f
+ = 1 *
+As£mbËr
+::
+kIn¡rSize
+;
+
+246 \18cڡ \12
+ gkNoCodeAgeSequ\92ûL\92gth
+ =
+
+247 (
+kNoCodeAgeSequ\92ûIn¡ruùiÚs
+ *
+As£mbËr
+::
+kIn¡rSize
+);
+
+250
+ gHªdË
+<
+ gObjeù
+>
+ gR\96ocInfo
+::
+code_age_¡ub_hªdË
+(
+As£mbËr
+*
+Üig\9a
+) {
+
+251
+UNREACHABLE
+();
+
+252 \15
+ gHªdË
+<
+ gObjeù
+>();
+
+256
+Code
+*
+ gR\96ocInfo
+::
+code_age_¡ub
+() {
+
+257
+DCHECK
+(
+rmode_
+ =ð
+R\96ocInfo
+::
+CODE_AGE_SEQUENCE
+);
+
+258 \15
+ gCode
+::
+G\91CodeFromT¬g\91Add»ss
+(
+
+259
+As£mbËr
+::
+\8frg\91_add»ss_©
+(
+pc_
+ +
+kCodeAg\9agT¬g\91D\96\8f
+,
+ho¡_
+));
+
+263 \1e
+ gR\96ocInfo
+::
+£t_code_age_¡ub
+(
+Code
+*
+¡ub
+,
+
+264
+ICacheFlushMode
+
+iÿche_æush_mode
+) {
+
+265
+DCHECK
+(
+rmode_
+ =ð
+R\96ocInfo
+::
+CODE_AGE_SEQUENCE
+);
+
+266
+ gAs£mbËr
+::
+£t_\8frg\91_add»ss_©
+(
+pc_
+ +
+kCodeAg\9agT¬g\91D\96\8f
+,
+ho¡_
+,
+
+267
+¡ub
+->
+\9a¡ruùiÚ_¡¬t
+(),
+
+268
+iÿche_æush_mode
+);
+
+272
+Add»ss
+
+ gR\96ocInfo
+::
+ÿÎ_add»ss
+() {
+
+273
+DCHECK
+((
+IsJSR\91uº
+(
+rmode
+()è&&
+IsP©chedR\91uºSequ\92û
+()) ||
+
+274 (
+IsDebugB»akSlÙ
+(
+rmode
+()è&&
+IsP©chedDebugB»akSlÙSequ\92û
+()));
+
+278 \15
+ gAs£mbËr
+::
+\8frg\91_add»ss_©
+(
+pc_
+,
+ho¡_
+);
+
+282 \1e
+ gR\96ocInfo
+::
+£t_ÿÎ_add»ss
+(
+Add»ss
+
+\8frg\91
+) {
+
+283
+DCHECK
+((
+IsJSR\91uº
+(
+rmode
+()è&&
+IsP©chedR\91uºSequ\92û
+()) ||
+
+284 (
+IsDebugB»akSlÙ
+(
+rmode
+()è&&
+IsP©chedDebugB»akSlÙSequ\92û
+()));
+
+285
+ gAs£mbËr
+::
+£t_\8frg\91_add»ss_©
+(
+pc_
+,
+ho¡_
+,
+\8frg\91
+);
+
+286 ià(
+ho¡
+(è!ð
+NULL
+) {
+
+287
+Objeù
+*
+\8frg\91_code
+ =
+Code
+::
+G\91CodeFromT¬g\91Add»ss
+(
+\8frg\91
+);
+
+288
+ho¡
+()->
+G\91H\97p
+()->
+\9aüem\92\8fl_m¬k\9ag
+()->
+RecÜdWr\99eIÁoCode
+(
+
+289
+ho¡
+(),
+this
+,
+H\97pObjeù
+::
+ÿ¡
+(
+\8frg\91_code
+));
+
+294
+Objeù
+*
+ gR\96ocInfo
+::
+ÿÎ_objeù
+(è{ \15 *
+ÿÎ_objeù_add»ss
+(); }
+
+297 \1e
+ gR\96ocInfo
+::
+£t_ÿÎ_objeù
+(
+Objeù
+*
+\8frg\91
+) {
+
+298 *
+ÿÎ_objeù_add»ss
+(èð
+\8frg\91
+;
+
+302
+Objeù
+**
+ gR\96ocInfo
+::
+ÿÎ_objeù_add»ss
+() {
+
+303
+DCHECK
+((
+IsJSR\91uº
+(
+rmode
+()è&&
+IsP©chedR\91uºSequ\92û
+()) ||
+
+304 (
+IsDebugB»akSlÙ
+(
+rmode
+()è&&
+IsP©chedDebugB»akSlÙSequ\92û
+()));
+
+305 \15
+ g»\9a\8b½»t_ÿ¡
+<
+ gObjeù
+**>(
+ gpc_
+ + 2 *
+ gAs£mbËr
+::
+kIn¡rSize
+);
+
+309 \1e
+ gR\96ocInfo
+::
+W\9deOut
+() {
+
+310
+DCHECK
+(
+IsEmbeddedObjeù
+(
+rmode_
+è||
+IsCodeT¬g\91
+(rmode_) ||
+
+311
+IsRuÁimeEÁry
+(
+rmode_
+è||
+IsEx\8bº®Reã»nû
+(rmode_));
+
+312
+ gAs£mbËr
+::
+£t_\8frg\91_add»ss_©
+(
+pc_
+,
+ho¡_
+,
+NULL
+);
+
+316
+boÞ
+
+ gR\96ocInfo
+::
+IsP©chedR\91uºSequ\92û
+() {
+
+322
+In¡r
+
+\9a¡r0
+ =
+As£mbËr
+::
+\9a¡r_©
+(
+pc_
+);
+
+323
+In¡r
+
+ g\9a¡r1
+ =
+As£mbËr
+::
+\9a¡r_©
+(
+pc_
+ + 1 * As£mbËr::
+kIn¡rSize
+);
+
+324 #ià
+V8_TARGET_ARCH_PPC64
+
+
+325
+In¡r
+
+ g\9a¡r3
+ =
+As£mbËr
+::
+\9a¡r_©
+(
+pc_
+ + (3 * As£mbËr::
+kIn¡rSize
+));
+
+326
+In¡r
+
+ g\9a¡r4
+ =
+As£mbËr
+::
+\9a¡r_©
+(
+pc_
+ + (4 * As£mbËr::
+kIn¡rSize
+));
+
+327
+In¡r
+
+ gb\9a¡r
+ =
+As£mbËr
+::
+\9a¡r_©
+(
+pc_
+ + (7 * As£mbËr::
+kIn¡rSize
+));
+
+329
+In¡r
+
+ gb\9a¡r
+ =
+As£mbËr
+::
+\9a¡r_©
+(
+pc_
+ + 4 * As£mbËr::
+kIn¡rSize
+);
+
+331
+boÞ
+
+ g·tched_»tuº
+ =
+
+332 ((
+\9a¡r0
+ &
+kOpcodeMask
+è=ð
+ADDIS
+ && (
+\9a¡r1
+ & kOpcodeMaskè=ð
+ORI
+ &&
+
+333 #ià
+V8_TARGET_ARCH_PPC64
+
+
+334 (
+\9a¡r3
+ &
+kOpcodeMask
+è=ð
+ORIS
+ && (
+\9a¡r4
+ & kOpcodeMaskè=ð
+ORI
+ &&
+
+336 (
+b\9a¡r
+ == 0x7d821008));
+
+339 \15
+ g·tched_»tuº
+;
+
+343
+boÞ
+
+ gR\96ocInfo
+::
+IsP©chedDebugB»akSlÙSequ\92û
+() {
+
+344
+In¡r
+
+cu¼\92t_\9a¡r
+ =
+As£mbËr
+::
+\9a¡r_©
+(
+pc_
+);
+
+345 \15 !
+ gAs£mbËr
+::
+IsNÝ
+(
+cu¼\92t_\9a¡r
+,
+As£mbËr
+::
+DEBUG_BREAK_NOP
+);
+
+349 \1e
+ gR\96ocInfo
+::
+Vis\99
+(
+Isީe
+*
+isީe
+,
+ObjeùVis\99Ü
+*
+vis\99Ü
+) {
+
+350
+ gR\96ocInfo
+::
+Mode
+
+mode
+ =
+rmode
+();
+
+351 ià(
+ gmode
+ =ð
+R\96ocInfo
+::
+EMBEDDED_OBJECT
+) {
+
+352
+vis\99Ü
+->
+Vis\99EmbeddedPo\9a\8br
+(
+this
+);
+
+353 } \vià(
+ gR\96ocInfo
+::
+IsCodeT¬g\91
+(
+mode
+)) {
+
+354
+vis\99Ü
+->
+Vis\99CodeT¬g\91
+(
+this
+);
+
+355 } \vià(
+ gmode
+ =ð
+R\96ocInfo
+::
+CELL
+) {
+
+356
+vis\99Ü
+->
+Vis\99C\96l
+(
+this
+);
+
+357 } \vià(
+ gmode
+ =ð
+R\96ocInfo
+::
+EXTERNAL_REFERENCE
+) {
+
+358
+vis\99Ü
+->
+Vis\99Ex\8bº®Reã»nû
+(
+this
+);
+
+359 } \vià(
+ gR\96ocInfo
+::
+IsCodeAgeSequ\92û
+(
+mode
+)) {
+
+360
+vis\99Ü
+->
+Vis\99CodeAgeSequ\92û
+(
+this
+);
+
+361 } \vià(((
+ gR\96ocInfo
+::
+IsJSR\91uº
+(
+mode
+è&&
+IsP©chedR\91uºSequ\92û
+()) ||
+
+362 (
+R\96ocInfo
+::
+IsDebugB»akSlÙ
+(
+mode
+) &&
+
+363
+IsP©chedDebugB»akSlÙSequ\92û
+())) &&
+
+364
+isީe
+->
+debug
+()->
+has_b»ak_po\9ats
+()) {
+
+365
+vis\99Ü
+->
+Vis\99DebugT¬g\91
+(
+this
+);
+
+366 } \vià(
+IsRuÁimeEÁry
+(
+mode
+)) {
+
+367
+ gvis\99Ü
+->
+Vis\99RuÁimeEÁry
+(
+this
+);
+
+372
+ g\8bm¶©e
+ <
+ty³Çme
+
+ gS\8fticVis\99Ü
+>
+
+373 \1e
+ gR\96ocInfo
+::
+Vis\99
+(
+H\97p
+*
+h\97p
+) {
+
+374
+R\96ocInfo
+::
+Mode
+
+mode
+ =
+rmode
+();
+
+375 ià(
+ gmode
+ =ð
+R\96ocInfo
+::
+EMBEDDED_OBJECT
+) {
+
+376
+S\8fticVis\99Ü
+::
+Vis\99EmbeddedPo\9a\8br
+(
+h\97p
+,
+this
+);
+
+377 } \vià(
+ gR\96ocInfo
+::
+IsCodeT¬g\91
+(
+mode
+)) {
+
+378
+S\8fticVis\99Ü
+::
+Vis\99CodeT¬g\91
+(
+h\97p
+,
+this
+);
+
+379 } \vià(
+ gmode
+ =ð
+R\96ocInfo
+::
+CELL
+) {
+
+380
+S\8fticVis\99Ü
+::
+Vis\99C\96l
+(
+h\97p
+,
+this
+);
+
+381 } \vià(
+ gmode
+ =ð
+R\96ocInfo
+::
+EXTERNAL_REFERENCE
+) {
+
+382
+S\8fticVis\99Ü
+::
+Vis\99Ex\8bº®Reã»nû
+(
+this
+);
+
+383 } \vià(
+ gR\96ocInfo
+::
+IsCodeAgeSequ\92û
+(
+mode
+)) {
+
+384
+S\8fticVis\99Ü
+::
+Vis\99CodeAgeSequ\92û
+(
+h\97p
+,
+this
+);
+
+385 } \vià(
+ gh\97p
+->
+isީe
+()->
+debug
+()->
+has_b»ak_po\9ats
+() &&
+
+386 ((
+ gR\96ocInfo
+::
+IsJSR\91uº
+(
+mode
+è&&
+IsP©chedR\91uºSequ\92û
+()) ||
+
+387 (
+R\96ocInfo
+::
+IsDebugB»akSlÙ
+(
+mode
+) &&
+
+388
+IsP©chedDebugB»akSlÙSequ\92û
+()))) {
+
+389
+S\8fticVis\99Ü
+::
+Vis\99DebugT¬g\91
+(
+h\97p
+,
+this
+);
+
+390 } \vià(
+IsRuÁimeEÁry
+(
+mode
+)) {
+
+391
+ gS\8fticVis\99Ü
+::
+Vis\99RuÁimeEÁry
+(
+this
+);
+
+395
+ gO³¿nd
+::
+O³¿nd
+(
+\9a\8d\8c_t
+
+immed\9f\8b
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+) {
+
+396
+rm_
+ =
+no_»g
+;
+
+397
+ gimm_
+ =
+immed\9f\8b
+;
+
+398
+ grmode_
+ =
+rmode
+;
+
+401
+ gO³¿nd
+::
+O³¿nd
+(cڡ
+Ex\8bº®Reã»nû
+&
+f
+) {
+
+402
+rm_
+ =
+no_»g
+;
+
+403
+ gimm_
+ =
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+f
+.
+add»ss
+());
+
+404
+ grmode_
+ =
+R\96ocInfo
+::
+EXTERNAL_REFERENCE
+;
+
+407
+ gO³¿nd
+::
+O³¿nd
+(
+Smi
+*
+v®ue
+) {
+
+408
+rm_
+ =
+no_»g
+;
+
+409
+ gimm_
+ =
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+v®ue
+);
+
+410
+ grmode_
+ =
+kR\96ocInfo_NONEPTR
+;
+
+413
+ gO³¿nd
+::
+O³¿nd
+(
+Regi¡\94
+
+rm
+) {
+
+414
+rm_
+ =
+rm
+;
+
+415
+ grmode_
+ =
+kR\96ocInfo_NONEPTR
+;
+
+418 \1e
+ gAs£mbËr
+::
+CheckBufãr
+() {
+
+419 ià(
+bufãr_¥aû
+(è<ð
+kG
+) {
+
+420
+GrowBufãr
+();
+
+424 \1e
+ gAs£mbËr
+::
+CheckT¿mpÞ\9aePoÞQuick
+() {
+
+425 ià(
+pc_off£t
+(è>ð
+Ãxt_bufãr_check_
+) {
+
+426
+CheckT¿mpÞ\9aePoÞ
+();
+
+430 \1e
+ gAs£mbËr
+::
+em\99
+(
+In¡r
+
+x
+) {
+
+431
+CheckBufãr
+();
+
+432 *
+ g»\9a\8b½»t_ÿ¡
+<
+ gIn¡r
+*>(
+ gpc_
+èð
+x
+;
+
+433
+ gpc_
+ +ð
+kIn¡rSize
+;
+
+434
+CheckT¿mpÞ\9aePoÞQuick
+();
+
+437
+boÞ
+
+ gO³¿nd
+::
+is_»g
+(ècÚ¡ { \15
+rm_
+.
+is_v®id
+(); }
+
+441
+Add»ss
+
+ gAs£mbËr
+::
+\8frg\91_add»ss_©
+(Add»s
+pc
+,
+
+442
+CÚ¡ªtPoÞA¼ay
+*
+cÚ¡ªt_poÞ
+) {
+
+443
+In¡r
+
+ g\9a¡r1
+ =
+\9a¡r_©
+(
+pc
+);
+
+444
+In¡r
+
+ g\9a¡r2
+ =
+\9a¡r_©
+(
+pc
+ +
+kIn¡rSize
+);
+
+446 ià(
+IsLis
+(
+\9a¡r1
+è&&
+IsOri
+(
+\9a¡r2
+)) {
+
+447 #ià
+V8_TARGET_ARCH_PPC64
+
+
+448
+In¡r
+
+ g\9a¡r4
+ =
+\9a¡r_©
+(
+pc
+ + (3 *
+kIn¡rSize
+));
+
+449
+In¡r
+
+ g\9a¡r5
+ =
+\9a¡r_©
+(
+pc
+ + (4 *
+kIn¡rSize
+));
+
+451
+u\9at64_t
+
+ ghi
+ = (
+¡©ic_ÿ¡
+<
+u\9at32_t
+>((
+\9a¡r1
+ &
+kImm16Mask
+) << 16) |
+
+452
+¡©ic_ÿ¡
+<
+u\9at32_t
+>(
+\9a¡r2
+ &
+kImm16Mask
+));
+
+453
+u\9at64_t
+
+ glo
+ = (
+¡©ic_ÿ¡
+<
+u\9at32_t
+>((
+\9a¡r4
+ &
+kImm16Mask
+) << 16) |
+
+454
+¡©ic_ÿ¡
+<
+u\9at32_t
+>(
+\9a¡r5
+ &
+kImm16Mask
+));
+
+455 \15
+ g»\9a\8b½»t_ÿ¡
+<
+ gAdd»ss
+>((
+ ghi
+ << 32è|
+ glo
+);
+
+458 \15
+ g»\9a\8b½»t_ÿ¡
+<
+ gAdd»ss
+>(((
+ g\9a¡r1
+ &
+ gkImm16Mask
+) << 16) |
+
+459 (
+ g\9a¡r2
+ &
+ gkImm16Mask
+));
+
+462 #ià
+V8_OOL_CONSTANT_POOL
+
+
+463 \15
+ gMemÜy
+::
+Add»ss_©
+(
+\8frg\91_cÚ¡ªt_poÞ_add»ss_©
+(
+pc
+,
+cÚ¡ªt_poÞ
+));
+
+465
+DCHECK
+(
+çl£
+);
+
+466 \15 (
+ gAdd»ss
+)0;
+
+471 #ià
+V8_OOL_CONSTANT_POOL
+
+
+472
+boÞ
+
+ gAs£mbËr
+::
+IsCÚ¡ªtPoÞLßdS\8f¹
+(
+Add»ss
+
+pc
+) {
+
+473 #ià
+V8_TARGET_ARCH_PPC64
+
+
+474 ià(!
+IsLi
+(
+\9a¡r_©
+(
+pc
+))è\15
+çl£
+;
+
+475
+ gpc
+ +ð
+kIn¡rSize
+;
+
+477 \15
+G\91RA
+(
+\9a¡r_©
+(
+pc
+)).
+is
+(
+kCÚ¡ªtPoÞRegi¡\94
+);
+
+481
+boÞ
+
+ gAs£mbËr
+::
+IsCÚ¡ªtPoÞLßdEnd
+(
+Add»ss
+
+pc
+) {
+
+482 #ià
+V8_TARGET_ARCH_PPC64
+
+
+483
+pc
+ -ð
+kIn¡rSize
+;
+
+485 \15
+IsCÚ¡ªtPoÞLßdS\8f¹
+(
+pc
+);
+
+489 \12
+ gAs£mbËr
+::
+G\91CÚ¡ªtPoÞOff£t
+(
+Add»ss
+
+pc
+) {
+
+490
+DCHECK
+(
+IsCÚ¡ªtPoÞLßdS\8f¹
+(
+pc
+));
+
+491
+In¡r
+
+ g\9a¡r
+ =
+\9a¡r_©
+(
+pc
+);
+
+492 \12
+ goff£t
+ =
+SIGN_EXT_IMM16
+((
+\9a¡r
+ &
+kImm16Mask
+));
+
+493 \15
+ goff£t
+;
+
+497 \1e
+ gAs£mbËr
+::
+S\91CÚ¡ªtPoÞOff£t
+(
+Add»ss
+
+pc
+, \12
+off£t
+) {
+
+498
+DCHECK
+(
+IsCÚ¡ªtPoÞLßdS\8f¹
+(
+pc
+));
+
+499
+DCHECK
+(
+is_\9at16
+(
+off£t
+));
+
+500
+In¡r
+
+ g\9a¡r
+ =
+\9a¡r_©
+(
+pc
+);
+
+501
+ g\9a¡r
+ &ð~
+kImm16Mask
+;
+
+502
+ g\9a¡r
+ |ð(
+off£t
+ &
+kImm16Mask
+);
+
+503
+\9a¡r_©_put
+(
+pc
+,
+\9a¡r
+);
+
+507
+Add»ss
+
+ gAs£mbËr
+::
+\8frg\91_cÚ¡ªt_poÞ_add»ss_©
+(
+
+508
+Add»ss
+
+pc
+,
+CÚ¡ªtPoÞA¼ay
+*
+cÚ¡ªt_poÞ
+) {
+
+509
+Add»ss
+
+ gaddr
+ =
+»\9a\8b½»t_ÿ¡
+<Add»ss>(
+cÚ¡ªt_poÞ
+);
+
+510
+DCHECK
+(
+addr
+);
+
+511
+ gaddr
+ +ð
+G\91CÚ¡ªtPoÞOff£t
+(
+pc
+);
+
+512 \15
+ gaddr
+;
+
+521 \1e
+ gAs£mbËr
+::
+de£r\9fliz©iÚ_£t_¥ec\9fl_\8frg\91_©
+(
+
+522
+Add»ss
+
+\9a¡ruùiÚ_·ylßd
+,
+Code
+*
+code
+, Add»s
+\8frg\91
+) {
+
+523
+£t_\8frg\91_add»ss_©
+(
+\9a¡ruùiÚ_·ylßd
+,
+code
+,
+\8frg\91
+);
+
+527 \1e
+ gAs£mbËr
+::
+£t_\8frg\91_add»ss_©
+(
+Add»ss
+
+pc
+,
+
+528
+CÚ¡ªtPoÞA¼ay
+*
+cÚ¡ªt_poÞ
+,
+
+529
+Add»ss
+
+\8frg\91
+,
+
+530
+ICacheFlushMode
+
+iÿche_æush_mode
+) {
+
+531
+In¡r
+
+ g\9a¡r1
+ =
+\9a¡r_©
+(
+pc
+);
+
+532
+In¡r
+
+ g\9a¡r2
+ =
+\9a¡r_©
+(
+pc
+ +
+kIn¡rSize
+);
+
+534 ià(
+IsLis
+(
+\9a¡r1
+è&&
+IsOri
+(
+\9a¡r2
+)) {
+
+535 #ià
+V8_TARGET_ARCH_PPC64
+
+
+536
+In¡r
+
+ g\9a¡r4
+ =
+\9a¡r_©
+(
+pc
+ + (3 *
+kIn¡rSize
+));
+
+537
+In¡r
+
+ g\9a¡r5
+ =
+\9a¡r_©
+(
+pc
+ + (4 *
+kIn¡rSize
+));
+
+539
+u\9at32_t
+*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<u\9at32_t*>(
+pc
+);
+
+540
+u\9a\8d\8c_t
+
+ g\99¬g\91
+ =
+»\9a\8b½»t_ÿ¡
+<u\9a\8d\8c_t>(
+\8frg\91
+);
+
+542
+ g\9a¡r5
+ &ð~
+kImm16Mask
+;
+
+543
+ g\9a¡r5
+ |ð
+\99¬g\91
+ &
+kImm16Mask
+;
+
+544
+ g\99¬g\91
+ =
+\99¬g\91
+ >> 16;
+
+546
+ g\9a¡r4
+ &ð~
+kImm16Mask
+;
+
+547
+ g\9a¡r4
+ |ð
+\99¬g\91
+ &
+kImm16Mask
+;
+
+548
+ g\99¬g\91
+ =
+\99¬g\91
+ >> 16;
+
+550
+ g\9a¡r2
+ &ð~
+kImm16Mask
+;
+
+551
+ g\9a¡r2
+ |ð
+\99¬g\91
+ &
+kImm16Mask
+;
+
+552
+ g\99¬g\91
+ =
+\99¬g\91
+ >> 16;
+
+554
+ g\9a¡r1
+ &ð~
+kImm16Mask
+;
+
+555
+ g\9a¡r1
+ |ð
+\99¬g\91
+ &
+kImm16Mask
+;
+
+556
+ g\99¬g\91
+ =
+\99¬g\91
+ >> 16;
+
+558 *
+ gp
+ =
+\9a¡r1
+;
+
+559 *(
+ gp
+ + 1èð
+\9a¡r2
+;
+
+560 *(
+ gp
+ + 3èð
+\9a¡r4
+;
+
+561 *(
+ gp
+ + 4èð
+\9a¡r5
+;
+
+562 ià(
+ giÿche_æush_mode
+ !ð
+SKIP_ICACHE_FLUSH
+) {
+
+563
+CpuF\97tu»s
+::
+FlushICache
+(
+p
+, 5 *
+kIn¡rSize
+);
+
+566
+u\9at32_t
+*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<u\9at32_t*>(
+pc
+);
+
+567
+u\9at32_t
+
+ g\99¬g\91
+ =
+»\9a\8b½»t_ÿ¡
+<u\9at32_t>(
+\8frg\91
+);
+
+568 \12
+ glo_wÜd
+ =
+\99¬g\91
+ &
+kImm16Mask
+;
+
+569 \12
+ ghi_wÜd
+ =
+\99¬g\91
+ >> 16;
+
+570
+ g\9a¡r1
+ &ð~
+kImm16Mask
+;
+
+571
+ g\9a¡r1
+ |ð
+hi_wÜd
+;
+
+572
+ g\9a¡r2
+ &ð~
+kImm16Mask
+;
+
+573
+ g\9a¡r2
+ |ð
+lo_wÜd
+;
+
+575 *
+ gp
+ =
+\9a¡r1
+;
+
+576 *(
+ gp
+ + 1èð
+\9a¡r2
+;
+
+577 ià(
+ giÿche_æush_mode
+ !ð
+SKIP_ICACHE_FLUSH
+) {
+
+578
+CpuF\97tu»s
+::
+FlushICache
+(
+p
+, 2 *
+kIn¡rSize
+);
+
+582 #ià
+V8_OOL_CONSTANT_POOL
+
+
+583
+ gMemÜy
+::
+Add»ss_©
+(
+\8frg\91_cÚ¡ªt_poÞ_add»ss_©
+(
+pc
+,
+cÚ¡ªt_poÞ
+)) =
+
+584
+\8frg\91
+;
+
+586
+UNREACHABLE
+();
+
+ @assembler-ppc.cc
+
+37 \ 2
+ ~"¤c/v8.h
+"
+
+39 #ià
+V8_TARGET_ARCH_PPC
+
+
+41 \ 2
+ ~"¤c/ba£/b\99s.h
+"
+
+42 \ 2
+ ~"¤c/ba£/ýu.h
+"
+
+43 \ 2
+ ~"¤c/maüo-as£mbËr.h
+"
+
+44 \ 2
+ ~"¤c/µc/as£mbËr-µc-\9al.h
+"
+
+45 \ 2
+ ~"¤c/£r\9flize.h
+"
+
+47
+Çme¥aû
+
+ gv8
+ {
+
+48
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+51 \18\1d
+CpuF\97tu»sIm¶\9bdByComp\9e\94
+() {
+
+52 \1d
+ gªsw\94
+ = 0;
+
+53 \15
+ gªsw\94
+;
+
+57 \1e
+ gCpuF\97tu»s
+::
+ProbeIm¶
+(
+boÞ
+
+üoss_comp\9ee
+) {
+
+58
+suµÜ\8bd_
+ |ð
+CpuF\97tu»sIm¶\9bdByComp\9e\94
+();
+
+59
+ gÿche_l\9ae_size_
+ = 128;
+
+62 ià(
+ güoss_comp\9ee
+) \15;
+
+67 #iâdeà
+USE_SIMULATOR
+
+
+69
+ gba£
+::
+CPU
+
+ýu
+;
+
+70 #ià
+V8_TARGET_ARCH_PPC64
+
+
+71 ià(
+ gýu
+.
+·¹
+(è=ð
+ba£
+::
+CPU
+::
+PPC_POWER8
+) {
+
+72
+suµÜ\8bd_
+ |ð(1u <<
+FPR_GPR_MOV
+);
+
+75 ià(
+ gýu
+.
+·¹
+(è=ð
+ba£
+::
+CPU
+::
+PPC_POWER6
+ ||
+
+76
+ýu
+.
+·¹
+(è=ð
+ba£
+::
+CPU
+::
+PPC_POWER7
+ ||
+
+77
+ýu
+.
+·¹
+(è=ð
+ba£
+::
+CPU
+::
+PPC_POWER8
+) {
+
+78
+suµÜ\8bd_
+ |ð(1u <<
+LWSYNC
+);
+
+80 #ià
+V8_OS_LINUX
+
+
+81 ià(!(
+ gýu
+.
+·¹
+(è=ð
+ba£
+::
+CPU
+::
+PPC_G5
+ ||
+ýu
+.·¹(è=ðba£::CPU::
+PPC_G4
+)) {
+
+83
+suµÜ\8bd_
+ |ð(1u <<
+FPU
+);
+
+85 ià(
+ gýu
+.
+ÿche_l\9ae_size
+() != 0) {
+
+86
+ÿche_l\9ae_size_
+ =
+ýu
+.
+ÿche_l\9ae_size
+();
+
+88 #\96ià
+V8_OS_AIX
+
+
+90
+ gsuµÜ\8bd_
+ |ð(1u <<
+FPU
+);
+
+93
+ gsuµÜ\8bd_
+ |ð(1u <<
+FPU
+);
+
+94
+ gsuµÜ\8bd_
+ |ð(1u <<
+LWSYNC
+);
+
+95 #ià
+V8_TARGET_ARCH_PPC64
+
+
+96
+ gsuµÜ\8bd_
+ |ð(1u <<
+FPR_GPR_MOV
+);
+
+102 \1e
+ gCpuF\97tu»s
+::
+Pr\9atT¬g\91
+() {
+
+103 cڡ \ 5*
+µc_¬ch
+ =
+NULL
+;
+
+105 #ià
+V8_TARGET_ARCH_PPC64
+
+
+106
+ gµc_¬ch
+ = "ppc64";
+
+108
+ gµc_¬ch
+ = "ppc";
+
+111
+´\9atf
+("\8frg\91 %s\n",
+µc_¬ch
+);
+
+115 \1e
+ gCpuF\97tu»s
+::
+Pr\9atF\97tu»s
+() {
+
+116
+´\9atf
+("FPU=%d\n",
+CpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+FPU
+));
+
+120
+Regi¡\94
+
+ToRegi¡\94
+(\12
+num
+) {
+
+121
+DCHECK
+(
+num
+ >ð0 &&\82um <
+kNumRegi¡\94s
+);
+
+122 cڡ
+Regi¡\94
+
+ gkRegi¡\94s
+[] = {
+r0
+,
+¥
+,
+r2
+,
+r3
+,
+r4
+,
+r5
+,
+r6
+,
+r7
+,
+
+123
+r8
+,
+r9
+,
+r10
+,
+r11
+,
+\9d
+,
+r13
+,
+r14
+,
+r15
+,
+
+124
+r16
+,
+r17
+,
+r18
+,
+r19
+,
+r20
+,
+r21
+,
+r22
+,
+r23
+,
+
+125
+r24
+,
+r25
+,
+r26
+,
+r27
+,
+r28
+,
+r29
+,
+r30
+,
+å
+};
+
+126 \15
+ gkRegi¡\94s
+[
+num
+];
+
+130 cڡ \ 5*
+ gDoubËRegi¡\94
+::
+AÎoÿtiÚIndexToS\8c\9ag
+(\12
+\9adex
+) {
+
+131
+DCHECK
+(
+\9adex
+ >ð0 && index <
+kMaxNumAÎoÿ\8fbËRegi¡\94s
+);
+
+132 cڡ \ 5* cڡ
+ gÇmes
+[] = {
+
+136 \15
+ gÇmes
+[
+\9adex
+];
+
+143 cڡ \12
+ gR\96ocInfo
+::
+kAµlyMask
+ = 1 <<
+R\96ocInfo
+::
+INTERNAL_REFERENCE
+;
+
+146
+boÞ
+
+ gR\96ocInfo
+::
+IsCodedS³c\9fÎy
+() {
+
+151 \15
+\8cue
+;
+
+155
+boÞ
+
+ gR\96ocInfo
+::
+IsInCÚ¡ªtPoÞ
+() {
+
+156 #ià
+V8_OOL_CONSTANT_POOL
+
+
+157 \15
+As£mbËr
+::
+IsCÚ¡ªtPoÞLßdS\8f¹
+(
+pc_
+);
+
+159 \15
+ gçl£
+;
+
+164 \1e
+ gR\96ocInfo
+::
+P©chCode
+(
+by\8b
+*
+\9a¡ruùiÚs
+, \12
+\9a¡ruùiÚ_couÁ
+) {
+
+166
+In¡r
+*
+ gpc
+ =
+»\9a\8b½»t_ÿ¡
+<In¡r*>(
+pc_
+);
+
+167
+In¡r
+*
+ g\9a¡r
+ =
+»\9a\8b½»t_ÿ¡
+<In¡r*>(
+\9a¡ruùiÚs
+);
+
+168 \ f\12
+ gi
+ = 0; i <
+ g\9a¡ruùiÚ_couÁ
+; i++) {
+
+169 *(
+ gpc
+ +
+ gi
+èð*(
+\9a¡r
+ +
+i
+);
+
+173
+ gCpuF\97tu»s
+::
+FlushICache
+(
+pc_
+,
+\9a¡ruùiÚ_couÁ
+ *
+As£mbËr
+::
+kIn¡rSize
+);
+
+179 \1e
+ gR\96ocInfo
+::
+P©chCodeW\99hC®l
+(
+Add»ss
+
+\8frg\91
+, \12
+gu¬d_by\8bs
+) {
+
+181
+UNIMPLEMENTED
+();
+
+189
+ gO³¿nd
+::
+O³¿nd
+(
+HªdË
+<
+Objeù
+>
+hªdË
+) {
+
+190
+AÎowDeã¼edHªdËD\94eã»nû
+
+us\9ag_¿w_add»ss
+;
+
+191
+ grm_
+ =
+no_»g
+;
+
+193
+Objeù
+*
+ gobj
+ = *
+hªdË
+;
+
+194 ià(
+ gobj
+->
+IsH\97pObjeù
+()) {
+
+195
+DCHECK
+(!
+H\97pObjeù
+::
+ÿ¡
+(
+obj
+)->
+G\91H\97p
+()->
+InNewS·û
+(obj));
+
+196
+ gimm_
+ =
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+hªdË
+.
+loÿtiÚ
+());
+
+197
+ grmode_
+ =
+R\96ocInfo
+::
+EMBEDDED_OBJECT
+;
+
+200
+ gimm_
+ =
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+obj
+);
+
+201
+ grmode_
+ =
+kR\96ocInfo_NONEPTR
+;
+
+206
+ gMemO³¿nd
+::
+MemO³¿nd
+(
+Regi¡\94
+
+º
+,
+\9at32_t
+
+off£t
+) {
+
+207
+ g¿_
+ =
+º
+;
+
+208
+ grb_
+ =
+no_»g
+;
+
+209
+ goff£t_
+ =
+off£t
+;
+
+213
+ gMemO³¿nd
+::
+MemO³¿nd
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rb
+) {
+
+214
+ g¿_
+ =
+¿
+;
+
+215
+ grb_
+ =
+rb
+;
+
+216
+ goff£t_
+ = 0;
+
+224 \18cڡ \12
+ gkM\9aim®BufãrSize
+ = 4 *
+KB
+;
+
+227
+ gAs£mbËr
+::
+As£mbËr
+(
+Isީe
+*
+isީe
+, \1e*
+bufãr
+, \12
+bufãr_size
+)
+
+228 :
+As£mbËrBa£
+(
+isީe
+,
+bufãr
+,
+bufãr_size
+),
+
+229
+»cÜded_a¡_id_
+(
+Ty³F\93dbackId
+::
+NÚe
+()),
+
+230 #ià
+V8_OOL_CONSTANT_POOL
+
+
+231
+cÚ¡ªt_poÞ_bu\9ed\94_
+(),
+
+233
+pos\99iÚs_»cÜd\94_
+(
+this
+) {
+
+234
+ g»loc_\9afo_wr\99\94
+.
+R\95os\99iÚ
+(
+bufãr_
+ +
+bufãr_size_
+,
+pc_
+);
+
+236
+ gno_\8campÞ\9ae_poÞ_befÜe_
+ = 0;
+
+237
+ g\8campÞ\9ae_poÞ_blocked_á\9ag_
+ = 0;
+
+240
+ gÃxt_bufãr_check_
+ =
+
+241
+FLAG_fÜû_lÚg_b¿nches
+ ?
+kMaxIÁ
+ :
+kMaxCÚdB¿nchR\97ch
+ -
+
+242
+kMaxBlockT¿mpÞ\9aeSeùiÚSize
+;
+
+243
+ g\9a\8bº®_\8campÞ\9ae_exû±iÚ_
+ =
+çl£
+;
+
+244
+ gϡ_bound_pos_
+ = 0;
+
+245
+ g\8campÞ\9ae_em\99\8bd_
+ =
+FLAG_fÜû_lÚg_b¿nches
+;
+
+246
+ gunbound_Ïb\96s_couÁ_
+ = 0;
+
+247
+CˬRecÜdedA¡Id
+();
+
+251 \1e
+ gAs£mbËr
+::
+G\91Code
+(
+CodeDesc
+*
+desc
+) {
+
+253
+desc
+->
+bufãr
+ =
+bufãr_
+;
+
+254
+ gdesc
+->
+ gbufãr_size
+ =
+bufãr_size_
+;
+
+255
+ gdesc
+->
+ g\9a¡r_size
+ =
+pc_off£t
+();
+
+256
+ gdesc
+->
+ g»loc_size
+ = (
+bufãr_
+ +
+bufãr_size_
+è-
+»loc_\9afo_wr\99\94
+.
+pos
+();
+
+257
+ gdesc
+->
+ gÜig\9a
+ =
+this
+;
+
+261 \1e
+ gAs£mbËr
+::
+Align
+(\12
+m
+) {
+
+262 #ià
+V8_TARGET_ARCH_PPC64
+
+
+263
+DCHECK
+(
+m
+ >ð4 &&
+ba£
+::
+b\99s
+::
+IsPow\94OfTwo64
+(m));
+
+265
+DCHECK
+(
+m
+ >ð4 &&
+ba£
+::
+b\99s
+::
+IsPow\94OfTwo32
+(m));
+
+267 \1f(
+pc_off£t
+(è& (
+ gm
+ - 1)) != 0) {
+
+268
+nÝ
+();
+
+273 \1e
+ gAs£mbËr
+::
+CodeT¬g\91Align
+(è{
+Align
+(8); }
+
+276
+CÚd\99iÚ
+
+ gAs£mbËr
+::
+G\91CÚd\99iÚ
+(
+In¡r
+
+\9a¡r
+) {
+
+277 \1a
+\9a¡r
+ &
+kCÚdMask
+) {
+
+278 \ 4
+BT
+:
+
+279 \15
+eq
+;
+
+280 \ 4
+ gBF
+:
+
+281 \15
+Ã
+;
+
+283
+UNIMPLEMENTED
+();
+
+285 \15
+ g®
+;
+
+289
+boÞ
+
+ gAs£mbËr
+::
+IsLis
+(
+In¡r
+
+\9a¡r
+) {
+
+290 \15 ((
+\9a¡r
+ &
+kOpcodeMask
+è=ð
+ADDIS
+è&&
+G\91RA
+(\9a¡r).
+is
+(
+r0
+);
+
+294
+boÞ
+
+ gAs£mbËr
+::
+IsLi
+(
+In¡r
+
+\9a¡r
+) {
+
+295 \15 ((
+\9a¡r
+ &
+kOpcodeMask
+è=ð
+ADDI
+è&&
+G\91RA
+(\9a¡r).
+is
+(
+r0
+);
+
+299
+boÞ
+
+ gAs£mbËr
+::
+IsAddic
+(
+In¡r
+
+\9a¡r
+è{ \15 (\9a¡¸&
+kOpcodeMask
+è=ð
+ADDIC
+; }
+
+302
+boÞ
+
+ gAs£mbËr
+::
+IsOri
+(
+In¡r
+
+\9a¡r
+è{ \15 (\9a¡¸&
+kOpcodeMask
+è=ð
+ORI
+; }
+
+305
+boÞ
+
+ gAs£mbËr
+::
+IsB¿nch
+(
+In¡r
+
+\9a¡r
+è{ \15 ((\9a¡¸&
+kOpcodeMask
+è=ð
+BCX
+); }
+
+308
+Regi¡\94
+
+ gAs£mbËr
+::
+G\91RA
+(
+In¡r
+
+\9a¡r
+) {
+
+309
+Regi¡\94
+
+»g
+;
+
+310
+ g»g
+.
+ gcode_
+ =
+In¡ruùiÚ
+::
+RAV®ue
+(
+\9a¡r
+);
+
+311 \15
+ g»g
+;
+
+315
+Regi¡\94
+
+ gAs£mbËr
+::
+G\91RB
+(
+In¡r
+
+\9a¡r
+) {
+
+316
+Regi¡\94
+
+»g
+;
+
+317
+ g»g
+.
+ gcode_
+ =
+In¡ruùiÚ
+::
+RBV®ue
+(
+\9a¡r
+);
+
+318 \15
+ g»g
+;
+
+322 #ià
+V8_TARGET_ARCH_PPC64
+
+
+324
+boÞ
+
+ gAs£mbËr
+::
+Is64B\99LßdIÁoR12
+(
+In¡r
+
+\9a¡r1
+, In¡¸
+\9a¡r2
+, In¡¸
+\9a¡r3
+,
+
+325
+In¡r
+
+\9a¡r4
+, In¡¸
+\9a¡r5
+) {
+
+332 \15 (((
+ g\9a¡r1
+ >> 16è=ð0x3d80è&& ((
+\9a¡r2
+ >> 16) == 0x618c) &&
+
+333 (
+\9a¡r3
+ =ð0x798c07c6è&& ((
+\9a¡r4
+ >> 16) == 0x658c) &&
+
+334 ((
+\9a¡r5
+ >> 16) == 0x618c));
+
+338
+boÞ
+
+ gAs£mbËr
+::
+Is32B\99LßdIÁoR12
+(
+In¡r
+
+\9a¡r1
+, In¡¸
+\9a¡r2
+) {
+
+342 \15 (((
+ g\9a¡r1
+ >> 16è=ð0x3d80è&& ((
+\9a¡r2
+ >> 16) == 0x618c));
+
+347
+boÞ
+
+ gAs£mbËr
+::
+IsCmpRegi¡\94
+(
+In¡r
+
+\9a¡r
+) {
+
+348 \15 (((
+\9a¡r
+ &
+kOpcodeMask
+è=ð
+EXT2
+) &&
+
+349 ((
+\9a¡r
+ &
+kExt2OpcodeMask
+è=ð
+CMP
+));
+
+353
+boÞ
+
+ gAs£mbËr
+::
+IsRlw\9am
+(
+In¡r
+
+\9a¡r
+) {
+
+354 \15 ((
+\9a¡r
+ &
+kOpcodeMask
+è=ð
+RLWINMX
+);
+
+358 #ià
+V8_TARGET_ARCH_PPC64
+
+
+359
+boÞ
+
+ gAs£mbËr
+::
+IsRldiþ
+(
+In¡r
+
+\9a¡r
+) {
+
+360 \15 (((
+\9a¡r
+ &
+kOpcodeMask
+è=ð
+EXT5
+) &&
+
+361 ((
+\9a¡r
+ &
+kExt5OpcodeMask
+è=ð
+RLDICL
+));
+
+366
+boÞ
+
+ gAs£mbËr
+::
+IsCmpImmed\9f\8b
+(
+In¡r
+
+\9a¡r
+) {
+
+367 \15 ((
+\9a¡r
+ &
+kOpcodeMask
+è=ð
+CMPI
+);
+
+371
+boÞ
+
+ gAs£mbËr
+::
+IsCrS\91
+(
+In¡r
+
+\9a¡r
+) {
+
+372 \15 (((
+\9a¡r
+ &
+kOpcodeMask
+è=ð
+EXT1
+) &&
+
+373 ((
+\9a¡r
+ &
+kExt1OpcodeMask
+è=ð
+CREQV
+));
+
+377
+Regi¡\94
+
+ gAs£mbËr
+::
+G\91CmpImmed\9f\8bRegi¡\94
+(
+In¡r
+
+\9a¡r
+) {
+
+378
+DCHECK
+(
+IsCmpImmed\9f\8b
+(
+\9a¡r
+));
+
+379 \15
+G\91RA
+(
+\9a¡r
+);
+
+383 \12
+ gAs£mbËr
+::
+G\91CmpImmed\9f\8bRawImmed\9f\8b
+(
+In¡r
+
+\9a¡r
+) {
+
+384
+DCHECK
+(
+IsCmpImmed\9f\8b
+(
+\9a¡r
+));
+
+385 \15
+ g\9a¡r
+ &
+ gkOff16Mask
+;
+
+401 cڡ \12
+ gkEndOfCha\9a
+ = -4;
+
+404 \12
+ gAs£mbËr
+::
+\8frg\91_©
+(\12
+pos
+) {
+
+405
+In¡r
+
+\9a¡r
+ =
+\9a¡r_©
+(
+pos
+);
+
+407 \12
+ gÝcode
+ =
+\9a¡r
+ &
+kOpcodeMask
+;
+
+408 ià(
+ gBX
+ =ð
+Ýcode
+) {
+
+409 \12
+imm26
+ = ((
+\9a¡r
+ &
+kImm26Mask
+) << 6) >> 6;
+
+410
+ gimm26
+ &ð~(
+kAAMask
+ |
+kLKMask
+);
+
+411 ià(
+ gimm26
+ =ð0è\15
+kEndOfCha\9a
+;
+
+412 \15
+ gpos
+ +
+ gimm26
+;
+
+413 } \vià(
+ gBCX
+ =ð
+Ýcode
+) {
+
+414 \12
+imm16
+ =
+SIGN_EXT_IMM16
+((
+\9a¡r
+ &
+kImm16Mask
+));
+
+415
+ gimm16
+ &ð~(
+kAAMask
+ |
+kLKMask
+);
+
+416 ià(
+ gimm16
+ =ð0è\15
+kEndOfCha\9a
+;
+
+417 \15
+ gpos
+ +
+ gimm16
+;
+
+418 } \vià((
+ g\9a¡r
+ & ~
+ gkImm26Mask
+) == 0) {
+
+420 ià(
+\9a¡r
+ == 0) {
+
+421 \15
+kEndOfCha\9a
+;
+
+423
+\9at32_t
+
+ gimm26
+ =
+SIGN_EXT_IMM26
+(
+\9a¡r
+);
+
+424 \15 (
+ gimm26
+ +
+ gpos
+);
+
+428
+PPCPORT_UNIMPLEMENTED
+();
+
+429
+DCHECK
+(
+çl£
+);
+
+434 \1e
+ gAs£mbËr
+::
+\8frg\91_©_put
+(\12
+pos
+, \12
+\8frg\91_pos
+) {
+
+435
+In¡r
+
+ g\9a¡r
+ =
+\9a¡r_©
+(
+pos
+);
+
+436 \12
+ gÝcode
+ =
+\9a¡r
+ &
+kOpcodeMask
+;
+
+439 ià(
+ gBX
+ =ð
+Ýcode
+) {
+
+440 \12
+imm26
+ =
+\8frg\91_pos
+ -
+pos
+;
+
+441
+DCHECK
+((
+imm26
+ & (
+kAAMask
+ |
+kLKMask
+)) == 0);
+
+442
+ g\9a¡r
+ &ð((~
+kImm26Mask
+è|
+kAAMask
+ |
+kLKMask
+);
+
+443
+DCHECK
+(
+is_\9at26
+(
+imm26
+));
+
+444
+\9a¡r_©_put
+(
+pos
+,
+\9a¡r
+ | (
+imm26
+ &
+kImm26Mask
+));
+
+446 } \vià(
+ gBCX
+ =ð
+Ýcode
+) {
+
+447 \12
+imm16
+ =
+\8frg\91_pos
+ -
+pos
+;
+
+448
+DCHECK
+((
+imm16
+ & (
+kAAMask
+ |
+kLKMask
+)) == 0);
+
+449
+ g\9a¡r
+ &ð((~
+kImm16Mask
+è|
+kAAMask
+ |
+kLKMask
+);
+
+450
+DCHECK
+(
+is_\9at16
+(
+imm16
+));
+
+451
+\9a¡r_©_put
+(
+pos
+,
+\9a¡r
+ | (
+imm16
+ &
+kImm16Mask
+));
+
+453 } \vià((
+ g\9a¡r
+ & ~
+ gkImm26Mask
+) == 0) {
+
+454
+DCHECK
+(
+\8frg\91_pos
+ =ð
+kEndOfCha\9a
+ ||\81arget_pos >= 0);
+
+459
+Regi¡\94
+
+ gd¡
+ =
+r3
+;
+
+460
+DCHECK
+(
+IsNÝ
+(
+\9a¡r_©
+(
+pos
+ +
+kIn¡rSize
+)));
+
+461
+u\9at32_t
+
+ g\8frg\91
+ =
+\8frg\91_pos
+ + (
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+);
+
+462
+CodeP©ch\94
+
+·tch\94
+(
+»\9a\8b½»t_ÿ¡
+<
+by\8b
+*>(
+bufãr_
+ +
+pos
+), 2,
+
+463
+CodeP©ch\94
+::
+DONT_FLUSH
+);
+
+464 \12
+ g\8frg\91_hi
+ =
+¡©ic_ÿ¡
+<\12>(
+\8frg\91
+) >> 16;
+
+465 \12
+ g\8frg\91_lo
+ =
+¡©ic_ÿ¡
+<\12>(
+\8frg\91
+) & 0XFFFF;
+
+467
+ g·tch\94
+.
+masm
+()->
+lis
+(
+d¡
+,
+O³¿nd
+(
+SIGN_EXT_IMM16
+(
+\8frg\91_hi
+)));
+
+468
+ g·tch\94
+.
+masm
+()->
+Üi
+(
+d¡
+, d¡,
+O³¿nd
+(
+\8frg\91_lo
+));
+
+472
+DCHECK
+(
+çl£
+);
+
+476 \12
+ gAs£mbËr
+::
+max_»ach_äom
+(\12
+pos
+) {
+
+477
+In¡r
+
+\9a¡r
+ =
+\9a¡r_©
+(
+pos
+);
+
+478 \12
+ gÝcode
+ =
+\9a¡r
+ &
+kOpcodeMask
+;
+
+481 ià(
+ gBX
+ =ð
+Ýcode
+) {
+
+483 } \vià(
+ gBCX
+ =ð
+Ýcode
+) {
+
+485 } \vià((
+ g\9a¡r
+ & ~
+ gkImm26Mask
+) == 0) {
+
+490
+DCHECK
+(
+çl£
+);
+
+495 \1e
+ gAs£mbËr
+::
+b\9ad_to
+(
+Lab\96
+*
+L
+, \12
+pos
+) {
+
+496
+DCHECK
+(0 <ð
+pos
+ &&\85o <ð
+pc_off£t
+());
+
+497
+\9at32_t
+
+ g\8campÞ\9ae_pos
+ =
+kInv®idSlÙPos
+;
+
+498 ià(
+ gL
+->
+is_l\9aked
+(è&& !
+ g\8campÞ\9ae_em\99\8bd_
+) {
+
+499
+ gunbound_Ïb\96s_couÁ_
+--;
+
+500
+ gÃxt_bufãr_check_
+ +ð
+kT¿mpÞ\9aeSlÙsSize
+;
+
+503 \1f
+ gL
+->
+is_l\9aked
+()) {
+
+504 \12
+ gfixup_pos
+ =
+L
+->
+pos
+();
+
+505
+\9at32_t
+
+ goff£t
+ =
+pos
+ -
+fixup_pos
+;
+
+506 \12
+ gmaxR\97ch
+ =
+max_»ach_äom
+(
+fixup_pos
+);
+
+507
+Ãxt
+(
+L
+);
+
+508 ià(
+is_\9a\8a
+(
+off£t
+,
+maxR\97ch
+è=ð
+çl£
+) {
+
+509 ià(
+\8campÞ\9ae_pos
+ =ð
+kInv®idSlÙPos
+) {
+
+510
+\8campÞ\9ae_pos
+ =
+g\91_\8campÞ\9ae_\92\8cy
+();
+
+511
+CHECK
+(
+\8campÞ\9ae_pos
+ !ð
+kInv®idSlÙPos
+);
+
+512
+\8frg\91_©_put
+(
+\8campÞ\9ae_pos
+,
+pos
+);
+
+514
+\8frg\91_©_put
+(
+fixup_pos
+,
+\8campÞ\9ae_pos
+);
+
+516
+\8frg\91_©_put
+(
+fixup_pos
+,
+pos
+);
+
+519
+ gL
+->
+b\9ad_to
+(
+pos
+);
+
+523 ià(
+ gpos
+ >
+ gϡ_bound_pos_
+èÏ¡_bound_pos_ =
+pos
+;
+
+527 \1e
+ gAs£mbËr
+::
+b\9ad
+(
+Lab\96
+*
+L
+) {
+
+528
+DCHECK
+(!
+L
+->
+is_bound
+());
+
+529
+b\9ad_to
+(
+L
+,
+pc_off£t
+());
+
+533 \1e
+ gAs£mbËr
+::
+Ãxt
+(
+Lab\96
+*
+L
+) {
+
+534
+DCHECK
+(
+L
+->
+is_l\9aked
+());
+
+535 \12
+ gl\9ak
+ =
+\8frg\91_©
+(
+L
+->
+pos
+());
+
+536 ià(
+ gl\9ak
+ =ð
+kEndOfCha\9a
+) {
+
+537
+L
+->
+Unu£
+();
+
+539
+DCHECK
+(
+l\9ak
+ >= 0);
+
+540
+ gL
+->
+l\9ak_to
+(
+l\9ak
+);
+
+545
+boÞ
+
+ gAs£mbËr
+::
+is_ì
+(
+Lab\96
+*
+L
+,
+CÚd\99iÚ
+
+cÚd
+) {
+
+546
+DCHECK
+(
+L
+->
+is_bound
+());
+
+547 ià(
+ gL
+->
+is_bound
+(è=ð
+çl£
+) \15 false;
+
+549 \12
+ gmaxR\97ch
+ = ((
+cÚd
+ =ð
+®
+) ? 26 : 16);
+
+550 \12
+ goff£t
+ =
+L
+->
+pos
+(è-
+pc_off£t
+();
+
+552 \15
+is_\9a\8a
+(
+off£t
+,
+maxR\97ch
+);
+
+556 \1e
+ gAs£mbËr
+::
+a_fÜm
+(
+In¡r
+
+\9a¡r
+,
+DoubËRegi¡\94
+
+ät
+, DoubËRegi¡\94
+äa
+,
+
+557
+DoubËRegi¡\94
+
+äb
+,
+RCB\99
+
+r
+) {
+
+558
+em\99
+(
+\9a¡r
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äa
+.code(è*
+B16
+ |
+äb
+.code(è*
+B11
+ |
+r
+);
+
+562 \1e
+ gAs£mbËr
+::
+d_fÜm
+(
+In¡r
+
+\9a¡r
+,
+Regi¡\94
+
+¹
+, Regi¡\94
+¿
+,
+
+563 cڡ
+\9a\8d\8c_t
+
+v®
+,
+boÞ
+
+sigÃd_di¥
+) {
+
+564 ià(
+ gsigÃd_di¥
+) {
+
+565 ià(!
+is_\9at16
+(
+v®
+)) {
+
+566
+Pr\9atF
+("v® = %"
+V8PRIdPTR
+ ", 0x%"
+V8PRIxPTR
+ "\n",
+v®
+, val);
+
+568
+DCHECK
+(
+is_\9at16
+(
+v®
+));
+
+570 ià(!
+is_u\9at16
+(
+v®
+)) {
+
+571
+Pr\9atF
+("v® = %"
+V8PRIdPTR
+ ", 0x%"
+V8PRIxPTR
+
+
+573
+v®
+, v®,
+is_u\9at16
+(v®),
+kImm16Mask
+);
+
+575
+DCHECK
+(
+is_u\9at16
+(
+v®
+));
+
+577
+em\99
+(
+\9a¡r
+ |
+¹
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ | (
+kImm16Mask
+ &
+v®
+));
+
+581 \1e
+ gAs£mbËr
+::
+x_fÜm
+(
+In¡r
+
+\9a¡r
+,
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+,
+
+582
+RCB\99
+
+r
+) {
+
+583
+em\99
+(
+\9a¡r
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+r
+);
+
+587 \1e
+ gAs£mbËr
+::
+xo_fÜm
+(
+In¡r
+
+\9a¡r
+,
+Regi¡\94
+
+¹
+, Regi¡\94
+¿
+, Regi¡\94
+rb
+,
+
+588
+OEB\99
+
+o
+,
+RCB\99
+
+r
+) {
+
+589
+em\99
+(
+\9a¡r
+ |
+¹
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+o
+ |
+r
+);
+
+593 \1e
+ gAs£mbËr
+::
+md_fÜm
+(
+In¡r
+
+\9a¡r
+,
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+shiá
+,
+
+594 \12
+maskb\99
+,
+RCB\99
+
+r
+) {
+
+595 \12
+ gsh0_4
+ =
+shiá
+ & 0x1f;
+
+596 \12
+ gsh5
+ = (
+shiá
+ >> 5) & 0x1;
+
+597 \12
+ gm0_4
+ =
+maskb\99
+ & 0x1f;
+
+598 \12
+ gm5
+ = (
+maskb\99
+ >> 5) & 0x1;
+
+600
+em\99
+(
+\9a¡r
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+sh0_4
+ *
+B11
+ |
+m0_4
+ *
+B6
+ |
+
+601
+m5
+ *
+B5
+ |
+sh5
+ *
+B1
+ |
+r
+);
+
+605 \1e
+ gAs£mbËr
+::
+mds_fÜm
+(
+In¡r
+
+\9a¡r
+,
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+,
+
+606 \12
+maskb\99
+,
+RCB\99
+
+r
+) {
+
+607 \12
+ gm0_4
+ =
+maskb\99
+ & 0x1f;
+
+608 \12
+ gm5
+ = (
+maskb\99
+ >> 5) & 0x1;
+
+610
+em\99
+(
+\9a¡r
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+m0_4
+ *
+B6
+ |
+
+611
+m5
+ *
+B5
+ |
+r
+);
+
+616
+\9at32_t
+
+ gAs£mbËr
+::
+g\91_\8campÞ\9ae_\92\8cy
+() {
+
+617
+\9at32_t
+
+\8campÞ\9ae_\92\8cy
+ =
+kInv®idSlÙPos
+;
+
+619 ià(!
+ g\9a\8bº®_\8campÞ\9ae_exû±iÚ_
+) {
+
+620
+ g\8campÞ\9ae_\92\8cy
+ =
+\8campÞ\9ae_
+.
+\8fke_¦Ù
+();
+
+622 ià(
+ gkInv®idSlÙPos
+ =ð
+\8campÞ\9ae_\92\8cy
+) {
+
+623
+\9a\8bº®_\8campÞ\9ae_exû±iÚ_
+ =
+\8cue
+;
+
+626 \15
+ g\8campÞ\9ae_\92\8cy
+;
+
+630 \12
+ gAs£mbËr
+::
+b¿nch_off£t
+(
+Lab\96
+*
+L
+,
+boÞ
+
+jump_\96im\9a©iÚ_®lowed
+) {
+
+631 \12
+ g\8frg\91_pos
+;
+
+632 ià(
+ gL
+->
+is_bound
+()) {
+
+633
+ g\8frg\91_pos
+ =
+L
+->
+pos
+();
+
+635 ià(
+ gL
+->
+is_l\9aked
+()) {
+
+636
+ g\8frg\91_pos
+ =
+L
+->
+pos
+();
+
+642
+ g\8frg\91_pos
+ =
+pc_off£t
+();
+
+643 ià(!
+ g\8campÞ\9ae_em\99\8bd_
+) {
+
+644
+ gunbound_Ïb\96s_couÁ_
+++;
+
+645
+ gÃxt_bufãr_check_
+ -ð
+kT¿mpÞ\9aeSlÙsSize
+;
+
+648
+ gL
+->
+l\9ak_to
+(
+pc_off£t
+());
+
+651 \15
+ g\8frg\91_pos
+ -
+pc_off£t
+();
+
+658 \1e
+ gAs£mbËr
+::
+bþr
+(
+BOf\9bld
+
+bo
+,
+LKB\99
+
+lk
+) {
+
+659
+pos\99iÚs_»cÜd\94
+()->
+Wr\99eRecÜdedPos\99iÚs
+();
+
+660
+em\99
+(
+EXT1
+ |
+bo
+ |
+BCLRX
+ |
+lk
+);
+
+664 \1e
+ gAs£mbËr
+::
+bcùr
+(
+BOf\9bld
+
+bo
+,
+LKB\99
+
+lk
+) {
+
+665
+pos\99iÚs_»cÜd\94
+()->
+Wr\99eRecÜdedPos\99iÚs
+();
+
+666
+em\99
+(
+EXT1
+ |
+bo
+ |
+BCCTRX
+ |
+lk
+);
+
+671 \1e
+ gAs£mbËr
+::
+bÌ
+(è{
+bþr
+(
+BA
+,
+L\97veLK
+); }
+
+675 \1e
+ gAs£mbËr
+::
+bùr
+(è{
+bcùr
+(
+BA
+,
+L\97veLK
+); }
+
+678 \1e
+ gAs£mbËr
+::
+bù¾
+(è{
+bcùr
+(
+BA
+,
+S\91LK
+); }
+
+681 \1e
+ gAs£mbËr
+::
+bc
+(\12
+b¿nch_off£t
+,
+BOf\9bld
+
+bo
+, \12
+cÚd\99iÚ_b\99
+,
+LKB\99
+
+lk
+) {
+
+682 ià(
+ glk
+ =ð
+S\91LK
+) {
+
+683
+pos\99iÚs_»cÜd\94
+()->
+Wr\99eRecÜdedPos\99iÚs
+();
+
+685
+DCHECK
+(
+is_\9at16
+(
+b¿nch_off£t
+));
+
+686
+em\99
+(
+BCX
+ |
+bo
+ |
+cÚd\99iÚ_b\99
+ *
+B16
+ | (
+kImm16Mask
+ &
+b¿nch_off£t
+è|
+lk
+);
+
+690 \1e
+ gAs£mbËr
+::
+b
+(\12
+b¿nch_off£t
+,
+LKB\99
+
+lk
+) {
+
+691 ià(
+ glk
+ =ð
+S\91LK
+) {
+
+692
+pos\99iÚs_»cÜd\94
+()->
+Wr\99eRecÜdedPos\99iÚs
+();
+
+694
+DCHECK
+((
+b¿nch_off£t
+ & 3) == 0);
+
+695 \12
+ gimm26
+ =
+b¿nch_off£t
+;
+
+696
+DCHECK
+(
+is_\9at26
+(
+imm26
+));
+
+698
+em\99
+(
+BX
+ | (
+imm26
+ &
+kImm26Mask
+è|
+lk
+);
+
+702 \1e
+ gAs£mbËr
+::
+xÜi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+703
+d_fÜm
+(
+XORI
+,
+¤c
+,
+d¡
+,
+imm
+.
+imm_
+,
+çl£
+);
+
+707 \1e
+ gAs£mbËr
+::
+xÜis
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+708
+d_fÜm
+(
+XORIS
+,
+rs
+,
+¿
+,
+imm
+.
+imm_
+,
+çl£
+);
+
+712 \1e
+ gAs£mbËr
+::
+xÜ_
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+rc
+) {
+
+713
+x_fÜm
+(
+EXT2
+ |
+XORX
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+rc
+);
+
+717 \1e
+ gAs£mbËr
+::
+ú\8ezw_
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+,
+RCB\99
+
+rc
+) {
+
+718
+x_fÜm
+(
+EXT2
+ |
+CNTLZWX
+,
+¿
+,
+rs
+,
+r0
+,
+rc
+);
+
+722 \1e
+ gAs£mbËr
+::
+ªd_
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+,
+RCB\99
+
+rc
+) {
+
+723
+x_fÜm
+(
+EXT2
+ |
+ANDX
+,
+¿
+,
+rs
+,
+rb
+,
+rc
+);
+
+727 \1e
+ gAs£mbËr
+::
+¾w\9am
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+, \12
+mb
+, \12
+me
+,
+
+728
+RCB\99
+
+rc
+) {
+
+729
+ gsh
+ &= 0x1f;
+
+730
+ gmb
+ &= 0x1f;
+
+731
+ gme
+ &= 0x1f;
+
+732
+em\99
+(
+RLWINMX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+sh
+ *
+B11
+ |
+mb
+ *
+B6
+ |
+
+733
+me
+ << 1 |
+rc
+);
+
+737 \1e
+ gAs£mbËr
+::
+¾wnm
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+, \12
+mb
+, \12
+me
+,
+
+738
+RCB\99
+
+rc
+) {
+
+739
+ gmb
+ &= 0x1f;
+
+740
+ gme
+ &= 0x1f;
+
+741
+em\99
+(
+RLWNMX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+mb
+ *
+B6
+ |
+
+742
+me
+ << 1 |
+rc
+);
+
+746 \1e
+ gAs£mbËr
+::
+¾wimi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+, \12
+mb
+, \12
+me
+,
+
+747
+RCB\99
+
+rc
+) {
+
+748
+ gsh
+ &= 0x1f;
+
+749
+ gmb
+ &= 0x1f;
+
+750
+ gme
+ &= 0x1f;
+
+751
+em\99
+(
+RLWIMIX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+sh
+ *
+B11
+ |
+mb
+ *
+B6
+ |
+
+752
+me
+ << 1 |
+rc
+);
+
+756 \1e
+ gAs£mbËr
+::
+¦wi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+RCB\99
+
+rc
+) {
+
+757
+DCHECK
+((32 >
+v®
+.
+imm_
+) && (val.imm_ >= 0));
+
+758
+¾w\9am
+(
+d¡
+,
+¤c
+,
+v®
+.
+imm_
+, 0, 31 - v®.imm_,
+rc
+);
+
+762 \1e
+ gAs£mbËr
+::
+¤wi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+RCB\99
+
+rc
+) {
+
+763
+DCHECK
+((32 >
+v®
+.
+imm_
+) && (val.imm_ >= 0));
+
+764
+¾w\9am
+(
+d¡
+,
+¤c
+, 32 -
+v®
+.
+imm_
+, v®.imm_, 31,
+rc
+);
+
+768 \1e
+ gAs£mbËr
+::
+þ¼wi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+
+769
+RCB\99
+
+rc
+) {
+
+770
+DCHECK
+((32 >
+v®
+.
+imm_
+) && (val.imm_ >= 0));
+
+771
+¾w\9am
+(
+d¡
+,
+¤c
+, 0, 0, 31 -
+v®
+.
+imm_
+,
+rc
+);
+
+775 \1e
+ gAs£mbËr
+::
+þ¾wi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+
+776
+RCB\99
+
+rc
+) {
+
+777
+DCHECK
+((32 >
+v®
+.
+imm_
+) && (val.imm_ >= 0));
+
+778
+¾w\9am
+(
+d¡
+,
+¤c
+, 0,
+v®
+.
+imm_
+, 31,
+rc
+);
+
+782 \1e
+ gAs£mbËr
+::
+¤awi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+,
+RCB\99
+
+r
+) {
+
+783
+em\99
+(
+EXT2
+ |
+SRAWIX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+sh
+ *
+B11
+ |
+r
+);
+
+787 \1e
+ gAs£mbËr
+::
+¤w
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+r
+) {
+
+788
+x_fÜm
+(
+EXT2
+ |
+SRWX
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+r
+);
+
+792 \1e
+ gAs£mbËr
+::
+¦w
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+r
+) {
+
+793
+x_fÜm
+(
+EXT2
+ |
+SLWX
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+r
+);
+
+797 \1e
+ gAs£mbËr
+::
+¤aw
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+,
+RCB\99
+
+r
+) {
+
+798
+x_fÜm
+(
+EXT2
+ |
+SRAW
+,
+¿
+,
+rs
+,
+rb
+,
+r
+);
+
+802 \1e
+ gAs£mbËr
+::
+rÙlw
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+,
+RCB\99
+
+r
+) {
+
+803
+¾wnm
+(
+¿
+,
+rs
+,
+rb
+, 0, 31,
+r
+);
+
+807 \1e
+ gAs£mbËr
+::
+rÙlwi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+,
+RCB\99
+
+r
+) {
+
+808
+¾w\9am
+(
+¿
+,
+rs
+,
+sh
+, 0, 31,
+r
+);
+
+812 \1e
+ gAs£mbËr
+::
+rÙrwi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+,
+RCB\99
+
+r
+) {
+
+813
+¾w\9am
+(
+¿
+,
+rs
+, 32 -
+sh
+, 0, 31,
+r
+);
+
+817 \1e
+ gAs£mbËr
+::
+subi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+818
+addi
+(
+d¡
+,
+¤c
+,
+O³¿nd
+(-(
+imm
+.
+imm_
+)));
+
+821 \1e
+ gAs£mbËr
+::
+addc
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+,
+
+822
+RCB\99
+
+r
+) {
+
+823
+xo_fÜm
+(
+EXT2
+ |
+ADDCX
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+o
+,
+r
+);
+
+827 \1e
+ gAs£mbËr
+::
+addze
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+,
+OEB\99
+
+o
+,
+RCB\99
+
+r
+) {
+
+829
+em\99
+(
+EXT2
+ |
+ADDZEX
+ |
+d¡
+.
+code
+(è*
+B21
+ |
+¤c1
+.code(è*
+B16
+ |
+o
+ |
+r
+);
+
+833 \1e
+ gAs£mbËr
+::
+sub
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+,
+
+834
+RCB\99
+
+r
+) {
+
+835
+xo_fÜm
+(
+EXT2
+ |
+SUBFX
+,
+d¡
+,
+¤c2
+,
+¤c1
+,
+o
+,
+r
+);
+
+839 \1e
+ gAs£mbËr
+::
+subfc
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+,
+
+840
+RCB\99
+
+r
+) {
+
+841
+xo_fÜm
+(
+EXT2
+ |
+SUBFCX
+,
+d¡
+,
+¤c2
+,
+¤c1
+,
+o
+,
+r
+);
+
+845 \1e
+ gAs£mbËr
+::
+subfic
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+846
+d_fÜm
+(
+SUBFIC
+,
+d¡
+,
+¤c
+,
+imm
+.
+imm_
+,
+\8cue
+);
+
+850 \1e
+ gAs£mbËr
+::
+add
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+,
+
+851
+RCB\99
+
+r
+) {
+
+852
+xo_fÜm
+(
+EXT2
+ |
+ADDX
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+o
+,
+r
+);
+
+857 \1e
+ gAs£mbËr
+::
+muÎw
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+,
+
+858
+RCB\99
+
+r
+) {
+
+859
+xo_fÜm
+(
+EXT2
+ |
+MULLW
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+o
+,
+r
+);
+
+864 \1e
+ gAs£mbËr
+::
+mulhw
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+,
+
+865
+RCB\99
+
+r
+) {
+
+866
+xo_fÜm
+(
+EXT2
+ |
+MULHWX
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+o
+,
+r
+);
+
+871 \1e
+ gAs£mbËr
+::
+divw
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+,
+
+872
+RCB\99
+
+r
+) {
+
+873
+xo_fÜm
+(
+EXT2
+ |
+DIVW
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+o
+,
+r
+);
+
+877 \1e
+ gAs£mbËr
+::
+addi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+878
+DCHECK
+(!
+¤c
+.
+is
+(
+r0
+));
+
+879
+d_fÜm
+(
+ADDI
+,
+d¡
+,
+¤c
+,
+imm
+.
+imm_
+,
+\8cue
+);
+
+883 \1e
+ gAs£mbËr
+::
+addis
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+884
+DCHECK
+(!
+¤c
+.
+is
+(
+r0
+));
+
+885
+d_fÜm
+(
+ADDIS
+,
+d¡
+,
+¤c
+,
+imm
+.
+imm_
+,
+\8cue
+);
+
+889 \1e
+ gAs£mbËr
+::
+addic
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+890
+d_fÜm
+(
+ADDIC
+,
+d¡
+,
+¤c
+,
+imm
+.
+imm_
+,
+\8cue
+);
+
+894 \1e
+ gAs£mbËr
+::
+ªdi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+895
+d_fÜm
+(
+ANDIx
+,
+rs
+,
+¿
+,
+imm
+.
+imm_
+,
+çl£
+);
+
+899 \1e
+ gAs£mbËr
+::
+ªdis
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+900
+d_fÜm
+(
+ANDISx
+,
+rs
+,
+¿
+,
+imm
+.
+imm_
+,
+çl£
+);
+
+904 \1e
+ gAs£mbËr
+::
+nÜ
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+r
+) {
+
+905
+x_fÜm
+(
+EXT2
+ |
+NORX
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+r
+);
+
+909 \1e
+ gAs£mbËr
+::
+nÙx
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+RCB\99
+
+r
+) {
+
+910
+x_fÜm
+(
+EXT2
+ |
+NORX
+,
+d¡
+,
+¤c
+, src,
+r
+);
+
+914 \1e
+ gAs£mbËr
+::
+Üi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+915
+d_fÜm
+(
+ORI
+,
+rs
+,
+¿
+,
+imm
+.
+imm_
+,
+çl£
+);
+
+919 \1e
+ gAs£mbËr
+::
+Üis
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+920
+d_fÜm
+(
+ORIS
+,
+¤c
+,
+d¡
+,
+imm
+.
+imm_
+,
+çl£
+);
+
+924 \1e
+ gAs£mbËr
+::
+Üx
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+rc
+) {
+
+925
+x_fÜm
+(
+EXT2
+ |
+ORX
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+rc
+);
+
+929 \1e
+ gAs£mbËr
+::
+cmpi
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+,
+CRegi¡\94
+
+ü
+) {
+
+930
+\9a\8d\8c_t
+
+ gimm16
+ =
+¤c2
+.
+imm_
+;
+
+931 #ià
+V8_TARGET_ARCH_PPC64
+
+
+932 \12
+ gL
+ = 1;
+
+934 \12
+ gL
+ = 0;
+
+936
+DCHECK
+(
+is_\9at16
+(
+imm16
+));
+
+937
+DCHECK
+(
+ü
+.
+code
+() >= 0 && cr.code() <= 7);
+
+938
+ gimm16
+ &ð
+kImm16Mask
+;
+
+939
+em\99
+(
+CMPI
+ |
+ü
+.
+code
+(è*
+B23
+ |
+L
+ *
+B21
+ |
+¤c1
+.code(è*
+B16
+ |
+imm16
+);
+
+943 \1e
+ gAs£mbËr
+::
+cm¶i
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+,
+CRegi¡\94
+
+ü
+) {
+
+944
+u\9a\8d\8c_t
+
+ guimm16
+ =
+¤c2
+.
+imm_
+;
+
+945 #ià
+V8_TARGET_ARCH_PPC64
+
+
+946 \12
+ gL
+ = 1;
+
+948 \12
+ gL
+ = 0;
+
+950
+DCHECK
+(
+is_u\9at16
+(
+uimm16
+));
+
+951
+DCHECK
+(
+ü
+.
+code
+() >= 0 && cr.code() <= 7);
+
+952
+ guimm16
+ &ð
+kImm16Mask
+;
+
+953
+em\99
+(
+CMPLI
+ |
+ü
+.
+code
+(è*
+B23
+ |
+L
+ *
+B21
+ |
+¤c1
+.code(è*
+B16
+ |
+uimm16
+);
+
+957 \1e
+ gAs£mbËr
+::
+cmp
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+,
+CRegi¡\94
+
+ü
+) {
+
+958 #ià
+V8_TARGET_ARCH_PPC64
+
+
+959 \12
+ gL
+ = 1;
+
+961 \12
+ gL
+ = 0;
+
+963
+DCHECK
+(
+ü
+.
+code
+() >= 0 && cr.code() <= 7);
+
+964
+em\99
+(
+EXT2
+ |
+CMP
+ |
+ü
+.
+code
+(è*
+B23
+ |
+L
+ *
+B21
+ |
+¤c1
+.code(è*
+B16
+ |
+
+965
+¤c2
+.
+code
+(è*
+B11
+);
+
+969 \1e
+ gAs£mbËr
+::
+cm¶
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+,
+CRegi¡\94
+
+ü
+) {
+
+970 #ià
+V8_TARGET_ARCH_PPC64
+
+
+971 \12
+ gL
+ = 1;
+
+973 \12
+ gL
+ = 0;
+
+975
+DCHECK
+(
+ü
+.
+code
+() >= 0 && cr.code() <= 7);
+
+976
+em\99
+(
+EXT2
+ |
+CMPL
+ |
+ü
+.
+code
+(è*
+B23
+ |
+L
+ *
+B21
+ |
+¤c1
+.code(è*
+B16
+ |
+
+977
+¤c2
+.
+code
+(è*
+B11
+);
+
+981 \1e
+ gAs£mbËr
+::
+cmpwi
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+,
+CRegi¡\94
+
+ü
+) {
+
+982
+\9a\8d\8c_t
+
+ gimm16
+ =
+¤c2
+.
+imm_
+;
+
+983 \12
+ gL
+ = 0;
+
+984
+DCHECK
+(
+is_\9at16
+(
+imm16
+));
+
+985
+DCHECK
+(
+ü
+.
+code
+() >= 0 && cr.code() <= 7);
+
+986
+ gimm16
+ &ð
+kImm16Mask
+;
+
+987
+em\99
+(
+CMPI
+ |
+ü
+.
+code
+(è*
+B23
+ |
+L
+ *
+B21
+ |
+¤c1
+.code(è*
+B16
+ |
+imm16
+);
+
+991 \1e
+ gAs£mbËr
+::
+cm¶wi
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+,
+CRegi¡\94
+
+ü
+) {
+
+992
+u\9a\8d\8c_t
+
+ guimm16
+ =
+¤c2
+.
+imm_
+;
+
+993 \12
+ gL
+ = 0;
+
+994
+DCHECK
+(
+is_u\9at16
+(
+uimm16
+));
+
+995
+DCHECK
+(
+ü
+.
+code
+() >= 0 && cr.code() <= 7);
+
+996
+ guimm16
+ &ð
+kImm16Mask
+;
+
+997
+em\99
+(
+CMPLI
+ |
+ü
+.
+code
+(è*
+B23
+ |
+L
+ *
+B21
+ |
+¤c1
+.code(è*
+B16
+ |
+uimm16
+);
+
+1001 \1e
+ gAs£mbËr
+::
+cmpw
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+,
+CRegi¡\94
+
+ü
+) {
+
+1002 \12
+ gL
+ = 0;
+
+1003
+DCHECK
+(
+ü
+.
+code
+() >= 0 && cr.code() <= 7);
+
+1004
+em\99
+(
+EXT2
+ |
+CMP
+ |
+ü
+.
+code
+(è*
+B23
+ |
+L
+ *
+B21
+ |
+¤c1
+.code(è*
+B16
+ |
+
+1005
+¤c2
+.
+code
+(è*
+B11
+);
+
+1009 \1e
+ gAs£mbËr
+::
+cm¶w
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+,
+CRegi¡\94
+
+ü
+) {
+
+1010 \12
+ gL
+ = 0;
+
+1011
+DCHECK
+(
+ü
+.
+code
+() >= 0 && cr.code() <= 7);
+
+1012
+em\99
+(
+EXT2
+ |
+CMPL
+ |
+ü
+.
+code
+(è*
+B23
+ |
+L
+ *
+B21
+ |
+¤c1
+.code(è*
+B16
+ |
+
+1013
+¤c2
+.
+code
+(è*
+B11
+);
+
+1018 \1e
+ gAs£mbËr
+::
+li
+(
+Regi¡\94
+
+d¡
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+1019
+d_fÜm
+(
+ADDI
+,
+d¡
+,
+r0
+,
+imm
+.
+imm_
+,
+\8cue
+);
+
+1023 \1e
+ gAs£mbËr
+::
+lis
+(
+Regi¡\94
+
+d¡
+, cڡ
+O³¿nd
+&
+imm
+) {
+
+1024
+d_fÜm
+(
+ADDIS
+,
+d¡
+,
+r0
+,
+imm
+.
+imm_
+,
+\8cue
+);
+
+1029 \1e
+ gAs£mbËr
+::
+mr
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+) {
+
+1031
+Üx
+(
+d¡
+,
+¤c
+, src);
+
+1035 \1e
+ gAs£mbËr
+::
+lbz
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1036
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1037
+d_fÜm
+(
+LBZ
+,
+d¡
+,
+¤c
+.
+¿
+(), src.
+off£t
+(),
+\8cue
+);
+
+1041 \1e
+ gAs£mbËr
+::
+lbzx
+(
+Regi¡\94
+
+¹
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1042
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1043
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1044
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1045
+em\99
+(
+EXT2
+ |
+LBZX
+ |
+¹
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1046
+L\97veRC
+);
+
+1050 \1e
+ gAs£mbËr
+::
+lbzux
+(
+Regi¡\94
+
+¹
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1051
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1052
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1053
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1054
+em\99
+(
+EXT2
+ |
+LBZUX
+ |
+¹
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1055
+L\97veRC
+);
+
+1059 \1e
+ gAs£mbËr
+::
+lhz
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1060
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1061
+d_fÜm
+(
+LHZ
+,
+d¡
+,
+¤c
+.
+¿
+(), src.
+off£t
+(),
+\8cue
+);
+
+1065 \1e
+ gAs£mbËr
+::
+lhzx
+(
+Regi¡\94
+
+¹
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1066
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1067
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1068
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1069
+em\99
+(
+EXT2
+ |
+LHZX
+ |
+¹
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1070
+L\97veRC
+);
+
+1074 \1e
+ gAs£mbËr
+::
+lhzux
+(
+Regi¡\94
+
+¹
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1075
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1076
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1077
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1078
+em\99
+(
+EXT2
+ |
+LHZUX
+ |
+¹
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1079
+L\97veRC
+);
+
+1083 \1e
+ gAs£mbËr
+::
+lwz
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1084
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1085
+d_fÜm
+(
+LWZ
+,
+d¡
+,
+¤c
+.
+¿
+(), src.
+off£t
+(),
+\8cue
+);
+
+1089 \1e
+ gAs£mbËr
+::
+lwzu
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1090
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1091
+d_fÜm
+(
+LWZU
+,
+d¡
+,
+¤c
+.
+¿
+(), src.
+off£t
+(),
+\8cue
+);
+
+1095 \1e
+ gAs£mbËr
+::
+lwzx
+(
+Regi¡\94
+
+¹
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1096
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1097
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1098
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1099
+em\99
+(
+EXT2
+ |
+LWZX
+ |
+¹
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1100
+L\97veRC
+);
+
+1104 \1e
+ gAs£mbËr
+::
+lwzux
+(
+Regi¡\94
+
+¹
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1105
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1106
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1107
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1108
+em\99
+(
+EXT2
+ |
+LWZUX
+ |
+¹
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1109
+L\97veRC
+);
+
+1113 \1e
+ gAs£mbËr
+::
+lwa
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1114 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1115 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1116
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1117
+DCHECK
+(!(
+off£t
+ & 3è&&
+is_\9at16
+(offset));
+
+1118
+ goff£t
+ =
+kImm16Mask
+ &
+off£t
+;
+
+1119
+em\99
+(
+LD
+ |
+d¡
+.
+code
+(è*
+B21
+ |
+¤c
+.
+¿
+().code(è*
+B16
+ |
+off£t
+ | 2);
+
+1121
+lwz
+(
+d¡
+,
+¤c
+);
+
+1126 \1e
+ gAs£mbËr
+::
+¡b
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1127
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1128
+d_fÜm
+(
+STB
+,
+d¡
+,
+¤c
+.
+¿
+(), src.
+off£t
+(),
+\8cue
+);
+
+1132 \1e
+ gAs£mbËr
+::
+¡bx
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1133
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1134
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1135
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1136
+em\99
+(
+EXT2
+ |
+STBX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1137
+L\97veRC
+);
+
+1141 \1e
+ gAs£mbËr
+::
+¡bux
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1142
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1143
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1144
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1145
+em\99
+(
+EXT2
+ |
+STBUX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1146
+L\97veRC
+);
+
+1150 \1e
+ gAs£mbËr
+::
+¡h
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1151
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1152
+d_fÜm
+(
+STH
+,
+d¡
+,
+¤c
+.
+¿
+(), src.
+off£t
+(),
+\8cue
+);
+
+1156 \1e
+ gAs£mbËr
+::
+¡hx
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1157
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1158
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1159
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1160
+em\99
+(
+EXT2
+ |
+STHX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1161
+L\97veRC
+);
+
+1165 \1e
+ gAs£mbËr
+::
+¡hux
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1166
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1167
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1168
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1169
+em\99
+(
+EXT2
+ |
+STHUX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1170
+L\97veRC
+);
+
+1174 \1e
+ gAs£mbËr
+::
+¡w
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1175
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1176
+d_fÜm
+(
+STW
+,
+d¡
+,
+¤c
+.
+¿
+(), src.
+off£t
+(),
+\8cue
+);
+
+1180 \1e
+ gAs£mbËr
+::
+¡wu
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1181
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1182
+d_fÜm
+(
+STWU
+,
+d¡
+,
+¤c
+.
+¿
+(), src.
+off£t
+(),
+\8cue
+);
+
+1186 \1e
+ gAs£mbËr
+::
+¡wx
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1187
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1188
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1189
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1190
+em\99
+(
+EXT2
+ |
+STWX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1191
+L\97veRC
+);
+
+1195 \1e
+ gAs£mbËr
+::
+¡wux
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1196
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1197
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1198
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1199
+em\99
+(
+EXT2
+ |
+STWUX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1200
+L\97veRC
+);
+
+1204 \1e
+ gAs£mbËr
+::
+extsb
+(
+Regi¡\94
+
+rs
+, Regi¡\94
+¿
+,
+RCB\99
+
+rc
+) {
+
+1205
+em\99
+(
+EXT2
+ |
+EXTSB
+ |
+¿
+.
+code
+(è*
+B21
+ |
+rs
+.code(è*
+B16
+ |
+rc
+);
+
+1209 \1e
+ gAs£mbËr
+::
+extsh
+(
+Regi¡\94
+
+rs
+, Regi¡\94
+¿
+,
+RCB\99
+
+rc
+) {
+
+1210
+em\99
+(
+EXT2
+ |
+EXTSH
+ |
+¿
+.
+code
+(è*
+B21
+ |
+rs
+.code(è*
+B16
+ |
+rc
+);
+
+1214 \1e
+ gAs£mbËr
+::
+Ãg
+(
+Regi¡\94
+
+¹
+, Regi¡\94
+¿
+,
+OEB\99
+
+o
+,
+RCB\99
+
+r
+) {
+
+1215
+em\99
+(
+EXT2
+ |
+NEGX
+ |
+¹
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+o
+ |
+r
+);
+
+1219 \1e
+ gAs£mbËr
+::
+ªdc
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+rc
+) {
+
+1220
+x_fÜm
+(
+EXT2
+ |
+ANDCX
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+rc
+);
+
+1224 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1226 \1e
+ gAs£mbËr
+::
+ld
+(
+Regi¡\94
+
+rd
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1227 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1228
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1229
+DCHECK
+(!(
+off£t
+ & 3è&&
+is_\9at16
+(offset));
+
+1230
+ goff£t
+ =
+kImm16Mask
+ &
+off£t
+;
+
+1231
+em\99
+(
+LD
+ |
+rd
+.
+code
+(è*
+B21
+ |
+¤c
+.
+¿
+().code(è*
+B16
+ |
+off£t
+);
+
+1235 \1e
+ gAs£mbËr
+::
+ldx
+(
+Regi¡\94
+
+rd
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1236
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1237
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1238
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1239
+em\99
+(
+EXT2
+ |
+LDX
+ |
+rd
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+);
+
+1243 \1e
+ gAs£mbËr
+::
+ldu
+(
+Regi¡\94
+
+rd
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1244 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1245
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1246
+DCHECK
+(!(
+off£t
+ & 3è&&
+is_\9at16
+(offset));
+
+1247
+ goff£t
+ =
+kImm16Mask
+ &
+off£t
+;
+
+1248
+em\99
+(
+LD
+ |
+rd
+.
+code
+(è*
+B21
+ |
+¤c
+.
+¿
+().code(è*
+B16
+ |
+off£t
+ | 1);
+
+1252 \1e
+ gAs£mbËr
+::
+ldux
+(
+Regi¡\94
+
+rd
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1253
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1254
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1255
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1256
+em\99
+(
+EXT2
+ |
+LDUX
+ |
+rd
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+);
+
+1260 \1e
+ gAs£mbËr
+::
+¡d
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1261 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1262
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1263
+DCHECK
+(!(
+off£t
+ & 3è&&
+is_\9at16
+(offset));
+
+1264
+ goff£t
+ =
+kImm16Mask
+ &
+off£t
+;
+
+1265
+em\99
+(
+STD
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¤c
+.
+¿
+().code(è*
+B16
+ |
+off£t
+);
+
+1269 \1e
+ gAs£mbËr
+::
+¡dx
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1270
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1271
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1272
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1273
+em\99
+(
+EXT2
+ |
+STDX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+);
+
+1277 \1e
+ gAs£mbËr
+::
+¡du
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1278 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1279
+DCHECK
+(!
+¤c
+.
+¿_
+.
+is
+(
+r0
+));
+
+1280
+DCHECK
+(!(
+off£t
+ & 3è&&
+is_\9at16
+(offset));
+
+1281
+ goff£t
+ =
+kImm16Mask
+ &
+off£t
+;
+
+1282
+em\99
+(
+STD
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¤c
+.
+¿
+().code(è*
+B16
+ |
+off£t
+ | 1);
+
+1286 \1e
+ gAs£mbËr
+::
+¡dux
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1287
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1288
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1289
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1290
+em\99
+(
+EXT2
+ |
+STDUX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+);
+
+1294 \1e
+ gAs£mbËr
+::
+¾dic
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+, \12
+mb
+,
+RCB\99
+
+r
+) {
+
+1295
+md_fÜm
+(
+EXT5
+ |
+RLDIC
+,
+¿
+,
+rs
+,
+sh
+,
+mb
+,
+r
+);
+
+1299 \1e
+ gAs£mbËr
+::
+¾diþ
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+, \12
+mb
+,
+RCB\99
+
+r
+) {
+
+1300
+md_fÜm
+(
+EXT5
+ |
+RLDICL
+,
+¿
+,
+rs
+,
+sh
+,
+mb
+,
+r
+);
+
+1304 \1e
+ gAs£mbËr
+::
+¾dþ
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+, \12
+mb
+,
+RCB\99
+
+r
+) {
+
+1305
+mds_fÜm
+(
+EXT5
+ |
+RLDCL
+,
+¿
+,
+rs
+,
+rb
+,
+mb
+,
+r
+);
+
+1309 \1e
+ gAs£mbËr
+::
+¾diü
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+, \12
+me
+,
+RCB\99
+
+r
+) {
+
+1310
+md_fÜm
+(
+EXT5
+ |
+RLDICR
+,
+¿
+,
+rs
+,
+sh
+,
+me
+,
+r
+);
+
+1314 \1e
+ gAs£mbËr
+::
+¦di
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+RCB\99
+
+rc
+) {
+
+1315
+DCHECK
+((64 >
+v®
+.
+imm_
+) && (val.imm_ >= 0));
+
+1316
+¾diü
+(
+d¡
+,
+¤c
+,
+v®
+.
+imm_
+, 63 - v®.imm_,
+rc
+);
+
+1320 \1e
+ gAs£mbËr
+::
+¤di
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+RCB\99
+
+rc
+) {
+
+1321
+DCHECK
+((64 >
+v®
+.
+imm_
+) && (val.imm_ >= 0));
+
+1322
+¾diþ
+(
+d¡
+,
+¤c
+, 64 -
+v®
+.
+imm_
+, v®.imm_,
+rc
+);
+
+1326 \1e
+ gAs£mbËr
+::
+þ¼di
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+
+1327
+RCB\99
+
+rc
+) {
+
+1328
+DCHECK
+((64 >
+v®
+.
+imm_
+) && (val.imm_ >= 0));
+
+1329
+¾diü
+(
+d¡
+,
+¤c
+, 0, 63 -
+v®
+.
+imm_
+,
+rc
+);
+
+1333 \1e
+ gAs£mbËr
+::
+þ¾di
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+
+1334
+RCB\99
+
+rc
+) {
+
+1335
+DCHECK
+((64 >
+v®
+.
+imm_
+) && (val.imm_ >= 0));
+
+1336
+¾diþ
+(
+d¡
+,
+¤c
+, 0,
+v®
+.
+imm_
+,
+rc
+);
+
+1340 \1e
+ gAs£mbËr
+::
+¾dimi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+, \12
+mb
+,
+RCB\99
+
+r
+) {
+
+1341
+md_fÜm
+(
+EXT5
+ |
+RLDIMI
+,
+¿
+,
+rs
+,
+sh
+,
+mb
+,
+r
+);
+
+1345 \1e
+ gAs£mbËr
+::
+¤adi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+,
+RCB\99
+
+r
+) {
+
+1346 \12
+ gsh0_4
+ =
+sh
+ & 0x1f;
+
+1347 \12
+ gsh5
+ = (
+sh
+ >> 5) & 0x1;
+
+1349
+em\99
+(
+EXT2
+ |
+SRADIX
+ |
+rs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+sh0_4
+ *
+B11
+ |
+
+1350
+sh5
+ *
+B1
+ |
+r
+);
+
+1354 \1e
+ gAs£mbËr
+::
+¤d
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+r
+) {
+
+1355
+x_fÜm
+(
+EXT2
+ |
+SRDX
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+r
+);
+
+1359 \1e
+ gAs£mbËr
+::
+¦d
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+r
+) {
+
+1360
+x_fÜm
+(
+EXT2
+ |
+SLDX
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+r
+);
+
+1364 \1e
+ gAs£mbËr
+::
+¤ad
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+,
+RCB\99
+
+r
+) {
+
+1365
+x_fÜm
+(
+EXT2
+ |
+SRAD
+,
+¿
+,
+rs
+,
+rb
+,
+r
+);
+
+1369 \1e
+ gAs£mbËr
+::
+rÙld
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+,
+RCB\99
+
+r
+) {
+
+1370
+¾dþ
+(
+¿
+,
+rs
+,
+rb
+, 0,
+r
+);
+
+1374 \1e
+ gAs£mbËr
+::
+rÙldi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+,
+RCB\99
+
+r
+) {
+
+1375
+¾diþ
+(
+¿
+,
+rs
+,
+sh
+, 0,
+r
+);
+
+1379 \1e
+ gAs£mbËr
+::
+rÙrdi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+,
+RCB\99
+
+r
+) {
+
+1380
+¾diþ
+(
+¿
+,
+rs
+, 64 -
+sh
+, 0,
+r
+);
+
+1384 \1e
+ gAs£mbËr
+::
+ú\8ezd_
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+,
+RCB\99
+
+rc
+) {
+
+1385
+x_fÜm
+(
+EXT2
+ |
+CNTLZDX
+,
+¿
+,
+rs
+,
+r0
+,
+rc
+);
+
+1389 \1e
+ gAs£mbËr
+::
+extsw
+(
+Regi¡\94
+
+rs
+, Regi¡\94
+¿
+,
+RCB\99
+
+rc
+) {
+
+1390
+em\99
+(
+EXT2
+ |
+EXTSW
+ |
+¿
+.
+code
+(è*
+B21
+ |
+rs
+.code(è*
+B16
+ |
+rc
+);
+
+1394 \1e
+ gAs£mbËr
+::
+muÎd
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+,
+
+1395
+RCB\99
+
+r
+) {
+
+1396
+xo_fÜm
+(
+EXT2
+ |
+MULLD
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+o
+,
+r
+);
+
+1400 \1e
+ gAs£mbËr
+::
+divd
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+,
+
+1401
+RCB\99
+
+r
+) {
+
+1402
+xo_fÜm
+(
+EXT2
+ |
+DIVD
+,
+d¡
+,
+¤c1
+,
+¤c2
+,
+o
+,
+r
+);
+
+1407 \1e
+ gAs£mbËr
+::
+çke_asm
+(\f
+FAKE_OPCODE_T
+
+fÝcode
+) {
+
+1408
+DCHECK
+(
+fÝcode
+ <
+fLa¡Fak\94
+);
+
+1409
+em\99
+(
+FAKE_OPCODE
+ |
+FAKER_SUBOPCODE
+ |
+fÝcode
+);
+
+1413 \1e
+ gAs£mbËr
+::
+m¬k\94_asm
+(\12
+mcode
+) {
+
+1414 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim_¡ubs
+) {
+
+1415
+DCHECK
+(
+mcode
+ <
+F_NEXT_AVAILABLE_STUB_MARKER
+);
+
+1416
+em\99
+(
+FAKE_OPCODE
+ |
+MARKER_SUBOPCODE
+ |
+mcode
+);
+
+1424 \1e
+ gAs£mbËr
+::
+funùiÚ_desü\9dtÜ
+() {
+
+1425
+DCHECK
+(
+pc_off£t
+() == 0);
+
+1426
+RecÜdR\96ocInfo
+(
+R\96ocInfo
+::
+INTERNAL_REFERENCE
+);
+
+1427
+em\99_±r
+(
+»\9a\8b½»t_ÿ¡
+<
+u\9a\8d\8c_t
+>(
+pc_
+è+ 3 *
+kPo\9a\8brSize
+);
+
+1428
+em\99_±r
+(0);
+
+1429
+em\99_±r
+(0);
+
+1433 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+ ||
+V8_OOL_CONSTANT_POOL
+
+
+1434 \1e
+ gAs£mbËr
+::
+R\96oÿ\8bIÁ\94ÇlReã»nû
+(
+Add»ss
+
+pc
+,
+\9a\8d\8c_t
+
+d\96\8f
+,
+
+1435
+Add»ss
+
+code_¡¬t
+,
+
+1436
+ICacheFlushMode
+
+iÿche_æush_mode
+) {
+
+1437
+DCHECK
+(
+d\96\8f
+ ||
+code_¡¬t
+);
+
+1438 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+
+
+1439
+u\9a\8d\8c_t
+*
+ gfd
+ =
+»\9a\8b½»t_ÿ¡
+<u\9a\8d\8c_t*>(
+pc
+);
+
+1440 ià(
+ gfd
+[1] =ð0 &&
+fd
+[2] == 0) {
+
+1442 ià(
+d\96\8f
+) {
+
+1443
+fd
+[0] +ð
+d\96\8f
+;
+
+1445
+ gfd
+[0] =
+»\9a\8b½»t_ÿ¡
+<
+u\9a\8d\8c_t
+>(
+code_¡¬t
+è+ 3 *
+kPo\9a\8brSize
+;
+
+1450 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1452
+CÚ¡ªtPoÞA¼ay
+*
+ gcÚ¡ªt_poÞ
+ =
+NULL
+;
+
+1453 ià(
+ gd\96\8f
+) {
+
+1454
+ gcode_¡¬t
+ =
+\8frg\91_add»ss_©
+(
+pc
+,
+cÚ¡ªt_poÞ
+è+
+ gd\96\8f
+;
+
+1456
+£t_\8frg\91_add»ss_©
+(
+pc
+,
+cÚ¡ªt_poÞ
+,
+code_¡¬t
+,
+iÿche_æush_mode
+);
+
+1461 \12
+ gAs£mbËr
+::
+DecodeIÁ\94ÇlReã»nû
+(
+VeùÜ
+<\ 5>
+bufãr
+,
+Add»ss
+
+pc
+) {
+
+1462 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+
+
+1463
+u\9a\8d\8c_t
+*
+ gfd
+ =
+»\9a\8b½»t_ÿ¡
+<u\9a\8d\8c_t*>(
+pc
+);
+
+1464 ià(
+ gfd
+[1] =ð0 &&
+fd
+[2] == 0) {
+
+1466
+SNPr\9atF
+(
+bufãr
+, "[%08"
+V8PRIxPTR
+ ", %08" V8PRIxPTR ", %08" V8PRIxPTR
+
+1469
+fd
+[0], fd[1], fd[2]);
+
+1470 \15
+ gkPo\9a\8brSize
+ * 3;
+
+1478 \12
+ gAs£mbËr
+::
+\9a¡ruùiÚs_»qu\9ced_fÜ_mov
+(cڡ
+O³¿nd
+&
+x
+) const {
+
+1479 #ià
+V8_OOL_CONSTANT_POOL
+ ||
+DEBUG
+
+
+1480
+boÞ
+
+ÿnO±imize
+ =
+
+1481 !(
+x
+.
+mu¡_ou\8dut_»loc_\9afo
+(
+this
+è||
+is_\8campÞ\9ae_poÞ_blocked
+());
+
+1483 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1484 ià(
+u£_cÚ¡ªt_poÞ_fÜ_mov
+(
+x
+,
+ÿnO±imize
+)) {
+
+1487 \15
+ gkMovIn¡ruùiÚsCÚ¡ªtPoÞ
+;
+
+1490
+DCHECK
+(!
+ÿnO±imize
+);
+
+1491 \15
+ gkMovIn¡ruùiÚsNoCÚ¡ªtPoÞ
+;
+
+1495 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1496
+boÞ
+
+ gAs£mbËr
+::
+u£_cÚ¡ªt_poÞ_fÜ_mov
+(cڡ
+O³¿nd
+&
+x
+,
+
+1497
+boÞ
+
+ÿnO±imize
+) const {
+
+1498 ià(!
+is_oÞ_cÚ¡ªt_poÞ_ava\9eabË
+(è||
+is_cÚ¡ªt_poÞ_fuÎ
+()) {
+
+1501 \15
+ gçl£
+;
+
+1504
+\9a\8d\8c_t
+
+ gv®ue
+ =
+x
+.
+immed\9f\8b
+();
+
+1505 ià(
+ gÿnO±imize
+ &&
+is_\9at16
+(
+v®ue
+)) {
+
+1507 \15
+ gçl£
+;
+
+1510 \15
+ g\8cue
+;
+
+1514 \1e
+ gAs£mbËr
+::
+Ensu»S·ûFÜ
+(\12
+¥aû_Ãeded
+) {
+
+1515 ià(
+bufãr_¥aû
+(è<ð(
+kG
+ +
+¥aû_Ãeded
+)) {
+
+1516
+GrowBufãr
+();
+
+1522
+boÞ
+
+ gO³¿nd
+::
+mu¡_ou\8dut_»loc_\9afo
+(cڡ
+As£mbËr
+*
+as£mbËr
+) const {
+
+1523 ià(
+rmode_
+ =ð
+R\96ocInfo
+::
+EXTERNAL_REFERENCE
+) {
+
+1524 ià(
+as£mbËr
+ !ð
+NULL
+ &&\87s£mbËr->
+´ediùabË_code_size
+()è\15
+\8cue
+;
+
+1525 \15
+ gas£mbËr
+->
+£r\9fliz\94_\92abËd
+();
+
+1526 } \vià(
+ gR\96ocInfo
+::
+IsNÚe
+(
+rmode_
+)) {
+
+1527 \15
+çl£
+;
+
+1529 \15
+ g\8cue
+;
+
+1539 \1e
+ gAs£mbËr
+::
+mov
+(
+Regi¡\94
+
+d¡
+, cڡ
+O³¿nd
+&
+¤c
+) {
+
+1540
+\9a\8d\8c_t
+
+ gv®ue
+ =
+¤c
+.
+immed\9f\8b
+();
+
+1541
+boÞ
+
+ gÿnO±imize
+;
+
+1542
+R\96ocInfo
+
+r\9afo
+(
+pc_
+,
+¤c
+.
+rmode_
+,
+v®ue
+,
+NULL
+);
+
+1544 ià(
+ g¤c
+.
+mu¡_ou\8dut_»loc_\9afo
+(
+this
+)) {
+
+1545
+RecÜdR\96ocInfo
+(
+r\9afo
+);
+
+1548
+ gÿnO±imize
+ =
+
+1549 !(
+¤c
+.
+mu¡_ou\8dut_»loc_\9afo
+(
+this
+è||
+is_\8campÞ\9ae_poÞ_blocked
+());
+
+1551 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1552 ià(
+u£_cÚ¡ªt_poÞ_fÜ_mov
+(
+¤c
+,
+ÿnO±imize
+)) {
+
+1553
+DCHECK
+(
+is_oÞ_cÚ¡ªt_poÞ_ava\9eabË
+());
+
+1554
+CÚ¡ªtPoÞAddEÁry
+(
+r\9afo
+);
+
+1555 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1556
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+this
+);
+
+1559
+li
+(
+d¡
+,
+O³¿nd
+::
+Z\94o
+());
+
+1560
+ldx
+(
+d¡
+,
+MemO³¿nd
+(
+kCÚ¡ªtPoÞRegi¡\94
+, dst));
+
+1562
+lwz
+(
+d¡
+,
+MemO³¿nd
+(
+kCÚ¡ªtPoÞRegi¡\94
+, 0));
+
+1568 ià(
+ gÿnO±imize
+) {
+
+1569 ià(
+is_\9at16
+(
+v®ue
+)) {
+
+1570
+li
+(
+d¡
+,
+O³¿nd
+(
+v®ue
+));
+
+1572
+u\9at16_t
+
+ gu16
+;
+
+1573 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1574 ià(
+is_\9at32
+(
+v®ue
+)) {
+
+1576
+lis
+(
+d¡
+,
+O³¿nd
+(
+v®ue
+ >> 16));
+
+1577 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1579 ià(
+is_\9at48
+(
+v®ue
+)) {
+
+1580
+li
+(
+d¡
+,
+O³¿nd
+(
+v®ue
+ >> 32));
+
+1582
+lis
+(
+d¡
+,
+O³¿nd
+(
+v®ue
+ >> 48));
+
+1583
+ gu16
+ = ((
+v®ue
+ >> 32) & 0xffff);
+
+1584 ià(
+ gu16
+) {
+
+1585
+Üi
+(
+d¡
+, d¡,
+O³¿nd
+(
+u16
+));
+
+1588
+¦di
+(
+d¡
+, d¡,
+O³¿nd
+(32));
+
+1589
+ gu16
+ = ((
+v®ue
+ >> 16) & 0xffff);
+
+1590 ià(
+ gu16
+) {
+
+1591
+Üis
+(
+d¡
+, d¡,
+O³¿nd
+(
+u16
+));
+
+1595
+ gu16
+ = (
+v®ue
+ & 0xffff);
+
+1596 ià(
+ gu16
+) {
+
+1597
+Üi
+(
+d¡
+, d¡,
+O³¿nd
+(
+u16
+));
+
+1603
+DCHECK
+(!
+ÿnO±imize
+);
+
+1606
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+this
+);
+
+1607 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1608
+\9at32_t
+
+ ghi_32
+ =
+¡©ic_ÿ¡
+<\9at32_t>(
+v®ue
+ >> 32);
+
+1609
+\9at32_t
+
+ glo_32
+ =
+¡©ic_ÿ¡
+<\9at32_t>(
+v®ue
+);
+
+1610 \12
+ ghi_wÜd
+ =
+¡©ic_ÿ¡
+<\12>(
+hi_32
+ >> 16);
+
+1611 \12
+ glo_wÜd
+ =
+¡©ic_ÿ¡
+<\12>(
+hi_32
+ & 0xffff);
+
+1612
+lis
+(
+d¡
+,
+O³¿nd
+(
+SIGN_EXT_IMM16
+(
+hi_wÜd
+)));
+
+1613
+Üi
+(
+d¡
+, d¡,
+O³¿nd
+(
+lo_wÜd
+));
+
+1614
+¦di
+(
+d¡
+, d¡,
+O³¿nd
+(32));
+
+1615
+ ghi_wÜd
+ =
+¡©ic_ÿ¡
+<\12>(((
+lo_32
+ >> 16) & 0xffff));
+
+1616
+ glo_wÜd
+ =
+¡©ic_ÿ¡
+<\12>(
+lo_32
+ & 0xffff);
+
+1617
+Üis
+(
+d¡
+, d¡,
+O³¿nd
+(
+hi_wÜd
+));
+
+1618
+Üi
+(
+d¡
+, d¡,
+O³¿nd
+(
+lo_wÜd
+));
+
+1620 \12
+ ghi_wÜd
+ =
+¡©ic_ÿ¡
+<\12>(
+v®ue
+ >> 16);
+
+1621 \12
+ glo_wÜd
+ =
+¡©ic_ÿ¡
+<\12>(
+v®ue
+ & 0xffff);
+
+1622
+lis
+(
+d¡
+,
+O³¿nd
+(
+SIGN_EXT_IMM16
+(
+hi_wÜd
+)));
+
+1623
+Üi
+(
+d¡
+, d¡,
+O³¿nd
+(
+lo_wÜd
+));
+
+1629 \1e
+ gAs£mbËr
+::
+mov_Ïb\96_off£t
+(
+Regi¡\94
+
+d¡
+,
+Lab\96
+*
+Ïb\96
+) {
+
+1630 ià(
+ gÏb\96
+->
+is_bound
+()) {
+
+1631 \12
+ g\8frg\91
+ =
+Ïb\96
+->
+pos
+();
+
+1632
+mov
+(
+d¡
+,
+O³¿nd
+(
+\8frg\91
+ +
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+1634
+boÞ
+
+ gis_l\9aked
+ =
+Ïb\96
+->
+is_l\9aked
+();
+
+1637
+DCHECK
+(
+d¡
+.
+is
+(
+r3
+));
+
+1638 \12
+ gl\9ak
+ =
+is_l\9aked
+ ?
+Ïb\96
+->
+pos
+(è-
+pc_off£t
+() : 0;
+
+1639
+ gÏb\96
+->
+l\9ak_to
+(
+pc_off£t
+());
+
+1641 ià(!
+ gis_l\9aked
+ && !
+ g\8campÞ\9ae_em\99\8bd_
+) {
+
+1642
+ gunbound_Ïb\96s_couÁ_
+++;
+
+1643
+ gÃxt_bufãr_check_
+ -ð
+kT¿mpÞ\9aeSlÙsSize
+;
+
+1653
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+this
+);
+
+1654
+em\99
+(
+l\9ak
+);
+
+1655
+nÝ
+();
+
+1661 \1e
+ gAs£mbËr
+::
+üxÜ
+(\12
+bt
+, \12
+ba
+, \12
+bb
+) {
+
+1662
+em\99
+(
+EXT1
+ |
+CRXOR
+ |
+bt
+ *
+B21
+ |
+ba
+ *
+B16
+ |
+bb
+ *
+B11
+);
+
+1666 \1e
+ gAs£mbËr
+::
+üeqv
+(\12
+bt
+, \12
+ba
+, \12
+bb
+) {
+
+1667
+em\99
+(
+EXT1
+ |
+CREQV
+ |
+bt
+ *
+B21
+ |
+ba
+ *
+B16
+ |
+bb
+ *
+B11
+);
+
+1671 \1e
+ gAs£mbËr
+::
+mær
+(
+Regi¡\94
+
+d¡
+) {
+
+1672
+em\99
+(
+EXT2
+ |
+MFSPR
+ |
+d¡
+.
+code
+(è*
+B21
+ | 256 << 11);
+
+1676 \1e
+ gAs£mbËr
+::
+m\8er
+(
+Regi¡\94
+
+¤c
+) {
+
+1677
+em\99
+(
+EXT2
+ |
+MTSPR
+ |
+¤c
+.
+code
+(è*
+B21
+ | 256 << 11);
+
+1681 \1e
+ gAs£mbËr
+::
+mtùr
+(
+Regi¡\94
+
+¤c
+) {
+
+1682
+em\99
+(
+EXT2
+ |
+MTSPR
+ |
+¤c
+.
+code
+(è*
+B21
+ | 288 << 11);
+
+1686 \1e
+ gAs£mbËr
+::
+mtx\94
+(
+Regi¡\94
+
+¤c
+) {
+
+1687
+em\99
+(
+EXT2
+ |
+MTSPR
+ |
+¤c
+.
+code
+(è*
+B21
+ | 32 << 11);
+
+1691 \1e
+ gAs£mbËr
+::
+müfs
+(\12
+bf
+, \12
+bç
+) {
+
+1692
+em\99
+(
+EXT4
+ |
+MCRFS
+ |
+bf
+ *
+B23
+ |
+bç
+ *
+B18
+);
+
+1696 \1e
+ gAs£mbËr
+::
+mfü
+(
+Regi¡\94
+
+d¡
+è{
+em\99
+(
+EXT2
+ |
+MFCR
+ | d¡.
+code
+(è*
+B21
+); }
+
+1699 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1700 \1e
+ gAs£mbËr
+::
+mfård
+(
+Regi¡\94
+
+d¡
+,
+DoubËRegi¡\94
+
+¤c
+) {
+
+1701
+em\99
+(
+EXT2
+ |
+MFVSRD
+ |
+¤c
+.
+code
+(è*
+B21
+ |
+d¡
+.code(è*
+B16
+);
+
+1705 \1e
+ gAs£mbËr
+::
+mfårwz
+(
+Regi¡\94
+
+d¡
+,
+DoubËRegi¡\94
+
+¤c
+) {
+
+1706
+em\99
+(
+EXT2
+ |
+MFVSRWZ
+ |
+¤c
+.
+code
+(è*
+B21
+ |
+d¡
+.code(è*
+B16
+);
+
+1710 \1e
+ gAs£mbËr
+::
+mtård
+(
+DoubËRegi¡\94
+
+d¡
+,
+Regi¡\94
+
+¤c
+) {
+
+1711
+em\99
+(
+EXT2
+ |
+MTVSRD
+ |
+d¡
+.
+code
+(è*
+B21
+ |
+¤c
+.code(è*
+B16
+);
+
+1715 \1e
+ gAs£mbËr
+::
+mtårwz
+(
+DoubËRegi¡\94
+
+d¡
+,
+Regi¡\94
+
+¤c
+) {
+
+1716
+em\99
+(
+EXT2
+ |
+MTVSRWZ
+ |
+d¡
+.
+code
+(è*
+B21
+ |
+¤c
+.code(è*
+B16
+);
+
+1720 \1e
+ gAs£mbËr
+::
+mtårwa
+(
+DoubËRegi¡\94
+
+d¡
+,
+Regi¡\94
+
+¤c
+) {
+
+1721
+em\99
+(
+EXT2
+ |
+MTVSRWA
+ |
+d¡
+.
+code
+(è*
+B21
+ |
+¤c
+.code(è*
+B16
+);
+
+1729 \1e
+ gAs£mbËr
+::
+¡Ý
+(cڡ \ 5*
+msg
+,
+CÚd\99iÚ
+
+cÚd
+,
+\9at32_t
+
+code
+,
+
+1730
+CRegi¡\94
+
+ü
+) {
+
+1731 ià(
+ gcÚd
+ !ð
+®
+) {
+
+1732
+Lab\96
+
+sk\9d
+;
+
+1733
+b
+(
+Neg©eCÚd\99iÚ
+(
+cÚd
+), &
+sk\9d
+,
+ü
+);
+
+1734
+bk±
+(0);
+
+1735
+b\9ad
+(&
+sk\9d
+);
+
+1737
+bk±
+(0);
+
+1742 \1e
+ gAs£mbËr
+::
+bk±
+(
+u\9at32_t
+
+imm16
+è{
+em\99
+(0x7d821008); }
+
+1745 \1e
+ gAs£mbËr
+::
+\9afo
+(cڡ \ 5*
+msg
+,
+CÚd\99iÚ
+
+cÚd
+,
+\9at32_t
+
+code
+,
+
+1746
+CRegi¡\94
+
+ü
+) {
+
+1747 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim_¡ubs
+) {
+
+1748
+em\99
+(0x7d9ff808);
+
+1749 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1750
+u\9at64_t
+
+ gv®ue
+ =
+»\9a\8b½»t_ÿ¡
+<u\9at64_t>(
+msg
+);
+
+1751
+em\99
+(
+¡©ic_ÿ¡
+<
+u\9at32_t
+>(
+v®ue
+ >> 32));
+
+1752
+em\99
+(
+¡©ic_ÿ¡
+<
+u\9at32_t
+>(
+v®ue
+ & 0xFFFFFFFF));
+
+1754
+em\99
+(
+»\9a\8b½»t_ÿ¡
+<
+In¡r
+>(
+msg
+));
+
+1760 \1e
+ gAs£mbËr
+::
+dcbf
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rb
+) {
+
+1761
+em\99
+(
+EXT2
+ |
+DCBF
+ |
+¿
+.
+code
+(è*
+B16
+ |
+rb
+.code(è*
+B11
+);
+
+1765 \1e
+ gAs£mbËr
+::
+sync
+(è{
+em\99
+(
+EXT2
+ |
+SYNC
+); }
+
+1768 \1e
+ gAs£mbËr
+::
+lwsync
+(è{
+em\99
+(
+EXT2
+ |
+SYNC
+ | 1 *
+B21
+); }
+
+1771 \1e
+ gAs£mbËr
+::
+icbi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rb
+) {
+
+1772
+em\99
+(
+EXT2
+ |
+ICBI
+ |
+¿
+.
+code
+(è*
+B16
+ |
+rb
+.code(è*
+B11
+);
+
+1776 \1e
+ gAs£mbËr
+::
+isync
+(è{
+em\99
+(
+EXT1
+ |
+ISYNC
+); }
+
+1781 \1e
+ gAs£mbËr
+::
+lfd
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1782 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1783
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1784
+DCHECK
+(
+is_\9at16
+(
+off£t
+));
+
+1785 \12
+ gimm16
+ =
+off£t
+ &
+kImm16Mask
+;
+
+1787
+em\99
+(
+LFD
+ |
+ät
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+imm16
+);
+
+1791 \1e
+ gAs£mbËr
+::
+lfdu
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1792 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1793
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1794
+DCHECK
+(
+is_\9at16
+(
+off£t
+));
+
+1795 \12
+ gimm16
+ =
+off£t
+ &
+kImm16Mask
+;
+
+1797
+em\99
+(
+LFDU
+ |
+ät
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+imm16
+);
+
+1801 \1e
+ gAs£mbËr
+::
+lfdx
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1802
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1803
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1804
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1805
+em\99
+(
+EXT2
+ |
+LFDX
+ |
+ät
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1806
+L\97veRC
+);
+
+1810 \1e
+ gAs£mbËr
+::
+lfdux
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1811
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1812
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1813
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1814
+em\99
+(
+EXT2
+ |
+LFDUX
+ |
+ät
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1815
+L\97veRC
+);
+
+1819 \1e
+ gAs£mbËr
+::
+lfs
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1820 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1821
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1822
+DCHECK
+(
+is_\9at16
+(
+off£t
+));
+
+1823
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1824 \12
+ gimm16
+ =
+off£t
+ &
+kImm16Mask
+;
+
+1826
+em\99
+(
+LFS
+ |
+ät
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+imm16
+);
+
+1830 \1e
+ gAs£mbËr
+::
+lfsu
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1831 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1832
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1833
+DCHECK
+(
+is_\9at16
+(
+off£t
+));
+
+1834
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1835 \12
+ gimm16
+ =
+off£t
+ &
+kImm16Mask
+;
+
+1837
+em\99
+(
+LFSU
+ |
+ät
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+imm16
+);
+
+1841 \1e
+ gAs£mbËr
+::
+lfsx
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1842
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1843
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1844
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1845
+em\99
+(
+EXT2
+ |
+LFSX
+ |
+ät
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1846
+L\97veRC
+);
+
+1850 \1e
+ gAs£mbËr
+::
+lfsux
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1851
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1852
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1853
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1854
+em\99
+(
+EXT2
+ |
+LFSUX
+ |
+ät
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1855
+L\97veRC
+);
+
+1859 \1e
+ gAs£mbËr
+::
+¡fd
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1860 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1861
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1862
+DCHECK
+(
+is_\9at16
+(
+off£t
+));
+
+1863
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1864 \12
+ gimm16
+ =
+off£t
+ &
+kImm16Mask
+;
+
+1866
+em\99
+(
+STFD
+ |
+äs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+imm16
+);
+
+1870 \1e
+ gAs£mbËr
+::
+¡fdu
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1871 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1872
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1873
+DCHECK
+(
+is_\9at16
+(
+off£t
+));
+
+1874
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1875 \12
+ gimm16
+ =
+off£t
+ &
+kImm16Mask
+;
+
+1877
+em\99
+(
+STFDU
+ |
+äs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+imm16
+);
+
+1881 \1e
+ gAs£mbËr
+::
+¡fdx
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1882
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1883
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1884
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1885
+em\99
+(
+EXT2
+ |
+STFDX
+ |
+äs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1886
+L\97veRC
+);
+
+1890 \1e
+ gAs£mbËr
+::
+¡fdux
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1891
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1892
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1893
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1894
+em\99
+(
+EXT2
+ |
+STFDUX
+ |
+äs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1895
+L\97veRC
+);
+
+1899 \1e
+ gAs£mbËr
+::
+¡fs
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1900 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1901
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1902
+DCHECK
+(
+is_\9at16
+(
+off£t
+));
+
+1903
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1904 \12
+ gimm16
+ =
+off£t
+ &
+kImm16Mask
+;
+
+1906
+em\99
+(
+STFS
+ |
+äs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+imm16
+);
+
+1910 \1e
+ gAs£mbËr
+::
+¡fsu
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1911 \12
+ goff£t
+ =
+¤c
+.
+off£t
+();
+
+1912
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1913
+DCHECK
+(
+is_\9at16
+(
+off£t
+));
+
+1914
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1915 \12
+ gimm16
+ =
+off£t
+ &
+kImm16Mask
+;
+
+1917
+em\99
+(
+STFSU
+ |
+äs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+imm16
+);
+
+1921 \1e
+ gAs£mbËr
+::
+¡fsx
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1922
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1923
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1924
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1925
+em\99
+(
+EXT2
+ |
+STFSX
+ |
+äs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1926
+L\97veRC
+);
+
+1930 \1e
+ gAs£mbËr
+::
+¡fsux
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+) {
+
+1931
+Regi¡\94
+
+ g¿
+ =
+¤c
+.
+¿
+();
+
+1932
+Regi¡\94
+
+ grb
+ =
+¤c
+.
+rb
+();
+
+1933
+DCHECK
+(!
+¿
+.
+is
+(
+r0
+));
+
+1934
+em\99
+(
+EXT2
+ |
+STFSUX
+ |
+äs
+.
+code
+(è*
+B21
+ |
+¿
+.code(è*
+B16
+ |
+rb
+.code(è*
+B11
+ |
+
+1935
+L\97veRC
+);
+
+1939 \1e
+ gAs£mbËr
+::
+fsub
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+1940 cڡ
+DoubËRegi¡\94
+
+äb
+,
+RCB\99
+
+rc
+) {
+
+1941
+a_fÜm
+(
+EXT4
+ |
+FSUB
+,
+ät
+,
+äa
+,
+äb
+,
+rc
+);
+
+1945 \1e
+ gAs£mbËr
+::
+çdd
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+1946 cڡ
+DoubËRegi¡\94
+
+äb
+,
+RCB\99
+
+rc
+) {
+
+1947
+a_fÜm
+(
+EXT4
+ |
+FADD
+,
+ät
+,
+äa
+,
+äb
+,
+rc
+);
+
+1951 \1e
+ gAs£mbËr
+::
+fmul
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+1952 cڡ
+DoubËRegi¡\94
+
+äc
+,
+RCB\99
+
+rc
+) {
+
+1953
+em\99
+(
+EXT4
+ |
+FMUL
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äa
+.code(è*
+B16
+ |
+äc
+.code(è*
+B6
+ |
+
+1954
+rc
+);
+
+1958 \1e
+ gAs£mbËr
+::
+fdiv
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+1959 cڡ
+DoubËRegi¡\94
+
+äb
+,
+RCB\99
+
+rc
+) {
+
+1960
+a_fÜm
+(
+EXT4
+ |
+FDIV
+,
+ät
+,
+äa
+,
+äb
+,
+rc
+);
+
+1964 \1e
+ gAs£mbËr
+::
+fcmpu
+(cڡ
+DoubËRegi¡\94
+
+äa
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1965
+CRegi¡\94
+
+ü
+) {
+
+1966
+DCHECK
+(
+ü
+.
+code
+() >= 0 && cr.code() <= 7);
+
+1967
+em\99
+(
+EXT4
+ |
+FCMPU
+ |
+ü
+.
+code
+(è*
+B23
+ |
+äa
+.code(è*
+B16
+ |
+äb
+.code(è*
+B11
+);
+
+1971 \1e
+ gAs£mbËr
+::
+fmr
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1972
+RCB\99
+
+rc
+) {
+
+1973
+em\99
+(
+EXT4
+ |
+FMR
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äb
+.code(è*
+B11
+ |
+rc
+);
+
+1977 \1e
+ gAs£mbËr
+::
+fùiwz
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+) {
+
+1978
+em\99
+(
+EXT4
+ |
+FCTIWZ
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äb
+.code(è*
+B11
+);
+
+1982 \1e
+ gAs£mbËr
+::
+fùiw
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+) {
+
+1983
+em\99
+(
+EXT4
+ |
+FCTIW
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äb
+.code(è*
+B11
+);
+
+1987 \1e
+ gAs£mbËr
+::
+äim
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+) {
+
+1988
+em\99
+(
+EXT4
+ |
+FRIM
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äb
+.code(è*
+B11
+);
+
+1992 \1e
+ gAs£mbËr
+::
+ä¥
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1993
+RCB\99
+
+rc
+) {
+
+1994
+em\99
+(
+EXT4
+ |
+FRSP
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äb
+.code(è*
+B11
+ |
+rc
+);
+
+1998 \1e
+ gAs£mbËr
+::
+fcfid
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1999
+RCB\99
+
+rc
+) {
+
+2000
+em\99
+(
+EXT4
+ |
+FCFID
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äb
+.code(è*
+B11
+ |
+rc
+);
+
+2004 \1e
+ gAs£mbËr
+::
+fùid
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+2005
+RCB\99
+
+rc
+) {
+
+2006
+em\99
+(
+EXT4
+ |
+FCTID
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äb
+.code(è*
+B11
+ |
+rc
+);
+
+2010 \1e
+ gAs£mbËr
+::
+fùidz
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+2011
+RCB\99
+
+rc
+) {
+
+2012
+em\99
+(
+EXT4
+ |
+FCTIDZ
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äb
+.code(è*
+B11
+ |
+rc
+);
+
+2016 \1e
+ gAs£mbËr
+::
+f£l
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+2017 cڡ
+DoubËRegi¡\94
+
+äc
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+2018
+RCB\99
+
+rc
+) {
+
+2019
+em\99
+(
+EXT4
+ |
+FSEL
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äa
+.code(è*
+B16
+ |
+äb
+.code(è*
+B11
+ |
+
+2020
+äc
+.
+code
+(è*
+B6
+ |
+rc
+);
+
+2024 \1e
+ gAs£mbËr
+::
+âeg
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+2025
+RCB\99
+
+rc
+) {
+
+2026
+em\99
+(
+EXT4
+ |
+FNEG
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äb
+.code(è*
+B11
+ |
+rc
+);
+
+2030 \1e
+ gAs£mbËr
+::
+mtfsfi
+(\12
+bf
+, \12
+immed\9f\8b
+,
+RCB\99
+
+rc
+) {
+
+2031
+em\99
+(
+EXT4
+ |
+MTFSFI
+ |
+bf
+ *
+B23
+ |
+immed\9f\8b
+ *
+B12
+ |
+rc
+);
+
+2035 \1e
+ gAs£mbËr
+::
+mffs
+(cڡ
+DoubËRegi¡\94
+
+ät
+,
+RCB\99
+
+rc
+) {
+
+2036
+em\99
+(
+EXT4
+ |
+MFFS
+ |
+ät
+.
+code
+(è*
+B21
+ |
+rc
+);
+
+2040 \1e
+ gAs£mbËr
+::
+mtfsf
+(cڡ
+DoubËRegi¡\94
+
+äb
+,
+boÞ
+
+L
+, \12
+FLM
+, boÞ
+W
+,
+
+2041
+RCB\99
+
+rc
+) {
+
+2042
+em\99
+(
+EXT4
+ |
+MTFSF
+ |
+äb
+.
+code
+(è*
+B11
+ |
+W
+ *
+B16
+ |
+FLM
+ *
+B17
+ |
+L
+ *
+B25
+ |
+rc
+);
+
+2046 \1e
+ gAs£mbËr
+::
+fsq¹
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+2047
+RCB\99
+
+rc
+) {
+
+2048
+em\99
+(
+EXT4
+ |
+FSQRT
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äb
+.code(è*
+B11
+ |
+rc
+);
+
+2052 \1e
+ gAs£mbËr
+::
+çbs
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+2053
+RCB\99
+
+rc
+) {
+
+2054
+em\99
+(
+EXT4
+ |
+FABS
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äb
+.code(è*
+B11
+ |
+rc
+);
+
+2058 \1e
+ gAs£mbËr
+::
+fmadd
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+2059 cڡ
+DoubËRegi¡\94
+
+äc
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+2060
+RCB\99
+
+rc
+) {
+
+2061
+em\99
+(
+EXT4
+ |
+FMADD
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äa
+.code(è*
+B16
+ |
+äb
+.code(è*
+B11
+ |
+
+2062
+äc
+.
+code
+(è*
+B6
+ |
+rc
+);
+
+2066 \1e
+ gAs£mbËr
+::
+fmsub
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+2067 cڡ
+DoubËRegi¡\94
+
+äc
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+2068
+RCB\99
+
+rc
+) {
+
+2069
+em\99
+(
+EXT4
+ |
+FMSUB
+ |
+ät
+.
+code
+(è*
+B21
+ |
+äa
+.code(è*
+B16
+ |
+äb
+.code(è*
+B11
+ |
+
+2070
+äc
+.
+code
+(è*
+B6
+ |
+rc
+);
+
+2075 \1e
+ gAs£mbËr
+::
+nÝ
+(\12
+ty³
+) {
+
+2076
+Regi¡\94
+
+»g
+ =
+r0
+;
+
+2077 \1a
+ gty³
+) {
+
+2078 \ 4
+ gNON_MARKING_NOP
+:
+
+2079
+»g
+ =
+r0
+;
+
+2081 \ 4
+ gGROUP_ENDING_NOP
+:
+
+2082
+»g
+ =
+r2
+;
+
+2084 \ 4
+ gDEBUG_BREAK_NOP
+:
+
+2085
+»g
+ =
+r3
+;
+
+2088
+UNIMPLEMENTED
+();
+
+2091
+Üi
+(
+»g
+,\84eg,
+O³¿nd
+::
+Z\94o
+());
+
+2095
+boÞ
+
+ gAs£mbËr
+::
+IsNÝ
+(
+In¡r
+
+\9a¡r
+, \12
+ty³
+) {
+
+2096 \12
+ g»g
+ = 0;
+
+2097 \1a
+ gty³
+) {
+
+2098 \ 4
+ gNON_MARKING_NOP
+:
+
+2099
+»g
+ = 0;
+
+2101 \ 4
+ gGROUP_ENDING_NOP
+:
+
+2102
+»g
+ = 2;
+
+2104 \ 4
+ gDEBUG_BREAK_NOP
+:
+
+2105
+»g
+ = 3;
+
+2108
+UNIMPLEMENTED
+();
+
+2110 \15
+ g\9a¡r
+ =ð(
+ORI
+ |
+»g
+ *
+B21
+ |\84eg *
+B16
+);
+
+2115 \1e
+ gAs£mbËr
+::
+RecÜdJSR\91uº
+() {
+
+2116
+pos\99iÚs_»cÜd\94
+()->
+Wr\99eRecÜdedPos\99iÚs
+();
+
+2117
+CheckBufãr
+();
+
+2118
+RecÜdR\96ocInfo
+(
+R\96ocInfo
+::
+JS_RETURN
+);
+
+2122 \1e
+ gAs£mbËr
+::
+RecÜdDebugB»akSlÙ
+() {
+
+2123
+pos\99iÚs_»cÜd\94
+()->
+Wr\99eRecÜdedPos\99iÚs
+();
+
+2124
+CheckBufãr
+();
+
+2125
+RecÜdR\96ocInfo
+(
+R\96ocInfo
+::
+DEBUG_BREAK_SLOT
+);
+
+2129 \1e
+ gAs£mbËr
+::
+RecÜdComm\92t
+(cڡ \ 5*
+msg
+) {
+
+2130 ià(
+FLAG_code_comm\92ts
+) {
+
+2131
+CheckBufãr
+();
+
+2132
+RecÜdR\96ocInfo
+(
+R\96ocInfo
+::
+COMMENT
+,
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+msg
+));
+
+2137 \1e
+ gAs£mbËr
+::
+GrowBufãr
+() {
+
+2138 ià(!
+own_bufãr_
+è
+FATAL
+("external code buffer is\81oo small");
+
+2141
+CodeDesc
+
+ gdesc
+;
+
+2142 ià(
+ gbufãr_size_
+ < 4 *
+ gKB
+) {
+
+2143
+ gdesc
+.
+ gbufãr_size
+ = 4 *
+KB
+;
+
+2144 } \vià(
+ gbufãr_size_
+ < 1 *
+ gMB
+) {
+
+2145
+ gdesc
+.
+ gbufãr_size
+ = 2 *
+bufãr_size_
+;
+
+2147
+ gdesc
+.
+ gbufãr_size
+ =
+bufãr_size_
+ + 1 *
+MB
+;
+
+2149
+CHECK_GT
+(
+desc
+.
+bufãr_size
+, 0);
+
+2152
+ gdesc
+.
+ gbufãr
+ =
+NewA¼ay
+<
+by\8b
+>(
+desc
+.
+bufãr_size
+);
+
+2154
+ gdesc
+.
+ g\9a¡r_size
+ =
+pc_off£t
+();
+
+2155
+ gdesc
+.
+ g»loc_size
+ = (
+bufãr_
+ +
+bufãr_size_
+è-
+»loc_\9afo_wr\99\94
+.
+pos
+();
+
+2158
+\9a\8d\8c_t
+
+ gpc_d\96\8f
+ =
+desc
+.
+bufãr
+ -
+bufãr_
+;
+
+2159
+\9a\8d\8c_t
+
+ grc_d\96\8f
+ =
+
+2160 (
+desc
+.
+bufãr
+ + desc.
+bufãr_size
+è- (
+bufãr_
+ +
+bufãr_size_
+);
+
+2161
+memmove
+(
+desc
+.
+bufãr
+,
+bufãr_
+, desc.
+\9a¡r_size
+);
+
+2162
+memmove
+(
+»loc_\9afo_wr\99\94
+.
+pos
+(è+
+rc_d\96\8f
+,\84eloc_info_writer.pos(),
+
+2163
+desc
+.
+»loc_size
+);
+
+2166
+D\96\91eA¼ay
+(
+bufãr_
+);
+
+2167
+ gbufãr_
+ =
+desc
+.
+bufãr
+;
+
+2168
+ gbufãr_size_
+ =
+desc
+.
+bufãr_size
+;
+
+2169
+ gpc_
+ +ð
+pc_d\96\8f
+;
+
+2170
+ g»loc_\9afo_wr\99\94
+.
+R\95os\99iÚ
+(
+»loc_\9afo_wr\99\94
+.
+pos
+(è+
+rc_d\96\8f
+,
+
+2171
+»loc_\9afo_wr\99\94
+.
+ϡ_pc
+(è+
+pc_d\96\8f
+);
+
+2177 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+ ||
+V8_OOL_CONSTANT_POOL
+
+
+2179 \ f
+R\96ocI\8b¿tÜ
+
+\99
+(
+desc
+); !
+ g\99
+.
+dÚe
+(); it.
+Ãxt
+()) {
+
+2180
+ gR\96ocInfo
+::
+Mode
+
+rmode
+ =
+\99
+.
+r\9afo
+()->rmode();
+
+2181 ià(
+ grmode
+ =ð
+R\96ocInfo
+::
+INTERNAL_REFERENCE
+) {
+
+2182
+R\96oÿ\8bIÁ\94ÇlReã»nû
+(
+\99
+.
+r\9afo
+()->
+pc
+(),
+pc_d\96\8f
+, 0);
+
+2185 #ià
+V8_OOL_CONSTANT_POOL
+
+
+2186
+ gcÚ¡ªt_poÞ_bu\9ed\94_
+.
+R\96oÿ\8b
+(
+pc_d\96\8f
+);
+
+2192 \1e
+ gAs£mbËr
+::
+db
+(
+u\9at8_t
+
+d©a
+) {
+
+2193
+CheckBufãr
+();
+
+2194 *
+ g»\9a\8b½»t_ÿ¡
+<
+ gu\9at8_t
+*>(
+ gpc_
+èð
+d©a
+;
+
+2195
+ gpc_
+ +ð\17(
+u\9at8_t
+);
+
+2199 \1e
+ gAs£mbËr
+::
+dd
+(
+u\9at32_t
+
+d©a
+) {
+
+2200
+CheckBufãr
+();
+
+2201 *
+ g»\9a\8b½»t_ÿ¡
+<
+ gu\9at32_t
+*>(
+ gpc_
+èð
+d©a
+;
+
+2202
+ gpc_
+ +ð\17(
+u\9at32_t
+);
+
+2206 \1e
+ gAs£mbËr
+::
+em\99_±r
+(
+u\9a\8d\8c_t
+
+d©a
+) {
+
+2207
+CheckBufãr
+();
+
+2208 *
+ g»\9a\8b½»t_ÿ¡
+<
+ gu\9a\8d\8c_t
+*>(
+ gpc_
+èð
+d©a
+;
+
+2209
+ gpc_
+ +ð\17(
+u\9a\8d\8c_t
+);
+
+2213 \1e
+ gAs£mbËr
+::
+RecÜdR\96ocInfo
+(
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+\9a\8d\8c_t
+
+d©a
+) {
+
+2214
+R\96ocInfo
+
+r\9afo
+(
+pc_
+,
+rmode
+,
+d©a
+,
+NULL
+);
+
+2215
+RecÜdR\96ocInfo
+(
+r\9afo
+);
+
+2219 \1e
+ gAs£mbËr
+::
+RecÜdR\96ocInfo
+(cڡ
+R\96ocInfo
+&
+r\9afo
+) {
+
+2220 ià(
+r\9afo
+.
+rmode
+(è>ð
+R\96ocInfo
+::
+JS_RETURN
+ &&
+
+2221
+r\9afo
+.
+rmode
+(è<ð
+R\96ocInfo
+::
+DEBUG_BREAK_SLOT
+) {
+
+2223
+DCHECK
+(
+R\96ocInfo
+::
+IsDebugB»akSlÙ
+(
+r\9afo
+.
+rmode
+()) ||
+
+2224
+R\96ocInfo
+::
+IsJSR\91uº
+(
+r\9afo
+.
+rmode
+()) ||
+
+2225
+R\96ocInfo
+::
+IsComm\92t
+(
+r\9afo
+.
+rmode
+()) ||
+
+2226
+R\96ocInfo
+::
+IsPos\99iÚ
+(
+r\9afo
+.
+rmode
+()));
+
+2228 ià(!
+ gR\96ocInfo
+::
+IsNÚe
+(
+r\9afo
+.
+rmode
+())) {
+
+2230 ià(
+r\9afo
+.
+rmode
+(è=ð
+R\96ocInfo
+::
+EXTERNAL_REFERENCE
+) {
+
+2231 ià(!
+£r\9fliz\94_\92abËd
+(è&& !
+em\99_debug_code
+()) {
+
+2235
+DCHECK
+(
+bufãr_¥aû
+(è>ð
+kMaxR\96ocSize
+);
+
+2236 ià(
+ gr\9afo
+.
+rmode
+(è=ð
+R\96ocInfo
+::
+CODE_TARGET_WITH_ID
+) {
+
+2237
+R\96ocInfo
+
+»loc_\9afo_w\99h_a¡_id
+(
+r\9afo
+.
+pc
+(),\84\9afo.
+rmode
+(),
+
+2238
+RecÜdedA¡Id
+().
+ToIÁ
+(),
+NULL
+);
+
+2239
+CˬRecÜdedA¡Id
+();
+
+2240
+ g»loc_\9afo_wr\99\94
+.
+Wr\99e
+(&
+»loc_\9afo_w\99h_a¡_id
+);
+
+2242
+ g»loc_\9afo_wr\99\94
+.
+Wr\99e
+(&
+r\9afo
+);
+
+2248 \1e
+ gAs£mbËr
+::
+BlockT¿mpÞ\9aePoÞFÜ
+(\12
+\9a¡ruùiÚs
+) {
+
+2249
+BlockT¿mpÞ\9aePoÞBefÜe
+(
+pc_off£t
+(è+
+\9a¡ruùiÚs
+ *
+kIn¡rSize
+);
+
+2253 \1e
+ gAs£mbËr
+::
+CheckT¿mpÞ\9aePoÞ
+() {
+
+2259 ià((
+\8campÞ\9ae_poÞ_blocked_á\9ag_
+ > 0) ||
+
+2260 (
+pc_off£t
+(è<
+no_\8campÞ\9ae_poÞ_befÜe_
+)) {
+
+2263 ià(
+\8campÞ\9ae_poÞ_blocked_á\9ag_
+ > 0) {
+
+2264
+Ãxt_bufãr_check_
+ =
+pc_off£t
+(è+
+kIn¡rSize
+;
+
+2266
+ gÃxt_bufãr_check_
+ =
+no_\8campÞ\9ae_poÞ_befÜe_
+;
+
+2271
+DCHECK
+(!
+\8campÞ\9ae_em\99\8bd_
+);
+
+2272
+DCHECK
+(
+unbound_Ïb\96s_couÁ_
+ >= 0);
+
+2273 ià(
+ gunbound_Ïb\96s_couÁ_
+ > 0) {
+
+2276
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+this
+);
+
+2277
+Lab\96
+
+ gaá\94_poÞ
+;
+
+2278
+b
+(&
+aá\94_poÞ
+);
+
+2280 \12
+ gpoÞ_¡¬t
+ =
+pc_off£t
+();
+
+2281 \ f\12
+ gi
+ = 0; i <
+ gunbound_Ïb\96s_couÁ_
+; i++) {
+
+2282
+b
+(&
+aá\94_poÞ
+);
+
+2284
+b\9ad
+(&
+aá\94_poÞ
+);
+
+2285
+ g\8campÞ\9ae_
+ =
+T¿mpÞ\9ae
+(
+poÞ_¡¬t
+,
+unbound_Ïb\96s_couÁ_
+);
+
+2287
+ g\8campÞ\9ae_em\99\8bd_
+ =
+\8cue
+;
+
+2290
+ gÃxt_bufãr_check_
+ =
+kMaxIÁ
+;
+
+2295
+ gÃxt_bufãr_check_
+ =
+
+2296
+pc_off£t
+(è+
+kMaxCÚdB¿nchR\97ch
+ -
+kMaxBlockT¿mpÞ\9aeSeùiÚSize
+;
+
+2302
+ gHªdË
+<
+ gCÚ¡ªtPoÞA¼ay
+>
+ gAs£mbËr
+::
+NewCÚ¡ªtPoÞ
+(
+Isީe
+*
+isީe
+) {
+
+2303 #ià
+V8_OOL_CONSTANT_POOL
+
+
+2304 \15
+cÚ¡ªt_poÞ_bu\9ed\94_
+.
+New
+(
+isީe
+);
+
+2307
+DCHECK
+(!
+FLAG_\92abË_oÞ_cÚ¡ªt_poÞ
+);
+
+2308 \15
+ gisީe
+->
+çùÜy
+()->
+em±y_cÚ¡ªt_poÞ_¬¿y
+();
+
+2313 \1e
+ gAs£mbËr
+::
+PÝuÏ\8bCÚ¡ªtPoÞ
+(
+CÚ¡ªtPoÞA¼ay
+*
+cÚ¡ªt_poÞ
+) {
+
+2314 #ià
+V8_OOL_CONSTANT_POOL
+
+
+2315
+cÚ¡ªt_poÞ_bu\9ed\94_
+.
+PÝuÏ\8b
+(
+this
+,
+cÚ¡ªt_poÞ
+);
+
+2318
+DCHECK
+(!
+FLAG_\92abË_oÞ_cÚ¡ªt_poÞ
+);
+
+2323 #ià
+V8_OOL_CONSTANT_POOL
+
+
+2324
+ gCÚ¡ªtPoÞBu\9ed\94
+::
+CÚ¡ªtPoÞBu\9ed\94
+()
+
+2325 :
+size_
+(0),
+
+2326
+\92\8c\9bs_
+(),
+
+2327
+cu¼\92t_£ùiÚ_
+(
+CÚ¡ªtPoÞA¼ay
+::
+SMALL_SECTION
+) {}
+
+2330
+boÞ
+
+CÚ¡ªtPoÞBu\9ed\94
+::
+IsEm±y
+(è{ \15
+\92\8c\9bs_
+.
+size
+() == 0; }
+
+2333
+ gCÚ¡ªtPoÞA¼ay
+::
+Ty³
+
+CÚ¡ªtPoÞBu\9ed\94
+::
+G\91CÚ¡ªtPoÞTy³
+(
+
+2334
+R\96ocInfo
+::
+Mode
+
+rmode
+) {
+
+2335 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2337 ià(!
+R\96ocInfo
+::
+IsGCR\96ocMode
+(
+rmode
+)) {
+
+2338 \15
+CÚ¡ªtPoÞA¼ay
+::
+INT64
+;
+
+2340 ià(
+ grmode
+ =ð
+R\96ocInfo
+::
+NONE64
+) {
+
+2341 \15
+CÚ¡ªtPoÞA¼ay
+::
+INT64
+;
+
+2342 } \vià(!
+ gR\96ocInfo
+::
+IsGCR\96ocMode
+(
+rmode
+)) {
+
+2343 \15
+CÚ¡ªtPoÞA¼ay
+::
+INT32
+;
+
+2345 } \vià(
+ gR\96ocInfo
+::
+IsCodeT¬g\91
+(
+rmode
+)) {
+
+2346 \15
+CÚ¡ªtPoÞA¼ay
+::
+CODE_PTR
+;
+
+2348
+DCHECK
+(
+R\96ocInfo
+::
+IsGCR\96ocMode
+(
+rmode
+è&& !R\96ocInfo::
+IsCodeT¬g\91
+(rmode));
+
+2349 \15
+ gCÚ¡ªtPoÞA¼ay
+::
+HEAP_PTR
+;
+
+2354
+ gCÚ¡ªtPoÞA¼ay
+::
+LayoutSeùiÚ
+
+CÚ¡ªtPoÞBu\9ed\94
+::
+AddEÁry
+(
+
+2355
+As£mbËr
+*
+assm
+, cڡ
+R\96ocInfo
+&
+r\9afo
+) {
+
+2356
+ gR\96ocInfo
+::
+Mode
+
+rmode
+ =
+r\9afo
+.rmode();
+
+2357
+DCHECK
+(
+rmode
+ !ð
+R\96ocInfo
+::
+COMMENT
+ &&\84mod\90!ðR\96ocInfo::
+POSITION
+ &&
+
+2358
+rmode
+ !ð
+R\96ocInfo
+::
+STATEMENT_POSITION
+ &&
+
+2359
+rmode
+ !ð
+R\96ocInfo
+::
+CONST_POOL
+);
+
+2362 \12
+ gm\94ged_\9adex
+ = -1;
+
+2363
+ gCÚ¡ªtPoÞA¼ay
+::
+LayoutSeùiÚ
+
+\92\8cy_£ùiÚ
+ =
+cu¼\92t_£ùiÚ_
+;
+
+2364 ià(
+ gR\96ocInfo
+::
+IsNÚe
+(
+rmode
+) ||
+
+2365 (!
+assm
+->
+£r\9fliz\94_\92abËd
+(è&& (
+rmode
+ >ð
+R\96ocInfo
+::
+CELL
+))) {
+
+2366
+size_t
+
+i
+;
+
+2367
+ g¡d
+::
+veùÜ
+<
+CÚ¡ªtPoÞEÁry
+>::
+cÚ¡_\99\94©Ü
+
+\99
+;
+
+2368 \ f
+ g\99
+ =
+\92\8c\9bs_
+.
+beg\9a
+(),
+ gi
+ = 0; i\88!ð\92\8c\9bs_.
+\92d
+(); it++, i++) {
+
+2369 ià(
+ gR\96ocInfo
+::
+IsEqu®
+(
+r\9afo
+,
+\99
+->
+r\9afo_
+)) {
+
+2371
+ gm\94ged_\9adex
+ =
+i
+;
+
+2372
+ g\92\8cy_£ùiÚ
+ =
+\92\8c\9bs_
+[
+i
+].
+£ùiÚ_
+;
+
+2377
+DCHECK
+(
+\92\8cy_£ùiÚ
+ <ð
+cu¼\92t_£ùiÚ_
+);
+
+2378
+ g\92\8c\9bs_
+.
+push_back
+(
+CÚ¡ªtPoÞEÁry
+(
+r\9afo
+,
+\92\8cy_£ùiÚ
+,
+m\94ged_\9adex
+));
+
+2380 ià(
+ gm\94ged_\9adex
+ == -1) {
+
+2382
+numb\94_of_\92\8c\9bs_
+[
+\92\8cy_£ùiÚ
+].
+\9aüem\92t
+(
+G\91CÚ¡ªtPoÞTy³
+(
+rmode
+));
+
+2387 ià(
+ gcu¼\92t_£ùiÚ_
+ =ð
+CÚ¡ªtPoÞA¼ay
+::
+SMALL_SECTION
+) {
+
+2388
+size_
+ =
+CÚ¡ªtPoÞA¼ay
+::
+SizeFÜ
+(*
+sm®l_\92\8c\9bs
+());
+
+2389 ià(!
+is_u\9at12
+(
+size_
+)) {
+
+2390
+ gcu¼\92t_£ùiÚ_
+ =
+CÚ¡ªtPoÞA¼ay
+::
+EXTENDED_SECTION
+;
+
+2393
+ gsize_
+ =
+CÚ¡ªtPoÞA¼ay
+::
+SizeFÜEx\8bnded
+(*
+sm®l_\92\8c\9bs
+(),
+
+2394 *
+ex\8bnded_\92\8c\9bs
+());
+
+2397 \15
+ g\92\8cy_£ùiÚ
+;
+
+2401 \1e
+ gCÚ¡ªtPoÞBu\9ed\94
+::
+R\96oÿ\8b
+(
+\9a\8d\8c_t
+
+pc_d\96\8f
+) {
+
+2402 \ f
+¡d
+::
+veùÜ
+<
+CÚ¡ªtPoÞEÁry
+>::
+\99\94©Ü
+
+\92\8cy
+ =
+\92\8c\9bs_
+.
+beg\9a
+();
+
+2403
+ g\92\8cy
+ !ð
+\92\8c\9bs_
+.
+\92d
+();\83ntry++) {
+
+2404
+DCHECK
+(
+\92\8cy
+->
+r\9afo_
+.
+rmode
+(è!ð
+R\96ocInfo
+::
+JS_RETURN
+);
+
+2405
+ g\92\8cy
+->
+ gr\9afo_
+.
+£t_pc
+(
+\92\8cy
+->
+r\9afo_
+.
+pc
+(è+
+pc_d\96\8f
+);
+
+2410
+ gHªdË
+<
+ gCÚ¡ªtPoÞA¼ay
+>
+ gCÚ¡ªtPoÞBu\9ed\94
+::
+New
+(
+Isީe
+*
+isީe
+) {
+
+2411 ià(
+IsEm±y
+()) {
+
+2412 \15
+isީe
+->
+çùÜy
+()->
+em±y_cÚ¡ªt_poÞ_¬¿y
+();
+
+2413 } \vià(
+ex\8bnded_\92\8c\9bs
+()->
+is_em±y
+()) {
+
+2414 \15
+ gisީe
+->
+çùÜy
+()->
+NewCÚ¡ªtPoÞA¼ay
+(*
+sm®l_\92\8c\9bs
+());
+
+2416
+DCHECK
+(
+cu¼\92t_£ùiÚ_
+ =ð
+CÚ¡ªtPoÞA¼ay
+::
+EXTENDED_SECTION
+);
+
+2417 \15
+ gisީe
+->
+çùÜy
+()->
+NewEx\8bndedCÚ¡ªtPoÞA¼ay
+(
+
+2418 *
+sm®l_\92\8c\9bs
+(), *
+ex\8bnded_\92\8c\9bs
+());
+
+2423 \1e
+ gCÚ¡ªtPoÞBu\9ed\94
+::
+PÝuÏ\8b
+(
+As£mbËr
+*
+assm
+,
+
+2424
+CÚ¡ªtPoÞA¼ay
+*
+cÚ¡ªt_poÞ
+) {
+
+2425
+DCHECK_EQ
+(
+ex\8bnded_\92\8c\9bs
+()->
+is_em±y
+(),
+
+2426 !
+cÚ¡ªt_poÞ
+->
+is_ex\8bnded_Ïyout
+());
+
+2427
+DCHECK
+(
+sm®l_\92\8c\9bs
+()->
+equ®s
+(
+CÚ¡ªtPoÞA¼ay
+::
+Numb\94OfEÁr\9bs
+(
+
+2428
+cÚ¡ªt_poÞ
+,
+CÚ¡ªtPoÞA¼ay
+::
+SMALL_SECTION
+)));
+
+2429 ià(
+ gcÚ¡ªt_poÞ
+->
+is_ex\8bnded_Ïyout
+()) {
+
+2430
+DCHECK
+(
+ex\8bnded_\92\8c\9bs
+()->
+equ®s
+(
+CÚ¡ªtPoÞA¼ay
+::
+Numb\94OfEÁr\9bs
+(
+
+2431
+cÚ¡ªt_poÞ
+,
+CÚ¡ªtPoÞA¼ay
+::
+EXTENDED_SECTION
+)));
+
+2435 \12
+ goff£ts
+[
+CÚ¡ªtPoÞA¼ay
+::
+NUMBER_OF_LAYOUT_SECTIONS
+]
+
+2436 [
+CÚ¡ªtPoÞA¼ay
+::
+NUMBER_OF_TYPES
+];
+
+2437 \ f\12
+ g£ùiÚ
+ = 0; seùiÚ <ð
+cÚ¡ªt_poÞ
+->
+f\9a®_£ùiÚ
+(); section++) {
+
+2438 \12
+ g£ùiÚ_¡¬t
+ = (
+£ùiÚ
+ =ð
+CÚ¡ªtPoÞA¼ay
+::
+EXTENDED_SECTION
+)
+
+2439 ?
+sm®l_\92\8c\9bs
+()->
+tÙ®_couÁ
+()
+
+2441 \ f\12
+ gi
+ = 0; i <
+ gCÚ¡ªtPoÞA¼ay
+::
+NUMBER_OF_TYPES
+; i++) {
+
+2442
+ gCÚ¡ªtPoÞA¼ay
+::
+Ty³
+
+ty³
+ =
+¡©ic_ÿ¡
+<
+CÚ¡ªtPoÞA¼ay
+::Ty³>(
+i
+);
+
+2443 ià(
+ gnumb\94_of_\92\8c\9bs_
+[
+£ùiÚ
+].
+couÁ_of
+(
+ty³
+) != 0) {
+
+2444
+off£ts
+[
+£ùiÚ
+][
+ty³
+] =
+cÚ¡ªt_poÞ
+->
+Off£tOfEËm\92tAt
+(
+
+2445
+numb\94_of_\92\8c\9bs_
+[
+£ùiÚ
+].
+ba£_of
+(
+ty³
+è+
+£ùiÚ_¡¬t
+);
+
+2450 \ f
+ g¡d
+::
+veùÜ
+<
+CÚ¡ªtPoÞEÁry
+>::
+\99\94©Ü
+
+\92\8cy
+ =
+\92\8c\9bs_
+.
+beg\9a
+();
+
+2451
+ g\92\8cy
+ !ð
+\92\8c\9bs_
+.
+\92d
+();\83ntry++) {
+
+2452
+R\96ocInfo
+
+ gr\9afo
+ =
+\92\8cy
+->
+r\9afo_
+;
+
+2453
+ gR\96ocInfo
+::
+Mode
+
+rmode
+ =
+\92\8cy
+->
+r\9afo_
+.rmode();
+
+2454
+ gCÚ¡ªtPoÞA¼ay
+::
+Ty³
+
+ty³
+ =
+G\91CÚ¡ªtPoÞTy³
+(
+rmode
+);
+
+2457 \12
+ goff£t
+;
+
+2458 ià(
+ g\92\8cy
+->
+ gm\94ged_\9adex_
+ == -1) {
+
+2459
+off£t
+ =
+off£ts
+[
+\92\8cy
+->
+£ùiÚ_
+][
+ty³
+];
+
+2460
+ goff£ts
+[
+\92\8cy
+->
+£ùiÚ_
+][
+ty³
+] +ð
+CÚ¡ªtPoÞA¼ay
+::
+\92\8cy_size
+(type);
+
+2461 ià(
+ gty³
+ =ð
+CÚ¡ªtPoÞA¼ay
+::
+INT64
+) {
+
+2462 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2463
+cÚ¡ªt_poÞ
+->
+£t_©_off£t
+(
+off£t
+,
+r\9afo
+.
+d©a
+());
+
+2465
+ gcÚ¡ªt_poÞ
+->
+£t_©_off£t
+(
+off£t
+,
+r\9afo
+.
+d©a64
+());
+
+2466 } \vià(
+ gty³
+ =ð
+CÚ¡ªtPoÞA¼ay
+::
+INT32
+) {
+
+2467
+cÚ¡ªt_poÞ
+->
+£t_©_off£t
+(
+off£t
+,
+
+2468
+¡©ic_ÿ¡
+<
+\9at32_t
+>(
+r\9afo
+.
+d©a
+()));
+
+2470 } \vià(
+ gty³
+ =ð
+CÚ¡ªtPoÞA¼ay
+::
+CODE_PTR
+) {
+
+2471
+cÚ¡ªt_poÞ
+->
+£t_©_off£t
+(
+off£t
+,
+
+2472
+»\9a\8b½»t_ÿ¡
+<
+Add»ss
+>(
+r\9afo
+.
+d©a
+()));
+
+2474
+DCHECK
+(
+ty³
+ =ð
+CÚ¡ªtPoÞA¼ay
+::
+HEAP_PTR
+);
+
+2475
+ gcÚ¡ªt_poÞ
+->
+£t_©_off£t
+(
+off£t
+,
+
+2476
+»\9a\8b½»t_ÿ¡
+<
+Objeù
+*>(
+r\9afo
+.
+d©a
+()));
+
+2478
+ goff£t
+ -ð
+kH\97pObjeùTag
+;
+
+2479
+ g\92\8cy
+->
+ gm\94ged_\9adex_
+ =
+off£t
+;
+
+2481
+DCHECK
+(
+\92\8cy
+->
+m\94ged_\9adex_
+ < (\92\8cy -
+\92\8c\9bs_
+.
+beg\9a
+()));
+
+2482
+ goff£t
+ =
+\92\8c\9bs_
+[
+\92\8cy
+->
+m\94ged_\9adex_
+].merged_index_;
+
+2486
+ gAs£mbËr
+::
+S\91CÚ¡ªtPoÞOff£t
+(
+r\9afo
+.
+pc
+(),
+off£t
+);
+
+ @assembler-ppc.h
+
+40 #iâdeà
+V8_PPC_ASSEMBLER_PPC_H_
+
+
+41 \ 1
+ #V8_PPC_ASSEMBLER_PPC_H_
+
+
+ )
+
+43 \ 2
+ ~<¡dio.h
+>
+
+44 \ 2
+ ~<veùÜ
+>
+
+46 \ 2
+ ~"¤c/as£mbËr.h
+"
+
+47 \ 2
+ ~"¤c/µc/cÚ¡ªts-µc.h
+"
+
+48 \ 2
+ ~"¤c/£r\9flize.h
+"
+
+50 \ 1
+ #ABI_USES_FUNCTION_DESCRIPTORS
+ \
+
+51 (
+V8_HOST_ARCH_PPC
+ && (
+V8_OS_AIX
+ || \
+
+52 (
+V8_TARGET_ARCH_PPC64
+ &&
+V8_TARGET_BIG_ENDIAN
+)))
+
+ )
+
+54 \ 1
+ #ABI_PASSES_HANDLES_IN_REGS
+ \
+
+55 (!
+V8_HOST_ARCH_PPC
+ ||
+V8_OS_AIX
+ ||
+V8_TARGET_ARCH_PPC64
+)
+
+ )
+
+57 \ 1
+ #ABI_RETURNS_HANDLES_IN_REGS
+ \
+
+58 (!
+V8_HOST_ARCH_PPC
+ ||
+V8_TARGET_LITTLE_ENDIAN
+)
+
+ )
+
+60 \ 1
+ #ABI_RETURNS_OBJECT_PAIRS_IN_REGS
+ \
+
+61 (!
+V8_HOST_ARCH_PPC
+ ||
+V8_TARGET_LITTLE_ENDIAN
+)
+
+ )
+
+63 \ 1
+ #ABI_TOC_ADDRESSABILITY_VIA_IP
+ \
+
+64 (
+V8_HOST_ARCH_PPC
+ &&
+V8_TARGET_ARCH_PPC64
+ &&
+V8_TARGET_LITTLE_ENDIAN
+)
+
+ )
+
+66 #ià!
+V8_HOST_ARCH_PPC
+ ||
+V8_OS_AIX
+ ||
+V8_TARGET_ARCH_PPC64
+
+
+67 \ 1
+ #ABI_TOC_REGISTER
+
+kRegi¡\94_r2_Code
+
+
+ )
+
+69 \ 1
+ #ABI_TOC_REGISTER
+
+kRegi¡\94_r13_Code
+
+
+ )
+
+72 \ 1
+ #INSTR_AND_DATA_CACHE_COHERENCY
+
+LWSYNC
+
+
+ )
+
+74
+Çme¥aû
+
+ gv8
+ {
+
+75
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+99 \19
+ sRegi¡\94
+ {
+
+100 \18cڡ \12
+ gkNumRegi¡\94s
+ = 32;
+
+101 \18cڡ \12
+ gkSizeInBy\8bs
+ =
+kPo\9a\8brSize
+;
+
+103 #ià
+V8_TARGET_LITTLE_ENDIAN
+
+
+104 \18cڡ \12
+ gkMªtis§Off£t
+ = 0;
+
+105 \18cڡ \12
+ gkExpÚ\92tOff£t
+ = 4;
+
+107 \18cڡ \12
+ gkMªtis§Off£t
+ = 4;
+
+108 \18cڡ \12
+ gkExpÚ\92tOff£t
+ = 0;
+
+111 \18cڡ \12
+ gkAÎoÿ\8fbËLowRªgeBeg\9a
+ = 3;
+
+112 \18cڡ \12
+ gkAÎoÿ\8fbËLowRªgeEnd
+ = 10;
+
+113 \18cڡ \12
+ gkAÎoÿ\8fbËHighRªgeBeg\9a
+ = 14;
+
+114 #ià
+V8_OOL_CONSTANT_POOL
+
+
+115 \18cڡ \12
+ gkAÎoÿ\8fbËHighRªgeEnd
+ = 27;
+
+117 \18cڡ \12
+ gkAÎoÿ\8fbËHighRªgeEnd
+ = 28;
+
+119 \18cڡ \12
+ gkAÎoÿ\8fbËCÚ\8bxt
+ = 30;
+
+121 \18cڡ \12
+ gkNumAÎoÿ\8fbËLow
+ =
+
+122
+kAÎoÿ\8fbËLowRªgeEnd
+ -
+kAÎoÿ\8fbËLowRªgeBeg\9a
+ + 1;
+
+123 \18cڡ \12
+ gkNumAÎoÿ\8fbËHigh
+ =
+
+124
+kAÎoÿ\8fbËHighRªgeEnd
+ -
+kAÎoÿ\8fbËHighRªgeBeg\9a
+ + 1;
+
+125 \18cڡ \12
+ gkMaxNumAÎoÿ\8fbËRegi¡\94s
+ =
+
+126
+kNumAÎoÿ\8fbËLow
+ +
+kNumAÎoÿ\8fbËHigh
+ + 1;
+
+128 \18\12
+NumAÎoÿ\8fbËRegi¡\94s
+(è{ \15
+ gkMaxNumAÎoÿ\8fbËRegi¡\94s
+; }
+
+130 \18\12
+ToAÎoÿtiÚIndex
+(
+Regi¡\94
+
+»g
+) {
+
+131 \12
+ g\9adex
+;
+
+132 \12
+ gcode
+ =
+»g
+.
+code
+();
+
+133 ià(
+ gcode
+ =ð
+kAÎoÿ\8fbËCÚ\8bxt
+) {
+
+135
+\9adex
+ =
+NumAÎoÿ\8fbËRegi¡\94s
+() - 1;
+
+136 } \vià(
+ gcode
+ <ð
+kAÎoÿ\8fbËLowRªgeEnd
+) {
+
+138
+\9adex
+ =
+code
+ -
+kAÎoÿ\8fbËLowRªgeBeg\9a
+;
+
+141
+ g\9adex
+ =
+code
+ -
+kAÎoÿ\8fbËHighRªgeBeg\9a
+ +
+kNumAÎoÿ\8fbËLow
+;
+
+143
+DCHECK
+(
+\9adex
+ >ð0 && index <
+kMaxNumAÎoÿ\8fbËRegi¡\94s
+);
+
+144 \15
+ g\9adex
+;
+
+147 \18
+Regi¡\94
+
+FromAÎoÿtiÚIndex
+(\12
+\9adex
+) {
+
+148
+DCHECK
+(
+\9adex
+ >ð0 && index <
+kMaxNumAÎoÿ\8fbËRegi¡\94s
+);
+
+150 ià(
+ g\9adex
+ =ð
+kMaxNumAÎoÿ\8fbËRegi¡\94s
+ - 1) {
+
+151 \15
+äom_code
+(
+kAÎoÿ\8fbËCÚ\8bxt
+);
+
+153 \15 (
+ g\9adex
+ <
+ gkNumAÎoÿ\8fbËLow
+)
+
+154 ?
+äom_code
+(
+\9adex
+ +
+kAÎoÿ\8fbËLowRªgeBeg\9a
+)
+
+155 :
+äom_code
+(
+\9adex
+ -
+kNumAÎoÿ\8fbËLow
+ +
+
+156
+kAÎoÿ\8fbËHighRªgeBeg\9a
+);
+
+159 \18cڡ \ 5*
+AÎoÿtiÚIndexToS\8c\9ag
+(\12
+\9adex
+) {
+
+160
+DCHECK
+(
+\9adex
+ >ð0 && index <
+kMaxNumAÎoÿ\8fbËRegi¡\94s
+);
+
+161 cڡ \ 5* cڡ
+ gÇmes
+[] = {
+
+184 #ià!
+V8_OOL_CONSTANT_POOL
+
+
+189 \15
+ gÇmes
+[
+\9adex
+];
+
+192 \18
+Regi¡\94
+
+äom_code
+(\12
+code
+) {
+
+193
+Regi¡\94
+
+ gr
+ = {
+code
+};
+
+194 \15
+ gr
+;
+
+197
+boÞ
+
+is_v®id
+(ècÚ¡ { \15 0 <ð
+code_
+ && code_ <
+kNumRegi¡\94s
+; }
+
+198
+boÞ
+
+is
+(
+Regi¡\94
+
+»g
+ècÚ¡ { \15
+ gcode_
+ =ð»g.
+code_
+; }
+
+199 \12
+code
+() const {
+
+200
+DCHECK
+(
+is_v®id
+());
+
+201 \15
+ gcode_
+;
+
+203 \12
+b\99
+() const {
+
+204
+DCHECK
+(
+is_v®id
+());
+
+205 \15 1 <<
+ gcode_
+;
+
+208 \1e
+£t_code
+(\12
+code
+) {
+
+209
+ gcode_
+ =
+code
+;
+
+210
+DCHECK
+(
+is_v®id
+());
+
+214 \12
+ gcode_
+;
+
+218 cڡ \12
+ gkRegi¡\94_no_»g_Code
+ = -1;
+
+219 cڡ \12
+ gkRegi¡\94_r0_Code
+ = 0;
+
+220 cڡ \12
+ gkRegi¡\94_¥_Code
+ = 1;
+
+221 cڡ \12
+ gkRegi¡\94_r2_Code
+ = 2;
+
+222 cڡ \12
+ gkRegi¡\94_r3_Code
+ = 3;
+
+223 cڡ \12
+ gkRegi¡\94_r4_Code
+ = 4;
+
+224 cڡ \12
+ gkRegi¡\94_r5_Code
+ = 5;
+
+225 cڡ \12
+ gkRegi¡\94_r6_Code
+ = 6;
+
+226 cڡ \12
+ gkRegi¡\94_r7_Code
+ = 7;
+
+227 cڡ \12
+ gkRegi¡\94_r8_Code
+ = 8;
+
+228 cڡ \12
+ gkRegi¡\94_r9_Code
+ = 9;
+
+229 cڡ \12
+ gkRegi¡\94_r10_Code
+ = 10;
+
+230 cڡ \12
+ gkRegi¡\94_r11_Code
+ = 11;
+
+231 cڡ \12
+ gkRegi¡\94_\9d_Code
+ = 12;
+
+232 cڡ \12
+ gkRegi¡\94_r13_Code
+ = 13;
+
+233 cڡ \12
+ gkRegi¡\94_r14_Code
+ = 14;
+
+234 cڡ \12
+ gkRegi¡\94_r15_Code
+ = 15;
+
+236 cڡ \12
+ gkRegi¡\94_r16_Code
+ = 16;
+
+237 cڡ \12
+ gkRegi¡\94_r17_Code
+ = 17;
+
+238 cڡ \12
+ gkRegi¡\94_r18_Code
+ = 18;
+
+239 cڡ \12
+ gkRegi¡\94_r19_Code
+ = 19;
+
+240 cڡ \12
+ gkRegi¡\94_r20_Code
+ = 20;
+
+241 cڡ \12
+ gkRegi¡\94_r21_Code
+ = 21;
+
+242 cڡ \12
+ gkRegi¡\94_r22_Code
+ = 22;
+
+243 cڡ \12
+ gkRegi¡\94_r23_Code
+ = 23;
+
+244 cڡ \12
+ gkRegi¡\94_r24_Code
+ = 24;
+
+245 cڡ \12
+ gkRegi¡\94_r25_Code
+ = 25;
+
+246 cڡ \12
+ gkRegi¡\94_r26_Code
+ = 26;
+
+247 cڡ \12
+ gkRegi¡\94_r27_Code
+ = 27;
+
+248 cڡ \12
+ gkRegi¡\94_r28_Code
+ = 28;
+
+249 cڡ \12
+ gkRegi¡\94_r29_Code
+ = 29;
+
+250 cڡ \12
+ gkRegi¡\94_r30_Code
+ = 30;
+
+251 cڡ \12
+ gkRegi¡\94_å_Code
+ = 31;
+
+253 cڡ
+Regi¡\94
+
+ gno_»g
+ = {
+kRegi¡\94_no_»g_Code
+};
+
+255 cڡ
+Regi¡\94
+
+ gr0
+ = {
+kRegi¡\94_r0_Code
+};
+
+256 cڡ
+Regi¡\94
+
+ g¥
+ = {
+kRegi¡\94_¥_Code
+};
+
+257 cڡ
+Regi¡\94
+
+ gr2
+ = {
+kRegi¡\94_r2_Code
+};
+
+258 cڡ
+Regi¡\94
+
+ gr3
+ = {
+kRegi¡\94_r3_Code
+};
+
+259 cڡ
+Regi¡\94
+
+ gr4
+ = {
+kRegi¡\94_r4_Code
+};
+
+260 cڡ
+Regi¡\94
+
+ gr5
+ = {
+kRegi¡\94_r5_Code
+};
+
+261 cڡ
+Regi¡\94
+
+ gr6
+ = {
+kRegi¡\94_r6_Code
+};
+
+262 cڡ
+Regi¡\94
+
+ gr7
+ = {
+kRegi¡\94_r7_Code
+};
+
+263 cڡ
+Regi¡\94
+
+ gr8
+ = {
+kRegi¡\94_r8_Code
+};
+
+264 cڡ
+Regi¡\94
+
+ gr9
+ = {
+kRegi¡\94_r9_Code
+};
+
+265 cڡ
+Regi¡\94
+
+ gr10
+ = {
+kRegi¡\94_r10_Code
+};
+
+266 cڡ
+Regi¡\94
+
+ gr11
+ = {
+kRegi¡\94_r11_Code
+};
+
+267 cڡ
+Regi¡\94
+
+ g\9d
+ = {
+kRegi¡\94_\9d_Code
+};
+
+268 cڡ
+Regi¡\94
+
+ gr13
+ = {
+kRegi¡\94_r13_Code
+};
+
+269 cڡ
+Regi¡\94
+
+ gr14
+ = {
+kRegi¡\94_r14_Code
+};
+
+270 cڡ
+Regi¡\94
+
+ gr15
+ = {
+kRegi¡\94_r15_Code
+};
+
+272 cڡ
+Regi¡\94
+
+ gr16
+ = {
+kRegi¡\94_r16_Code
+};
+
+273 cڡ
+Regi¡\94
+
+ gr17
+ = {
+kRegi¡\94_r17_Code
+};
+
+274 cڡ
+Regi¡\94
+
+ gr18
+ = {
+kRegi¡\94_r18_Code
+};
+
+275 cڡ
+Regi¡\94
+
+ gr19
+ = {
+kRegi¡\94_r19_Code
+};
+
+276 cڡ
+Regi¡\94
+
+ gr20
+ = {
+kRegi¡\94_r20_Code
+};
+
+277 cڡ
+Regi¡\94
+
+ gr21
+ = {
+kRegi¡\94_r21_Code
+};
+
+278 cڡ
+Regi¡\94
+
+ gr22
+ = {
+kRegi¡\94_r22_Code
+};
+
+279 cڡ
+Regi¡\94
+
+ gr23
+ = {
+kRegi¡\94_r23_Code
+};
+
+280 cڡ
+Regi¡\94
+
+ gr24
+ = {
+kRegi¡\94_r24_Code
+};
+
+281 cڡ
+Regi¡\94
+
+ gr25
+ = {
+kRegi¡\94_r25_Code
+};
+
+282 cڡ
+Regi¡\94
+
+ gr26
+ = {
+kRegi¡\94_r26_Code
+};
+
+283 cڡ
+Regi¡\94
+
+ gr27
+ = {
+kRegi¡\94_r27_Code
+};
+
+284 cڡ
+Regi¡\94
+
+ gr28
+ = {
+kRegi¡\94_r28_Code
+};
+
+285 cڡ
+Regi¡\94
+
+ gr29
+ = {
+kRegi¡\94_r29_Code
+};
+
+286 cڡ
+Regi¡\94
+
+ gr30
+ = {
+kRegi¡\94_r30_Code
+};
+
+287 cڡ
+Regi¡\94
+
+ gå
+ = {
+kRegi¡\94_å_Code
+};
+
+290 cڡ
+Regi¡\94
+
+ gý
+ = {
+kRegi¡\94_r30_Code
+};
+
+291 cڡ
+Regi¡\94
+
+ gkRoÙRegi¡\94
+ = {
+kRegi¡\94_r29_Code
+};
+
+292 #ià
+V8_OOL_CONSTANT_POOL
+
+
+293 cڡ
+Regi¡\94
+
+ gkCÚ¡ªtPoÞRegi¡\94
+ = {
+kRegi¡\94_r28_Code
+};
+
+297 \19
+ sDoubËRegi¡\94
+ {
+
+298 \18cڡ \12
+ gkNumRegi¡\94s
+ = 32;
+
+299 \18cڡ \12
+ gkMaxNumRegi¡\94s
+ =
+kNumRegi¡\94s
+;
+
+300 \18cڡ \12
+ gkNumVÞ©\9eeRegi¡\94s
+ = 14;
+
+301 \18cڡ \12
+ gkSizeInBy\8bs
+ = 8;
+
+303 \18cڡ \12
+ gkAÎoÿ\8fbËLowRªgeBeg\9a
+ = 1;
+
+304 \18cڡ \12
+ gkAÎoÿ\8fbËLowRªgeEnd
+ = 12;
+
+305 \18cڡ \12
+ gkAÎoÿ\8fbËHighRªgeBeg\9a
+ = 15;
+
+306 \18cڡ \12
+ gkAÎoÿ\8fbËHighRªgeEnd
+ = 31;
+
+308 \18cڡ \12
+ gkNumAÎoÿ\8fbËLow
+ =
+
+309
+kAÎoÿ\8fbËLowRªgeEnd
+ -
+kAÎoÿ\8fbËLowRªgeBeg\9a
+ + 1;
+
+310 \18cڡ \12
+ gkNumAÎoÿ\8fbËHigh
+ =
+
+311
+kAÎoÿ\8fbËHighRªgeEnd
+ -
+kAÎoÿ\8fbËHighRªgeBeg\9a
+ + 1;
+
+312 \18cڡ \12
+ gkMaxNumAÎoÿ\8fbËRegi¡\94s
+ =
+
+313
+kNumAÎoÿ\8fbËLow
+ +
+kNumAÎoÿ\8fbËHigh
+;
+
+314 \18\12
+NumAÎoÿ\8fbËRegi¡\94s
+(è{ \15
+ gkMaxNumAÎoÿ\8fbËRegi¡\94s
+; }
+
+317
+\9al\9ae
+ \18\12
+NumAÎoÿ\8fbËAl\9f£dRegi¡\94s
+() {
+
+318 \15
+NumAÎoÿ\8fbËRegi¡\94s
+();
+
+321 \18\12
+ToAÎoÿtiÚIndex
+(
+DoubËRegi¡\94
+
+»g
+) {
+
+322 \12
+ gcode
+ =
+»g
+.
+code
+();
+
+323 \12
+ g\9adex
+ = (
+code
+ <ð
+kAÎoÿ\8fbËLowRªgeEnd
+)
+
+324 ?
+code
+ -
+kAÎoÿ\8fbËLowRªgeBeg\9a
+
+
+325 :
+code
+ -
+kAÎoÿ\8fbËHighRªgeBeg\9a
+ +
+kNumAÎoÿ\8fbËLow
+;
+
+326
+DCHECK
+(
+\9adex
+ <
+kMaxNumAÎoÿ\8fbËRegi¡\94s
+);
+
+327 \15
+ g\9adex
+;
+
+330 \18
+DoubËRegi¡\94
+
+FromAÎoÿtiÚIndex
+(\12
+\9adex
+) {
+
+331
+DCHECK
+(
+\9adex
+ >ð0 && index <
+kMaxNumAÎoÿ\8fbËRegi¡\94s
+);
+
+332 \15 (
+ g\9adex
+ <
+ gkNumAÎoÿ\8fbËLow
+)
+
+333 ?
+äom_code
+(
+\9adex
+ +
+kAÎoÿ\8fbËLowRªgeBeg\9a
+)
+
+334 :
+äom_code
+(
+\9adex
+ -
+kNumAÎoÿ\8fbËLow
+ +
+
+335
+kAÎoÿ\8fbËHighRªgeBeg\9a
+);
+
+338 \18cڡ \ 5*
+AÎoÿtiÚIndexToS\8c\9ag
+(\12
+\9adex
+);
+
+340 \18
+DoubËRegi¡\94
+
+äom_code
+(\12
+code
+) {
+
+341
+DoubËRegi¡\94
+
+ gr
+ = {
+code
+};
+
+342 \15
+ gr
+;
+
+345
+boÞ
+
+is_v®id
+(ècÚ¡ { \15 0 <ð
+code_
+ && code_ <
+kMaxNumRegi¡\94s
+; }
+
+346
+boÞ
+
+is
+(
+DoubËRegi¡\94
+
+»g
+ècÚ¡ { \15
+ gcode_
+ =ð»g.
+code_
+; }
+
+348 \12
+code
+() const {
+
+349
+DCHECK
+(
+is_v®id
+());
+
+350 \15
+ gcode_
+;
+
+352 \12
+b\99
+() const {
+
+353
+DCHECK
+(
+is_v®id
+());
+
+354 \15 1 <<
+ gcode_
+;
+
+356 \1e
+¥l\99_code
+(\12*
+vm
+, \12*
+m
+) const {
+
+357
+DCHECK
+(
+is_v®id
+());
+
+358 *
+ gm
+ = (
+code_
+ & 0x10) >> 4;
+
+359 *
+ gvm
+ =
+code_
+ & 0x0F;
+
+362 \12
+ gcode_
+;
+
+366 cڡ
+DoubËRegi¡\94
+
+ gno_d»g
+ = {-1};
+
+367 cڡ
+DoubËRegi¡\94
+
+ gd0
+ = {0};
+
+368 cڡ
+DoubËRegi¡\94
+
+ gd1
+ = {1};
+
+369 cڡ
+DoubËRegi¡\94
+
+ gd2
+ = {2};
+
+370 cڡ
+DoubËRegi¡\94
+
+ gd3
+ = {3};
+
+371 cڡ
+DoubËRegi¡\94
+
+ gd4
+ = {4};
+
+372 cڡ
+DoubËRegi¡\94
+
+ gd5
+ = {5};
+
+373 cڡ
+DoubËRegi¡\94
+
+ gd6
+ = {6};
+
+374 cڡ
+DoubËRegi¡\94
+
+ gd7
+ = {7};
+
+375 cڡ
+DoubËRegi¡\94
+
+ gd8
+ = {8};
+
+376 cڡ
+DoubËRegi¡\94
+
+ gd9
+ = {9};
+
+377 cڡ
+DoubËRegi¡\94
+
+ gd10
+ = {10};
+
+378 cڡ
+DoubËRegi¡\94
+
+ gd11
+ = {11};
+
+379 cڡ
+DoubËRegi¡\94
+
+ gd12
+ = {12};
+
+380 cڡ
+DoubËRegi¡\94
+
+ gd13
+ = {13};
+
+381 cڡ
+DoubËRegi¡\94
+
+ gd14
+ = {14};
+
+382 cڡ
+DoubËRegi¡\94
+
+ gd15
+ = {15};
+
+383 cڡ
+DoubËRegi¡\94
+
+ gd16
+ = {16};
+
+384 cڡ
+DoubËRegi¡\94
+
+ gd17
+ = {17};
+
+385 cڡ
+DoubËRegi¡\94
+
+ gd18
+ = {18};
+
+386 cڡ
+DoubËRegi¡\94
+
+ gd19
+ = {19};
+
+387 cڡ
+DoubËRegi¡\94
+
+ gd20
+ = {20};
+
+388 cڡ
+DoubËRegi¡\94
+
+ gd21
+ = {21};
+
+389 cڡ
+DoubËRegi¡\94
+
+ gd22
+ = {22};
+
+390 cڡ
+DoubËRegi¡\94
+
+ gd23
+ = {23};
+
+391 cڡ
+DoubËRegi¡\94
+
+ gd24
+ = {24};
+
+392 cڡ
+DoubËRegi¡\94
+
+ gd25
+ = {25};
+
+393 cڡ
+DoubËRegi¡\94
+
+ gd26
+ = {26};
+
+394 cڡ
+DoubËRegi¡\94
+
+ gd27
+ = {27};
+
+395 cڡ
+DoubËRegi¡\94
+
+ gd28
+ = {28};
+
+396 cڡ
+DoubËRegi¡\94
+
+ gd29
+ = {29};
+
+397 cڡ
+DoubËRegi¡\94
+
+ gd30
+ = {30};
+
+398 cڡ
+DoubËRegi¡\94
+
+ gd31
+ = {31};
+
+403 \ 1
+ #kF\9c¡C®ËeSavedDoubËReg
+
+d14
+
+
+ )
+
+404 \ 1
+ #kLa¡C®ËeSavedDoubËReg
+
+d31
+
+
+ )
+
+405 \ 1
+ #kDoubËRegZ\94o
+
+d14
+
+
+ )
+
+406 \ 1
+ #kSü©chDoubËReg
+
+d13
+
+
+ )
+
+408
+Regi¡\94
+
+ToRegi¡\94
+(\12
+num
+);
+
+411 \19
+ sCRegi¡\94
+ {
+
+412
+boÞ
+
+is_v®id
+(ècÚ¡ { \15 0 <ð
+code_
+ && code_ < 16; }
+
+413
+boÞ
+
+is
+(
+CRegi¡\94
+
+üeg
+ècÚ¡ { \15
+ gcode_
+ =ðüeg.
+code_
+; }
+
+414 \12
+code
+() const {
+
+415
+DCHECK
+(
+is_v®id
+());
+
+416 \15
+ gcode_
+;
+
+418 \12
+b\99
+() const {
+
+419
+DCHECK
+(
+is_v®id
+());
+
+420 \15 1 <<
+ gcode_
+;
+
+424 \12
+ gcode_
+;
+
+428 cڡ
+CRegi¡\94
+
+ gno_üeg
+ = {-1};
+
+430 cڡ
+CRegi¡\94
+
+ gü0
+ = {0};
+
+431 cڡ
+CRegi¡\94
+
+ gü1
+ = {1};
+
+432 cڡ
+CRegi¡\94
+
+ gü2
+ = {2};
+
+433 cڡ
+CRegi¡\94
+
+ gü3
+ = {3};
+
+434 cڡ
+CRegi¡\94
+
+ gü4
+ = {4};
+
+435 cڡ
+CRegi¡\94
+
+ gü5
+ = {5};
+
+436 cڡ
+CRegi¡\94
+
+ gü6
+ = {6};
+
+437 cڡ
+CRegi¡\94
+
+ gü7
+ = {7};
+
+438 cڡ
+CRegi¡\94
+
+ gü8
+ = {8};
+
+439 cڡ
+CRegi¡\94
+
+ gü9
+ = {9};
+
+440 cڡ
+CRegi¡\94
+
+ gü10
+ = {10};
+
+441 cڡ
+CRegi¡\94
+
+ gü11
+ = {11};
+
+442 cڡ
+CRegi¡\94
+
+ gü12
+ = {12};
+
+443 cڡ
+CRegi¡\94
+
+ gü13
+ = {13};
+
+444 cڡ
+CRegi¡\94
+
+ gü14
+ = {14};
+
+445 cڡ
+CRegi¡\94
+
+ gü15
+ = {15};
+
+450 #ià
+V8_TARGET_ARCH_PPC64
+
+
+451 cڡ
+ gR\96ocInfo
+::
+Mode
+
+kR\96ocInfo_NONEPTR
+ =
+R\96ocInfo
+::
+NONE64
+;
+
+453 cڡ
+ gR\96ocInfo
+::
+Mode
+
+kR\96ocInfo_NONEPTR
+ =
+R\96ocInfo
+::
+NONE32
+;
+
+457 þas
+ cO³¿nd
+
+ gBASE_EMBEDDED
+ {
+
+458
+ gpublic
+:
+
+460
+INLINE
+(
+ex¶ic\99
+
+O³¿nd
+(
+\9a\8d\8c_t
+
+immed\9f\8b
+,
+
+461
+R\96ocInfo
+::
+Mode
+
+rmode
+ =
+kR\96ocInfo_NONEPTR
+));
+
+462
+INLINE
+(\18
+O³¿nd
+
+Z\94o
+()è{ \15 O³¿nd(
+¡©ic_ÿ¡
+<
+\9a\8d\8c_t
+>(0)); }
+
+463
+INLINE
+(
+ex¶ic\99
+
+O³¿nd
+(cڡ
+Ex\8bº®Reã»nû
+&
+f
+));
+
+464
+ex¶ic\99
+
+O³¿nd
+(
+HªdË
+<
+Objeù
+>
+hªdË
+);
+
+465
+INLINE
+(
+ex¶ic\99
+
+O³¿nd
+(
+Smi
+*
+v®ue
+));
+
+468
+INLINE
+(
+ex¶ic\99
+
+O³¿nd
+(
+Regi¡\94
+
+rm
+));
+
+471
+INLINE
+(
+boÞ
+
+is_»g
+() const);
+
+480
+boÞ
+
+mu¡_ou\8dut_»loc_\9afo
+(cڡ
+As£mbËr
+*
+as£mbËr
+) const;
+
+482
+\9al\9ae
+
+\9a\8d\8c_t
+
+immed\9f\8b
+() const {
+
+483
+DCHECK
+(!
+rm_
+.
+is_v®id
+());
+
+484 \15
+ gimm_
+;
+
+487
+Regi¡\94
+
+rm
+(ècÚ¡ { \15
+ grm_
+; }
+
+489
+ g´iv©e
+:
+
+490
+Regi¡\94
+
+rm_
+;
+
+491
+\9a\8d\8c_t
+
+ gimm_
+;
+
+492
+ gR\96ocInfo
+::
+Mode
+
+rmode_
+;
+
+494
+ä\9bnd
+
+þass
+
+ gAs£mbËr
+;
+
+495
+ä\9bnd
+
+þass
+
+ gMaüoAs£mbËr
+;
+
+502 þas
+ cMemO³¿nd
+
+ gBASE_EMBEDDED
+ {
+
+503
+ gpublic
+:
+
+504
+ex¶ic\99
+
+MemO³¿nd
+(
+Regi¡\94
+
+º
+,
+\9at32_t
+
+off£t
+ = 0);
+
+506
+ex¶ic\99
+
+MemO³¿nd
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rb
+);
+
+508
+\9at32_t
+
+off£t
+() const {
+
+509
+DCHECK
+(
+rb_
+.
+is
+(
+no_»g
+));
+
+510 \15
+ goff£t_
+;
+
+514
+Regi¡\94
+
+¿
+() const {
+
+515
+DCHECK
+(!
+¿_
+.
+is
+(
+no_»g
+));
+
+516 \15
+ g¿_
+;
+
+519
+Regi¡\94
+
+rb
+() const {
+
+520
+DCHECK
+(
+off£t_
+ =ð0 && !
+rb_
+.
+is
+(
+no_»g
+));
+
+521 \15
+ grb_
+;
+
+524
+ g´iv©e
+:
+
+525
+Regi¡\94
+
+¿_
+;
+
+526
+\9at32_t
+
+ goff£t_
+;
+
+527
+Regi¡\94
+
+ grb_
+;
+
+529
+ä\9bnd
+
+þass
+
+ gAs£mbËr
+;
+
+533 #ià
+V8_OOL_CONSTANT_POOL
+
+
+535 þas
+ cCÚ¡ªtPoÞBu\9ed\94
+
+ gBASE_EMBEDDED
+ {
+
+536
+ gpublic
+:
+
+537
+CÚ¡ªtPoÞBu\9ed\94
+();
+
+538
+ gCÚ¡ªtPoÞA¼ay
+::
+LayoutSeùiÚ
+
+AddEÁry
+(
+As£mbËr
+*
+assm
+,
+
+539 cڡ
+R\96ocInfo
+&
+r\9afo
+);
+
+540 \1e
+R\96oÿ\8b
+(
+\9a\8d\8c_t
+
+pc_d\96\8f
+);
+
+541
+boÞ
+
+IsEm±y
+();
+
+542
+ gHªdË
+<
+ gCÚ¡ªtPoÞA¼ay
+>
+New
+(
+Isީe
+*
+isީe
+);
+
+543 \1e
+PÝuÏ\8b
+(
+As£mbËr
+*
+assm
+,
+CÚ¡ªtPoÞA¼ay
+*
+cÚ¡ªt_poÞ
+);
+
+545
+\9al\9ae
+
+ gCÚ¡ªtPoÞA¼ay
+::
+LayoutSeùiÚ
+
+cu¼\92t_£ùiÚ
+() const {
+
+546 \15
+cu¼\92t_£ùiÚ_
+;
+
+568
+\9al\9ae
+
+boÞ
+
+is_fuÎ
+(ècÚ¡ { \15 !
+is_\9at16
+(
+size_
+); }
+
+570
+\9al\9ae
+
+ gCÚ¡ªtPoÞA¼ay
+::
+Numb\94OfEÁr\9bs
+*
+numb\94_of_\92\8c\9bs
+(
+
+571
+CÚ¡ªtPoÞA¼ay
+::
+LayoutSeùiÚ
+
+£ùiÚ
+) {
+
+572 \15 &
+numb\94_of_\92\8c\9bs_
+[
+£ùiÚ
+];
+
+575
+\9al\9ae
+
+ gCÚ¡ªtPoÞA¼ay
+::
+Numb\94OfEÁr\9bs
+*
+sm®l_\92\8c\9bs
+() {
+
+576 \15
+numb\94_of_\92\8c\9bs
+(
+CÚ¡ªtPoÞA¼ay
+::
+SMALL_SECTION
+);
+
+579
+\9al\9ae
+
+ gCÚ¡ªtPoÞA¼ay
+::
+Numb\94OfEÁr\9bs
+*
+ex\8bnded_\92\8c\9bs
+() {
+
+580 \15
+numb\94_of_\92\8c\9bs
+(
+CÚ¡ªtPoÞA¼ay
+::
+EXTENDED_SECTION
+);
+
+583
+ g´iv©e
+:
+
+584 \19
+ sCÚ¡ªtPoÞEÁry
+ {
+
+585
+CÚ¡ªtPoÞEÁry
+(
+R\96ocInfo
+
+r\9afo
+,
+CÚ¡ªtPoÞA¼ay
+::
+LayoutSeùiÚ
+
+£ùiÚ
+,
+
+586 \12
+m\94ged_\9adex
+)
+
+587 :
+r\9afo_
+(
+r\9afo
+),
+£ùiÚ_
+(
+£ùiÚ
+),
+m\94ged_\9adex_
+(
+m\94ged_\9adex
+) {}
+
+589
+R\96ocInfo
+
+ gr\9afo_
+;
+
+590
+ gCÚ¡ªtPoÞA¼ay
+::
+LayoutSeùiÚ
+
+£ùiÚ_
+;
+
+591 \12
+ gm\94ged_\9adex_
+;
+
+594
+ gCÚ¡ªtPoÞA¼ay
+::
+Ty³
+
+G\91CÚ¡ªtPoÞTy³
+(
+R\96ocInfo
+::
+Mode
+
+rmode
+);
+
+596
+u\9at32_t
+
+ gsize_
+;
+
+597
+ g¡d
+::
+veùÜ
+<
+CÚ¡ªtPoÞEÁry
+>
+\92\8c\9bs_
+;
+
+598
+ gCÚ¡ªtPoÞA¼ay
+::
+LayoutSeùiÚ
+
+cu¼\92t_£ùiÚ_
+;
+
+599
+ gCÚ¡ªtPoÞA¼ay
+::
+Numb\94OfEÁr\9bs
+
+numb\94_of_\92\8c\9bs_
+[2];
+
+604 þas
+ cAs£mbËr
+ :
+public
+
+As£mbËrBa£
+ {
+
+605
+public
+:
+
+619
+As£mbËr
+(
+Isީe
+*
+isީe
+, \1e*
+bufãr
+, \12
+bufãr_size
+);
+
+620
+ gv\9ctu®
+ ~
+As£mbËr
+() {}
+
+625 \1e
+G\91Code
+(
+CodeDesc
+*
+desc
+);
+
+642 \1e
+b\9ad
+(
+Lab\96
+*
+L
+);
+
+645
+boÞ
+
+is_ì
+(
+Lab\96
+*
+L
+,
+CÚd\99iÚ
+
+cÚd
+);
+
+650 \12
+b¿nch_off£t
+(
+Lab\96
+*
+L
+,
+boÞ
+
+jump_\96im\9a©iÚ_®lowed
+);
+
+654 \1e
+Ïb\96_©_put
+(
+Lab\96
+*
+L
+, \12
+©_off£t
+);
+
+656 #ià
+V8_OOL_CONSTANT_POOL
+
+
+657
+INLINE
+(\18
+boÞ
+
+IsCÚ¡ªtPoÞLßdS\8f¹
+(
+Add»ss
+
+pc
+));
+
+658
+INLINE
+(\18
+boÞ
+
+IsCÚ¡ªtPoÞLßdEnd
+(
+Add»ss
+
+pc
+));
+
+659
+INLINE
+(\18\12
+G\91CÚ¡ªtPoÞOff£t
+(
+Add»ss
+
+pc
+));
+
+660
+INLINE
+(\18\1e
+S\91CÚ¡ªtPoÞOff£t
+(
+Add»ss
+
+pc
+, \12
+off£t
+));
+
+664
+INLINE
+(\18
+Add»ss
+
+\8frg\91_cÚ¡ªt_poÞ_add»ss_©
+(
+
+665
+Add»ss
+
+pc
+,
+CÚ¡ªtPoÞA¼ay
+*
+cÚ¡ªt_poÞ
+));
+
+669
+INLINE
+(\18
+Add»ss
+
+\8frg\91_add»ss_©
+(Add»s
+pc
+,
+
+670
+CÚ¡ªtPoÞA¼ay
+*
+cÚ¡ªt_poÞ
+));
+
+671
+INLINE
+(\18\1e
+£t_\8frg\91_add»ss_©
+(
+
+672
+Add»ss
+
+pc
+,
+CÚ¡ªtPoÞA¼ay
+*
+cÚ¡ªt_poÞ
+, Add»s
+\8frg\91
+,
+
+673
+ICacheFlushMode
+
+iÿche_æush_mode
+ =
+FLUSH_ICACHE_IF_NEEDED
+));
+
+674
+INLINE
+(\18
+Add»ss
+
+\8frg\91_add»ss_©
+(Add»s
+pc
+,
+Code
+*
+code
+)) {
+
+675
+CÚ¡ªtPoÞA¼ay
+*
+ gcÚ¡ªt_poÞ
+ =
+code
+ ? code->
+cÚ¡ªt_poÞ
+(è:
+NULL
+;
+
+676 \15
+\8frg\91_add»ss_©
+(
+pc
+,
+cÚ¡ªt_poÞ
+);
+
+678
+INLINE
+(\18\1e
+£t_\8frg\91_add»ss_©
+(
+
+679
+Add»ss
+
+pc
+,
+Code
+*
+code
+, Add»s
+\8frg\91
+,
+
+680
+ICacheFlushMode
+
+iÿche_æush_mode
+ =
+FLUSH_ICACHE_IF_NEEDED
+)) {
+
+681
+CÚ¡ªtPoÞA¼ay
+*
+cÚ¡ªt_poÞ
+ =
+code
+ ? code->cÚ¡ªt_poÞ(è:
+NULL
+;
+
+682
+£t_\8frg\91_add»ss_©
+(
+pc
+,
+cÚ¡ªt_poÞ
+,
+\8frg\91
+,
+iÿche_æush_mode
+);
+
+687
+\9al\9ae
+ \18
+Add»ss
+
+\8frg\91_add»ss_äom_»tuº_add»ss
+(Add»s
+pc
+);
+
+691
+INLINE
+(\18
+Add»ss
+
+»tuº_add»ss_äom_ÿÎ_¡¬t
+(Add»s
+pc
+));
+
+694
+INLINE
+(\18
+Add»ss
+
+b»ak_add»ss_äom_»tuº_add»ss
+(Add»s
+pc
+));
+
+698
+\9al\9ae
+ \18\1e
+de£r\9fliz©iÚ_£t_¥ec\9fl_\8frg\91_©
+(
+
+699
+Add»ss
+
+\9a¡ruùiÚ_·ylßd
+,
+Code
+*
+code
+, Add»s
+\8frg\91
+);
+
+702 \18cڡ \12
+ gkIn¡rSize
+ = \17(
+In¡r
+);
+
+710 \18cڡ \12
+ gkS³c\9flT¬g\91Size
+ = 0;
+
+713 #ià
+V8_TARGET_ARCH_PPC64
+
+
+714 \18cڡ \12
+ gkMovIn¡ruùiÚsCÚ¡ªtPoÞ
+ = 2;
+
+715 \18cڡ \12
+ gkMovIn¡ruùiÚsNoCÚ¡ªtPoÞ
+ = 5;
+
+717 \18cڡ \12
+ gkMovIn¡ruùiÚsCÚ¡ªtPoÞ
+ = 1;
+
+718 \18cڡ \12
+ gkMovIn¡ruùiÚsNoCÚ¡ªtPoÞ
+ = 2;
+
+720 #ià
+V8_OOL_CONSTANT_POOL
+
+
+721 \18cڡ \12
+ gkMovIn¡ruùiÚs
+ =
+kMovIn¡ruùiÚsCÚ¡ªtPoÞ
+;
+
+723 \18cڡ \12
+ gkMovIn¡ruùiÚs
+ =
+kMovIn¡ruùiÚsNoCÚ¡ªtPoÞ
+;
+
+734 \18cڡ \12
+ gkC®lT¬g\91Add»ssOff£t
+ =
+
+735 (
+kMovIn¡ruùiÚs
+ + 2è*
+kIn¡rSize
+;
+
+743 \18cڡ \12
+ gkP©chR\91uºSequ\92ûAdd»ssOff£t
+ = 0 *
+kIn¡rSize
+;
+
+751 \18cڡ \12
+ gkP©chDebugB»akSlÙAdd»ssOff£t
+ = 0 *
+kIn¡rSize
+;
+
+755 \18cڡ \12
+ gkJSR\91uºSequ\92ûIn¡ruùiÚs
+ =
+
+756
+kMovIn¡ruùiÚsNoCÚ¡ªtPoÞ
+ + 3;
+
+760 \18cڡ \12
+ gkDebugB»akSlÙIn¡ruùiÚs
+ =
+
+761
+kMovIn¡ruùiÚsNoCÚ¡ªtPoÞ
+ + 2;
+
+762 \18cڡ \12
+ gkDebugB»akSlÙL\92gth
+ =
+
+763
+kDebugB»akSlÙIn¡ruùiÚs
+ *
+kIn¡rSize
+;
+
+765 \18
+\9al\9ae
+ \12
+\92code_üb\99
+(cڡ
+CRegi¡\94
+&
+ü
+, \f
+CRB\99
+
+üb\99
+) {
+
+766 \15 ((
+ gü
+.
+code
+(è*
+ gCRWIDTH
+è+
+ güb\99
+);
+
+775 \1e
+Align
+(\12
+m
+);
+
+777 \1e
+CodeT¬g\91Align
+();
+
+780 \1e
+bþr
+(
+BOf\9bld
+
+bo
+,
+LKB\99
+
+lk
+);
+
+781 \1e
+bÌ
+();
+
+782 \1e
+bc
+(\12
+b¿nch_off£t
+,
+BOf\9bld
+
+bo
+, \12
+cÚd\99iÚ_b\99
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+);
+
+783 \1e
+b
+(\12
+b¿nch_off£t
+,
+LKB\99
+
+lk
+);
+
+785 \1e
+bcùr
+(
+BOf\9bld
+
+bo
+,
+LKB\99
+
+lk
+);
+
+786 \1e
+bùr
+();
+
+787 \1e
+bù¾
+();
+
+790 \1e
+b
+(
+Lab\96
+*
+L
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+è{ b(
+b¿nch_off£t
+(L,
+çl£
+),\86k); }
+
+792 \1e
+bc_shÜt
+(
+CÚd\99iÚ
+
+cÚd
+,
+Lab\96
+*
+L
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+,
+
+793
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+794
+DCHECK
+(
+cÚd
+ !ð
+®
+);
+
+795
+DCHECK
+(
+ü
+.
+code
+() >= 0 && cr.code() <= 7);
+
+797 \12
+ gb_off£t
+ =
+b¿nch_off£t
+(
+L
+,
+çl£
+);
+
+799 \1a
+ gcÚd
+) {
+
+800 \ 4
+ geq
+:
+
+801
+bc
+(
+b_off£t
+,
+BT
+,
+\92code_üb\99
+(
+ü
+,
+CR_EQ
+),
+lk
+);
+
+803 \ 4
+ gÃ
+:
+
+804
+bc
+(
+b_off£t
+,
+BF
+,
+\92code_üb\99
+(
+ü
+,
+CR_EQ
+),
+lk
+);
+
+806 \ 4
+ ggt
+:
+
+807
+bc
+(
+b_off£t
+,
+BT
+,
+\92code_üb\99
+(
+ü
+,
+CR_GT
+),
+lk
+);
+
+809 \ 4
+ gË
+:
+
+810
+bc
+(
+b_off£t
+,
+BF
+,
+\92code_üb\99
+(
+ü
+,
+CR_GT
+),
+lk
+);
+
+812 \ 4
+ gÉ
+:
+
+813
+bc
+(
+b_off£t
+,
+BT
+,
+\92code_üb\99
+(
+ü
+,
+CR_LT
+),
+lk
+);
+
+815 \ 4
+ gge
+:
+
+816
+bc
+(
+b_off£t
+,
+BF
+,
+\92code_üb\99
+(
+ü
+,
+CR_LT
+),
+lk
+);
+
+818 \ 4
+ gunÜd\94ed
+:
+
+819
+bc
+(
+b_off£t
+,
+BT
+,
+\92code_üb\99
+(
+ü
+,
+CR_FU
+),
+lk
+);
+
+821 \ 4
+ gÜd\94ed
+:
+
+822
+bc
+(
+b_off£t
+,
+BF
+,
+\92code_üb\99
+(
+ü
+,
+CR_FU
+),
+lk
+);
+
+824 \ 4
+ gov\94æow
+:
+
+825
+bc
+(
+b_off£t
+,
+BT
+,
+\92code_üb\99
+(
+ü
+,
+CR_SO
+),
+lk
+);
+
+827 \ 4
+ gnoov\94æow
+:
+
+828
+bc
+(
+b_off£t
+,
+BF
+,
+\92code_üb\99
+(
+ü
+,
+CR_SO
+),
+lk
+);
+
+831
+UNIMPLEMENTED
+();
+
+835 \1e
+b
+(
+CÚd\99iÚ
+
+cÚd
+,
+Lab\96
+*
+L
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+836 ià(
+cÚd
+ =ð
+®
+) {
+
+837
+b
+(
+L
+,
+lk
+);
+
+841 ià((
+ gL
+->
+is_bound
+(è&&
+is_ì
+(
+L
+,
+cÚd
+)è|| !
+is_\8campÞ\9ae_em\99\8bd
+()) {
+
+842
+bc_shÜt
+(
+cÚd
+,
+L
+,
+ü
+,
+lk
+);
+
+846
+Lab\96
+
+ gsk\9d
+;
+
+847
+CÚd\99iÚ
+
+ gÃg_cÚd
+ =
+Neg©eCÚd\99iÚ
+(
+cÚd
+);
+
+848
+bc_shÜt
+(
+Ãg_cÚd
+, &
+sk\9d
+,
+ü
+);
+
+849
+b
+(
+L
+,
+lk
+);
+
+850
+b\9ad
+(&
+sk\9d
+);
+
+853 \1e
+bÃ
+(
+Lab\96
+*
+L
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+854
+b
+(
+Ã
+,
+L
+,
+ü
+,
+lk
+);
+
+856 \1e
+beq
+(
+Lab\96
+*
+L
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+857
+b
+(
+eq
+,
+L
+,
+ü
+,
+lk
+);
+
+859 \1e
+bÉ
+(
+Lab\96
+*
+L
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+860
+b
+(
+É
+,
+L
+,
+ü
+,
+lk
+);
+
+862 \1e
+bge
+(
+Lab\96
+*
+L
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+863
+b
+(
+ge
+,
+L
+,
+ü
+,
+lk
+);
+
+865 \1e
+bË
+(
+Lab\96
+*
+L
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+866
+b
+(
+Ë
+,
+L
+,
+ü
+,
+lk
+);
+
+868 \1e
+bgt
+(
+Lab\96
+*
+L
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+869
+b
+(
+gt
+,
+L
+,
+ü
+,
+lk
+);
+
+871 \1e
+bunÜd\94ed
+(
+Lab\96
+*
+L
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+872
+b
+(
+unÜd\94ed
+,
+L
+,
+ü
+,
+lk
+);
+
+874 \1e
+bÜd\94ed
+(
+Lab\96
+*
+L
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+875
+b
+(
+Üd\94ed
+,
+L
+,
+ü
+,
+lk
+);
+
+877 \1e
+bov\94æow
+(
+Lab\96
+*
+L
+,
+CRegi¡\94
+
+ü
+ =
+ü0
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+878
+b
+(
+ov\94æow
+,
+L
+,
+ü
+,
+lk
+);
+
+880 \1e
+bnoov\94æow
+(
+Lab\96
+*
+L
+,
+CRegi¡\94
+
+ü
+ =
+ü0
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+881
+b
+(
+noov\94æow
+,
+L
+,
+ü
+,
+lk
+);
+
+885 \1e
+bdnz
+(
+Lab\96
+*
+L
+,
+LKB\99
+
+lk
+ =
+L\97veLK
+) {
+
+886
+bc
+(
+b¿nch_off£t
+(
+L
+,
+çl£
+),
+DCBNZ
+, 0,
+lk
+);
+
+891 \1e
+sub
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+s
+ =
+L\97veOE
+,
+
+892
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+894 \1e
+subfic
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+);
+
+896 \1e
+subfc
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+s
+ =
+L\97veOE
+,
+
+897
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+899 \1e
+add
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+s
+ =
+L\97veOE
+,
+
+900
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+902 \1e
+addc
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+ =
+L\97veOE
+,
+
+903
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+905 \1e
+addze
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+,
+OEB\99
+
+o
+,
+RCB\99
+
+r
+);
+
+907 \1e
+muÎw
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+ =
+L\97veOE
+,
+
+908
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+910 \1e
+mulhw
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+ =
+L\97veOE
+,
+
+911
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+913 \1e
+divw
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+ =
+L\97veOE
+,
+
+914
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+916 \1e
+addi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+);
+
+917 \1e
+addis
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+);
+
+918 \1e
+addic
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+);
+
+920 \1e
+ªd_
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+921 \1e
+ªdc
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+922 \1e
+ªdi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+imm
+);
+
+923 \1e
+ªdis
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+imm
+);
+
+924 \1e
+nÜ
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+925 \1e
+nÙx
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+926 \1e
+Üi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+);
+
+927 \1e
+Üis
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+);
+
+928 \1e
+Üx
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+929 \1e
+xÜi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+imm
+);
+
+930 \1e
+xÜis
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+imm
+);
+
+931 \1e
+xÜ_
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+932 \1e
+cmpi
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+933 \1e
+cm¶i
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+934 \1e
+cmpwi
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+935 \1e
+cm¶wi
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+936 \1e
+li
+(
+Regi¡\94
+
+d¡
+, cڡ
+O³¿nd
+&
+¤c
+);
+
+937 \1e
+lis
+(
+Regi¡\94
+
+d¡
+, cڡ
+O³¿nd
+&
+imm
+);
+
+938 \1e
+mr
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+);
+
+940 \1e
+lbz
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+941 \1e
+lbzx
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+942 \1e
+lbzux
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+943 \1e
+lhz
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+944 \1e
+lhzx
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+945 \1e
+lhzux
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+946 \1e
+lwz
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+947 \1e
+lwzu
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+948 \1e
+lwzx
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+949 \1e
+lwzux
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+950 \1e
+lwa
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+951 \1e
+¡b
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+952 \1e
+¡bx
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+953 \1e
+¡bux
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+954 \1e
+¡h
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+955 \1e
+¡hx
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+956 \1e
+¡hux
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+957 \1e
+¡w
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+958 \1e
+¡wu
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+959 \1e
+¡wx
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+960 \1e
+¡wux
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+962 \1e
+extsb
+(
+Regi¡\94
+
+rs
+, Regi¡\94
+¿
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+963 \1e
+extsh
+(
+Regi¡\94
+
+rs
+, Regi¡\94
+¿
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+965 \1e
+Ãg
+(
+Regi¡\94
+
+¹
+, Regi¡\94
+¿
+,
+OEB\99
+
+o
+ =
+L\97veOE
+,
+RCB\99
+
+c
+ =
+L\97veRC
+);
+
+967 #ià
+V8_TARGET_ARCH_PPC64
+
+
+968 \1e
+ld
+(
+Regi¡\94
+
+rd
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+969 \1e
+ldx
+(
+Regi¡\94
+
+rd
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+970 \1e
+ldu
+(
+Regi¡\94
+
+rd
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+971 \1e
+ldux
+(
+Regi¡\94
+
+rd
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+972 \1e
+¡d
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+973 \1e
+¡dx
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+974 \1e
+¡du
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+975 \1e
+¡dux
+(
+Regi¡\94
+
+rs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+976 \1e
+¾dic
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, \12
+sh
+, \12
+mb
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+977 \1e
+¾diþ
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, \12
+sh
+, \12
+mb
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+978 \1e
+¾dþ
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+, \12
+mb
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+979 \1e
+¾diü
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, \12
+sh
+, \12
+me
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+980 \1e
+¾dimi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, \12
+sh
+, \12
+mb
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+981 \1e
+¦di
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+982 \1e
+¤di
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+983 \1e
+þ¼di
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+
+984
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+985 \1e
+þ¾di
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+
+986
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+987 \1e
+¤adi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+988 \1e
+¤d
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+989 \1e
+¦d
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+990 \1e
+¤ad
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+991 \1e
+rÙld
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+992 \1e
+rÙldi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+993 \1e
+rÙrdi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+994 \1e
+ú\8ezd_
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+995 \1e
+extsw
+(
+Regi¡\94
+
+rs
+, Regi¡\94
+¿
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+996 \1e
+muÎd
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+ =
+L\97veOE
+,
+
+997
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+998 \1e
+divd
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+o
+ =
+L\97veOE
+,
+
+999
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+1002 \1e
+¾w\9am
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+, \12
+mb
+, \12
+me
+,
+
+1003
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1004 \1e
+¾wimi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+, \12
+mb
+, \12
+me
+,
+
+1005
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1006 \1e
+¾wnm
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+, \12
+mb
+, \12
+me
+,
+
+1007
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1008 \1e
+¦wi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1009 \1e
+¤wi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1010 \1e
+þ¼wi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+
+1011
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1012 \1e
+þ¾wi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, cڡ
+O³¿nd
+&
+v®
+,
+
+1013
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1014 \1e
+¤awi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+1015 \1e
+¤w
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+1016 \1e
+¦w
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+1017 \1e
+¤aw
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+1018 \1e
+rÙlw
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+1019 \1e
+rÙlwi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+1020 \1e
+rÙrwi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+sh
+,
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+1022 \1e
+ú\8ezw_
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1024 \1e
+subi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+);
+
+1026 \1e
+cmp
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+1027 \1e
+cm¶
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+1028 \1e
+cmpw
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+1029 \1e
+cm¶w
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+1031 \1e
+mov
+(
+Regi¡\94
+
+d¡
+, cڡ
+O³¿nd
+&
+¤c
+);
+
+1035 \1e
+mov_Ïb\96_off£t
+(
+Regi¡\94
+
+d¡
+,
+Lab\96
+*
+Ïb\96
+);
+
+1038 \1e
+mul
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c1
+, Regi¡\94
+¤c2
+,
+OEB\99
+
+s
+ =
+L\97veOE
+,
+
+1039
+RCB\99
+
+r
+ =
+L\97veRC
+);
+
+1044 \1e
+üxÜ
+(\12
+bt
+, \12
+ba
+, \12
+bb
+);
+
+1045 \1e
+üþr
+(\12
+bt
+è{
+üxÜ
+(bt, bt, bt); }
+
+1046 \1e
+üeqv
+(\12
+bt
+, \12
+ba
+, \12
+bb
+);
+
+1047 \1e
+ü£t
+(\12
+bt
+è{
+üeqv
+(bt, bt, bt); }
+
+1048 \1e
+mær
+(
+Regi¡\94
+
+d¡
+);
+
+1049 \1e
+m\8er
+(
+Regi¡\94
+
+¤c
+);
+
+1050 \1e
+mtùr
+(
+Regi¡\94
+
+¤c
+);
+
+1051 \1e
+mtx\94
+(
+Regi¡\94
+
+¤c
+);
+
+1052 \1e
+müfs
+(\12
+bf
+, \12
+bç
+);
+
+1053 \1e
+mfü
+(
+Regi¡\94
+
+d¡
+);
+
+1054 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1055 \1e
+mfård
+(
+Regi¡\94
+
+d¡
+,
+DoubËRegi¡\94
+
+¤c
+);
+
+1056 \1e
+mfårwz
+(
+Regi¡\94
+
+d¡
+,
+DoubËRegi¡\94
+
+¤c
+);
+
+1057 \1e
+mtård
+(
+DoubËRegi¡\94
+
+d¡
+,
+Regi¡\94
+
+¤c
+);
+
+1058 \1e
+mtårwz
+(
+DoubËRegi¡\94
+
+d¡
+,
+Regi¡\94
+
+¤c
+);
+
+1059 \1e
+mtårwa
+(
+DoubËRegi¡\94
+
+d¡
+,
+Regi¡\94
+
+¤c
+);
+
+1062 \1e
+çke_asm
+(\f
+FAKE_OPCODE_T
+
+fÝcode
+);
+
+1063 \1e
+m¬k\94_asm
+(\12
+mcode
+);
+
+1064 \1e
+funùiÚ_desü\9dtÜ
+();
+
+1067 \1e
+¡Ý
+(cڡ \ 5*
+msg
+,
+CÚd\99iÚ
+
+cÚd
+ =
+®
+,
+
+1068
+\9at32_t
+
+code
+ =
+kDeçuÉStÝCode
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+1070 \1e
+bk±
+(
+u\9at32_t
+
+imm16
+);
+
+1073 \1e
+\9afo
+(cڡ \ 5*
+msg
+,
+CÚd\99iÚ
+
+cÚd
+ =
+®
+,
+
+1074
+\9at32_t
+
+code
+ =
+kDeçuÉStÝCode
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+1076 \1e
+dcbf
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rb
+);
+
+1077 \1e
+sync
+();
+
+1078 \1e
+lwsync
+();
+
+1079 \1e
+icbi
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rb
+);
+
+1080 \1e
+isync
+();
+
+1083 \1e
+lfd
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1084 \1e
+lfdu
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1085 \1e
+lfdx
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1086 \1e
+lfdux
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1087 \1e
+lfs
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1088 \1e
+lfsu
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1089 \1e
+lfsx
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1090 \1e
+lfsux
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1091 \1e
+¡fd
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1092 \1e
+¡fdu
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1093 \1e
+¡fdx
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1094 \1e
+¡fdux
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1095 \1e
+¡fs
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1096 \1e
+¡fsu
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1097 \1e
+¡fsx
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1098 \1e
+¡fsux
+(cڡ
+DoubËRegi¡\94
+
+äs
+, cڡ
+MemO³¿nd
+&
+¤c
+);
+
+1100 \1e
+çdd
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+1101 cڡ
+DoubËRegi¡\94
+
+äb
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1102 \1e
+fsub
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+1103 cڡ
+DoubËRegi¡\94
+
+äb
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1104 \1e
+fdiv
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+1105 cڡ
+DoubËRegi¡\94
+
+äb
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1106 \1e
+fmul
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+1107 cڡ
+DoubËRegi¡\94
+
+äc
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1108 \1e
+fcmpu
+(cڡ
+DoubËRegi¡\94
+
+äa
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1109
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+1110 \1e
+fmr
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1111
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1112 \1e
+fùiwz
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+);
+
+1113 \1e
+fùiw
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+);
+
+1114 \1e
+äim
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+);
+
+1115 \1e
+ä¥
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1116
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1117 \1e
+fcfid
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1118
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1119 \1e
+fùid
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1120
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1121 \1e
+fùidz
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1122
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1123 \1e
+f£l
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+1124 cڡ
+DoubËRegi¡\94
+
+äc
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1125
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1126 \1e
+âeg
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1127
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1128 \1e
+mtfsfi
+(\12
+bf
+, \12
+immed\9f\8b
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1129 \1e
+mffs
+(cڡ
+DoubËRegi¡\94
+
+ät
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1130 \1e
+mtfsf
+(cڡ
+DoubËRegi¡\94
+
+äb
+,
+boÞ
+
+L
+ = 1, \12
+FLM
+ = 0, boÞ
+W
+ = 0,
+
+1131
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1132 \1e
+fsq¹
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1133
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1134 \1e
+çbs
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1135
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1136 \1e
+fmadd
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+1137 cڡ
+DoubËRegi¡\94
+
+äc
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1138
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1139 \1e
+fmsub
+(cڡ
+DoubËRegi¡\94
+
+ät
+, cÚ¡ DoubËRegi¡\94
+äa
+,
+
+1140 cڡ
+DoubËRegi¡\94
+
+äc
+, cÚ¡ DoubËRegi¡\94
+äb
+,
+
+1141
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+1147 \f
+ eNÝM¬k\94Ty³s
+ {
+
+1148
+ gNON_MARKING_NOP
+ = 0,
+
+1149
+ gGROUP_ENDING_NOP
+,
+
+1150
+ gDEBUG_BREAK_NOP
+,
+
+1152
+ gPROPERTY_ACCESS_INLINED
+,
+
+1153
+ gPROPERTY_ACCESS_INLINED_CONTEXT
+,
+
+1154
+ gPROPERTY_ACCESS_INLINED_CONTEXT_DONT_DELETE
+,
+
+1156
+ gLAST_CODE_MARKER
+,
+
+1157
+ gFIRST_IC_MARKER
+ =
+PROPERTY_ACCESS_INLINED
+
+
+1160 \1e
+nÝ
+(\12
+ty³
+ = 0);
+
+1162 \1e
+push
+(
+Regi¡\94
+
+¤c
+) {
+
+1163 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1164
+¡du
+(
+¤c
+,
+MemO³¿nd
+(
+¥
+, -
+kPo\9a\8brSize
+));
+
+1166
+¡wu
+(
+¤c
+,
+MemO³¿nd
+(
+¥
+, -
+kPo\9a\8brSize
+));
+
+1170 \1e
+pÝ
+(
+Regi¡\94
+
+d¡
+) {
+
+1171 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1172
+ld
+(
+d¡
+,
+MemO³¿nd
+(
+¥
+));
+
+1174
+lwz
+(
+d¡
+,
+MemO³¿nd
+(
+¥
+));
+
+1176
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+1179 \1e
+pÝ
+(è{
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kPo\9a\8brSize
+)); }
+
+1182 \1e
+jmp
+(
+Lab\96
+*
+L
+è{
+b
+(L); }
+
+1185 \12
+SizeOfCodeG\92\94©edS\9aû
+(
+Lab\96
+*
+Ïb\96
+) {
+
+1186 \15
+pc_off£t
+(è-
+ gÏb\96
+->
+pos
+();
+
+1190 \12
+In¡ruùiÚsG\92\94©edS\9aû
+(
+Lab\96
+*
+Ïb\96
+) {
+
+1191 \15
+SizeOfCodeG\92\94©edS\9aû
+(
+Ïb\96
+è/
+ gkIn¡rSize
+;
+
+1195 þas
+ cBlockT¿mpÞ\9aePoÞScÝe
+ {
+
+1196
+ gpublic
+:
+
+1197
+ex¶ic\99
+
+BlockT¿mpÞ\9aePoÞScÝe
+(
+As£mbËr
+*
+as£m
+è:
+as£m_
+(assem) {
+
+1198
+as£m_
+->
+S\8f¹BlockT¿mpÞ\9aePoÞ
+();
+
+1200 ~
+BlockT¿mpÞ\9aePoÞScÝe
+(è{
+ gas£m_
+->
+EndBlockT¿mpÞ\9aePoÞ
+(); }
+
+1202
+ g´iv©e
+:
+
+1203
+As£mbËr
+*
+as£m_
+;
+
+1205
+DISALLOW_IMPLICIT_CONSTRUCTORS
+(
+BlockT¿mpÞ\9aePoÞScÝe
+);
+
+1211 \1e
+RecÜdJSR\91uº
+();
+
+1214 \1e
+RecÜdDebugB»akSlÙ
+();
+
+1218 \1e
+S\91RecÜdedA¡Id
+(
+Ty³F\93dbackId
+
+a¡_id
+) {
+
+1221
+ g»cÜded_a¡_id_
+ =
+a¡_id
+;
+
+1224
+Ty³F\93dbackId
+
+RecÜdedA¡Id
+() {
+
+1226 \15
+ g»cÜded_a¡_id_
+;
+
+1229 \1e
+CˬRecÜdedA¡Id
+(è{
+ g»cÜded_a¡_id_
+ =
+Ty³F\93dbackId
+::
+NÚe
+(); }
+
+1233 \1e
+RecÜdComm\92t
+(cڡ \ 5*
+msg
+);
+
+1237 \1e
+db
+(
+u\9at8_t
+
+d©a
+);
+
+1238 \1e
+dd
+(
+u\9at32_t
+
+d©a
+);
+
+1239 \1e
+em\99_±r
+(
+u\9a\8d\8c_t
+
+d©a
+);
+
+1241
+Pos\99iÚsRecÜd\94
+*
+pos\99iÚs_»cÜd\94
+(è{ \15 &
+ gpos\99iÚs_»cÜd\94_
+; }
+
+1244
+In¡r
+
+\9a¡r_©
+(\12
+pos
+è{ \15 *
+ g»\9a\8b½»t_ÿ¡
+<
+ gIn¡r
+*>(
+ gbufãr_
+ +
+ gpos
+); }
+
+1245 \1e
+\9a¡r_©_put
+(\12
+pos
+,
+In¡r
+
+\9a¡r
+) {
+
+1246 *
+ g»\9a\8b½»t_ÿ¡
+<
+ gIn¡r
+*>(
+ gbufãr_
+ +
+ gpos
+èð
+\9a¡r
+;
+
+1248 \18
+In¡r
+
+\9a¡r_©
+(
+by\8b
+*
+pc
+è{ \15 *
+ g»\9a\8b½»t_ÿ¡
+<
+ gIn¡r
+*>(
+ gpc
+); }
+
+1249 \18\1e
+\9a¡r_©_put
+(
+by\8b
+*
+pc
+,
+In¡r
+
+\9a¡r
+) {
+
+1250 *
+ g»\9a\8b½»t_ÿ¡
+<
+ gIn¡r
+*>(
+ gpc
+èð
+\9a¡r
+;
+
+1252 \18
+CÚd\99iÚ
+
+G\91CÚd\99iÚ
+(
+In¡r
+
+\9a¡r
+);
+
+1254 \18
+boÞ
+
+IsLis
+(
+In¡r
+
+\9a¡r
+);
+
+1255 \18
+boÞ
+
+IsLi
+(
+In¡r
+
+\9a¡r
+);
+
+1256 \18
+boÞ
+
+IsAddic
+(
+In¡r
+
+\9a¡r
+);
+
+1257 \18
+boÞ
+
+IsOri
+(
+In¡r
+
+\9a¡r
+);
+
+1259 \18
+boÞ
+
+IsB¿nch
+(
+In¡r
+
+\9a¡r
+);
+
+1260 \18
+Regi¡\94
+
+G\91RA
+(
+In¡r
+
+\9a¡r
+);
+
+1261 \18
+Regi¡\94
+
+G\91RB
+(
+In¡r
+
+\9a¡r
+);
+
+1262 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1263 \18
+boÞ
+
+Is64B\99LßdIÁoR12
+(
+In¡r
+
+\9a¡r1
+, In¡¸
+\9a¡r2
+, In¡¸
+\9a¡r3
+,
+
+1264
+In¡r
+
+\9a¡r4
+, In¡¸
+\9a¡r5
+);
+
+1266 \18
+boÞ
+
+Is32B\99LßdIÁoR12
+(
+In¡r
+
+\9a¡r1
+, In¡¸
+\9a¡r2
+);
+
+1269 \18
+boÞ
+
+IsCmpRegi¡\94
+(
+In¡r
+
+\9a¡r
+);
+
+1270 \18
+boÞ
+
+IsCmpImmed\9f\8b
+(
+In¡r
+
+\9a¡r
+);
+
+1271 \18
+boÞ
+
+IsRlw\9am
+(
+In¡r
+
+\9a¡r
+);
+
+1272 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1273 \18
+boÞ
+
+IsRldiþ
+(
+In¡r
+
+\9a¡r
+);
+
+1275 \18
+boÞ
+
+IsCrS\91
+(
+In¡r
+
+\9a¡r
+);
+
+1276 \18
+Regi¡\94
+
+G\91CmpImmed\9f\8bRegi¡\94
+(
+In¡r
+
+\9a¡r
+);
+
+1277 \18\12
+G\91CmpImmed\9f\8bRawImmed\9f\8b
+(
+In¡r
+
+\9a¡r
+);
+
+1278 \18
+boÞ
+
+IsNÝ
+(
+In¡r
+
+\9a¡r
+, \12
+ty³
+ =
+NON_MARKING_NOP
+);
+
+1282 \1e
+BlockT¿mpÞ\9aePoÞFÜ
+(\12
+\9a¡ruùiÚs
+);
+
+1283 \1e
+CheckT¿mpÞ\9aePoÞ
+();
+
+1285 \12
+\9a¡ruùiÚs_»qu\9ced_fÜ_mov
+(cڡ
+O³¿nd
+&
+x
+) const;
+
+1287 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1289
+boÞ
+
+u£_cÚ¡ªt_poÞ_fÜ_mov
+(cڡ
+O³¿nd
+&
+x
+, boÞ
+ÿnO±imize
+) const;
+
+1299 \1e
+Ensu»S·ûFÜ
+(\12
+¥aû_Ãeded
+);
+
+1303
+ gHªdË
+<
+ gCÚ¡ªtPoÞA¼ay
+>
+NewCÚ¡ªtPoÞ
+(
+Isީe
+*
+isީe
+);
+
+1306 \1e
+PÝuÏ\8bCÚ¡ªtPoÞ
+(
+CÚ¡ªtPoÞA¼ay
+*
+cÚ¡ªt_poÞ
+);
+
+1308 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1309
+boÞ
+
+is_cÚ¡ªt_poÞ_fuÎ
+() const {
+
+1310 \15
+ gcÚ¡ªt_poÞ_bu\9ed\94_
+.
+is_fuÎ
+();
+
+1313
+boÞ
+
+u£_ex\8bnded_cÚ¡ªt_poÞ
+() const {
+
+1314 \15
+ gcÚ¡ªt_poÞ_bu\9ed\94_
+.
+cu¼\92t_£ùiÚ
+() ==
+
+1315
+CÚ¡ªtPoÞA¼ay
+::
+EXTENDED_SECTION
+;
+
+1319 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+ ||
+V8_OOL_CONSTANT_POOL
+
+
+1320 \18\1e
+R\96oÿ\8bIÁ\94ÇlReã»nû
+(
+
+1321
+Add»ss
+
+pc
+,
+\9a\8d\8c_t
+
+d\96\8f
+, Add»s
+code_¡¬t
+,
+
+1322
+ICacheFlushMode
+
+iÿche_æush_mode
+ =
+FLUSH_ICACHE_IF_NEEDED
+);
+
+1323 \18\12
+DecodeIÁ\94ÇlReã»nû
+(
+VeùÜ
+<\ 5>
+bufãr
+,
+Add»ss
+
+pc
+);
+
+1326
+ g´Ùeùed
+:
+
+1330
+Ty³F\93dbackId
+
+»cÜded_a¡_id_
+;
+
+1332 \12
+bufãr_¥aû
+(ècÚ¡ { \15
+ g»loc_\9afo_wr\99\94
+.
+pos
+(è-
+ gpc_
+; }
+
+1335 \12
+\8frg\91_©
+(\12
+pos
+);
+
+1338 \1e
+\8frg\91_©_put
+(\12
+pos
+, \12
+\8frg\91_pos
+);
+
+1341 \1e
+RecÜdR\96ocInfo
+(
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+\9a\8d\8c_t
+
+d©a
+ = 0);
+
+1342 \1e
+RecÜdR\96ocInfo
+(cڡ
+R\96ocInfo
+&
+r\9afo
+);
+
+1343 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1344
+ gCÚ¡ªtPoÞA¼ay
+::
+LayoutSeùiÚ
+
+CÚ¡ªtPoÞAddEÁry
+(
+
+1345 cڡ
+R\96ocInfo
+&
+r\9afo
+) {
+
+1346 \15
+cÚ¡ªt_poÞ_bu\9ed\94_
+.
+AddEÁry
+(
+this
+,
+r\9afo
+);
+
+1351 \1e
+BlockT¿mpÞ\9aePoÞBefÜe
+(\12
+pc_off£t
+) {
+
+1352 ià(
+ gno_\8campÞ\9ae_poÞ_befÜe_
+ <
+ gpc_off£t
+)
+
+1353
+ gno_\8campÞ\9ae_poÞ_befÜe_
+ =
+pc_off£t
+;
+
+1356 \1e
+S\8f¹BlockT¿mpÞ\9aePoÞ
+(è{
+ g\8campÞ\9ae_poÞ_blocked_á\9ag_
+++; }
+
+1358 \1e
+EndBlockT¿mpÞ\9aePoÞ
+(è{
+ g\8campÞ\9ae_poÞ_blocked_á\9ag_
+--; }
+
+1360
+boÞ
+
+is_\8campÞ\9ae_poÞ_blocked
+() const {
+
+1361 \15
+ g\8campÞ\9ae_poÞ_blocked_á\9ag_
+ > 0;
+
+1364
+boÞ
+
+has_exû±iÚ
+(ècÚ¡ { \15
+ g\9a\8bº®_\8campÞ\9ae_exû±iÚ_
+; }
+
+1366
+boÞ
+
+is_\8campÞ\9ae_em\99\8bd
+(ècÚ¡ { \15
+ g\8campÞ\9ae_em\99\8bd_
+; }
+
+1368 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1369 \1e
+£t_cÚ¡ªt_poÞ_ava\9eabË
+(
+boÞ
+
+ava\9eabË
+) {
+
+1370
+ gcÚ¡ªt_poÞ_ava\9eabË_
+ =
+ava\9eabË
+;
+
+1374
+ g´iv©e
+:
+
+1380 \18cڡ \12
+kG
+ = 32;
+
+1385 \12
+ gÃxt_bufãr_check_
+;
+
+1388 \12
+ g\8campÞ\9ae_poÞ_blocked_á\9ag_
+;
+
+1389 \12
+ gno_\8campÞ\9ae_poÞ_befÜe_
+;
+
+1393 \18cڡ \12
+ gkMaxR\96ocSize
+ =
+R\96ocInfoWr\99\94
+::
+kMaxSize
+;
+
+1394
+R\96ocInfoWr\99\94
+
+ g»loc_\9afo_wr\99\94
+;
+
+1397 \12
+ gϡ_bound_pos_
+;
+
+1399 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1400
+CÚ¡ªtPoÞBu\9ed\94
+
+ gcÚ¡ªt_poÞ_bu\9ed\94_
+;
+
+1404
+\9al\9ae
+ \1e
+CheckBufãr
+();
+
+1405 \1e
+GrowBufãr
+();
+
+1406
+\9al\9ae
+ \1e
+em\99
+(
+In¡r
+
+x
+);
+
+1407
+\9al\9ae
+ \1e
+CheckT¿mpÞ\9aePoÞQuick
+();
+
+1410 \1e
+a_fÜm
+(
+In¡r
+
+\9a¡r
+,
+DoubËRegi¡\94
+
+ät
+, DoubËRegi¡\94
+äa
+,
+
+1411
+DoubËRegi¡\94
+
+äb
+,
+RCB\99
+
+r
+);
+
+1412 \1e
+d_fÜm
+(
+In¡r
+
+\9a¡r
+,
+Regi¡\94
+
+¹
+, Regi¡\94
+¿
+, cڡ
+\9a\8d\8c_t
+
+v®
+,
+
+1413
+boÞ
+
+sigÃd_di¥
+);
+
+1414 \1e
+x_fÜm
+(
+In¡r
+
+\9a¡r
+,
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+,
+RCB\99
+
+r
+);
+
+1415 \1e
+xo_fÜm
+(
+In¡r
+
+\9a¡r
+,
+Regi¡\94
+
+¹
+, Regi¡\94
+¿
+, Regi¡\94
+rb
+,
+OEB\99
+
+o
+,
+
+1416
+RCB\99
+
+r
+);
+
+1417 \1e
+md_fÜm
+(
+In¡r
+
+\9a¡r
+,
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, \12
+shiá
+, \12
+maskb\99
+,
+
+1418
+RCB\99
+
+r
+);
+
+1419 \1e
+mds_fÜm
+(
+In¡r
+
+\9a¡r
+,
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, Regi¡\94
+rb
+, \12
+maskb\99
+,
+
+1420
+RCB\99
+
+r
+);
+
+1423 \1e
+´\9at
+(
+Lab\96
+*
+L
+);
+
+1424 \12
+max_»ach_äom
+(\12
+pos
+);
+
+1425 \1e
+b\9ad_to
+(
+Lab\96
+*
+L
+, \12
+pos
+);
+
+1426 \1e
+Ãxt
+(
+Lab\96
+*
+L
+);
+
+1428 þas
+ cT¿mpÞ\9ae
+ {
+
+1429
+ gpublic
+:
+
+1430
+T¿mpÞ\9ae
+() {
+
+1431
+Ãxt_¦Ù_
+ = 0;
+
+1432
+ gä\93_¦Ù_couÁ_
+ = 0;
+
+1434
+T¿mpÞ\9ae
+(\12
+¡¬t
+, \12
+¦Ù_couÁ
+) {
+
+1435
+ gÃxt_¦Ù_
+ =
+¡¬t
+;
+
+1436
+ gä\93_¦Ù_couÁ_
+ =
+¦Ù_couÁ
+;
+
+1438 \12
+\8fke_¦Ù
+() {
+
+1439 \12
+ g\8campÞ\9ae_¦Ù
+ =
+kInv®idSlÙPos
+;
+
+1440 ià(
+ gä\93_¦Ù_couÁ_
+ <= 0) {
+
+1444
+DCHECK
+(0);
+
+1447
+ g\8campÞ\9ae_¦Ù
+ =
+Ãxt_¦Ù_
+;
+
+1448
+ gä\93_¦Ù_couÁ_
+--;
+
+1449
+ gÃxt_¦Ù_
+ +ð
+kT¿mpÞ\9aeSlÙsSize
+;
+
+1451 \15
+ g\8campÞ\9ae_¦Ù
+;
+
+1454
+ g´iv©e
+:
+
+1455 \12
+Ãxt_¦Ù_
+;
+
+1456 \12
+ gä\93_¦Ù_couÁ_
+;
+
+1459
+\9at32_t
+
+g\91_\8campÞ\9ae_\92\8cy
+();
+
+1460 \12
+ gunbound_Ïb\96s_couÁ_
+;
+
+1466
+boÞ
+
+ g\8campÞ\9ae_em\99\8bd_
+;
+
+1467 \18cڡ \12
+ gkT¿mpÞ\9aeSlÙsSize
+ =
+kIn¡rSize
+;
+
+1468 \18cڡ \12
+ gkMaxCÚdB¿nchR\97ch
+ = (1 << (16 - 1)) - 1;
+
+1469 \18cڡ \12
+ gkMaxBlockT¿mpÞ\9aeSeùiÚSize
+ = 64 *
+kIn¡rSize
+;
+
+1470 \18cڡ \12
+ gkInv®idSlÙPos
+ = -1;
+
+1472
+T¿mpÞ\9ae
+
+ g\8campÞ\9ae_
+;
+
+1473
+boÞ
+
+ g\9a\8bº®_\8campÞ\9ae_exû±iÚ_
+;
+
+1475
+ä\9bnd
+
+þass
+
+ gRegExpMaüoAs£mbËrPPC
+;
+
+1476
+ä\9bnd
+
+þass
+
+ gR\96ocInfo
+;
+
+1477
+ä\9bnd
+
+þass
+
+ gCodeP©ch\94
+;
+
+1478
+ä\9bnd
+
+þass
+
+ gBlockT¿mpÞ\9aePoÞScÝe
+;
+
+1479
+Pos\99iÚsRecÜd\94
+
+ gpos\99iÚs_»cÜd\94_
+;
+
+1480
+ä\9bnd
+
+þass
+
+ gPos\99iÚsRecÜd\94
+;
+
+1481
+ä\9bnd
+
+þass
+
+ gEnsu»S·û
+;
+
+1485 þas
+ cEnsu»S·û
+
+ gBASE_EMBEDDED
+ {
+
+1486
+ gpublic
+:
+
+1487
+ex¶ic\99
+
+Ensu»S·û
+(
+As£mbËr
+*
+as£mbËr
+è{\87s£mbËr->
+CheckBufãr
+(); }
+
+ @builtins-ppc.cc
+
+5 \ 2
+ ~"¤c/v8.h
+"
+
+7 #ià
+V8_TARGET_ARCH_PPC
+
+
+9 \ 2
+ ~"¤c/codeg\92.h
+"
+
+10 \ 2
+ ~"¤c/debug.h
+"
+
+11 \ 2
+ ~"¤c/deÝtimiz\94.h
+"
+
+12 \ 2
+ ~"¤c/fuÎ-codeg\92.h
+"
+
+13 \ 2
+ ~"¤c/ruÁime/ruÁime.h
+"
+
+15
+Çme¥aû
+
+ gv8
+ {
+
+16
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+19 \ 1
+ #__
+
+ `ACCESS_MASM
+(
+masm
+)
+
+ )
+
+22 \1e
+ gBu\9et\9as
+::
+G\92\94©e_AdtÜ
+(
+MaüoAs£mbËr
+*
+masm
+,
+CFunùiÚId
+
+id
+,
+
+23
+Bu\9et\9aEx\8caArgum\92ts
+
+ex\8ca_¬gs
+) {
+
+36 \12
+ gnum_ex\8ca_¬gs
+ = 0;
+
+37 ià(
+ gex\8ca_¬gs
+ =ð
+NEEDS_CALLED_FUNCTION
+) {
+
+38
+num_ex\8ca_¬gs
+ = 1;
+
+39
+__
+
+push
+(
+r4
+);
+
+41
+DCHECK
+(
+ex\8ca_¬gs
+ =ð
+NO_EXTRA_ARGUMENTS
+);
+
+46
+__
+
+addi
+(
+r3
+,\843,
+O³¿nd
+(
+num_ex\8ca_¬gs
+ + 1));
+
+47
+__
+
+JumpToEx\8bº®Reã»nû
+(
+Ex\8bº®Reã»nû
+(
+id
+,
+masm
+->
+isީe
+()));
+
+52 \18\1e
+G\92\94©eLßdIÁ\94ÇlA¼ayFunùiÚ
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+53
+Regi¡\94
+
+»suÉ
+) {
+
+56
+__
+
+LßdP
+(
+»suÉ
+,
+
+57
+MemO³¿nd
+(
+ý
+,
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+GLOBAL_OBJECT_INDEX
+)));
+
+58
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+ÔesuÉ,
+Glob®Objeù
+::
+kN©iveCÚ\8bxtOff£t
+));
+
+60
+__
+
+LßdP
+(
+»suÉ
+,
+
+61
+MemO³¿nd
+(
+»suÉ
+,
+Cڋxt
+::
+SlÙOff£t
+(
+
+62
+Cڋxt
+::
+INTERNAL_ARRAY_FUNCTION_INDEX
+)));
+
+67 \18\1e
+G\92\94©eLßdA¼ayFunùiÚ
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+»suÉ
+) {
+
+70
+__
+
+LßdP
+(
+»suÉ
+,
+
+71
+MemO³¿nd
+(
+ý
+,
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+GLOBAL_OBJECT_INDEX
+)));
+
+72
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+ÔesuÉ,
+Glob®Objeù
+::
+kN©iveCÚ\8bxtOff£t
+));
+
+74
+__
+
+LßdP
+(
+
+75
+»suÉ
+,
+
+76
+MemO³¿nd
+(
+»suÉ
+,
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+ARRAY_FUNCTION_INDEX
+)));
+
+80 \1e
+ gBu\9et\9as
+::
+G\92\94©e_IÁ\94ÇlA¼ayCode
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+86
+Lab\96
+
+g\92\94ic_¬¿y_code
+,
+ gÚe_Ü_mÜe_¬gum\92ts
+,
+ gtwo_Ü_mÜe_¬gum\92ts
+;
+
+89
+G\92\94©eLßdIÁ\94ÇlA¼ayFunùiÚ
+(
+masm
+,
+r4
+);
+
+91 ià(
+ gFLAG_debug_code
+) {
+
+93
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kPrÙÙy³OrIn\99\9flMOff£t
+));
+
+94
+__
+
+Te¡IfSmi
+(
+r5
+,
+r0
+);
+
+95
+__
+
+As£¹
+(
+Ã
+,
+kUÃx³ùedIn\99\9flMFÜIÁ\94ÇlA¼ayFunùiÚ
+,
+ü0
+);
+
+96
+__
+
+Com·»ObjeùTy³
+(
+r5
+,
+r6
+,
+r7
+,
+MAP_TYPE
+);
+
+97
+__
+
+As£¹
+(
+eq
+,
+kUÃx³ùedIn\99\9flMFÜIÁ\94ÇlA¼ayFunùiÚ
+);
+
+103
+IÁ\94ÇlA¼ayCÚ¡ruùÜStub
+
+¡ub
+(
+masm
+->
+isީe
+());
+
+104
+__
+
+Ta\9eC®lStub
+(&
+¡ub
+);
+
+108 \1e
+ gBu\9et\9as
+::
+G\92\94©e_A¼ayCode
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+114
+Lab\96
+
+g\92\94ic_¬¿y_code
+,
+ gÚe_Ü_mÜe_¬gum\92ts
+,
+ gtwo_Ü_mÜe_¬gum\92ts
+;
+
+117
+G\92\94©eLßdA¼ayFunùiÚ
+(
+masm
+,
+r4
+);
+
+119 ià(
+ gFLAG_debug_code
+) {
+
+121
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kPrÙÙy³OrIn\99\9flMOff£t
+));
+
+122
+__
+
+Te¡IfSmi
+(
+r5
+,
+r0
+);
+
+123
+__
+
+As£¹
+(
+Ã
+,
+kUÃx³ùedIn\99\9flMFÜA¼ayFunùiÚ
+,
+ü0
+);
+
+124
+__
+
+Com·»ObjeùTy³
+(
+r5
+,
+r6
+,
+r7
+,
+MAP_TYPE
+);
+
+125
+__
+
+As£¹
+(
+eq
+,
+kUÃx³ùedIn\99\9flMFÜA¼ayFunùiÚ
+);
+
+130
+__
+
+LßdRoÙ
+(
+r5
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+131
+A¼ayCÚ¡ruùÜStub
+
+¡ub
+(
+masm
+->
+isީe
+());
+
+132
+__
+
+Ta\9eC®lStub
+(&
+¡ub
+);
+
+136 \1e
+ gBu\9et\9as
+::
+G\92\94©e_S\8c\9agCÚ¡ruùCode
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+144
+CouÁ\94s
+*
+couÁ\94s
+ =
+masm
+->
+isީe
+()->counters();
+
+145
+__
+
+Inüem\92tCouÁ\94
+(
+couÁ\94s
+->
+¡r\9ag_ùÜ_ÿÎs
+(), 1,
+r5
+,
+r6
+);
+
+147
+Regi¡\94
+
+ gfunùiÚ
+ =
+r4
+;
+
+148 ià(
+ gFLAG_debug_code
+) {
+
+149
+__
+
+LßdGlob®FunùiÚ
+(
+Cڋxt
+::
+STRING_FUNCTION_INDEX
+,
+r5
+);
+
+150
+__
+
+cmp
+(
+funùiÚ
+,
+r5
+);
+
+151
+__
+
+As£¹
+(
+eq
+,
+kUÃx³ùedS\8c\9agFunùiÚ
+);
+
+155
+Lab\96
+
+ gno_¬gum\92ts
+;
+
+156
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+157
+__
+
+beq
+(&
+no_¬gum\92ts
+);
+
+159
+__
+
+subi
+(
+r3
+,\843,
+O³¿nd
+(1));
+
+160
+__
+
+ShiáLeáImm
+(
+r3
+,\843,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+161
+__
+
+add
+(
+¥
+, sp,
+r3
+);
+
+162
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+));
+
+164
+__
+
+DrÝ
+(2);
+
+166
+Regi¡\94
+
+ g¬gum\92t
+ =
+r5
+;
+
+167
+Lab\96
+
+ gnÙ_ÿched
+,
+ g¬gum\92t_is_¡r\9ag
+;
+
+168
+__
+
+LookupNumb\94S\8c\9agCache
+(
+r3
+,
+
+169
+¬gum\92t
+,
+
+170
+r6
+,
+
+171
+r7
+,
+
+172
+r8
+,
+
+173 &
+nÙ_ÿched
+);
+
+174
+__
+
+Inüem\92tCouÁ\94
+(
+couÁ\94s
+->
+¡r\9ag_ùÜ_ÿched_numb\94
+(), 1,
+r6
+,
+r7
+);
+
+175
+__
+
+b\9ad
+(&
+¬gum\92t_is_¡r\9ag
+);
+
+183
+Lab\96
+
+ ggc_»qu\9ced
+;
+
+184
+__
+
+AÎoÿ\8b
+(
+JSV®ue
+::
+kSize
+,
+
+185
+r3
+,
+
+186
+r6
+,
+
+187
+r7
+,
+
+188 &
+gc_»qu\9ced
+,
+TAG_OBJECT
+);
+
+191
+Regi¡\94
+
+ gm
+ =
+r6
+;
+
+192
+__
+
+LßdGlob®FunùiÚIn\99\9flM
+(
+funùiÚ
+,
+m
+,
+r7
+);
+
+193 ià(
+ gFLAG_debug_code
+) {
+
+194
+__
+
+lbz
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kIn¡ªûSizeOff£t
+));
+
+195
+__
+
+cmpi
+(
+r7
+,
+O³¿nd
+(
+JSV®ue
+::
+kSize
+ >>
+kPo\9a\8brSizeLog2
+));
+
+196
+__
+
+As£¹
+(
+eq
+,
+kUÃx³ùedS\8c\9agW¿µ\94In¡ªûSize
+);
+
+197
+__
+
+lbz
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kUnu£dPrÝ\94tyF\9bldsOff£t
+));
+
+198
+__
+
+cmpi
+(
+r7
+,
+O³¿nd
+::
+Z\94o
+());
+
+199
+__
+
+As£¹
+(
+eq
+,
+kUÃx³ùedUnu£dPrÝ\94t\9bsOfS\8c\9agW¿µ\94
+);
+
+201
+__
+
+StÜeP
+(
+m
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pObjeù
+::
+kMOff£t
+),
+r0
+);
+
+203
+__
+
+LßdRoÙ
+(
+r6
+,
+H\97p
+::
+kEm±yFixedA¼ayRoÙIndex
+);
+
+204
+__
+
+StÜeP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kPrÝ\94t\9bsOff£t
+),
+r0
+);
+
+205
+__
+
+StÜeP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+),
+r0
+);
+
+207
+__
+
+StÜeP
+(
+¬gum\92t
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSV®ue
+::
+kV®ueOff£t
+),
+r0
+);
+
+210
+STATIC_ASSERT
+(
+JSV®ue
+::
+kSize
+ =ð4 *
+kPo\9a\8brSize
+);
+
+212
+__
+
+R\91
+();
+
+216
+Lab\96
+
+ gcÚv\94t_¬gum\92t
+;
+
+217
+__
+
+b\9ad
+(&
+nÙ_ÿched
+);
+
+218
+__
+
+JumpIfSmi
+(
+r3
+, &
+cÚv\94t_¬gum\92t
+);
+
+221
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+222
+__
+
+lbz
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+223
+STATIC_ASSERT
+(
+kNÙS\8c\9agTag
+ != 0);
+
+224
+__
+
+ªdi
+(
+r0
+,
+r6
+,
+O³¿nd
+(
+kIsNÙS\8c\9agMask
+));
+
+225
+__
+
+bÃ
+(&
+cÚv\94t_¬gum\92t
+,
+ü0
+);
+
+226
+__
+
+mr
+(
+¬gum\92t
+,
+r3
+);
+
+227
+__
+
+Inüem\92tCouÁ\94
+(
+couÁ\94s
+->
+¡r\9ag_ùÜ_cÚv\94siÚs
+(), 1,
+r6
+,
+r7
+);
+
+228
+__
+
+b
+(&
+¬gum\92t_is_¡r\9ag
+);
+
+231
+__
+
+b\9ad
+(&
+cÚv\94t_¬gum\92t
+);
+
+232
+__
+
+push
+(
+funùiÚ
+);
+
+233
+__
+
+Inüem\92tCouÁ\94
+(
+couÁ\94s
+->
+¡r\9ag_ùÜ_cÚv\94siÚs
+(), 1,
+r6
+,
+r7
+);
+
+235
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+236
+__
+
+push
+(
+r3
+);
+
+237
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+TO_STRING
+,
+CALL_FUNCTION
+);
+
+239
+__
+
+pÝ
+(
+funùiÚ
+);
+
+240
+__
+
+mr
+(
+¬gum\92t
+,
+r3
+);
+
+241
+__
+
+b
+(&
+¬gum\92t_is_¡r\9ag
+);
+
+245
+__
+
+b\9ad
+(&
+no_¬gum\92ts
+);
+
+246
+__
+
+LßdRoÙ
+(
+¬gum\92t
+,
+H\97p
+::
+kem±y_¡r\9agRoÙIndex
+);
+
+247
+__
+
+DrÝ
+(1);
+
+248
+__
+
+b
+(&
+¬gum\92t_is_¡r\9ag
+);
+
+252
+__
+
+b\9ad
+(&
+gc_»qu\9ced
+);
+
+253
+__
+
+Inüem\92tCouÁ\94
+(
+couÁ\94s
+->
+¡r\9ag_ùÜ_gc_»qu\9ced
+(), 1,
+r6
+,
+r7
+);
+
+255
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+256
+__
+
+push
+(
+¬gum\92t
+);
+
+257
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kNewS\8c\9agW¿µ\94
+, 1);
+
+259
+__
+
+R\91
+();
+
+263 \18\1e
+C®lRuÁimePassFunùiÚ
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+264
+RuÁime
+::
+FunùiÚId
+
+funùiÚ_id
+) {
+
+265
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+268
+__
+
+Push
+(
+r4
+,\844);
+
+270
+__
+
+C®lRuÁime
+(
+funùiÚ_id
+, 1);
+
+272
+__
+
+PÝ
+(
+r4
+);
+
+276 \18\1e
+G\92\94©eTa\9eC®lToSh¬edCode
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+277
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+278
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(\9d,
+Sh¬edFunùiÚInfo
+::
+kCodeOff£t
+));
+
+279
+__
+
+addi
+(
+\9d
+, ip,
+O³¿nd
+(
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+280
+__
+
+JumpToJSEÁry
+(
+\9d
+);
+
+284 \18\1e
+G\92\94©eTa\9eC®lToR\91uºedCode
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+285
+__
+
+addi
+(
+\9d
+,
+r3
+,
+O³¿nd
+(
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+286
+__
+
+JumpToJSEÁry
+(
+\9d
+);
+
+290 \1e
+ gBu\9et\9as
+::
+G\92\94©e_InO±imiz©iÚQueue
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+296
+Lab\96
+
+ok
+;
+
+297
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kS\8fckLim\99RoÙIndex
+);
+
+298
+__
+
+cm¶
+(
+¥
+,
+\9d
+);
+
+299
+__
+
+bge
+(&
+ok
+);
+
+301
+C®lRuÁimePassFunùiÚ
+(
+masm
+,
+RuÁime
+::
+kTryIn¡®lO±imizedCode
+);
+
+302
+G\92\94©eTa\9eC®lToR\91uºedCode
+(
+masm
+);
+
+304
+__
+
+b\9ad
+(&
+ok
+);
+
+305
+G\92\94©eTa\9eC®lToSh¬edCode
+(
+masm
+);
+
+309 \18\1e
+G\92\94©e_JSCÚ¡ruùStubH\96³r
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+310
+boÞ
+
+is_i_funùiÚ
+,
+
+311
+boÞ
+
+ü\97\8b_mem\92to
+) {
+
+321
+DCHECK
+(!
+is_i_funùiÚ
+ || !
+ü\97\8b_mem\92to
+);
+
+323
+Isީe
+*
+ gisީe
+ =
+masm
+->
+isީe
+();
+
+327
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+CONSTRUCT
+);
+
+329 ià(
+ gü\97\8b_mem\92to
+) {
+
+330
+__
+
+As£¹Undef\9aedOrAÎoÿtiÚS\99e
+(
+r5
+,
+r6
+);
+
+331
+__
+
+push
+(
+r5
+);
+
+335
+__
+
+SmiTag
+(
+r3
+);
+
+336
+__
+
+push
+(
+r3
+);
+
+337
+__
+
+push
+(
+r4
+);
+
+341
+Lab\96
+
+ g¹_ÿÎ
+,
+ g®loÿ\8bd
+;
+
+342 ià(
+ gFLAG_\9al\9ae_Ãw
+) {
+
+343
+Lab\96
+
+ gundo_®loÿtiÚ
+;
+
+344
+Ex\8bº®Reã»nû
+
+ gdebug_¡\95_\9a_å
+ =
+
+345
+Ex\8bº®Reã»nû
+::
+debug_¡\95_\9a_å_add»ss
+(
+isީe
+);
+
+346
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+debug_¡\95_\9a_å
+));
+
+347
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(r5));
+
+348
+__
+
+cmpi
+(
+r5
+,
+O³¿nd
+::
+Z\94o
+());
+
+349
+__
+
+bÃ
+(&
+¹_ÿÎ
+);
+
+353
+__
+
+LßdP
+(
+r5
+,
+
+354
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kPrÙÙy³OrIn\99\9flMOff£t
+));
+
+355
+__
+
+JumpIfSmi
+(
+r5
+, &
+¹_ÿÎ
+);
+
+356
+__
+
+Com·»ObjeùTy³
+(
+r5
+,
+r6
+,
+r7
+,
+MAP_TYPE
+);
+
+357
+__
+
+bÃ
+(&
+¹_ÿÎ
+);
+
+364
+__
+
+Com·»In¡ªûTy³
+(
+r5
+,
+r6
+,
+JS_FUNCTION_TYPE
+);
+
+365
+__
+
+beq
+(&
+¹_ÿÎ
+);
+
+367 ià(!
+ gis_i_funùiÚ
+) {
+
+368
+Lab\96
+
+ g®loÿ\8b
+;
+
+369
+MemO³¿nd
+
+ gb\99_f\9bld3
+ =
+F\9bldMemO³¿nd
+(
+r5
+,
+M
+::
+kB\99F\9bld3Off£t
+);
+
+371
+__
+
+lwz
+(
+r7
+,
+b\99_f\9bld3
+);
+
+372
+__
+
+ gDecodeF\9bld
+<
+ gM
+::
+CÚ¡ruùiÚCouÁ
+>(
+r11
+,
+ gr7
+);
+
+373
+STATIC_ASSERT
+(
+JSFunùiÚ
+::
+kNoSÏckT¿ck\9ag
+ == 0);
+
+374
+__
+
+cmpi
+(
+r11
+,
+O³¿nd
+::
+Z\94o
+());
+
+375
+__
+
+beq
+(&
+®loÿ\8b
+);
+
+377
+__
+
+Add
+(
+r7
+,\847, -(1 <<
+M
+::
+CÚ¡ruùiÚCouÁ
+::
+kShiá
+),
+r0
+);
+
+378
+__
+
+¡w
+(
+r7
+,
+b\99_f\9bld3
+);
+
+379
+__
+
+cmpi
+(
+r11
+,
+O³¿nd
+(
+JSFunùiÚ
+::
+kF\9aishSÏckT¿ck\9ag
+));
+
+380
+__
+
+bÃ
+(&
+®loÿ\8b
+);
+
+382
+__
+
+push
+(
+r4
+);
+
+384
+__
+
+Push
+(
+r5
+,
+r4
+);
+
+385
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kF\9a®izeIn¡ªûSize
+, 1);
+
+387
+__
+
+PÝ
+(
+r4
+,
+r5
+);
+
+389
+__
+
+b\9ad
+(&
+®loÿ\8b
+);
+
+395
+__
+
+lbz
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+M
+::
+kIn¡ªûSizeOff£t
+));
+
+396 ià(
+ gü\97\8b_mem\92to
+) {
+
+397
+__
+
+addi
+(
+r6
+,\846,
+O³¿nd
+(
+AÎoÿtiÚMem\92to
+::
+kSize
+ /
+kPo\9a\8brSize
+));
+
+400
+__
+
+AÎoÿ\8b
+(
+r6
+,
+r7
+,
+r8
+,
+r9
+, &
+¹_ÿÎ
+,
+SIZE_IN_WORDS
+);
+
+408
+__
+
+LßdRoÙ
+(
+r9
+,
+H\97p
+::
+kEm±yFixedA¼ayRoÙIndex
+);
+
+409
+__
+
+mr
+(
+r8
+,
+r7
+);
+
+410
+__
+
+StÜeP
+(
+r5
+,
+MemO³¿nd
+(
+r8
+,
+JSObjeù
+::
+kMOff£t
+));
+
+411
+__
+
+StÜeP
+(
+r9
+,
+MemO³¿nd
+(
+r8
+,
+JSObjeù
+::
+kPrÝ\94t\9bsOff£t
+));
+
+412
+__
+
+StÜeP
+(
+r9
+,
+MemO³¿nd
+(
+r8
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+));
+
+413
+__
+
+addi
+(
+r8
+,\848,
+O³¿nd
+(
+JSObjeù
+::
+kEËm\92tsOff£t
+ +
+kPo\9a\8brSize
+));
+
+415
+__
+
+ShiáLeáImm
+(
+r9
+,
+r6
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+416
+__
+
+add
+(
+r9
+,
+r7
+,\849);
+
+425
+DCHECK_EQ
+(3 *
+kPo\9a\8brSize
+,
+JSObjeù
+::
+kH\97d\94Size
+);
+
+426
+__
+
+LßdRoÙ
+(
+r10
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+428 ià(!
+ gis_i_funùiÚ
+) {
+
+429
+Lab\96
+
+ gno_\9aobjeù_¦ack_\8cack\9ag
+;
+
+432
+STATIC_ASSERT
+(
+JSFunùiÚ
+::
+kNoSÏckT¿ck\9ag
+ == 0);
+
+433
+__
+
+cmpi
+(
+r11
+,
+O³¿nd
+::
+Z\94o
+());
+
+434
+__
+
+beq
+(&
+no_\9aobjeù_¦ack_\8cack\9ag
+);
+
+437
+__
+
+lbz
+(
+r3
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+M
+::
+kP»AÎoÿ\8bdPrÝ\94tyF\9bldsOff£t
+));
+
+438 ià(
+ gFLAG_debug_code
+) {
+
+439
+__
+
+ShiáLeáImm
+(
+r0
+,
+r3
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+440
+__
+
+add
+(
+r0
+,
+r8
+,\840);
+
+442
+__
+
+cmp
+(
+r0
+,
+r9
+);
+
+443
+__
+
+As£¹
+(
+Ë
+,
+kUÃx³ùedNumb\94OfP»AÎoÿ\8bdPrÝ\94tyF\9blds
+);
+
+446
+Lab\96
+
+ gdÚe
+;
+
+447
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+448
+__
+
+beq
+(&
+dÚe
+);
+
+449
+__
+
+In\99\9flizeNF\9bldsW\99hF\9eËr
+(
+r8
+,
+r3
+,
+r10
+);
+
+450
+__
+
+b\9ad
+(&
+dÚe
+);
+
+453
+__
+
+LßdRoÙ
+(
+r10
+,
+H\97p
+::
+kOÃPo\9a\8brF\9eËrMRoÙIndex
+);
+
+456
+__
+
+b\9ad
+(&
+no_\9aobjeù_¦ack_\8cack\9ag
+);
+
+459 ià(
+ gü\97\8b_mem\92to
+) {
+
+460
+__
+
+subi
+(
+r3
+,
+r9
+,
+O³¿nd
+(
+AÎoÿtiÚMem\92to
+::
+kSize
+));
+
+461
+__
+
+In\99\9flizeF\9bldsW\99hF\9eËr
+(
+r8
+,
+r3
+,
+r10
+);
+
+465
+__
+
+LßdRoÙ
+(
+r10
+,
+H\97p
+::
+kAÎoÿtiÚMem\92toMRoÙIndex
+);
+
+466
+__
+
+StÜeP
+(
+r10
+,
+MemO³¿nd
+(
+r8
+,
+AÎoÿtiÚMem\92to
+::
+kMOff£t
+));
+
+468
+__
+
+LßdP
+(
+r10
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+469
+__
+
+StÜeP
+(
+r10
+,
+
+470
+MemO³¿nd
+(
+r8
+,
+AÎoÿtiÚMem\92to
+::
+kAÎoÿtiÚS\99eOff£t
+));
+
+471
+__
+
+addi
+(
+r8
+,\848,
+O³¿nd
+(
+AÎoÿtiÚMem\92to
+::
+kAÎoÿtiÚS\99eOff£t
+ +
+
+472
+kPo\9a\8brSize
+));
+
+474
+__
+
+In\99\9flizeF\9bldsW\99hF\9eËr
+(
+r8
+,
+r9
+,
+r10
+);
+
+481
+__
+
+addi
+(
+r7
+,\847,
+O³¿nd
+(
+kH\97pObjeùTag
+));
+
+488
+__
+
+lbz
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+M
+::
+kUnu£dPrÝ\94tyF\9bldsOff£t
+));
+
+491
+__
+
+lbz
+(
+r0
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+M
+::
+kP»AÎoÿ\8bdPrÝ\94tyF\9bldsOff£t
+));
+
+492
+__
+
+add
+(
+r6
+,\846,
+r0
+);
+
+493
+__
+
+lbz
+(
+r0
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+M
+::
+kInObjeùPrÝ\94t\9bsOff£t
+));
+
+494
+__
+
+sub
+(
+r6
+,\846,
+r0
+,
+L\97veOE
+,
+S\91RC
+);
+
+497
+__
+
+beq
+(&
+®loÿ\8bd
+,
+ü0
+);
+
+498
+__
+
+As£¹
+(
+ge
+,
+kPrÝ\94tyAÎoÿtiÚCouÁFa\9eed
+,
+ü0
+);
+
+506
+__
+
+addi
+(
+r3
+,
+r6
+,
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ /
+kPo\9a\8brSize
+));
+
+507
+__
+
+AÎoÿ\8b
+(
+
+508
+r3
+,
+r8
+,
+r9
+,
+r5
+, &
+undo_®loÿtiÚ
+,
+
+509
+¡©ic_ÿ¡
+<
+AÎoÿtiÚFÏgs
+>(
+RESULT_CONTAINS_TOP
+ |
+SIZE_IN_WORDS
+));
+
+516
+__
+
+LßdRoÙ
+(
+r9
+,
+H\97p
+::
+kFixedA¼ayMRoÙIndex
+);
+
+517
+__
+
+mr
+(
+r5
+,
+r8
+);
+
+518
+DCHECK_EQ
+(0 *
+kPo\9a\8brSize
+,
+JSObjeù
+::
+kMOff£t
+);
+
+519
+__
+
+StÜeP
+(
+r9
+,
+MemO³¿nd
+(
+r5
+));
+
+520
+DCHECK_EQ
+(1 *
+kPo\9a\8brSize
+,
+FixedA¼ay
+::
+kL\92gthOff£t
+);
+
+521
+__
+
+SmiTag
+(
+r3
+,
+r6
+);
+
+522
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+r5
+,
+kPo\9a\8brSize
+));
+
+523
+__
+
+addi
+(
+r5
+,\845,
+O³¿nd
+(2 *
+kPo\9a\8brSize
+));
+
+531
+DCHECK_EQ
+(2 *
+kPo\9a\8brSize
+,
+FixedA¼ay
+::
+kH\97d\94Size
+);
+
+533
+Lab\96
+
+ gdÚe
+;
+
+534
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+::
+Z\94o
+());
+
+535
+__
+
+beq
+(&
+dÚe
+);
+
+536 ià(!
+ gis_i_funùiÚ
+ ||
+ gü\97\8b_mem\92to
+) {
+
+537
+__
+
+LßdRoÙ
+(
+r10
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+538 } \vià(
+ gFLAG_debug_code
+) {
+
+539
+__
+
+LßdRoÙ
+(
+r11
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+540
+__
+
+cmp
+(
+r10
+,
+r11
+);
+
+541
+__
+
+As£¹
+(
+eq
+,
+kUndef\9aedV®ueNÙLßded
+);
+
+543
+__
+
+In\99\9flizeNF\9bldsW\99hF\9eËr
+(
+r5
+,
+r6
+,
+r10
+);
+
+544
+__
+
+b\9ad
+(&
+dÚe
+);
+
+552
+__
+
+addi
+(
+r8
+,\848,
+O³¿nd
+(
+kH\97pObjeùTag
+));
+
+553
+__
+
+StÜeP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+JSObjeù
+::
+kPrÝ\94t\9bsOff£t
+),
+r0
+);
+
+558
+__
+
+b
+(&
+®loÿ\8bd
+);
+
+564
+__
+
+b\9ad
+(&
+undo_®loÿtiÚ
+);
+
+565
+__
+
+UndoAÎoÿtiÚInNewS·û
+(
+r7
+,
+r8
+);
+
+570
+__
+
+b\9ad
+(&
+¹_ÿÎ
+);
+
+571 ià(
+ gü\97\8b_mem\92to
+) {
+
+573
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+574
+__
+
+push
+(
+r5
+);
+
+577
+__
+
+push
+(
+r4
+);
+
+578 ià(
+ gü\97\8b_mem\92to
+) {
+
+579
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kNewObjeùW\99hAÎoÿtiÚS\99e
+, 2);
+
+581
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kNewObjeù
+, 1);
+
+583
+__
+
+mr
+(
+r7
+,
+r3
+);
+
+588
+Lab\96
+
+ gcouÁ_\9aüem\92\8bd
+;
+
+589 ià(
+ gü\97\8b_mem\92to
+) {
+
+590
+__
+
+b
+(&
+couÁ_\9aüem\92\8bd
+);
+
+595
+__
+
+b\9ad
+(&
+®loÿ\8bd
+);
+
+597 ià(
+ gü\97\8b_mem\92to
+) {
+
+598
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+ * 2));
+
+599
+__
+
+LßdRoÙ
+(
+r8
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+600
+__
+
+cmp
+(
+r5
+,
+r8
+);
+
+601
+__
+
+beq
+(&
+couÁ_\9aüem\92\8bd
+);
+
+604
+__
+
+LßdP
+(
+
+605
+r6
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+AÎoÿtiÚS\99e
+::
+kP»\8bnu»C»©eCouÁOff£t
+));
+
+606
+__
+
+AddSmiL\99\94®
+(
+r6
+,\846,
+Smi
+::
+FromIÁ
+(1),
+r0
+);
+
+607
+__
+
+StÜeP
+(
+
+608
+r6
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+AÎoÿtiÚS\99e
+::
+kP»\8bnu»C»©eCouÁOff£t
+),
+
+609
+r0
+);
+
+610
+__
+
+b\9ad
+(&
+couÁ_\9aüem\92\8bd
+);
+
+613
+__
+
+Push
+(
+r7
+,\847);
+
+620
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+621
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+¥
+, 3 *
+kPo\9a\8brSize
+));
+
+624
+__
+
+addi
+(
+r5
+,
+å
+,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrSPOff£t
+));
+
+627
+__
+
+SmiUÁag
+(
+r3
+,
+r6
+);
+
+638
+Lab\96
+
+ gloÝ
+,
+ gno_¬gs
+;
+
+639
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+640
+__
+
+beq
+(&
+no_¬gs
+);
+
+641
+__
+
+ShiáLeáImm
+(
+\9d
+,
+r3
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+642
+__
+
+mtùr
+(
+r3
+);
+
+643
+__
+
+b\9ad
+(&
+loÝ
+);
+
+644
+__
+
+subi
+(
+\9d
+, ip,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+645
+__
+
+LßdPX
+(
+r0
+,
+MemO³¿nd
+(
+r5
+,
+\9d
+));
+
+646
+__
+
+push
+(
+r0
+);
+
+647
+__
+
+bdnz
+(&
+loÝ
+);
+
+648
+__
+
+b\9ad
+(&
+no_¬gs
+);
+
+653 ià(
+ gis_i_funùiÚ
+) {
+
+654
+__
+
+LßdP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCÚ\8bxtOff£t
+));
+
+655
+ gHªdË
+<
+ gCode
+>
+ gcode
+ =
+masm
+->
+isީe
+()->
+bu\9et\9as
+()->
+HªdËApiC®lCÚ¡ruù
+();
+
+656
+__
+
+C®l
+(
+code
+,
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+658
+P¬am\91\94CouÁ
+
+aùu®
+(
+r3
+);
+
+659
+__
+
+InvokeFunùiÚ
+(
+r4
+,
+aùu®
+,
+CALL_FUNCTION
+,
+NuÎC®lW¿µ\94
+());
+
+663 ià(!
+ gis_i_funùiÚ
+) {
+
+664
+ gmasm
+->
+isީe
+()->
+h\97p
+()->
+S\91CÚ¡ruùStubDeÝtPCOff£t
+(
+masm
+->
+pc_off£t
+());
+
+672
+__
+
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+677
+Lab\96
+
+ gu£_»ûiv\94
+,
+ gex\99
+;
+
+684
+__
+
+JumpIfSmi
+(
+r3
+, &
+u£_»ûiv\94
+);
+
+688
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,
+r6
+,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+689
+__
+
+bge
+(&
+ex\99
+);
+
+693
+__
+
+b\9ad
+(&
+u£_»ûiv\94
+);
+
+694
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+));
+
+698
+__
+
+b\9ad
+(&
+ex\99
+);
+
+703
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+708
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r4
+,\844);
+
+709
+__
+
+add
+(
+¥
+, sp,
+r4
+);
+
+710
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+711
+__
+
+Inüem\92tCouÁ\94
+(
+isީe
+->
+couÁ\94s
+()->
+cÚ¡ruùed_objeùs
+(), 1,
+r4
+,
+r5
+);
+
+712
+__
+
+bÌ
+();
+
+716 \1e
+ gBu\9et\9as
+::
+G\92\94©e_JSCÚ¡ruùStubG\92\94ic
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+717
+G\92\94©e_JSCÚ¡ruùStubH\96³r
+(
+masm
+,
+çl£
+,
+FLAG_´\91\92ur\9ag_ÿÎ_Ãw
+);
+
+721 \1e
+ gBu\9et\9as
+::
+G\92\94©e_JSCÚ¡ruùStubApi
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+722
+G\92\94©e_JSCÚ¡ruùStubH\96³r
+(
+masm
+,
+\8cue
+,
+çl£
+);
+
+726 \18\1e
+G\92\94©e_JSEÁryT¿mpÞ\9aeH\96³r
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+727
+boÞ
+
+is_cÚ¡ruù
+) {
+
+735
+ gProf\9eeEÁryHookStub
+::
+MaybeC®lEÁryHook
+(
+masm
+);
+
+738
+__
+
+li
+(
+ý
+,
+O³¿nd
+::
+Z\94o
+());
+
+742
+F¿meScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+745
+__
+
+LßdP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCÚ\8bxtOff£t
+));
+
+747
+__
+
+In\99\9flizeRoÙRegi¡\94
+();
+
+750
+__
+
+push
+(
+r4
+);
+
+751
+__
+
+push
+(
+r5
+);
+
+757
+Lab\96
+
+ gloÝ
+,
+ g\92\8cy
+;
+
+758
+__
+
+ShiáLeáImm
+(
+r0
+,
+r6
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+759
+__
+
+add
+(
+r5
+,
+r7
+,
+r0
+);
+
+761
+__
+
+b
+(&
+\92\8cy
+);
+
+762
+__
+
+b\9ad
+(&
+loÝ
+);
+
+763
+__
+
+LßdP
+(
+r8
+,
+MemO³¿nd
+(
+r7
+));
+
+764
+__
+
+addi
+(
+r7
+,\847,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+765
+__
+
+LßdP
+(
+r0
+,
+MemO³¿nd
+(
+r8
+));
+
+766
+__
+
+push
+(
+r0
+);
+
+767
+__
+
+b\9ad
+(&
+\92\8cy
+);
+
+768
+__
+
+cmp
+(
+r7
+,
+r5
+);
+
+769
+__
+
+bÃ
+(&
+loÝ
+);
+
+773
+__
+
+LßdRoÙ
+(
+r7
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+774
+__
+
+mr
+(
+r14
+,
+r7
+);
+
+775
+__
+
+mr
+(
+r15
+,
+r7
+);
+
+776
+__
+
+mr
+(
+r16
+,
+r7
+);
+
+777
+__
+
+mr
+(
+r17
+,
+r7
+);
+
+780
+__
+
+mr
+(
+r3
+,
+r6
+);
+
+781 ià(
+ gis_cÚ¡ruù
+) {
+
+783
+__
+
+LßdRoÙ
+(
+r5
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+784
+C®lCÚ¡ruùStub
+
+¡ub
+(
+masm
+->
+isީe
+(),
+NO_CALL_CONSTRUCTOR_FLAGS
+);
+
+785
+__
+
+C®lStub
+(&
+¡ub
+);
+
+787
+P¬am\91\94CouÁ
+
+aùu®
+(
+r3
+);
+
+788
+__
+
+InvokeFunùiÚ
+(
+r4
+,
+aùu®
+,
+CALL_FUNCTION
+,
+NuÎC®lW¿µ\94
+());
+
+793
+__
+
+bÌ
+();
+
+799 \1e
+ gBu\9et\9as
+::
+G\92\94©e_JSEÁryT¿mpÞ\9ae
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+800
+G\92\94©e_JSEÁryT¿mpÞ\9aeH\96³r
+(
+masm
+,
+çl£
+);
+
+804 \1e
+ gBu\9et\9as
+::
+G\92\94©e_JSCÚ¡ruùEÁryT¿mpÞ\9ae
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+805
+G\92\94©e_JSEÁryT¿mpÞ\9aeH\96³r
+(
+masm
+,
+\8cue
+);
+
+809 \1e
+ gBu\9et\9as
+::
+G\92\94©e_Comp\9eeLazy
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+810
+C®lRuÁimePassFunùiÚ
+(
+masm
+,
+RuÁime
+::
+kComp\9eeLazy
+);
+
+811
+G\92\94©eTa\9eC®lToR\91uºedCode
+(
+masm
+);
+
+815 \18\1e
+C®lComp\9eeO±imized
+(
+MaüoAs£mbËr
+*
+masm
+,
+boÞ
+
+cÚcu¼\92t
+) {
+
+816
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+819
+__
+
+Push
+(
+r4
+,\844);
+
+821
+__
+
+Push
+(
+masm
+->
+isީe
+()->
+çùÜy
+()->
+ToBoޗn
+(
+cÚcu¼\92t
+));
+
+823
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kComp\9eeO±imized
+, 2);
+
+825
+__
+
+pÝ
+(
+r4
+);
+
+829 \1e
+ gBu\9et\9as
+::
+G\92\94©e_Comp\9eeO±imized
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+830
+C®lComp\9eeO±imized
+(
+masm
+,
+çl£
+);
+
+831
+G\92\94©eTa\9eC®lToR\91uºedCode
+(
+masm
+);
+
+835 \1e
+ gBu\9et\9as
+::
+G\92\94©e_Comp\9eeO±imizedCÚcu¼\92t
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+836
+C®lComp\9eeO±imized
+(
+masm
+,
+\8cue
+);
+
+837
+G\92\94©eTa\9eC®lToR\91uºedCode
+(
+masm
+);
+
+841 \18\1e
+G\92\94©eMakeCodeYoungAga\9aCommÚ
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+849
+__
+
+mr
+(
+r3
+,
+\9d
+);
+
+856
+F¿meScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+MANUAL
+);
+
+857
+__
+
+mær
+(
+r0
+);
+
+858
+__
+
+MuÉiPush
+(
+r0
+.
+b\99
+(è|
+r3
+.b\99(è|
+r4
+.b\99(è|
+å
+.bit());
+
+859
+__
+
+P»·»C®lCFunùiÚ
+(2, 0,
+r5
+);
+
+860
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+masm
+->
+isީe
+())));
+
+861
+__
+
+C®lCFunùiÚ
+(
+
+862
+Ex\8bº®Reã»nû
+::
+g\91_make_code_young_funùiÚ
+(
+masm
+->
+isީe
+()), 2);
+
+863
+__
+
+MuÉiPÝ
+(
+r0
+.
+b\99
+(è|
+r3
+.b\99(è|
+r4
+.b\99(è|
+å
+.bit());
+
+864
+__
+
+m\8er
+(
+r0
+);
+
+865
+__
+
+mr
+(
+\9d
+,
+r3
+);
+
+866
+__
+
+Jump
+(
+\9d
+);
+
+869 \ 1
+ #DEFINE_CODE_AGE_BUILTIN_GENERATOR
+(
+C
+) \
+
+870 \1e
+Bu\9et\9as
+::
+G\92\94©e_Make
+##
+C
+##
+ `CodeYoungAga\9aEv\92M¬k\9ag
+( \
+
+871
+MaüoAs£mbËr
+*
+masm
+) { \
+
+872
+ `G\92\94©eMakeCodeYoungAga\9aCommÚ
+(
+masm
+); \
+
+874 \1e
+Bu\9et\9as
+::
+G\92\94©e_Make
+##
+C
+##
+ `CodeYoungAga\9aOddM¬k\9ag
+( \
+
+875
+MaüoAs£mbËr
+*
+masm
+) { \
+
+876
+ `G\92\94©eMakeCodeYoungAga\9aCommÚ
+(
+masm
+); \
+
+877 }
+
+ )
+
+878
+CODE_AGE_LIST
+(
+DEFINE_CODE_AGE_BUILTIN_GENERATOR
+)
+
+879 #undeà
+DEFINE_CODE_AGE_BUILTIN_GENERATOR
+
+
+882 \1e
+ gBu\9et\9as
+::
+G\92\94©e_M¬kCodeAsExecu\8bdOnû
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+890
+__
+
+mr
+(
+r3
+,
+\9d
+);
+
+897
+F¿meScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+MANUAL
+);
+
+898
+__
+
+mær
+(
+r0
+);
+
+899
+__
+
+MuÉiPush
+(
+r0
+.
+b\99
+(è|
+r3
+.b\99(è|
+r4
+.b\99(è|
+å
+.bit());
+
+900
+__
+
+P»·»C®lCFunùiÚ
+(2, 0,
+r5
+);
+
+901
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+masm
+->
+isީe
+())));
+
+902
+__
+
+C®lCFunùiÚ
+(
+
+903
+Ex\8bº®Reã»nû
+::
+g\91_m¬k_code_as_execu\8bd_funùiÚ
+(
+masm
+->
+isީe
+()),
+
+905
+__
+
+MuÉiPÝ
+(
+r0
+.
+b\99
+(è|
+r3
+.b\99(è|
+r4
+.b\99(è|
+å
+.bit());
+
+906
+__
+
+m\8er
+(
+r0
+);
+
+907
+__
+
+mr
+(
+\9d
+,
+r3
+);
+
+910
+__
+
+PushFixedF¿me
+(
+r4
+);
+
+911
+__
+
+addi
+(
+å
+,
+¥
+,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSizeFromFp
+));
+
+914
+__
+
+addi
+(
+r3
+,
+\9d
+,
+O³¿nd
+(
+kNoCodeAgeSequ\92ûL\92gth
+));
+
+915
+__
+
+Jump
+(
+r3
+);
+
+919 \1e
+ gBu\9et\9as
+::
+G\92\94©e_M¬kCodeAsExecu\8bdTwiû
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+920
+G\92\94©eMakeCodeYoungAga\9aCommÚ
+(
+masm
+);
+
+924 \18\1e
+G\92\94©e_NÙifyStubFa\9eu»H\96³r
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+925
+SaveFPRegsMode
+
+§ve_doubËs
+) {
+
+927
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+932
+__
+
+MuÉiPush
+(
+kJSC®ËrSaved
+ |
+kC®ËeSaved
+);
+
+934
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kNÙifyStubFa\9eu»
+, 0,
+§ve_doubËs
+);
+
+935
+__
+
+MuÉiPÝ
+(
+kJSC®ËrSaved
+ |
+kC®ËeSaved
+);
+
+938
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+939
+__
+
+bÌ
+();
+
+943 \1e
+ gBu\9et\9as
+::
+G\92\94©e_NÙifyStubFa\9eu»
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+944
+G\92\94©e_NÙifyStubFa\9eu»H\96³r
+(
+masm
+,
+kDÚtSaveFPRegs
+);
+
+948 \1e
+ gBu\9et\9as
+::
+G\92\94©e_NÙifyStubFa\9eu»SaveDoubËs
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+949
+G\92\94©e_NÙifyStubFa\9eu»H\96³r
+(
+masm
+,
+kSaveFPRegs
+);
+
+953 \18\1e
+G\92\94©e_NÙifyDeÝtimizedH\96³r
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+954
+DeÝtimiz\94
+::
+Ba\9eoutTy³
+
+ty³
+) {
+
+956
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+958
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+¡©ic_ÿ¡
+<\12>(
+ty³
+)));
+
+959
+__
+
+push
+(
+r3
+);
+
+960
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kNÙifyDeÝtimized
+, 1);
+
+964
+__
+
+LßdP
+(
+r9
+,
+MemO³¿nd
+(
+¥
+, 0 *
+kPo\9a\8brSize
+));
+
+965
+__
+
+SmiUÁag
+(
+r9
+);
+
+967
+Lab\96
+
+ gw\99h_tos_»gi¡\94
+,
+ gunknown_¡©e
+;
+
+968
+__
+
+cmpi
+(
+r9
+,
+O³¿nd
+(
+FuÎCodeG\92\94©Ü
+::
+NO_REGISTERS
+));
+
+969
+__
+
+bÃ
+(&
+w\99h_tos_»gi¡\94
+);
+
+970
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(1 *
+kPo\9a\8brSize
+));
+
+971
+__
+
+R\91
+();
+
+973
+__
+
+b\9ad
+(&
+w\99h_tos_»gi¡\94
+);
+
+974
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+975
+__
+
+cmpi
+(
+r9
+,
+O³¿nd
+(
+FuÎCodeG\92\94©Ü
+::
+TOS_REG
+));
+
+976
+__
+
+bÃ
+(&
+unknown_¡©e
+);
+
+977
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(2 *
+kPo\9a\8brSize
+));
+
+978
+__
+
+R\91
+();
+
+980
+__
+
+b\9ad
+(&
+unknown_¡©e
+);
+
+981
+__
+
+¡Ý
+("no cases\86eft");
+
+985 \1e
+ gBu\9et\9as
+::
+G\92\94©e_NÙifyDeÝtimized
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+986
+G\92\94©e_NÙifyDeÝtimizedH\96³r
+(
+masm
+,
+DeÝtimiz\94
+::
+EAGER
+);
+
+990 \1e
+ gBu\9et\9as
+::
+G\92\94©e_NÙifySoáDeÝtimized
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+991
+G\92\94©e_NÙifyDeÝtimizedH\96³r
+(
+masm
+,
+DeÝtimiz\94
+::
+SOFT
+);
+
+995 \1e
+ gBu\9et\9as
+::
+G\92\94©e_NÙifyLazyDeÝtimized
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+996
+G\92\94©e_NÙifyDeÝtimizedH\96³r
+(
+masm
+,
+DeÝtimiz\94
+::
+LAZY
+);
+
+1000 \1e
+ gBu\9et\9as
+::
+G\92\94©e_OnS\8fckR\95Ïûm\92t
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1002
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+1004
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+1006
+__
+
+push
+(
+r3
+);
+
+1007
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kComp\9eeFÜOnS\8fckR\95Ïûm\92t
+, 1);
+
+1011
+Lab\96
+
+ gsk\9d
+;
+
+1012
+__
+
+CmpSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(0),
+r0
+);
+
+1013
+__
+
+bÃ
+(&
+sk\9d
+);
+
+1014
+__
+
+R\91
+();
+
+1016
+__
+
+b\9ad
+(&
+sk\9d
+);
+
+1020
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+Code
+::
+kDeÝtimiz©iÚD©aOff£t
+));
+
+1022 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1024
+CÚ¡ªtPoÞUÇva\9eabËScÝe
+
+cÚ¡ªt_poÞ_uÇva\9eabË
+(
+masm
+);
+
+1025
+__
+
+LßdP
+(
+kCÚ¡ªtPoÞRegi¡\94
+,
+
+1026
+F\9bldMemO³¿nd
+(
+r3
+,
+Code
+::
+kCÚ¡ªtPoÞOff£t
+));
+
+1031
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+
+1032
+r4
+,
+FixedA¼ay
+::
+Off£tOfEËm\92tAt
+(
+
+1033
+DeÝtimiz©iÚIÅutD©a
+::
+kO¤PcOff£tIndex
+)));
+
+1034
+__
+
+SmiUÁag
+(
+r4
+);
+
+1038
+__
+
+add
+(
+r3
+,\843,
+r4
+);
+
+1039
+__
+
+addi
+(
+r0
+,
+r3
+,
+O³¿nd
+(
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+1040
+__
+
+m\8er
+(
+r0
+);
+
+1043
+__
+
+R\91
+();
+
+1044 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1050 \1e
+ gBu\9et\9as
+::
+G\92\94©e_O¤Aá\94S\8fckCheck
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1052
+Lab\96
+
+ok
+;
+
+1053
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kS\8fckLim\99RoÙIndex
+);
+
+1054
+__
+
+cm¶
+(
+¥
+,
+\9d
+);
+
+1055
+__
+
+bge
+(&
+ok
+);
+
+1057
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+1058
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kS\8fckGu¬d
+, 0);
+
+1060
+__
+
+Jump
+(
+masm
+->
+isީe
+()->
+bu\9et\9as
+()->
+OnS\8fckR\95Ïûm\92t
+(),
+
+1061
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+1063
+__
+
+b\9ad
+(&
+ok
+);
+
+1064
+__
+
+R\91
+();
+
+1068 \1e
+ gBu\9et\9as
+::
+G\92\94©e_FunùiÚC®l
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1072
+Lab\96
+
+dÚe
+;
+
+1073
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+1074
+__
+
+bÃ
+(&
+dÚe
+);
+
+1075
+__
+
+LßdRoÙ
+(
+r5
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+1076
+__
+
+push
+(
+r5
+);
+
+1077
+__
+
+addi
+(
+r3
+,\843,
+O³¿nd
+(1));
+
+1078
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1084
+Lab\96
+
+ g¦ow
+,
+ gnÚ_funùiÚ
+;
+
+1085
+__
+
+ShiáLeáImm
+(
+r4
+,
+r3
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+1086
+__
+
+add
+(
+r4
+,
+¥
+,\844);
+
+1087
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(r4));
+
+1088
+__
+
+JumpIfSmi
+(
+r4
+, &
+nÚ_funùiÚ
+);
+
+1089
+__
+
+Com·»ObjeùTy³
+(
+r4
+,
+r5
+,\845,
+JS_FUNCTION_TYPE
+);
+
+1090
+__
+
+bÃ
+(&
+¦ow
+);
+
+1095
+Lab\96
+
+ gshiá_¬gum\92ts
+;
+
+1096
+__
+
+li
+(
+r7
+,
+O³¿nd
+::
+Z\94o
+());
+
+1098
+Lab\96
+
+ gcÚv\94t_to_objeù
+,
+ gu£_glob®_´oxy
+,
+ g·tch_»ûiv\94
+;
+
+1100
+__
+
+LßdP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCÚ\8bxtOff£t
+));
+
+1103
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+1104
+__
+
+lwz
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+Sh¬edFunùiÚInfo
+::
+kComp\9e\94H\9atsOff£t
+));
+
+1105
+__
+
+Te¡B\99
+(
+r6
+,
+
+1106 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1107
+Sh¬edFunùiÚInfo
+::
+kS\8ciùModeFunùiÚ
+,
+
+1109
+Sh¬edFunùiÚInfo
+::
+kS\8ciùModeFunùiÚ
+ +
+kSmiTagSize
+,
+
+1111
+r0
+);
+
+1112
+__
+
+bÃ
+(&
+shiá_¬gum\92ts
+,
+ü0
+);
+
+1115
+__
+
+Te¡B\99
+(
+r6
+,
+
+1116 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1117
+Sh¬edFunùiÚInfo
+::
+kN©ive
+,
+
+1119
+Sh¬edFunùiÚInfo
+::
+kN©ive
+ +
+kSmiTagSize
+,
+
+1121
+r0
+);
+
+1122
+__
+
+bÃ
+(&
+shiá_¬gum\92ts
+,
+ü0
+);
+
+1125
+__
+
+ShiáLeáImm
+(
+\9d
+,
+r3
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+1126
+__
+
+add
+(
+r5
+,
+¥
+,
+\9d
+);
+
+1127
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+Ô5, -
+kPo\9a\8brSize
+));
+
+1131
+__
+
+JumpIfSmi
+(
+r5
+, &
+cÚv\94t_to_objeù
+);
+
+1133
+__
+
+LßdRoÙ
+(
+r6
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+1134
+__
+
+cmp
+(
+r5
+,
+r6
+);
+
+1135
+__
+
+beq
+(&
+u£_glob®_´oxy
+);
+
+1136
+__
+
+LßdRoÙ
+(
+r6
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+1137
+__
+
+cmp
+(
+r5
+,
+r6
+);
+
+1138
+__
+
+beq
+(&
+u£_glob®_´oxy
+);
+
+1140
+STATIC_ASSERT
+(
+LAST_SPEC_OBJECT_TYPE
+ =ð
+LAST_TYPE
+);
+
+1141
+__
+
+Com·»ObjeùTy³
+(
+r5
+,
+r6
+,\846,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+1142
+__
+
+bge
+(&
+shiá_¬gum\92ts
+);
+
+1144
+__
+
+b\9ad
+(&
+cÚv\94t_to_objeù
+);
+
+1148
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+1149
+__
+
+SmiTag
+(
+r3
+);
+
+1150
+__
+
+Push
+(
+r3
+,
+r5
+);
+
+1151
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+TO_OBJECT
+,
+CALL_FUNCTION
+);
+
+1152
+__
+
+mr
+(
+r5
+,
+r3
+);
+
+1154
+__
+
+pÝ
+(
+r3
+);
+
+1155
+__
+
+SmiUÁag
+(
+r3
+);
+
+1161
+__
+
+ShiáLeáImm
+(
+r7
+,
+r3
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+1162
+__
+
+add
+(
+r7
+,
+¥
+,\847);
+
+1163
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+r7
+));
+
+1164
+__
+
+li
+(
+r7
+,
+O³¿nd
+::
+Z\94o
+());
+
+1165
+__
+
+b
+(&
+·tch_»ûiv\94
+);
+
+1167
+__
+
+b\9ad
+(&
+u£_glob®_´oxy
+);
+
+1168
+__
+
+LßdP
+(
+r5
+,
+CÚ\8bxtO³¿nd
+(
+ý
+,
+Cڋxt
+::
+GLOBAL_OBJECT_INDEX
+));
+
+1169
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+Ô5,
+Glob®Objeù
+::
+kGlob®ProxyOff£t
+));
+
+1171
+__
+
+b\9ad
+(&
+·tch_»ûiv\94
+);
+
+1172
+__
+
+ShiáLeáImm
+(
+\9d
+,
+r3
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+1173
+__
+
+add
+(
+r6
+,
+¥
+,
+\9d
+);
+
+1174
+__
+
+StÜeP
+(
+r5
+,
+MemO³¿nd
+(
+r6
+, -
+kPo\9a\8brSize
+));
+
+1176
+__
+
+b
+(&
+shiá_¬gum\92ts
+);
+
+1180
+__
+
+b\9ad
+(&
+¦ow
+);
+
+1181
+__
+
+li
+(
+r7
+,
+O³¿nd
+(1,
+R\96ocInfo
+::
+NONE32
+));
+
+1182
+__
+
+cmpi
+(
+r5
+,
+O³¿nd
+(
+JS_FUNCTION_PROXY_TYPE
+));
+
+1183
+__
+
+beq
+(&
+shiá_¬gum\92ts
+);
+
+1184
+__
+
+b\9ad
+(&
+nÚ_funùiÚ
+);
+
+1185
+__
+
+li
+(
+r7
+,
+O³¿nd
+(2,
+R\96ocInfo
+::
+NONE32
+));
+
+1194
+__
+
+ShiáLeáImm
+(
+\9d
+,
+r3
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+1195
+__
+
+add
+(
+r5
+,
+¥
+,
+\9d
+);
+
+1196
+__
+
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+r5
+, -
+kPo\9a\8brSize
+));
+
+1204
+__
+
+b\9ad
+(&
+shiá_¬gum\92ts
+);
+
+1206
+Lab\96
+
+ gloÝ
+;
+
+1208
+__
+
+ShiáLeáImm
+(
+\9d
+,
+r3
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+1209
+__
+
+add
+(
+r5
+,
+¥
+,
+\9d
+);
+
+1211
+__
+
+b\9ad
+(&
+loÝ
+);
+
+1212
+__
+
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+r5
+, -
+kPo\9a\8brSize
+));
+
+1213
+__
+
+StÜeP
+(
+\9d
+,
+MemO³¿nd
+(
+r5
+));
+
+1214
+__
+
+subi
+(
+r5
+,\845,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+1215
+__
+
+cmp
+(
+r5
+,
+¥
+);
+
+1216
+__
+
+bÃ
+(&
+loÝ
+);
+
+1219
+__
+
+subi
+(
+r3
+,\843,
+O³¿nd
+(1));
+
+1220
+__
+
+pÝ
+();
+
+1229
+Lab\96
+
+ gfunùiÚ
+,
+ gnÚ_´oxy
+;
+
+1230
+__
+
+cmpi
+(
+r7
+,
+O³¿nd
+::
+Z\94o
+());
+
+1231
+__
+
+beq
+(&
+funùiÚ
+);
+
+1233
+__
+
+li
+(
+r5
+,
+O³¿nd
+::
+Z\94o
+());
+
+1234
+__
+
+cmpi
+(
+r7
+,
+O³¿nd
+(1));
+
+1235
+__
+
+bÃ
+(&
+nÚ_´oxy
+);
+
+1237
+__
+
+push
+(
+r4
+);
+
+1238
+__
+
+addi
+(
+r3
+,\843,
+O³¿nd
+(1));
+
+1239
+__
+
+G\91Bu\9et\9aFunùiÚ
+(
+r4
+,
+Bu\9et\9as
+::
+CALL_FUNCTION_PROXY
+);
+
+1240
+__
+
+Jump
+(
+masm
+->
+isީe
+()->
+bu\9et\9as
+()->
+Argum\92tsAdtÜT¿mpÞ\9ae
+(),
+
+1241
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+1243
+__
+
+b\9ad
+(&
+nÚ_´oxy
+);
+
+1244
+__
+
+G\91Bu\9et\9aFunùiÚ
+(
+r4
+,
+Bu\9et\9as
+::
+CALL_NON_FUNCTION
+);
+
+1245
+__
+
+Jump
+(
+masm
+->
+isީe
+()->
+bu\9et\9as
+()->
+Argum\92tsAdtÜT¿mpÞ\9ae
+(),
+
+1246
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+1247
+__
+
+b\9ad
+(&
+funùiÚ
+);
+
+1255
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+1256
+__
+
+LßdWÜdAr\99h
+(
+
+1257
+r5
+,
+F\9bldMemO³¿nd
+(
+r6
+,
+Sh¬edFunùiÚInfo
+::
+kFÜm®P¬am\91\94CouÁOff£t
+));
+
+1258 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+1259
+__
+
+SmiUÁag
+(
+r5
+);
+
+1261
+__
+
+cmp
+(
+r5
+,
+r3
+);
+
+1262
+__
+
+Jump
+(
+masm
+->
+isީe
+()->
+bu\9et\9as
+()->
+Argum\92tsAdtÜT¿mpÞ\9ae
+(),
+
+1263
+R\96ocInfo
+::
+CODE_TARGET
+,
+Ã
+);
+
+1265
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCodeEÁryOff£t
+));
+
+1266
+P¬am\91\94CouÁ
+
+ex³ùed
+(0);
+
+1267
+__
+
+InvokeCode
+(
+\9d
+,
+ex³ùed
+,\83x³ùed,
+JUMP_FUNCTION
+,
+NuÎC®lW¿µ\94
+());
+
+1271 \1e
+ gBu\9et\9as
+::
+G\92\94©e_FunùiÚAµly
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1272 cڡ \12
+kIndexOff£t
+ =
+
+1273
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kEx´essiÚsOff£t
+ - (2 *
+kPo\9a\8brSize
+);
+
+1274 cڡ \12
+ gkLim\99Off£t
+ =
+
+1275
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kEx´essiÚsOff£t
+ - (1 *
+kPo\9a\8brSize
+);
+
+1276 cڡ \12
+ gkArgsOff£t
+ = 2 *
+kPo\9a\8brSize
+;
+
+1277 cڡ \12
+ gkRecvOff£t
+ = 3 *
+kPo\9a\8brSize
+;
+
+1278 cڡ \12
+ gkFunùiÚOff£t
+ = 4 *
+kPo\9a\8brSize
+;
+
+1281
+F¿meAndCÚ¡ªtPoÞScÝe
+
+äame_scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+1283
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+kFunùiÚOff£t
+));
+
+1284
+__
+
+push
+(
+r3
+);
+
+1285
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+kArgsOff£t
+));
+
+1286
+__
+
+push
+(
+r3
+);
+
+1287
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+APPLY_PREPARE
+,
+CALL_FUNCTION
+);
+
+1292
+Lab\96
+
+ gokay
+;
+
+1293
+__
+
+LßdRoÙ
+(
+r5
+,
+H\97p
+::
+kR\97lS\8fckLim\99RoÙIndex
+);
+
+1296
+__
+
+sub
+(
+r5
+,
+¥
+,\845);
+
+1298
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r0
+,
+r3
+);
+
+1299
+__
+
+cmp
+(
+r5
+,
+r0
+);
+
+1300
+__
+
+bgt
+(&
+okay
+);
+
+1303
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+å
+,
+kFunùiÚOff£t
+));
+
+1304
+__
+
+Push
+(
+r4
+,
+r3
+);
+
+1305
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+STACK_OVERFLOW
+,
+CALL_FUNCTION
+);
+
+1309
+__
+
+b\9ad
+(&
+okay
+);
+
+1310
+__
+
+li
+(
+r4
+,
+O³¿nd
+::
+Z\94o
+());
+
+1311
+__
+
+Push
+(
+r3
+,
+r4
+);
+
+1314
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+kRecvOff£t
+));
+
+1317
+Lab\96
+
+ gpush_»ûiv\94
+;
+
+1318
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+å
+,
+kFunùiÚOff£t
+));
+
+1319
+__
+
+Com·»ObjeùTy³
+(
+r4
+,
+r5
+,\845,
+JS_FUNCTION_TYPE
+);
+
+1320
+__
+
+bÃ
+(&
+push_»ûiv\94
+);
+
+1323
+__
+
+LßdP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCÚ\8bxtOff£t
+));
+
+1325
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+1329
+Lab\96
+
+ gÿÎ_to_objeù
+,
+ gu£_glob®_´oxy
+;
+
+1330
+__
+
+lwz
+(
+r5
+,
+F\9bldMemO³¿nd
+Ô5,
+Sh¬edFunùiÚInfo
+::
+kComp\9e\94H\9atsOff£t
+));
+
+1331
+__
+
+Te¡B\99
+(
+r5
+,
+
+1332 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1333
+Sh¬edFunùiÚInfo
+::
+kS\8ciùModeFunùiÚ
+,
+
+1335
+Sh¬edFunùiÚInfo
+::
+kS\8ciùModeFunùiÚ
+ +
+kSmiTagSize
+,
+
+1337
+r0
+);
+
+1338
+__
+
+bÃ
+(&
+push_»ûiv\94
+,
+ü0
+);
+
+1341
+__
+
+Te¡B\99
+(
+r5
+,
+
+1342 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1343
+Sh¬edFunùiÚInfo
+::
+kN©ive
+,
+
+1345
+Sh¬edFunùiÚInfo
+::
+kN©ive
+ +
+kSmiTagSize
+,
+
+1347
+r0
+);
+
+1348
+__
+
+bÃ
+(&
+push_»ûiv\94
+,
+ü0
+);
+
+1351
+__
+
+JumpIfSmi
+(
+r3
+, &
+ÿÎ_to_objeù
+);
+
+1352
+__
+
+LßdRoÙ
+(
+r4
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+1353
+__
+
+cmp
+(
+r3
+,
+r4
+);
+
+1354
+__
+
+beq
+(&
+u£_glob®_´oxy
+);
+
+1355
+__
+
+LßdRoÙ
+(
+r4
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+1356
+__
+
+cmp
+(
+r3
+,
+r4
+);
+
+1357
+__
+
+beq
+(&
+u£_glob®_´oxy
+);
+
+1361
+STATIC_ASSERT
+(
+LAST_SPEC_OBJECT_TYPE
+ =ð
+LAST_TYPE
+);
+
+1362
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,\844,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+1363
+__
+
+bge
+(&
+push_»ûiv\94
+);
+
+1367
+__
+
+b\9ad
+(&
+ÿÎ_to_objeù
+);
+
+1368
+__
+
+push
+(
+r3
+);
+
+1369
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+TO_OBJECT
+,
+CALL_FUNCTION
+);
+
+1370
+__
+
+b
+(&
+push_»ûiv\94
+);
+
+1372
+__
+
+b\9ad
+(&
+u£_glob®_´oxy
+);
+
+1373
+__
+
+LßdP
+(
+r3
+,
+CÚ\8bxtO³¿nd
+(
+ý
+,
+Cڋxt
+::
+GLOBAL_OBJECT_INDEX
+));
+
+1374
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+Glob®Objeù
+::
+kGlob®ProxyOff£t
+));
+
+1378
+__
+
+b\9ad
+(&
+push_»ûiv\94
+);
+
+1379
+__
+
+push
+(
+r3
+);
+
+1382
+Lab\96
+
+ g\92\8cy
+,
+ gloÝ
+;
+
+1383
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+kIndexOff£t
+));
+
+1384
+__
+
+b
+(&
+\92\8cy
+);
+
+1389
+__
+
+b\9ad
+(&
+loÝ
+);
+
+1390
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+å
+,
+kArgsOff£t
+));
+
+1391
+__
+
+Push
+(
+r4
+,
+r3
+);
+
+1394
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kG\91PrÝ\94ty
+, 2);
+
+1395
+__
+
+push
+(
+r3
+);
+
+1398
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+kIndexOff£t
+));
+
+1399
+__
+
+AddSmiL\99\94®
+(
+r3
+,\843,
+Smi
+::
+FromIÁ
+(1),
+r0
+);
+
+1400
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+kIndexOff£t
+));
+
+1404
+__
+
+b\9ad
+(&
+\92\8cy
+);
+
+1405
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+å
+,
+kLim\99Off£t
+));
+
+1406
+__
+
+cmp
+(
+r3
+,
+r4
+);
+
+1407
+__
+
+bÃ
+(&
+loÝ
+);
+
+1410
+Lab\96
+
+ gÿÎ_´oxy
+;
+
+1411
+P¬am\91\94CouÁ
+
+aùu®
+(
+r3
+);
+
+1412
+__
+
+SmiUÁag
+(
+r3
+);
+
+1413
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+å
+,
+kFunùiÚOff£t
+));
+
+1414
+__
+
+Com·»ObjeùTy³
+(
+r4
+,
+r5
+,\845,
+JS_FUNCTION_TYPE
+);
+
+1415
+__
+
+bÃ
+(&
+ÿÎ_´oxy
+);
+
+1416
+__
+
+InvokeFunùiÚ
+(
+r4
+,
+aùu®
+,
+CALL_FUNCTION
+,
+NuÎC®lW¿µ\94
+());
+
+1418
+__
+
+L\97veF¿me
+(
+S\8fckF¿me
+::
+INTERNAL
+, 3 *
+kPo\9a\8brSize
+);
+
+1419
+__
+
+bÌ
+();
+
+1422
+__
+
+b\9ad
+(&
+ÿÎ_´oxy
+);
+
+1423
+__
+
+push
+(
+r4
+);
+
+1424
+__
+
+addi
+(
+r3
+,\843,
+O³¿nd
+(1));
+
+1425
+__
+
+li
+(
+r5
+,
+O³¿nd
+::
+Z\94o
+());
+
+1426
+__
+
+G\91Bu\9et\9aFunùiÚ
+(
+r4
+,
+Bu\9et\9as
+::
+CALL_FUNCTION_PROXY
+);
+
+1427
+__
+
+C®l
+(
+masm
+->
+isީe
+()->
+bu\9et\9as
+()->
+Argum\92tsAdtÜT¿mpÞ\9ae
+(),
+
+1428
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+1432
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(3 *
+kPo\9a\8brSize
+));
+
+1433
+__
+
+bÌ
+();
+
+1437 \18\1e
+Argum\92tAdtÜS\8fckCheck
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+1438
+Lab\96
+*
+¡ack_ov\94æow
+) {
+
+1447
+__
+
+LßdRoÙ
+(
+r8
+,
+H\97p
+::
+kR\97lS\8fckLim\99RoÙIndex
+);
+
+1450
+__
+
+sub
+(
+r8
+,
+¥
+,\848);
+
+1452
+__
+
+ShiáLeáImm
+(
+r0
+,
+r5
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+1453
+__
+
+cmp
+(
+r8
+,
+r0
+);
+
+1454
+__
+
+bË
+(
+¡ack_ov\94æow
+);
+
+1458 \18\1e
+EÁ\94Argum\92tsAdtÜF¿me
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1459
+__
+
+SmiTag
+(
+r3
+);
+
+1460
+__
+
+LßdSmiL\99\94®
+(
+r7
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+));
+
+1461
+__
+
+mær
+(
+r0
+);
+
+1462
+__
+
+push
+(
+r0
+);
+
+1463 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1464
+__
+
+Push
+(
+å
+,
+kCÚ¡ªtPoÞRegi¡\94
+,
+r7
+,
+r4
+,
+r3
+);
+
+1466
+__
+
+Push
+(
+å
+,
+r7
+,
+r4
+,
+r3
+);
+
+1468
+__
+
+addi
+(
+å
+,
+¥
+,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSizeFromFp
+ +
+
+1469
+kPo\9a\8brSize
+));
+
+1473 \18\1e
+L\97veArgum\92tsAdtÜF¿me
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1479
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+å
+, -(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSizeFromFp
+ +
+
+1480
+kPo\9a\8brSize
+)));
+
+1481 \12
+ g¡ack_adju¡m\92t
+ =
+kPo\9a\8brSize
+;
+
+1482
+__
+
+L\97veF¿me
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+,
+¡ack_adju¡m\92t
+);
+
+1483
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r0
+,
+r4
+);
+
+1484
+__
+
+add
+(
+¥
+, sp,
+r0
+);
+
+1488 \1e
+ gBu\9et\9as
+::
+G\92\94©e_Argum\92tsAdtÜT¿mpÞ\9ae
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1495
+Lab\96
+
+¡ack_ov\94æow
+;
+
+1496
+Argum\92tAdtÜS\8fckCheck
+(
+masm
+, &
+¡ack_ov\94æow
+);
+
+1497
+Lab\96
+
+ g\9avoke
+,
+ gdÚt_adt_¬gum\92ts
+;
+
+1499
+Lab\96
+
+ g\92ough
+,
+ gtoo_ãw
+;
+
+1500
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCodeEÁryOff£t
+));
+
+1501
+__
+
+cmp
+(
+r3
+,
+r5
+);
+
+1502
+__
+
+bÉ
+(&
+too_ãw
+);
+
+1503
+__
+
+cmpi
+(
+r5
+,
+O³¿nd
+(
+Sh¬edFunùiÚInfo
+::
+kDÚtAdtArgum\92tsS\92t\9a\96
+));
+
+1504
+__
+
+beq
+(&
+dÚt_adt_¬gum\92ts
+);
+
+1507
+__
+
+b\9ad
+(&
+\92ough
+);
+
+1508
+EÁ\94Argum\92tsAdtÜF¿me
+(
+masm
+);
+
+1515
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r3
+,\843);
+
+1516
+__
+
+add
+(
+r3
+,\843,
+å
+);
+
+1518
+__
+
+addi
+(
+r3
+,\843,
+O³¿nd
+(2 *
+kPo\9a\8brSize
+));
+
+1519
+__
+
+ShiáLeáImm
+(
+r5
+,\845,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+1520
+__
+
+sub
+(
+r5
+,
+r3
+,\845);
+
+1528
+Lab\96
+
+ gcÝy
+;
+
+1529
+__
+
+b\9ad
+(&
+cÝy
+);
+
+1530
+__
+
+LßdP
+(
+r0
+,
+MemO³¿nd
+(
+r3
+, 0));
+
+1531
+__
+
+push
+(
+r0
+);
+
+1532
+__
+
+cmp
+(
+r3
+,
+r5
+);
+
+1533
+__
+
+subi
+(
+r3
+,\843,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+1534
+__
+
+bÃ
+(&
+cÝy
+);
+
+1536
+__
+
+b
+(&
+\9avoke
+);
+
+1540
+__
+
+b\9ad
+(&
+too_ãw
+);
+
+1541
+EÁ\94Argum\92tsAdtÜF¿me
+(
+masm
+);
+
+1548
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r3
+,\843);
+
+1549
+__
+
+add
+(
+r3
+,\843,
+å
+);
+
+1556
+Lab\96
+
+ gcÝy
+;
+
+1557
+__
+
+b\9ad
+(&
+cÝy
+);
+
+1559
+__
+
+LßdP
+(
+r0
+,
+MemO³¿nd
+(
+r3
+, 2 *
+kPo\9a\8brSize
+));
+
+1560
+__
+
+push
+(
+r0
+);
+
+1561
+__
+
+cmp
+(
+r3
+,
+å
+);
+
+1562
+__
+
+subi
+(
+r3
+,\843,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+1563
+__
+
+bÃ
+(&
+cÝy
+);
+
+1569
+__
+
+LßdRoÙ
+(
+r0
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+1570
+__
+
+ShiáLeáImm
+(
+r5
+,\845,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+1571
+__
+
+sub
+(
+r5
+,
+å
+,\845);
+
+1573
+__
+
+subi
+(
+r5
+,\845,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSizeFromFp
+ +
+
+1574 2 *
+kPo\9a\8brSize
+));
+
+1576
+Lab\96
+
+ gf\9el
+;
+
+1577
+__
+
+b\9ad
+(&
+f\9el
+);
+
+1578
+__
+
+push
+(
+r0
+);
+
+1579
+__
+
+cmp
+(
+¥
+,
+r5
+);
+
+1580
+__
+
+bÃ
+(&
+f\9el
+);
+
+1584
+__
+
+b\9ad
+(&
+\9avoke
+);
+
+1585
+__
+
+C®lJSEÁry
+(
+\9d
+);
+
+1588
+ gmasm
+->
+isީe
+()->
+h\97p
+()->
+S\91Argum\92tsAdtÜDeÝtPCOff£t
+(
+masm
+->
+pc_off£t
+());
+
+1591
+L\97veArgum\92tsAdtÜF¿me
+(
+masm
+);
+
+1592
+__
+
+bÌ
+();
+
+1598
+__
+
+b\9ad
+(&
+dÚt_adt_¬gum\92ts
+);
+
+1599
+__
+
+JumpToJSEÁry
+(
+\9d
+);
+
+1601
+__
+
+b\9ad
+(&
+¡ack_ov\94æow
+);
+
+1603
+F¿meScÝe
+
+äame
+(
+masm
+,
+S\8fckF¿me
+::
+MANUAL
+);
+
+1604
+EÁ\94Argum\92tsAdtÜF¿me
+(
+masm
+);
+
+1605
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+STACK_OVERFLOW
+,
+CALL_FUNCTION
+);
+
+1606
+__
+
+bk±
+(0);
+
+1611 #undeà
+__
+
+
+ @code-stubs-ppc.cc
+
+5 \ 2
+ ~"¤c/v8.h
+"
+
+7 #ià
+V8_TARGET_ARCH_PPC
+
+
+9 \ 2
+ ~"¤c/ba£/b\99s.h
+"
+
+10 \ 2
+ ~"¤c/boÙ¡¿µ\94.h
+"
+
+11 \ 2
+ ~"¤c/code-¡ubs.h
+"
+
+12 \ 2
+ ~"¤c/codeg\92.h
+"
+
+13 \ 2
+ ~"¤c/ic/hªdËr-comp\9e\94.h
+"
+
+14 \ 2
+ ~"¤c/ic/ic.h
+"
+
+15 \ 2
+ ~"¤c/isÞ©e.h
+"
+
+16 \ 2
+ ~"¤c/j¤egexp.h
+"
+
+17 \ 2
+ ~"¤c/»gexp-maüo-as£mbËr.h
+"
+
+18 \ 2
+ ~"¤c/ruÁime/ruÁime.h
+"
+
+20
+Çme¥aû
+
+ gv8
+ {
+
+21
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+24 \18\1e
+In\99\9flizeA¼ayCÚ¡ruùÜDesü\9dtÜ
+(
+
+25
+Isީe
+*
+isީe
+,
+CodeStubDesü\9dtÜ
+*
+desü\9dtÜ
+,
+
+26 \12
+cÚ¡ªt_¡ack_·¿m\91\94_couÁ
+) {
+
+27
+Add»ss
+
+ gdeÝt_hªdËr
+ =
+
+28
+RuÁime
+::
+FunùiÚFÜId
+(RuÁime::
+kA¼ayCÚ¡ruùÜ
+)->
+\92\8cy
+;
+
+30 ià(
+ gcÚ¡ªt_¡ack_·¿m\91\94_couÁ
+ == 0) {
+
+31
+desü\9dtÜ
+->
+In\99\9flize
+(
+deÝt_hªdËr
+,
+cÚ¡ªt_¡ack_·¿m\91\94_couÁ
+,
+
+32
+JS_FUNCTION_STUB_MODE
+);
+
+34
+ gdesü\9dtÜ
+->
+In\99\9flize
+(
+r3
+,
+deÝt_hªdËr
+,
+cÚ¡ªt_¡ack_·¿m\91\94_couÁ
+,
+
+35
+JS_FUNCTION_STUB_MODE
+,
+PASS_ARGUMENTS
+);
+
+40 \18\1e
+In\99\9flizeIÁ\94ÇlA¼ayCÚ¡ruùÜDesü\9dtÜ
+(
+
+41
+Isީe
+*
+isީe
+,
+CodeStubDesü\9dtÜ
+*
+desü\9dtÜ
+,
+
+42 \12
+cÚ¡ªt_¡ack_·¿m\91\94_couÁ
+) {
+
+43
+Add»ss
+
+ gdeÝt_hªdËr
+ =
+
+44
+RuÁime
+::
+FunùiÚFÜId
+(RuÁime::
+kIÁ\94ÇlA¼ayCÚ¡ruùÜ
+)->
+\92\8cy
+;
+
+46 ià(
+ gcÚ¡ªt_¡ack_·¿m\91\94_couÁ
+ == 0) {
+
+47
+desü\9dtÜ
+->
+In\99\9flize
+(
+deÝt_hªdËr
+,
+cÚ¡ªt_¡ack_·¿m\91\94_couÁ
+,
+
+48
+JS_FUNCTION_STUB_MODE
+);
+
+50
+ gdesü\9dtÜ
+->
+In\99\9flize
+(
+r3
+,
+deÝt_hªdËr
+,
+cÚ¡ªt_¡ack_·¿m\91\94_couÁ
+,
+
+51
+JS_FUNCTION_STUB_MODE
+,
+PASS_ARGUMENTS
+);
+
+56 \1e
+ gA¼ayNoArgum\92tCÚ¡ruùÜStub
+::
+In\99\9flizeDesü\9dtÜ
+(
+
+57
+CodeStubDesü\9dtÜ
+*
+desü\9dtÜ
+) {
+
+58
+In\99\9flizeA¼ayCÚ¡ruùÜDesü\9dtÜ
+(
+isީe
+(),
+desü\9dtÜ
+, 0);
+
+62 \1e
+ gA¼ayS\9agËArgum\92tCÚ¡ruùÜStub
+::
+In\99\9flizeDesü\9dtÜ
+(
+
+63
+CodeStubDesü\9dtÜ
+*
+desü\9dtÜ
+) {
+
+64
+In\99\9flizeA¼ayCÚ¡ruùÜDesü\9dtÜ
+(
+isީe
+(),
+desü\9dtÜ
+, 1);
+
+68 \1e
+ gA¼ayNArgum\92tsCÚ¡ruùÜStub
+::
+In\99\9flizeDesü\9dtÜ
+(
+
+69
+CodeStubDesü\9dtÜ
+*
+desü\9dtÜ
+) {
+
+70
+In\99\9flizeA¼ayCÚ¡ruùÜDesü\9dtÜ
+(
+isީe
+(),
+desü\9dtÜ
+, -1);
+
+74 \1e
+ gIÁ\94ÇlA¼ayNoArgum\92tCÚ¡ruùÜStub
+::
+In\99\9flizeDesü\9dtÜ
+(
+
+75
+CodeStubDesü\9dtÜ
+*
+desü\9dtÜ
+) {
+
+76
+In\99\9flizeIÁ\94ÇlA¼ayCÚ¡ruùÜDesü\9dtÜ
+(
+isީe
+(),
+desü\9dtÜ
+, 0);
+
+80 \1e
+ gIÁ\94ÇlA¼ayS\9agËArgum\92tCÚ¡ruùÜStub
+::
+In\99\9flizeDesü\9dtÜ
+(
+
+81
+CodeStubDesü\9dtÜ
+*
+desü\9dtÜ
+) {
+
+82
+In\99\9flizeIÁ\94ÇlA¼ayCÚ¡ruùÜDesü\9dtÜ
+(
+isީe
+(),
+desü\9dtÜ
+, 1);
+
+86 \1e
+ gIÁ\94ÇlA¼ayNArgum\92tsCÚ¡ruùÜStub
+::
+In\99\9flizeDesü\9dtÜ
+(
+
+87
+CodeStubDesü\9dtÜ
+*
+desü\9dtÜ
+) {
+
+88
+In\99\9flizeIÁ\94ÇlA¼ayCÚ¡ruùÜDesü\9dtÜ
+(
+isީe
+(),
+desü\9dtÜ
+, -1);
+
+92 \ 1
+ #__
+
+ `ACCESS_MASM
+(
+masm
+)
+
+ )
+
+95 \18\1e
+Em\99Id\92tiÿlObjeùCom·risÚ
+(
+MaüoAs£mbËr
+*
+masm
+,
+Lab\96
+*
+¦ow
+,
+
+96
+CÚd\99iÚ
+
+cÚd
+);
+
+97 \18\1e
+Em\99SmiNÚsmiCom·risÚ
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+lhs
+,
+
+98
+Regi¡\94
+
+rhs
+,
+Lab\96
+*
+lhs_nÙ_Çn
+,
+
+99
+Lab\96
+*
+¦ow
+,
+boÞ
+
+¡riù
+);
+
+100 \18\1e
+Em\99S\8ciùTwoH\97pObjeùCom·»
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+lhs
+,
+
+101
+Regi¡\94
+
+rhs
+);
+
+104 \1e
+ gHydrog\92CodeStub
+::
+G\92\94©eLightweightMiss
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+105
+Ex\8bº®Reã»nû
+
+miss
+) {
+
+107
+isީe
+()->
+couÁ\94s
+()->
+code_¡ubs
+()->
+Inüem\92t
+();
+
+109
+C®lIÁ\94çûDesü\9dtÜ
+
+ gdesü\9dtÜ
+ =
+G\91C®lIÁ\94çûDesü\9dtÜ
+();
+
+110 \12
+ g·¿m_couÁ
+ =
+desü\9dtÜ
+.
+G\91Env\9cÚm\92tP¬am\91\94CouÁ
+();
+
+113
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+114
+DCHECK
+(
+·¿m_couÁ
+ == 0 ||
+
+115
+r3
+.
+is
+(
+desü\9dtÜ
+.
+G\91Env\9cÚm\92tP¬am\91\94Regi¡\94
+(
+·¿m_couÁ
+ - 1)));
+
+117 \ f\12
+ gi
+ = 0; i <
+ g·¿m_couÁ
+; ++i) {
+
+118
+__
+
+push
+(
+desü\9dtÜ
+.
+G\91Env\9cÚm\92tP¬am\91\94Regi¡\94
+(
+i
+));
+
+120
+__
+
+C®lEx\8bº®Reã»nû
+(
+miss
+,
+·¿m_couÁ
+);
+
+123
+__
+
+R\91
+();
+
+127 \1e
+ gDoubËToIStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+128
+Lab\96
+
+out_of_¿nge
+,
+ gÚly_low
+,
+ gÃg©e
+,
+ gdÚe
+,
+ gç¡·th_dÚe
+;
+
+129
+Regi¡\94
+
+ g\9aput_»g
+ =
+sourû
+();
+
+130
+Regi¡\94
+
+ g»suÉ_»g
+ =
+de¡\9a©iÚ
+();
+
+131
+DCHECK
+(
+is_\8cunÿt\9ag
+());
+
+133 \12
+ gdoubË_off£t
+ =
+off£t
+();
+
+136
+Regi¡\94
+
+ gsü©ch
+ =
+G\91Regi¡\94Th©IsNÙOÃOf
+(
+\9aput_»g
+,
+»suÉ_»g
+);
+
+137
+Regi¡\94
+
+ gsü©ch_low
+ =
+
+138
+G\91Regi¡\94Th©IsNÙOÃOf
+(
+\9aput_»g
+,
+»suÉ_»g
+,
+sü©ch
+);
+
+139
+Regi¡\94
+
+ gsü©ch_high
+ =
+
+140
+G\91Regi¡\94Th©IsNÙOÃOf
+(
+\9aput_»g
+,
+»suÉ_»g
+,
+sü©ch
+,
+sü©ch_low
+);
+
+141
+DoubËRegi¡\94
+
+ gdoubË_sü©ch
+ =
+kSü©chDoubËReg
+;
+
+143
+__
+
+push
+(
+sü©ch
+);
+
+145 ià(
+ g\9aput_»g
+.
+is
+(
+¥
+)è
+ gdoubË_off£t
+ +ð
+kPo\9a\8brSize
+;
+
+147 ià(!
+sk\9d_ç¡·th
+()) {
+
+149
+__
+
+lfd
+(
+doubË_sü©ch
+,
+MemO³¿nd
+(
+\9aput_»g
+,
+doubË_off£t
+));
+
+152
+__
+
+CÚv\94tDoubËToIÁ64
+(
+doubË_sü©ch
+,
+
+153 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+154
+sü©ch
+,
+
+156
+»suÉ_»g
+,
+d0
+);
+
+159 #ià
+V8_TARGET_ARCH_PPC64
+
+
+160
+__
+
+Te¡IfIÁ32
+(
+»suÉ_»g
+,
+sü©ch
+,
+r0
+);
+
+162
+__
+
+Te¡IfIÁ32
+(
+sü©ch
+,
+»suÉ_»g
+,
+r0
+);
+
+164
+__
+
+beq
+(&
+ç¡·th_dÚe
+);
+
+167
+__
+
+Push
+(
+sü©ch_high
+,
+sü©ch_low
+);
+
+169 ià(
+ g\9aput_»g
+.
+is
+(
+¥
+)è
+ gdoubË_off£t
+ +ð2 *
+kPo\9a\8brSize
+;
+
+171
+__
+
+lwz
+(
+sü©ch_high
+,
+
+172
+MemO³¿nd
+(
+\9aput_»g
+,
+doubË_off£t
+ +
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+173
+__
+
+lwz
+(
+sü©ch_low
+,
+
+174
+MemO³¿nd
+(
+\9aput_»g
+,
+doubË_off£t
+ +
+Regi¡\94
+::
+kMªtis§Off£t
+));
+
+176
+__
+
+Ex\8caùB\99Mask
+(
+sü©ch
+,
+sü©ch_high
+,
+H\97pNumb\94
+::
+kExpڒtMask
+);
+
+179
+STATIC_ASSERT
+(
+H\97pNumb\94
+::
+kExpÚ\92tB\9fs
+ + 1 == 1024);
+
+180
+__
+
+subi
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+H\97pNumb\94
+::
+kExpÚ\92tB\9fs
+ + 1));
+
+185
+__
+
+cmpi
+(
+sü©ch
+,
+O³¿nd
+(83));
+
+186
+__
+
+bge
+(&
+out_of_¿nge
+);
+
+193
+__
+
+subfic
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(51));
+
+194
+__
+
+cmpi
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+195
+__
+
+bË
+(&
+Úly_low
+);
+
+198
+__
+
+¤w
+(
+sü©ch_low
+, sü©ch_low,
+sü©ch
+);
+
+202
+__
+
+subfic
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(32));
+
+203
+__
+
+Ex\8caùB\99Mask
+(
+»suÉ_»g
+,
+sü©ch_high
+,
+H\97pNumb\94
+::
+kMªtis§Mask
+);
+
+205
+STATIC_ASSERT
+(
+H\97pNumb\94
+::
+kMªtis§B\99sInTÝWÜd
+ >= 16);
+
+206
+__
+
+Üis
+(
+»suÉ_»g
+,\84esult_reg,
+
+207
+O³¿nd
+(1 << ((
+H\97pNumb\94
+::
+kMªtis§B\99sInTÝWÜd
+) - 16)));
+
+208
+__
+
+¦w
+(
+r0
+,
+»suÉ_»g
+,
+sü©ch
+);
+
+209
+__
+
+Üx
+(
+»suÉ_»g
+,
+sü©ch_low
+,
+r0
+);
+
+210
+__
+
+b
+(&
+Ãg©e
+);
+
+212
+__
+
+b\9ad
+(&
+out_of_¿nge
+);
+
+213
+__
+
+mov
+(
+»suÉ_»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+214
+__
+
+b
+(&
+dÚe
+);
+
+216
+__
+
+b\9ad
+(&
+Úly_low
+);
+
+219
+__
+
+Ãg
+(
+sü©ch
+, scratch);
+
+220
+__
+
+¦w
+(
+»suÉ_»g
+,
+sü©ch_low
+,
+sü©ch
+);
+
+222
+__
+
+b\9ad
+(&
+Ãg©e
+);
+
+229
+__
+
+¤awi
+(
+r0
+,
+sü©ch_high
+, 31);
+
+230 #ià
+V8_TARGET_ARCH_PPC64
+
+
+231
+__
+
+¤di
+(
+r0
+,\840,
+O³¿nd
+(32));
+
+233
+__
+
+xÜ_
+(
+»suÉ_»g
+,\84esuÉ_»g,
+r0
+);
+
+234
+__
+
+¤wi
+(
+r0
+,
+sü©ch_high
+,
+O³¿nd
+(31));
+
+235
+__
+
+add
+(
+»suÉ_»g
+,\84esuÉ_»g,
+r0
+);
+
+237
+__
+
+b\9ad
+(&
+dÚe
+);
+
+238
+__
+
+PÝ
+(
+sü©ch_high
+,
+sü©ch_low
+);
+
+240
+__
+
+b\9ad
+(&
+ç¡·th_dÚe
+);
+
+241
+__
+
+pÝ
+(
+sü©ch
+);
+
+243
+__
+
+R\91
+();
+
+250 \18\1e
+Em\99Id\92tiÿlObjeùCom·risÚ
+(
+MaüoAs£mbËr
+*
+masm
+,
+Lab\96
+*
+¦ow
+,
+
+251
+CÚd\99iÚ
+
+cÚd
+) {
+
+252
+Lab\96
+
+ gnÙ_id\92tiÿl
+;
+
+253
+Lab\96
+
+ gh\97p_numb\94
+,
+ g»tuº_equ®
+;
+
+254
+__
+
+cmp
+(
+r3
+,
+r4
+);
+
+255
+__
+
+bÃ
+(&
+nÙ_id\92tiÿl
+);
+
+261 ià(
+ gcÚd
+ =ð
+É
+ ||
+cÚd
+ =ð
+gt
+) {
+
+262
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r7
+,\847,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+263
+__
+
+bge
+(
+¦ow
+);
+
+265
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r7
+,\847,
+HEAP_NUMBER_TYPE
+);
+
+266
+__
+
+beq
+(&
+h\97p_numb\94
+);
+
+268 ià(
+ gcÚd
+ !ð
+eq
+) {
+
+269
+__
+
+cmpi
+(
+r7
+,
+O³¿nd
+(
+FIRST_SPEC_OBJECT_TYPE
+));
+
+270
+__
+
+bge
+(
+¦ow
+);
+
+274 ià(
+ gcÚd
+ =ð
+Ë
+ ||
+cÚd
+ =ð
+ge
+) {
+
+275
+__
+
+cmpi
+(
+r7
+,
+O³¿nd
+(
+ODDBALL_TYPE
+));
+
+276
+__
+
+bÃ
+(&
+»tuº_equ®
+);
+
+277
+__
+
+LßdRoÙ
+(
+r5
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+278
+__
+
+cmp
+(
+r3
+,
+r5
+);
+
+279
+__
+
+bÃ
+(&
+»tuº_equ®
+);
+
+280 ià(
+ gcÚd
+ =ð
+Ë
+) {
+
+282
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+GREATER
+));
+
+285
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+LESS
+));
+
+287
+__
+
+R\91
+();
+
+292
+__
+
+b\9ad
+(&
+»tuº_equ®
+);
+
+293 ià(
+ gcÚd
+ =ð
+É
+) {
+
+294
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+GREATER
+));
+
+295 } \vià(
+ gcÚd
+ =ð
+gt
+) {
+
+296
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+LESS
+));
+
+298
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+EQUAL
+));
+
+300
+__
+
+R\91
+();
+
+305 ià(
+ gcÚd
+ !ð
+É
+ &&
+cÚd
+ !ð
+gt
+) {
+
+306
+__
+
+b\9ad
+(&
+h\97p_numb\94
+);
+
+313
+__
+
+lwz
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pNumb\94
+::
+kExpÚ\92tOff£t
+));
+
+315
+STATIC_ASSERT
+(
+H\97pNumb\94
+::
+kExpڒtMask
+ == 0x7ff00000u);
+
+316
+__
+
+Ex\8caùB\99Mask
+(
+r6
+,
+r5
+,
+H\97pNumb\94
+::
+kExpڒtMask
+);
+
+317
+__
+
+cm¶i
+(
+r6
+,
+O³¿nd
+(0x7ff));
+
+318
+__
+
+bÃ
+(&
+»tuº_equ®
+);
+
+321
+__
+
+¦wi
+(
+r5
+,\845,
+O³¿nd
+(
+H\97pNumb\94
+::
+kNÚMªtis§B\99sInTÝWÜd
+));
+
+323
+__
+
+lwz
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pNumb\94
+::
+kMªtis§Off£t
+));
+
+324
+__
+
+Üx
+(
+r3
+,
+r6
+,
+r5
+);
+
+325
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+330 ià(
+ gcÚd
+ !ð
+eq
+) {
+
+331
+Lab\96
+
+nÙ_equ®
+;
+
+332
+__
+
+bÃ
+(&
+nÙ_equ®
+);
+
+334
+__
+
+R\91
+();
+
+335
+__
+
+b\9ad
+(&
+nÙ_equ®
+);
+
+336 ià(
+ gcÚd
+ =ð
+Ë
+) {
+
+337
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+GREATER
+));
+
+339
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+LESS
+));
+
+342
+__
+
+R\91
+();
+
+346
+__
+
+b\9ad
+(&
+nÙ_id\92tiÿl
+);
+
+351 \18\1e
+Em\99SmiNÚsmiCom·risÚ
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+lhs
+,
+
+352
+Regi¡\94
+
+rhs
+,
+Lab\96
+*
+lhs_nÙ_Çn
+,
+
+353
+Lab\96
+*
+¦ow
+,
+boÞ
+
+¡riù
+) {
+
+354
+DCHECK
+((
+lhs
+.
+is
+(
+r3
+è&&
+rhs
+.is(
+r4
+)) || (lhs.is(r4) &&\84hs.is(r3)));
+
+356
+Lab\96
+
+ grhs_is_smi
+;
+
+357
+__
+
+JumpIfSmi
+(
+rhs
+, &
+rhs_is_smi
+);
+
+360
+__
+
+Com·»ObjeùTy³
+(
+rhs
+,
+r6
+,
+r7
+,
+HEAP_NUMBER_TYPE
+);
+
+361 ià(
+ g¡riù
+) {
+
+365
+Lab\96
+
+ gsk\9d
+;
+
+366
+__
+
+beq
+(&
+sk\9d
+);
+
+367 ià(!
+ grhs
+.
+is
+(
+r3
+)) {
+
+368
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+NOT_EQUAL
+));
+
+370
+__
+
+R\91
+();
+
+371
+__
+
+b\9ad
+(&
+sk\9d
+);
+
+375
+__
+
+bÃ
+(
+¦ow
+);
+
+380
+__
+
+SmiToDoubË
+(
+d7
+,
+lhs
+);
+
+382
+__
+
+lfd
+(
+d6
+,
+F\9bldMemO³¿nd
+(
+rhs
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+386
+__
+
+b
+(
+lhs_nÙ_Çn
+);
+
+388
+__
+
+b\9ad
+(&
+rhs_is_smi
+);
+
+390
+__
+
+Com·»ObjeùTy³
+(
+lhs
+,
+r7
+,\847,
+HEAP_NUMBER_TYPE
+);
+
+391 ià(
+ g¡riù
+) {
+
+395
+Lab\96
+
+ gsk\9d
+;
+
+396
+__
+
+beq
+(&
+sk\9d
+);
+
+397 ià(!
+ glhs
+.
+is
+(
+r3
+)) {
+
+398
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+NOT_EQUAL
+));
+
+400
+__
+
+R\91
+();
+
+401
+__
+
+b\9ad
+(&
+sk\9d
+);
+
+405
+__
+
+bÃ
+(
+¦ow
+);
+
+410
+__
+
+lfd
+(
+d7
+,
+F\9bldMemO³¿nd
+(
+lhs
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+412
+__
+
+SmiToDoubË
+(
+d6
+,
+rhs
+);
+
+418 \18\1e
+Em\99S\8ciùTwoH\97pObjeùCom·»
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+lhs
+,
+
+419
+Regi¡\94
+
+rhs
+) {
+
+420
+DCHECK
+((
+lhs
+.
+is
+(
+r3
+è&&
+rhs
+.is(
+r4
+)) || (lhs.is(r4) &&\84hs.is(r3)));
+
+425
+STATIC_ASSERT
+(
+LAST_TYPE
+ =ð
+LAST_SPEC_OBJECT_TYPE
+);
+
+426
+Lab\96
+
+ gf\9c¡_nÚ_objeù
+;
+
+429
+__
+
+Com·»ObjeùTy³
+(
+rhs
+,
+r5
+,\845,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+430
+__
+
+bÉ
+(&
+f\9c¡_nÚ_objeù
+);
+
+433
+Lab\96
+
+ g»tuº_nÙ_equ®
+;
+
+434
+__
+
+b\9ad
+(&
+»tuº_nÙ_equ®
+);
+
+435
+__
+
+R\91
+();
+
+437
+__
+
+b\9ad
+(&
+f\9c¡_nÚ_objeù
+);
+
+439
+__
+
+cmpi
+(
+r5
+,
+O³¿nd
+(
+ODDBALL_TYPE
+));
+
+440
+__
+
+beq
+(&
+»tuº_nÙ_equ®
+);
+
+442
+__
+
+Com·»ObjeùTy³
+(
+lhs
+,
+r6
+,\846,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+443
+__
+
+bge
+(&
+»tuº_nÙ_equ®
+);
+
+446
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+(
+ODDBALL_TYPE
+));
+
+447
+__
+
+beq
+(&
+»tuº_nÙ_equ®
+);
+
+451
+STATIC_ASSERT
+(
+kIÁ\94ÇlizedTag
+ =ð0 &&
+kS\8c\9agTag
+ == 0);
+
+452
+__
+
+Üx
+(
+r5
+,\845,
+r6
+);
+
+453
+__
+
+ªdi
+(
+r0
+,
+r5
+,
+O³¿nd
+(
+kIsNÙS\8c\9agMask
+ |
+kIsNÙIÁ\94ÇlizedMask
+));
+
+454
+__
+
+beq
+(&
+»tuº_nÙ_equ®
+,
+ü0
+);
+
+459 \18\1e
+Em\99CheckFÜTwoH\97pNumb\94s
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+lhs
+,
+
+460
+Regi¡\94
+
+rhs
+,
+
+461
+Lab\96
+*
+bÙh_lßded_as_doubËs
+,
+
+462
+Lab\96
+*
+nÙ_h\97p_numb\94s
+, Lab\96*
+¦ow
+) {
+
+463
+DCHECK
+((
+lhs
+.
+is
+(
+r3
+è&&
+rhs
+.is(
+r4
+)) || (lhs.is(r4) &&\84hs.is(r3)));
+
+465
+__
+
+Com·»ObjeùTy³
+(
+rhs
+,
+r6
+,
+r5
+,
+HEAP_NUMBER_TYPE
+);
+
+466
+__
+
+bÃ
+(
+nÙ_h\97p_numb\94s
+);
+
+467
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+lhs
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+468
+__
+
+cmp
+(
+r5
+,
+r6
+);
+
+469
+__
+
+bÃ
+(
+¦ow
+);
+
+473
+__
+
+lfd
+(
+d6
+,
+F\9bldMemO³¿nd
+(
+rhs
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+474
+__
+
+lfd
+(
+d7
+,
+F\9bldMemO³¿nd
+(
+lhs
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+476
+__
+
+b
+(
+bÙh_lßded_as_doubËs
+);
+
+481 \18\1e
+Em\99CheckFÜIÁ\94ÇlizedS\8c\9agsOrObjeùs
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+482
+Regi¡\94
+
+lhs
+, Regi¡\94
+rhs
+,
+
+483
+Lab\96
+*
+possibË_¡r\9ags
+,
+
+484
+Lab\96
+*
+nÙ_bÙh_¡r\9ags
+) {
+
+485
+DCHECK
+((
+lhs
+.
+is
+(
+r3
+è&&
+rhs
+.is(
+r4
+)) || (lhs.is(r4) &&\84hs.is(r3)));
+
+488
+Lab\96
+
+ gobjeù_\8b¡
+;
+
+489
+STATIC_ASSERT
+(
+kIÁ\94ÇlizedTag
+ =ð0 &&
+kS\8c\9agTag
+ == 0);
+
+490
+__
+
+ªdi
+(
+r0
+,
+r5
+,
+O³¿nd
+(
+kIsNÙS\8c\9agMask
+));
+
+491
+__
+
+bÃ
+(&
+objeù_\8b¡
+,
+ü0
+);
+
+492
+__
+
+ªdi
+(
+r0
+,
+r5
+,
+O³¿nd
+(
+kIsNÙIÁ\94ÇlizedMask
+));
+
+493
+__
+
+bÃ
+(
+possibË_¡r\9ags
+,
+ü0
+);
+
+494
+__
+
+Com·»ObjeùTy³
+(
+lhs
+,
+r6
+,\846,
+FIRST_NONSTRING_TYPE
+);
+
+495
+__
+
+bge
+(
+nÙ_bÙh_¡r\9ags
+);
+
+496
+__
+
+ªdi
+(
+r0
+,
+r6
+,
+O³¿nd
+(
+kIsNÙIÁ\94ÇlizedMask
+));
+
+497
+__
+
+bÃ
+(
+possibË_¡r\9ags
+,
+ü0
+);
+
+501
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+NOT_EQUAL
+));
+
+502
+__
+
+R\91
+();
+
+504
+__
+
+b\9ad
+(&
+objeù_\8b¡
+);
+
+505
+__
+
+cmpi
+(
+r5
+,
+O³¿nd
+(
+FIRST_SPEC_OBJECT_TYPE
+));
+
+506
+__
+
+bÉ
+(
+nÙ_bÙh_¡r\9ags
+);
+
+507
+__
+
+Com·»ObjeùTy³
+(
+lhs
+,
+r5
+,
+r6
+,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+508
+__
+
+bÉ
+(
+nÙ_bÙh_¡r\9ags
+);
+
+512
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+rhs
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+513
+__
+
+lbz
+(
+r5
+,
+F\9bldMemO³¿nd
+Ô5,
+M
+::
+kB\99F\9bldOff£t
+));
+
+514
+__
+
+lbz
+(
+r6
+,
+F\9bldMemO³¿nd
+Ô6,
+M
+::
+kB\99F\9bldOff£t
+));
+
+515
+__
+
+ªd_
+(
+r3
+,
+r5
+,
+r6
+);
+
+516
+__
+
+ªdi
+(
+r3
+,\843,
+O³¿nd
+(1 <<
+M
+::
+kIsUnd\91eùabË
+));
+
+517
+__
+
+xÜi
+(
+r3
+,\843,
+O³¿nd
+(1 <<
+M
+::
+kIsUnd\91eùabË
+));
+
+518
+__
+
+R\91
+();
+
+522 \18\1e
+Com·»ICStub_CheckIÅutTy³
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+\9aput
+,
+
+523
+Regi¡\94
+
+sü©ch
+,
+
+524
+Com·»ICS\8f\8b
+::
+S\8f\8b
+
+ex³ùed
+,
+
+525
+Lab\96
+*
+ç\9e
+) {
+
+526
+Lab\96
+
+ gok
+;
+
+527 ià(
+ gex³ùed
+ =ð
+Com·»ICS\8f\8b
+::
+SMI
+) {
+
+528
+__
+
+JumpIfNÙSmi
+(
+\9aput
+,
+ç\9e
+);
+
+529 } \vià(
+ gex³ùed
+ =ð
+Com·»ICS\8f\8b
+::
+NUMBER
+) {
+
+530
+__
+
+JumpIfSmi
+(
+\9aput
+, &
+ok
+);
+
+531
+__
+
+CheckM
+(
+\9aput
+,
+sü©ch
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+,
+ç\9e
+,
+
+532
+DONT_DO_SMI_CHECK
+);
+
+536
+__
+
+b\9ad
+(&
+ok
+);
+
+543 \1e
+ gCom·»ICStub
+::
+G\92\94©eG\92\94ic
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+544
+Regi¡\94
+
+lhs
+ =
+r4
+;
+
+545
+Regi¡\94
+
+ grhs
+ =
+r3
+;
+
+546
+CÚd\99iÚ
+
+ gcc
+ =
+G\91CÚd\99iÚ
+();
+
+548
+Lab\96
+
+ gmiss
+;
+
+549
+Com·»ICStub_CheckIÅutTy³
+(
+masm
+,
+lhs
+,
+r5
+,
+Ëá
+(), &
+miss
+);
+
+550
+Com·»ICStub_CheckIÅutTy³
+(
+masm
+,
+rhs
+,
+r6
+,
+right
+(), &
+miss
+);
+
+552
+Lab\96
+
+ g¦ow
+;
+
+553
+Lab\96
+
+ gnÙ_smis
+,
+ gbÙh_lßded_as_doubËs
+,
+ glhs_nÙ_Çn
+;
+
+555
+Lab\96
+
+ gnÙ_two_smis
+,
+ gsmi_dÚe
+;
+
+556
+__
+
+Üx
+(
+r5
+,
+r4
+,
+r3
+);
+
+557
+__
+
+JumpIfNÙSmi
+(
+r5
+, &
+nÙ_two_smis
+);
+
+558
+__
+
+SmiUÁag
+(
+r4
+);
+
+559
+__
+
+SmiUÁag
+(
+r3
+);
+
+560
+__
+
+sub
+(
+r3
+,
+r4
+,\843);
+
+561
+__
+
+R\91
+();
+
+562
+__
+
+b\9ad
+(&
+nÙ_two_smis
+);
+
+569
+Em\99Id\92tiÿlObjeùCom·risÚ
+(
+masm
+, &
+¦ow
+,
+cc
+);
+
+573
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+574
+DCHECK_EQ
+(0,
+Smi
+::
+FromIÁ
+(0));
+
+575
+__
+
+ªd_
+(
+r5
+,
+lhs
+,
+rhs
+);
+
+576
+__
+
+JumpIfNÙSmi
+(
+r5
+, &
+nÙ_smis
+);
+
+585
+Em\99SmiNÚsmiCom·risÚ
+(
+masm
+,
+lhs
+,
+rhs
+, &
+lhs_nÙ_Çn
+, &
+¦ow
+,
+¡riù
+());
+
+587
+__
+
+b\9ad
+(&
+bÙh_lßded_as_doubËs
+);
+
+589
+__
+
+b\9ad
+(&
+lhs_nÙ_Çn
+);
+
+590
+Lab\96
+
+ gno_Çn
+;
+
+591
+__
+
+fcmpu
+(
+d7
+,
+d6
+);
+
+593
+Lab\96
+
+ gÇn
+,
+ gequ®
+,
+ gËss_thª
+;
+
+594
+__
+
+bunÜd\94ed
+(&
+Çn
+);
+
+595
+__
+
+beq
+(&
+equ®
+);
+
+596
+__
+
+bÉ
+(&
+Ëss_thª
+);
+
+597
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+GREATER
+));
+
+598
+__
+
+R\91
+();
+
+599
+__
+
+b\9ad
+(&
+equ®
+);
+
+600
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+EQUAL
+));
+
+601
+__
+
+R\91
+();
+
+602
+__
+
+b\9ad
+(&
+Ëss_thª
+);
+
+603
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+LESS
+));
+
+604
+__
+
+R\91
+();
+
+606
+__
+
+b\9ad
+(&
+Çn
+);
+
+610 ià(
+ gcc
+ =ð
+É
+ ||
+cc
+ =ð
+Ë
+) {
+
+611
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+GREATER
+));
+
+613
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+LESS
+));
+
+615
+__
+
+R\91
+();
+
+617
+__
+
+b\9ad
+(&
+nÙ_smis
+);
+
+620 ià(
+¡riù
+()) {
+
+623
+Em\99S\8ciùTwoH\97pObjeùCom·»
+(
+masm
+,
+lhs
+,
+rhs
+);
+
+626
+Lab\96
+
+ gcheck_fÜ_\9a\8bº®ized_¡r\9ags
+;
+
+627
+Lab\96
+
+ gæ©_¡r\9ag_check
+;
+
+633
+Em\99CheckFÜTwoH\97pNumb\94s
+(
+masm
+,
+lhs
+,
+rhs
+, &
+bÙh_lßded_as_doubËs
+,
+
+634 &
+check_fÜ_\9a\8bº®ized_¡r\9ags
+,
+
+635 &
+æ©_¡r\9ag_check
+);
+
+637
+__
+
+b\9ad
+(&
+check_fÜ_\9a\8bº®ized_¡r\9ags
+);
+
+640 ià(
+ gcc
+ =ð
+eq
+ && !
+¡riù
+()) {
+
+644
+Em\99CheckFÜIÁ\94ÇlizedS\8c\9agsOrObjeùs
+(
+masm
+,
+lhs
+,
+rhs
+, &
+æ©_¡r\9ag_check
+,
+
+645 &
+¦ow
+);
+
+650
+__
+
+b\9ad
+(&
+æ©_¡r\9ag_check
+);
+
+652
+__
+
+JumpIfNÚSmisNÙBÙhSequ\92t\9flOÃBy\8bS\8c\9ags
+(
+lhs
+,
+rhs
+,
+r5
+,
+r6
+, &
+¦ow
+);
+
+654
+__
+
+Inüem\92tCouÁ\94
+(
+isީe
+()->
+couÁ\94s
+()->
+¡r\9ag_com·»_Çtive
+(), 1,
+r5
+,
+
+655
+r6
+);
+
+656 ià(
+ gcc
+ =ð
+eq
+) {
+
+657
+S\8c\9agH\96³r
+::
+G\92\94©eFÏtOÃBy\8bS\8c\9agEqu®s
+(
+masm
+,
+lhs
+,
+rhs
+,
+r5
+,
+r6
+);
+
+659
+ gS\8c\9agH\96³r
+::
+G\92\94©eCom·»FÏtOÃBy\8bS\8c\9ags
+(
+masm
+,
+lhs
+,
+rhs
+,
+r5
+,
+r6
+,
+r7
+);
+
+663
+__
+
+b\9ad
+(&
+¦ow
+);
+
+665
+__
+
+Push
+(
+lhs
+,
+rhs
+);
+
+667
+ gBu\9et\9as
+::
+JavaSü\9dt
+
+Çtive
+;
+
+668 ià(
+ gcc
+ =ð
+eq
+) {
+
+669
+Çtive
+ =
+¡riù
+(è?
+Bu\9et\9as
+::
+STRICT_EQUALS
+ : Bu\9et\9as::
+EQUALS
+;
+
+671
+ gÇtive
+ =
+Bu\9et\9as
+::
+COMPARE
+;
+
+672 \12
+ gnü
+;
+
+673 ià(
+ gcc
+ =ð
+É
+ ||
+cc
+ =ð
+Ë
+) {
+
+674
+nü
+ =
+GREATER
+;
+
+676
+DCHECK
+(
+cc
+ =ð
+gt
+ || cø=ð
+ge
+);
+
+677
+ gnü
+ =
+LESS
+;
+
+679
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+nü
+));
+
+680
+__
+
+push
+(
+r3
+);
+
+685
+__
+
+InvokeBu\9et\9a
+(
+Çtive
+,
+JUMP_FUNCTION
+);
+
+687
+__
+
+b\9ad
+(&
+miss
+);
+
+688
+G\92\94©eMiss
+(
+masm
+);
+
+692 \1e
+ gStÜeBufãrOv\94æowStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+696
+__
+
+mær
+(
+r0
+);
+
+697
+__
+
+MuÉiPush
+(
+kJSC®ËrSaved
+ |
+r0
+.
+b\99
+());
+
+698 ià(
+§ve_doubËs
+()) {
+
+699
+__
+
+SaveFPRegs
+(
+¥
+, 0,
+DoubËRegi¡\94
+::
+kNumVÞ©\9eeRegi¡\94s
+);
+
+701 cڡ \12
+ g¬gum\92t_couÁ
+ = 1;
+
+702 cڡ \12
+ gå_¬gum\92t_couÁ
+ = 0;
+
+703 cڡ
+Regi¡\94
+
+ gsü©ch
+ =
+r4
+;
+
+705
+AÎowEx\8bº®C®lTh©CªtCau£GC
+
+scÝe
+(
+masm
+);
+
+706
+__
+
+P»·»C®lCFunùiÚ
+(
+¬gum\92t_couÁ
+,
+å_¬gum\92t_couÁ
+,
+sü©ch
+);
+
+707
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+isީe
+())));
+
+708
+__
+
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+::
+¡Üe_bufãr_ov\94æow_funùiÚ
+(
+isީe
+()),
+
+709
+¬gum\92t_couÁ
+);
+
+710 ià(
+§ve_doubËs
+()) {
+
+711
+__
+
+Re¡ÜeFPRegs
+(
+¥
+, 0,
+DoubËRegi¡\94
+::
+kNumVÞ©\9eeRegi¡\94s
+);
+
+713
+__
+
+MuÉiPÝ
+(
+kJSC®ËrSaved
+ |
+r0
+.
+b\99
+());
+
+714
+__
+
+m\8er
+(
+r0
+);
+
+715
+__
+
+R\91
+();
+
+719 \1e
+ gStÜeRegi¡\94sS\8f\8bStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+720
+__
+
+PushSaãpo\9atRegi¡\94s
+();
+
+721
+__
+
+bÌ
+();
+
+725 \1e
+ gRe¡ÜeRegi¡\94sS\8f\8bStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+726
+__
+
+PÝSaãpo\9atRegi¡\94s
+();
+
+727
+__
+
+bÌ
+();
+
+731 \1e
+ gM©hPowStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+732 cڡ
+Regi¡\94
+
+ba£
+ =
+r4
+;
+
+733 cڡ
+Regi¡\94
+
+ gexpڒt
+ =
+M©hPowTaggedDesü\9dtÜ
+::
+expڒt
+();
+
+734
+DCHECK
+(
+expڒt
+.
+is
+(
+r5
+));
+
+735 cڡ
+Regi¡\94
+
+ gh\97²umb\94m
+ =
+r8
+;
+
+736 cڡ
+Regi¡\94
+
+ gh\97²umb\94
+ =
+r3
+;
+
+737 cڡ
+DoubËRegi¡\94
+
+ gdoubË_ba£
+ =
+d1
+;
+
+738 cڡ
+DoubËRegi¡\94
+
+ gdoubË_expÚ\92t
+ =
+d2
+;
+
+739 cڡ
+DoubËRegi¡\94
+
+ gdoubË_»suÉ
+ =
+d3
+;
+
+740 cڡ
+DoubËRegi¡\94
+
+ gdoubË_sü©ch
+ =
+d0
+;
+
+741 cڡ
+Regi¡\94
+
+ gsü©ch
+ =
+r11
+;
+
+742 cڡ
+Regi¡\94
+
+ gsü©ch2
+ =
+r10
+;
+
+744
+Lab\96
+
+ gÿÎ_ruÁime
+,
+ gdÚe
+,
+ g\9at_expÚ\92t
+;
+
+745 ià(
+expÚ\92t_ty³
+(è=ð
+ON_STACK
+) {
+
+746
+Lab\96
+
+ba£_is_smi
+,
+uÅack_expÚ\92t
+;
+
+750
+__
+
+LßdP
+(
+ba£
+,
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+751
+__
+
+LßdP
+(
+expڒt
+,
+MemO³¿nd
+(
+¥
+, 0 *
+kPo\9a\8brSize
+));
+
+753
+__
+
+LßdRoÙ
+(
+h\97²umb\94m
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+755
+__
+
+UÁagAndJumpIfSmi
+(
+sü©ch
+,
+ba£
+, &
+ba£_is_smi
+);
+
+756
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+ba£
+,
+JSObjeù
+::
+kMOff£t
+));
+
+757
+__
+
+cmp
+(
+sü©ch
+,
+h\97²umb\94m
+);
+
+758
+__
+
+bÃ
+(&
+ÿÎ_ruÁime
+);
+
+760
+__
+
+lfd
+(
+doubË_ba£
+,
+F\9bldMemO³¿nd
+(
+ba£
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+761
+__
+
+b
+(&
+uÅack_expÚ\92t
+);
+
+763
+__
+
+b\9ad
+(&
+ba£_is_smi
+);
+
+764
+__
+
+CÚv\94tIÁToDoubË
+(
+sü©ch
+,
+doubË_ba£
+);
+
+765
+__
+
+b\9ad
+(&
+uÅack_expÚ\92t
+);
+
+767
+__
+
+UÁagAndJumpIfSmi
+(
+sü©ch
+,
+expڒt
+, &
+\9at_expÚ\92t
+);
+
+768
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+expڒt
+,
+JSObjeù
+::
+kMOff£t
+));
+
+769
+__
+
+cmp
+(
+sü©ch
+,
+h\97²umb\94m
+);
+
+770
+__
+
+bÃ
+(&
+ÿÎ_ruÁime
+);
+
+772
+__
+
+lfd
+(
+doubË_expÚ\92t
+,
+
+773
+F\9bldMemO³¿nd
+(
+expڒt
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+774 } \vià(
+expÚ\92t_ty³
+(è=ð
+TAGGED
+) {
+
+776
+__
+
+UÁagAndJumpIfSmi
+(
+sü©ch
+,
+expڒt
+, &
+\9at_expÚ\92t
+);
+
+778
+__
+
+lfd
+(
+doubË_expÚ\92t
+,
+
+779
+F\9bldMemO³¿nd
+(
+expڒt
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+782 ià(
+expÚ\92t_ty³
+(è!ð
+INTEGER
+) {
+
+784
+__
+
+TryDoubËToIÁ32Exaù
+(
+sü©ch
+,
+doubË_expÚ\92t
+,
+sü©ch2
+,
+
+785
+doubË_sü©ch
+);
+
+786
+__
+
+beq
+(&
+\9at_expÚ\92t
+);
+
+788 ià(
+expÚ\92t_ty³
+(è=ð
+ON_STACK
+) {
+
+792
+Lab\96
+
+nÙ_¶us_h®f
+,
+nÙ_m\9aus_\9af1
+,
+nÙ_m\9aus_\9af2
+;
+
+795
+__
+
+LßdDoubËL\99\94®
+(
+doubË_sü©ch
+, 0.5,
+sü©ch
+);
+
+796
+__
+
+fcmpu
+(
+doubË_expÚ\92t
+,
+doubË_sü©ch
+);
+
+797
+__
+
+bÃ
+(&
+nÙ_¶us_h®f
+);
+
+801
+__
+
+LßdDoubËL\99\94®
+(
+doubË_sü©ch
+, -
+V8_INFINITY
+,
+sü©ch
+);
+
+802
+__
+
+fcmpu
+(
+doubË_ba£
+,
+doubË_sü©ch
+);
+
+803
+__
+
+bÃ
+(&
+nÙ_m\9aus_\9af1
+);
+
+804
+__
+
+âeg
+(
+doubË_»suÉ
+,
+doubË_sü©ch
+);
+
+805
+__
+
+b
+(&
+dÚe
+);
+
+806
+__
+
+b\9ad
+(&
+nÙ_m\9aus_\9af1
+);
+
+809
+__
+
+çdd
+(
+doubË_sü©ch
+,
+doubË_ba£
+,
+kDoubËRegZ\94o
+);
+
+810
+__
+
+fsq¹
+(
+doubË_»suÉ
+,
+doubË_sü©ch
+);
+
+811
+__
+
+b
+(&
+dÚe
+);
+
+813
+__
+
+b\9ad
+(&
+nÙ_¶us_h®f
+);
+
+814
+__
+
+LßdDoubËL\99\94®
+(
+doubË_sü©ch
+, -0.5,
+sü©ch
+);
+
+815
+__
+
+fcmpu
+(
+doubË_expÚ\92t
+,
+doubË_sü©ch
+);
+
+816
+__
+
+bÃ
+(&
+ÿÎ_ruÁime
+);
+
+820
+__
+
+LßdDoubËL\99\94®
+(
+doubË_sü©ch
+, -
+V8_INFINITY
+,
+sü©ch
+);
+
+821
+__
+
+fcmpu
+(
+doubË_ba£
+,
+doubË_sü©ch
+);
+
+822
+__
+
+bÃ
+(&
+nÙ_m\9aus_\9af2
+);
+
+823
+__
+
+fmr
+(
+doubË_»suÉ
+,
+kDoubËRegZ\94o
+);
+
+824
+__
+
+b
+(&
+dÚe
+);
+
+825
+__
+
+b\9ad
+(&
+nÙ_m\9aus_\9af2
+);
+
+828
+__
+
+çdd
+(
+doubË_sü©ch
+,
+doubË_ba£
+,
+kDoubËRegZ\94o
+);
+
+829
+__
+
+LßdDoubËL\99\94®
+(
+doubË_»suÉ
+, 1.0,
+sü©ch
+);
+
+830
+__
+
+fsq¹
+(
+doubË_sü©ch
+, double_scratch);
+
+831
+__
+
+fdiv
+(
+doubË_»suÉ
+, doubË_»suÉ,
+doubË_sü©ch
+);
+
+832
+__
+
+b
+(&
+dÚe
+);
+
+835
+__
+
+mær
+(
+r0
+);
+
+836
+__
+
+push
+(
+r0
+);
+
+838
+AÎowEx\8bº®C®lTh©CªtCau£GC
+
+scÝe
+(
+masm
+);
+
+839
+__
+
+P»·»C®lCFunùiÚ
+(0, 2,
+sü©ch
+);
+
+840
+__
+
+MovToFlßtP¬am\91\94s
+(
+doubË_ba£
+,
+doubË_expÚ\92t
+);
+
+841
+__
+
+C®lCFunùiÚ
+(
+
+842
+Ex\8bº®Reã»nû
+::
+pow\94_doubË_doubË_funùiÚ
+(
+isީe
+()), 0, 2);
+
+844
+__
+
+pÝ
+(
+r0
+);
+
+845
+__
+
+m\8er
+(
+r0
+);
+
+846
+__
+
+MovFromFlßtResuÉ
+(
+doubË_»suÉ
+);
+
+847
+__
+
+b
+(&
+dÚe
+);
+
+851
+__
+
+b\9ad
+(&
+\9at_expÚ\92t
+);
+
+854 ià(
+expÚ\92t_ty³
+(è=ð
+INTEGER
+) {
+
+855
+__
+
+mr
+(
+sü©ch
+,
+expڒt
+);
+
+858
+__
+
+mr
+(
+expڒt
+,
+sü©ch
+);
+
+860
+__
+
+fmr
+(
+doubË_sü©ch
+,
+doubË_ba£
+);
+
+861
+__
+
+li
+(
+sü©ch2
+,
+O³¿nd
+(1));
+
+862
+__
+
+CÚv\94tIÁToDoubË
+(
+sü©ch2
+,
+doubË_»suÉ
+);
+
+865
+Lab\96
+
+ gpos\99ive_expÚ\92t
+;
+
+866
+__
+
+cmpi
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+867
+__
+
+bge
+(&
+pos\99ive_expÚ\92t
+);
+
+868
+__
+
+Ãg
+(
+sü©ch
+, scratch);
+
+869
+__
+
+b\9ad
+(&
+pos\99ive_expÚ\92t
+);
+
+871
+Lab\96
+
+ gwh\9ee_\8cue
+,
+ gno_ÿ¼y
+,
+ gloÝ_\92d
+;
+
+872
+__
+
+b\9ad
+(&
+wh\9ee_\8cue
+);
+
+873
+__
+
+ªdi
+(
+sü©ch2
+,
+sü©ch
+,
+O³¿nd
+(1));
+
+874
+__
+
+beq
+(&
+no_ÿ¼y
+,
+ü0
+);
+
+875
+__
+
+fmul
+(
+doubË_»suÉ
+, doubË_»suÉ,
+doubË_sü©ch
+);
+
+876
+__
+
+b\9ad
+(&
+no_ÿ¼y
+);
+
+877
+__
+
+ShiáRightAr\99hImm
+(
+sü©ch
+, sü©ch, 1,
+S\91RC
+);
+
+878
+__
+
+beq
+(&
+loÝ_\92d
+,
+ü0
+);
+
+879
+__
+
+fmul
+(
+doubË_sü©ch
+, double_scratch, double_scratch);
+
+880
+__
+
+b
+(&
+wh\9ee_\8cue
+);
+
+881
+__
+
+b\9ad
+(&
+loÝ_\92d
+);
+
+883
+__
+
+cmpi
+(
+expڒt
+,
+O³¿nd
+::
+Z\94o
+());
+
+884
+__
+
+bge
+(&
+dÚe
+);
+
+886
+__
+
+li
+(
+sü©ch2
+,
+O³¿nd
+(1));
+
+887
+__
+
+CÚv\94tIÁToDoubË
+(
+sü©ch2
+,
+doubË_sü©ch
+);
+
+888
+__
+
+fdiv
+(
+doubË_»suÉ
+,
+doubË_sü©ch
+, double_result);
+
+891
+__
+
+fcmpu
+(
+doubË_»suÉ
+,
+kDoubËRegZ\94o
+);
+
+892
+__
+
+bÃ
+(&
+dÚe
+);
+
+895
+__
+
+CÚv\94tIÁToDoubË
+(
+expڒt
+,
+doubË_expÚ\92t
+);
+
+898
+CouÁ\94s
+*
+ gcouÁ\94s
+ =
+isީe
+()->
+couÁ\94s
+();
+
+899 ià(
+expÚ\92t_ty³
+(è=ð
+ON_STACK
+) {
+
+901
+__
+
+b\9ad
+(&
+ÿÎ_ruÁime
+);
+
+902
+__
+
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+kM©hPowRT
+, 2, 1);
+
+906
+__
+
+b\9ad
+(&
+dÚe
+);
+
+907
+__
+
+AÎoÿ\8bH\97pNumb\94
+(
+h\97²umb\94
+,
+sü©ch
+,
+sü©ch2
+,
+h\97²umb\94m
+,
+
+908 &
+ÿÎ_ruÁime
+);
+
+909
+__
+
+¡fd
+(
+doubË_»suÉ
+,
+
+910
+F\9bldMemO³¿nd
+(
+h\97²umb\94
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+911
+DCHECK
+(
+h\97²umb\94
+.
+is
+(
+r3
+));
+
+912
+__
+
+Inüem\92tCouÁ\94
+(
+couÁ\94s
+->
+m©h_pow
+(), 1,
+sü©ch
+,
+sü©ch2
+);
+
+913
+__
+
+R\91
+(2);
+
+915
+__
+
+mær
+(
+r0
+);
+
+916
+__
+
+push
+(
+r0
+);
+
+918
+AÎowEx\8bº®C®lTh©CªtCau£GC
+
+scÝe
+(
+masm
+);
+
+919
+__
+
+P»·»C®lCFunùiÚ
+(0, 2,
+sü©ch
+);
+
+920
+__
+
+MovToFlßtP¬am\91\94s
+(
+doubË_ba£
+,
+doubË_expÚ\92t
+);
+
+921
+__
+
+C®lCFunùiÚ
+(
+
+922
+Ex\8bº®Reã»nû
+::
+pow\94_doubË_doubË_funùiÚ
+(
+isީe
+()), 0, 2);
+
+924
+__
+
+pÝ
+(
+r0
+);
+
+925
+__
+
+m\8er
+(
+r0
+);
+
+926
+__
+
+MovFromFlßtResuÉ
+(
+doubË_»suÉ
+);
+
+928
+__
+
+b\9ad
+(&
+dÚe
+);
+
+929
+__
+
+Inüem\92tCouÁ\94
+(
+couÁ\94s
+->
+m©h_pow
+(), 1,
+sü©ch
+,
+sü©ch2
+);
+
+930
+__
+
+R\91
+();
+
+935
+boÞ
+
+ gCEÁryStub
+::
+N\93dsImmovabËCode
+(è{ \15
+\8cue
+; }
+
+938 \1e
+ gCodeStub
+::
+G\92\94©eStubsAh\97dOfTime
+(
+Isީe
+*
+isީe
+) {
+
+939
+CEÁryStub
+::
+G\92\94©eAh\97dOfTime
+(
+isީe
+);
+
+941
+ gStÜeBufãrOv\94æowStub
+::
+G\92\94©eFixedRegStubsAh\97dOfTime
+(
+isީe
+);
+
+942
+ gStubFa\9eu»T¿mpÞ\9aeStub
+::
+G\92\94©eAh\97dOfTime
+(
+isީe
+);
+
+943
+ gA¼ayCÚ¡ruùÜStubBa£
+::
+G\92\94©eStubsAh\97dOfTime
+(
+isީe
+);
+
+944
+ gC»©eAÎoÿtiÚS\99eStub
+::
+G\92\94©eAh\97dOfTime
+(
+isީe
+);
+
+945
+ gB\9a¬yOpICStub
+::
+G\92\94©eAh\97dOfTime
+(
+isީe
+);
+
+946
+ gStÜeRegi¡\94sS\8f\8bStub
+::
+G\92\94©eAh\97dOfTime
+(
+isީe
+);
+
+947
+ gRe¡ÜeRegi¡\94sS\8f\8bStub
+::
+G\92\94©eAh\97dOfTime
+(
+isީe
+);
+
+948
+ gB\9a¬yOpICW\99hAÎoÿtiÚS\99eStub
+::
+G\92\94©eAh\97dOfTime
+(
+isީe
+);
+
+952 \1e
+ gStÜeRegi¡\94sS\8f\8bStub
+::
+G\92\94©eAh\97dOfTime
+(
+Isީe
+*
+isީe
+) {
+
+953
+StÜeRegi¡\94sS\8f\8bStub
+
+¡ub
+(
+isީe
+);
+
+954
+ g¡ub
+.
+G\91Code
+();
+
+958 \1e
+ gRe¡ÜeRegi¡\94sS\8f\8bStub
+::
+G\92\94©eAh\97dOfTime
+(
+Isީe
+*
+isީe
+) {
+
+959
+Re¡ÜeRegi¡\94sS\8f\8bStub
+
+¡ub
+(
+isީe
+);
+
+960
+ g¡ub
+.
+G\91Code
+();
+
+964 \1e
+ gCodeStub
+::
+G\92\94©eFPStubs
+(
+Isީe
+*
+isީe
+) {
+
+966
+SaveFPRegsMode
+
+mode
+ =
+kSaveFPRegs
+;
+
+967
+CEÁryStub
+(
+isީe
+, 1,
+mode
+).
+G\91Code
+();
+
+968
+StÜeBufãrOv\94æowStub
+(
+isީe
+,
+mode
+).
+G\91Code
+();
+
+969
+ gisީe
+->
+£t_å_¡ubs_g\92\94©ed
+(
+\8cue
+);
+
+973 \1e
+ gCEÁryStub
+::
+G\92\94©eAh\97dOfTime
+(
+Isީe
+*
+isީe
+) {
+
+974
+CEÁryStub
+
+¡ub
+(
+isީe
+, 1,
+kDÚtSaveFPRegs
+);
+
+975
+ g¡ub
+.
+G\91Code
+();
+
+979 \1e
+ gCEÁryStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+987
+Prof\9eeEÁryHookStub
+::
+MaybeC®lEÁryHook
+(
+masm
+);
+
+989
+__
+
+mr
+(
+r15
+,
+r4
+);
+
+992
+__
+
+ShiáLeáImm
+(
+r4
+,
+r3
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+993
+__
+
+add
+(
+r4
+,\844,
+¥
+);
+
+994
+__
+
+subi
+(
+r4
+,\844,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+997
+F¿meScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+MANUAL
+);
+
+1000 \12
+ g¬g_¡ack_¥aû
+ = 1;
+
+1003 #ià
+V8_TARGET_ARCH_PPC64
+ && !
+ABI_RETURNS_OBJECT_PAIRS_IN_REGS
+
+
+1005 ià(
+»suÉ_size
+() > 1) {
+
+1006
+DCHECK_EQ
+(2,
+»suÉ_size
+());
+
+1007
+ g¬g_¡ack_¥aû
+ += 2;
+
+1011
+__
+
+EÁ\94Ex\99F¿me
+(
+§ve_doubËs
+(),
+¬g_¡ack_¥aû
+);
+
+1014
+__
+
+mr
+(
+r14
+,
+r3
+);
+
+1022
+Regi¡\94
+
+ gisÞ©e_»g
+ =
+r5
+;
+
+1023 #ià
+V8_TARGET_ARCH_PPC64
+ && !
+ABI_RETURNS_OBJECT_PAIRS_IN_REGS
+
+
+1024 ià(
+»suÉ_size
+() > 1) {
+
+1028
+__
+
+mr
+(
+r5
+,
+r4
+);
+
+1029
+__
+
+mr
+(
+r4
+,
+r3
+);
+
+1030
+__
+
+addi
+(
+r3
+,
+¥
+,
+O³¿nd
+((
+kS\8fckF¿meEx\8caP¬amSlÙ
+ + 1è*
+kPo\9a\8brSize
+));
+
+1031
+ gisÞ©e_»g
+ =
+r6
+;
+
+1036
+__
+
+mov
+(
+isÞ©e_»g
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+isީe
+())));
+
+1038 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+ && !
+def\9aed
+(
+USE_SIMULATOR
+)
+
+1040
+__
+
+LßdP
+(
+ToRegi¡\94
+(
+ABI_TOC_REGISTER
+),
+MemO³¿nd
+(
+r15
+,
+kPo\9a\8brSize
+));
+
+1041
+__
+
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+r15
+, 0));
+
+1042
+Regi¡\94
+
+ g\8frg\91
+ =
+\9d
+;
+
+1043 #\96ià
+ABI_TOC_ADDRESSABILITY_VIA_IP
+
+
+1044
+__
+
+Move
+(
+\9d
+,
+r15
+);
+
+1045
+Regi¡\94
+
+ g\8frg\91
+ =
+\9d
+;
+
+1047
+Regi¡\94
+
+ g\8frg\91
+ =
+r15
+;
+
+1058
+ gAs£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+masm
+);
+
+1059
+Lab\96
+
+ gh\94e
+;
+
+1060
+__
+
+b
+(&
+h\94e
+,
+S\91LK
+);
+
+1061
+__
+
+b\9ad
+(&
+h\94e
+);
+
+1062
+__
+
+mær
+(
+r8
+);
+
+1065
+__
+
+addi
+(
+r0
+,
+r8
+,
+O³¿nd
+(20));
+
+1067
+__
+
+StÜeP
+(
+r0
+,
+MemO³¿nd
+(
+¥
+,
+kS\8fckF¿meEx\8caP¬amSlÙ
+ *
+kPo\9a\8brSize
+));
+
+1068
+__
+
+C®l
+(
+\8frg\91
+);
+
+1073 #ià
+V8_TARGET_ARCH_PPC64
+ && !
+ABI_RETURNS_OBJECT_PAIRS_IN_REGS
+
+
+1075 ià(
+»suÉ_size
+() > 1) {
+
+1076
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+r3
+,
+kPo\9a\8brSize
+));
+
+1077
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(r3));
+
+1083 ià(
+ gFLAG_debug_code
+) {
+
+1084
+Lab\96
+
+ gokay
+;
+
+1085
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+1086
+__
+
+bÃ
+(&
+okay
+);
+
+1087
+__
+
+¡Ý
+("The hole\83scaped");
+
+1088
+__
+
+b\9ad
+(&
+okay
+);
+
+1092
+Lab\96
+
+ gexû±iÚ_»tuºed
+;
+
+1093
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kExû±iÚRoÙIndex
+);
+
+1094
+__
+
+beq
+(&
+exû±iÚ_»tuºed
+);
+
+1096
+Ex\8bº®Reã»nû
+
+³nd\9ag_exû±iÚ_add»ss
+(
+Isީe
+::
+kP\92d\9agExû±iÚAdd»ss
+,
+
+1097
+isީe
+());
+
+1101 ià(
+ gFLAG_debug_code
+) {
+
+1102
+Lab\96
+
+ gokay
+;
+
+1103
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+³nd\9ag_exû±iÚ_add»ss
+));
+
+1104
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(r5));
+
+1105
+__
+
+Com·»RoÙ
+(
+r5
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+1107
+__
+
+beq
+(&
+okay
+);
+
+1108
+__
+
+¡Ý
+("Unexpected\85ending\83xception");
+
+1109
+__
+
+b\9ad
+(&
+okay
+);
+
+1117
+__
+
+L\97veEx\99F¿me
+(
+§ve_doubËs
+(),
+r14
+,
+\8cue
+);
+
+1118
+__
+
+bÌ
+();
+
+1121
+__
+
+b\9ad
+(&
+exû±iÚ_»tuºed
+);
+
+1124
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+³nd\9ag_exû±iÚ_add»ss
+));
+
+1125
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+r5
+));
+
+1128
+__
+
+LßdRoÙ
+(
+r6
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+1129
+__
+
+StÜeP
+(
+r6
+,
+MemO³¿nd
+(
+r5
+));
+
+1133
+Lab\96
+
+ gthrow_\8brm\9a©iÚ_exû±iÚ
+;
+
+1134
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kT\94m\9a©iÚExû±iÚRoÙIndex
+);
+
+1135
+__
+
+beq
+(&
+throw_\8brm\9a©iÚ_exû±iÚ
+);
+
+1138
+__
+
+Throw
+(
+r3
+);
+
+1140
+__
+
+b\9ad
+(&
+throw_\8brm\9a©iÚ_exû±iÚ
+);
+
+1141
+__
+
+ThrowUnÿtchabË
+(
+r3
+);
+
+1145 \1e
+ gJSEÁryStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1152
+Lab\96
+
+\9avoke
+,
+ ghªdËr_\92\8cy
+,
+ gex\99
+;
+
+1155 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+
+
+1156
+__
+
+funùiÚ_desü\9dtÜ
+();
+
+1159
+ gProf\9eeEÁryHookStub
+::
+MaybeC®lEÁryHook
+(
+masm
+);
+
+1163
+__
+
+mær
+(
+r0
+);
+
+1164
+__
+
+StÜeP
+(
+r0
+,
+MemO³¿nd
+(
+¥
+,
+kS\8fckF¿meLRSlÙ
+ *
+kPo\9a\8brSize
+));
+
+1167
+__
+
+MuÉiPush
+(
+kC®ËeSaved
+);
+
+1181
+__
+
+li
+(
+r0
+,
+O³¿nd
+(-1));
+
+1182
+__
+
+push
+(
+r0
+);
+
+1183 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1184
+__
+
+mov
+(
+kCÚ¡ªtPoÞRegi¡\94
+,
+
+1185
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+em±y_cÚ¡ªt_poÞ_¬¿y
+()));
+
+1186
+__
+
+push
+(
+kCÚ¡ªtPoÞRegi¡\94
+);
+
+1188 \12
+ gm¬k\94
+ =
+ty³
+();
+
+1189
+__
+
+LßdSmiL\99\94®
+(
+r0
+,
+Smi
+::
+FromIÁ
+(
+m¬k\94
+));
+
+1190
+__
+
+push
+(
+r0
+);
+
+1191
+__
+
+push
+(
+r0
+);
+
+1193
+__
+
+mov
+(
+r8
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kCEÁryFPAdd»ss
+,
+isީe
+())));
+
+1194
+__
+
+LßdP
+(
+r0
+,
+MemO³¿nd
+(
+r8
+));
+
+1195
+__
+
+push
+(
+r0
+);
+
+1198
+__
+
+addi
+(
+å
+,
+¥
+,
+O³¿nd
+(-
+EÁryF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+1201
+Lab\96
+
+ gnÚ_ou\8brmo¡_js
+;
+
+1202
+Ex\8bº®Reã»nû
+
+js_\92\8cy_¥
+(
+Isީe
+::
+kJSEÁrySPAdd»ss
+,
+isީe
+());
+
+1203
+__
+
+mov
+(
+r8
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+js_\92\8cy_¥
+)));
+
+1204
+__
+
+LßdP
+(
+r9
+,
+MemO³¿nd
+(
+r8
+));
+
+1205
+__
+
+cmpi
+(
+r9
+,
+O³¿nd
+::
+Z\94o
+());
+
+1206
+__
+
+bÃ
+(&
+nÚ_ou\8brmo¡_js
+);
+
+1207
+__
+
+StÜeP
+(
+å
+,
+MemO³¿nd
+(
+r8
+));
+
+1208
+__
+
+LßdSmiL\99\94®
+(
+\9d
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+OUTERMOST_JSENTRY_FRAME
+));
+
+1209
+Lab\96
+
+ gcÚt
+;
+
+1210
+__
+
+b
+(&
+cÚt
+);
+
+1211
+__
+
+b\9ad
+(&
+nÚ_ou\8brmo¡_js
+);
+
+1212
+__
+
+LßdSmiL\99\94®
+(
+\9d
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+INNER_JSENTRY_FRAME
+));
+
+1213
+__
+
+b\9ad
+(&
+cÚt
+);
+
+1214
+__
+
+push
+(
+\9d
+);
+
+1218
+__
+
+b
+(&
+\9avoke
+);
+
+1220
+__
+
+b\9ad
+(&
+hªdËr_\92\8cy
+);
+
+1221
+ ghªdËr_off£t_
+ =
+hªdËr_\92\8cy
+.
+pos
+();
+
+1226
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kP\92d\9agExû±iÚAdd»ss
+,
+
+1227
+isީe
+())));
+
+1229
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+\9d
+));
+
+1230
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kExû±iÚRoÙIndex
+);
+
+1231
+__
+
+b
+(&
+ex\99
+);
+
+1235
+__
+
+b\9ad
+(&
+\9avoke
+);
+
+1237
+__
+
+PushTryHªdËr
+(
+S\8fckHªdËr
+::
+JS_ENTRY
+, 0);
+
+1244
+__
+
+mov
+(
+r8
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+the_hÞe_v®ue
+()));
+
+1245
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kP\92d\9agExû±iÚAdd»ss
+,
+
+1246
+isީe
+())));
+
+1247
+__
+
+StÜeP
+(
+r8
+,
+MemO³¿nd
+(
+\9d
+));
+
+1259 ià(
+ty³
+(è=ð
+S\8fckF¿me
+::
+ENTRY_CONSTRUCT
+) {
+
+1260
+Ex\8bº®Reã»nû
+
+cÚ¡ruù_\92\8cy
+(
+Bu\9et\9as
+::
+kJSCÚ¡ruùEÁryT¿mpÞ\9ae
+,
+
+1261
+isީe
+());
+
+1262
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+cÚ¡ruù_\92\8cy
+));
+
+1264
+Ex\8bº®Reã»nû
+
+\92\8cy
+(
+Bu\9et\9as
+::
+kJSEÁryT¿mpÞ\9ae
+,
+isީe
+());
+
+1265
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+\92\8cy
+));
+
+1267
+__
+
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(ip));
+
+1271
+__
+
+addi
+(
+\9d
+, ip,
+O³¿nd
+(
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+1272
+__
+
+mtùr
+(
+\9d
+);
+
+1273
+__
+
+bù¾
+();
+
+1276
+__
+
+PÝTryHªdËr
+();
+
+1278
+__
+
+b\9ad
+(&
+ex\99
+);
+
+1280
+Lab\96
+
+ gnÚ_ou\8brmo¡_js_2
+;
+
+1281
+__
+
+pÝ
+(
+r8
+);
+
+1282
+__
+
+CmpSmiL\99\94®
+(
+r8
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+OUTERMOST_JSENTRY_FRAME
+),
+r0
+);
+
+1283
+__
+
+bÃ
+(&
+nÚ_ou\8brmo¡_js_2
+);
+
+1284
+__
+
+mov
+(
+r9
+,
+O³¿nd
+::
+Z\94o
+());
+
+1285
+__
+
+mov
+(
+r8
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+js_\92\8cy_¥
+)));
+
+1286
+__
+
+StÜeP
+(
+r9
+,
+MemO³¿nd
+(
+r8
+));
+
+1287
+__
+
+b\9ad
+(&
+nÚ_ou\8brmo¡_js_2
+);
+
+1290
+__
+
+pÝ
+(
+r6
+);
+
+1291
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kCEÁryFPAdd»ss
+,
+isީe
+())));
+
+1292
+__
+
+StÜeP
+(
+r6
+,
+MemO³¿nd
+(
+\9d
+));
+
+1295
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(-
+EÁryF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+1298 #ifdeà
+DEBUG
+
+
+1299 ià(
+ gFLAG_debug_code
+) {
+
+1300
+Lab\96
+
+ gh\94e
+;
+
+1301
+__
+
+b
+(&
+h\94e
+,
+S\91LK
+);
+
+1302
+__
+
+b\9ad
+(&
+h\94e
+);
+
+1306
+__
+
+MuÉiPÝ
+(
+kC®ËeSaved
+);
+
+1308
+__
+
+LßdP
+(
+r0
+,
+MemO³¿nd
+(
+¥
+,
+kS\8fckF¿meLRSlÙ
+ *
+kPo\9a\8brSize
+));
+
+1309
+__
+
+mtùr
+(
+r0
+);
+
+1310
+__
+
+bùr
+();
+
+1322 \1e
+ gIn¡ªûofStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1324
+DCHECK
+(
+HasArgsInRegi¡\94s
+(è|| !
+HasC®lS\99eIÆ\9aeCheck
+());
+
+1327 cڡ
+Regi¡\94
+
+ gobjeù
+ =
+r3
+;
+
+1328
+Regi¡\94
+
+ gm
+ =
+r6
+;
+
+1329 cڡ
+Regi¡\94
+
+ gfunùiÚ
+ =
+r4
+;
+
+1330 cڡ
+Regi¡\94
+
+ g´ÙÙy³
+ =
+r7
+;
+
+1331 cڡ
+Regi¡\94
+
+ g\9al\9ae_s\99e
+ =
+r9
+;
+
+1332 cڡ
+Regi¡\94
+
+ gsü©ch
+ =
+r5
+;
+
+1333
+Regi¡\94
+
+ gsü©ch3
+ =
+no_»g
+;
+
+1336 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1337 cڡ
+\9at32_t
+
+ gkD\96\8fToLßdBoÞResuÉ
+ =
+
+1338 (
+As£mbËr
+::
+kMovIn¡ruùiÚs
+ + 4è* As£mbËr::
+kIn¡rSize
+;
+
+1340 cڡ
+\9at32_t
+
+ gkD\96\8fToLßdBoÞResuÉ
+ =
+
+1341 (
+As£mbËr
+::
+kMovIn¡ruùiÚs
+ + 3è* As£mbËr::
+kIn¡rSize
+;
+
+1344
+Lab\96
+
+ g¦ow
+,
+ gloÝ
+,
+ gis_\9a¡ªû
+,
+ gis_nÙ_\9a¡ªû
+,
+ gnÙ_js_objeù
+;
+
+1346 ià(!
+HasArgsInRegi¡\94s
+()) {
+
+1347
+__
+
+LßdP
+(
+objeù
+,
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+1348
+__
+
+LßdP
+(
+funùiÚ
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+1352
+__
+
+JumpIfSmi
+(
+objeù
+, &
+nÙ_js_objeù
+);
+
+1353
+__
+
+IsObjeùJSObjeùTy³
+(
+objeù
+,
+m
+,
+sü©ch
+, &
+nÙ_js_objeù
+);
+
+1357 ià(!
+HasC®lS\99eIÆ\9aeCheck
+(è&& !
+R\91uºTrueF®£Objeù
+()) {
+
+1358
+Lab\96
+
+ gmiss
+;
+
+1359
+__
+
+Com·»RoÙ
+(
+funùiÚ
+,
+H\97p
+::
+kIn¡ªûofCacheFunùiÚRoÙIndex
+);
+
+1360
+__
+
+bÃ
+(&
+miss
+);
+
+1361
+__
+
+Com·»RoÙ
+(
+m
+,
+H\97p
+::
+kIn¡ªûofCacheMRoÙIndex
+);
+
+1362
+__
+
+bÃ
+(&
+miss
+);
+
+1363
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kIn¡ªûofCacheAnsw\94RoÙIndex
+);
+
+1364
+__
+
+R\91
+(
+HasArgsInRegi¡\94s
+() ? 0 : 2);
+
+1366
+__
+
+b\9ad
+(&
+miss
+);
+
+1370
+__
+
+TryG\91FunùiÚPrÙÙy³
+(
+funùiÚ
+,
+´ÙÙy³
+,
+sü©ch
+, &
+¦ow
+,
+\8cue
+);
+
+1373
+__
+
+JumpIfSmi
+(
+´ÙÙy³
+, &
+¦ow
+);
+
+1374
+__
+
+IsObjeùJSObjeùTy³
+(
+´ÙÙy³
+,
+sü©ch
+, sü©ch, &
+¦ow
+);
+
+1378 ià(!
+HasC®lS\99eIÆ\9aeCheck
+()) {
+
+1379
+__
+
+StÜeRoÙ
+(
+funùiÚ
+,
+H\97p
+::
+kIn¡ªûofCacheFunùiÚRoÙIndex
+);
+
+1380
+__
+
+StÜeRoÙ
+(
+m
+,
+H\97p
+::
+kIn¡ªûofCacheMRoÙIndex
+);
+
+1382
+DCHECK
+(
+HasArgsInRegi¡\94s
+());
+
+1387 cڡ
+Regi¡\94
+
+ goff£t
+ =
+r8
+;
+
+1388
+__
+
+mær
+(
+\9al\9ae_s\99e
+);
+
+1389
+__
+
+sub
+(
+\9al\9ae_s\99e
+, iÆ\9ae_s\99e,
+off£t
+);
+
+1391
+__
+
+G\91R\96oÿ\8bdV®ue
+(
+\9al\9ae_s\99e
+,
+off£t
+,
+sü©ch
+);
+
+1392
+__
+
+StÜeP
+(
+m
+,
+F\9bldMemO³¿nd
+(
+off£t
+,
+C\96l
+::
+kV®ueOff£t
+),
+r0
+);
+
+1397
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kPrÙÙy³Off£t
+));
+
+1400
+ gsü©ch3
+ =
+m
+;
+
+1401
+ gm
+ =
+no_»g
+;
+
+1404
+__
+
+LßdRoÙ
+(
+sü©ch3
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+1405
+__
+
+b\9ad
+(&
+loÝ
+);
+
+1406
+__
+
+cmp
+(
+sü©ch
+,
+´ÙÙy³
+);
+
+1407
+__
+
+beq
+(&
+is_\9a¡ªû
+);
+
+1408
+__
+
+cmp
+(
+sü©ch
+,
+sü©ch3
+);
+
+1409
+__
+
+beq
+(&
+is_nÙ_\9a¡ªû
+);
+
+1410
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1411
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+M
+::
+kPrÙÙy³Off£t
+));
+
+1412
+__
+
+b
+(&
+loÝ
+);
+
+1413
+FaùÜy
+*
+ gçùÜy
+ =
+isީe
+()->
+çùÜy
+();
+
+1415
+__
+
+b\9ad
+(&
+is_\9a¡ªû
+);
+
+1416 ià(!
+HasC®lS\99eIÆ\9aeCheck
+()) {
+
+1417
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(0));
+
+1418
+__
+
+StÜeRoÙ
+(
+r3
+,
+H\97p
+::
+kIn¡ªûofCacheAnsw\94RoÙIndex
+);
+
+1419 ià(
+R\91uºTrueF®£Objeù
+()) {
+
+1420
+__
+
+Move
+(
+r3
+,
+çùÜy
+->
+\8cue_v®ue
+());
+
+1424
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+1425
+__
+
+addi
+(
+\9al\9ae_s\99e
+, iÆ\9ae_s\99e,
+O³¿nd
+(
+kD\96\8fToLßdBoÞResuÉ
+));
+
+1427
+__
+
+S\91R\96oÿ\8bdV®ue
+(
+\9al\9ae_s\99e
+,
+sü©ch
+,
+r3
+);
+
+1429 ià(!
+R\91uºTrueF®£Objeù
+()) {
+
+1430
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(0));
+
+1433
+__
+
+R\91
+(
+HasArgsInRegi¡\94s
+() ? 0 : 2);
+
+1435
+__
+
+b\9ad
+(&
+is_nÙ_\9a¡ªû
+);
+
+1436 ià(!
+HasC®lS\99eIÆ\9aeCheck
+()) {
+
+1437
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(1));
+
+1438
+__
+
+StÜeRoÙ
+(
+r3
+,
+H\97p
+::
+kIn¡ªûofCacheAnsw\94RoÙIndex
+);
+
+1439 ià(
+R\91uºTrueF®£Objeù
+()) {
+
+1440
+__
+
+Move
+(
+r3
+,
+çùÜy
+->
+çl£_v®ue
+());
+
+1444
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kF®£V®ueRoÙIndex
+);
+
+1445
+__
+
+addi
+(
+\9al\9ae_s\99e
+, iÆ\9ae_s\99e,
+O³¿nd
+(
+kD\96\8fToLßdBoÞResuÉ
+));
+
+1447
+__
+
+S\91R\96oÿ\8bdV®ue
+(
+\9al\9ae_s\99e
+,
+sü©ch
+,
+r3
+);
+
+1449 ià(!
+R\91uºTrueF®£Objeù
+()) {
+
+1450
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(1));
+
+1453
+__
+
+R\91
+(
+HasArgsInRegi¡\94s
+() ? 0 : 2);
+
+1455
+Lab\96
+
+ gobjeù_nÙ_nuÎ
+,
+ gobjeù_nÙ_nuÎ_Ü_smi
+;
+
+1456
+__
+
+b\9ad
+(&
+nÙ_js_objeù
+);
+
+1459
+__
+
+JumpIfSmi
+(
+funùiÚ
+, &
+¦ow
+);
+
+1460
+__
+
+Com·»ObjeùTy³
+(
+funùiÚ
+,
+sü©ch3
+,
+sü©ch
+,
+JS_FUNCTION_TYPE
+);
+
+1461
+__
+
+bÃ
+(&
+¦ow
+);
+
+1464
+__
+
+Cmpi
+(
+objeù
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+nuÎ_v®ue
+()),
+r0
+);
+
+1465
+__
+
+bÃ
+(&
+objeù_nÙ_nuÎ
+);
+
+1466 ià(
+R\91uºTrueF®£Objeù
+()) {
+
+1467
+__
+
+Move
+(
+r3
+,
+çùÜy
+->
+çl£_v®ue
+());
+
+1469
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(1));
+
+1471
+__
+
+R\91
+(
+HasArgsInRegi¡\94s
+() ? 0 : 2);
+
+1473
+__
+
+b\9ad
+(&
+objeù_nÙ_nuÎ
+);
+
+1475
+__
+
+JumpIfNÙSmi
+(
+objeù
+, &
+objeù_nÙ_nuÎ_Ü_smi
+);
+
+1476 ià(
+R\91uºTrueF®£Objeù
+()) {
+
+1477
+__
+
+Move
+(
+r3
+,
+çùÜy
+->
+çl£_v®ue
+());
+
+1479
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(1));
+
+1481
+__
+
+R\91
+(
+HasArgsInRegi¡\94s
+() ? 0 : 2);
+
+1483
+__
+
+b\9ad
+(&
+objeù_nÙ_nuÎ_Ü_smi
+);
+
+1485
+__
+
+IsObjeùJSS\8c\9agTy³
+(
+objeù
+,
+sü©ch
+, &
+¦ow
+);
+
+1486 ià(
+R\91uºTrueF®£Objeù
+()) {
+
+1487
+__
+
+Move
+(
+r3
+,
+çùÜy
+->
+çl£_v®ue
+());
+
+1489
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(1));
+
+1491
+__
+
+R\91
+(
+HasArgsInRegi¡\94s
+() ? 0 : 2);
+
+1494
+__
+
+b\9ad
+(&
+¦ow
+);
+
+1495 ià(!
+R\91uºTrueF®£Objeù
+()) {
+
+1496 ià(
+HasArgsInRegi¡\94s
+()) {
+
+1497
+__
+
+Push
+(
+r3
+,
+r4
+);
+
+1499
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+INSTANCE_OF
+,
+JUMP_FUNCTION
+);
+
+1502
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+1503
+__
+
+Push
+(
+r3
+,
+r4
+);
+
+1504
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+INSTANCE_OF
+,
+CALL_FUNCTION
+);
+
+1506
+Lab\96
+
+ g\8cue_v®ue
+,
+ gdÚe
+;
+
+1507
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+1508
+__
+
+beq
+(&
+\8cue_v®ue
+);
+
+1510
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kF®£V®ueRoÙIndex
+);
+
+1511
+__
+
+b
+(&
+dÚe
+);
+
+1513
+__
+
+b\9ad
+(&
+\8cue_v®ue
+);
+
+1514
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+1516
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1517
+__
+
+R\91
+(
+HasArgsInRegi¡\94s
+() ? 0 : 2);
+
+1522 \1e
+ gFunùiÚPrÙÙy³Stub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1523
+Lab\96
+
+miss
+;
+
+1524
+Regi¡\94
+
+ g»ûiv\94
+ =
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+();
+
+1526
+ gNamedLßdHªdËrComp\9e\94
+::
+G\92\94©eLßdFunùiÚPrÙÙy³
+(
+masm
+,
+»ûiv\94
+,
+r6
+,
+
+1527
+r7
+, &
+miss
+);
+
+1528
+__
+
+b\9ad
+(&
+miss
+);
+
+1529
+ gPrÝ\94tyAcûssComp\9e\94
+::
+Ta\9eC®lBu\9et\9a
+(
+
+1530
+masm
+,
+PrÝ\94tyAcûssComp\9e\94
+::
+MissBu\9et\9a
+(
+Code
+::
+LOAD_IC
+));
+
+1534 \1e
+ gLßdIndexedS\8c\9agStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1536
+Lab\96
+
+miss
+;
+
+1538
+Regi¡\94
+
+ g»ûiv\94
+ =
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+();
+
+1539
+Regi¡\94
+
+ g\9adex
+ =
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+();
+
+1540
+Regi¡\94
+
+ gsü©ch
+ =
+r6
+;
+
+1541
+Regi¡\94
+
+ g»suÉ
+ =
+r3
+;
+
+1542
+DCHECK
+(!
+sü©ch
+.
+is
+(
+»ûiv\94
+è&& !sü©ch.is(
+\9adex
+));
+
+1544
+S\8c\9agCh¬AtG\92\94©Ü
+
+ch¬_©_g\92\94©Ü
+(
+»ûiv\94
+,
+\9adex
+,
+sü©ch
+,
+»suÉ
+,
+
+1545 &
+miss
+,
+
+1546 &
+miss
+,
+
+1547 &
+miss
+,
+
+1548
+STRING_INDEX_IS_ARRAY_INDEX
+,
+
+1549
+RECEIVER_IS_STRING
+);
+
+1550
+ gch¬_©_g\92\94©Ü
+.
+G\92\94©eFa¡
+(
+masm
+);
+
+1551
+__
+
+R\91
+();
+
+1553
+StubRuÁimeC®lH\96³r
+
+ gÿÎ_h\96³r
+;
+
+1554
+ gch¬_©_g\92\94©Ü
+.
+G\92\94©eSlow
+(
+masm
+,
+ÿÎ_h\96³r
+);
+
+1556
+__
+
+b\9ad
+(&
+miss
+);
+
+1557
+ gPrÝ\94tyAcûssComp\9e\94
+::
+Ta\9eC®lBu\9et\9a
+(
+
+1558
+masm
+,
+PrÝ\94tyAcûssComp\9e\94
+::
+MissBu\9et\9a
+(
+Code
+::
+KEYED_LOAD_IC
+));
+
+1562 \1e
+ gArgum\92tsAcûssStub
+::
+G\92\94©eR\97dEËm\92t
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1565 cڡ \12
+kDi¥Ïûm\92t
+ =
+
+1566
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrSPOff£t
+ -
+kPo\9a\8brSize
+;
+
+1567
+DCHECK
+(
+r4
+.
+is
+(
+Argum\92tsAcûssR\97dDesü\9dtÜ
+::
+\9adex
+()));
+
+1568
+DCHECK
+(
+r3
+.
+is
+(
+Argum\92tsAcûssR\97dDesü\9dtÜ
+::
+·¿m\91\94_couÁ
+()));
+
+1571
+Lab\96
+
+ g¦ow
+;
+
+1572
+__
+
+JumpIfNÙSmi
+(
+r4
+, &
+¦ow
+);
+
+1575
+Lab\96
+
+ gadtÜ
+;
+
+1576
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+1577
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+r5
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+1578
+STATIC_ASSERT
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+ < 0x3fffu);
+
+1579
+__
+
+CmpSmiL\99\94®
+(
+r6
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+),
+r0
+);
+
+1580
+__
+
+beq
+(&
+adtÜ
+);
+
+1585
+__
+
+cm¶
+(
+r4
+,
+r3
+);
+
+1586
+__
+
+bge
+(&
+¦ow
+);
+
+1589
+__
+
+sub
+(
+r6
+,
+r3
+,
+r4
+);
+
+1590
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r6
+,\846);
+
+1591
+__
+
+add
+(
+r6
+,
+å
+,\846);
+
+1592
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+r6
+,
+kDi¥Ïûm\92t
+));
+
+1593
+__
+
+bÌ
+();
+
+1598
+__
+
+b\9ad
+(&
+adtÜ
+);
+
+1599
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+r5
+,
+Argum\92tsAdtÜF¿meCÚ¡ªts
+::
+kL\92gthOff£t
+));
+
+1600
+__
+
+cm¶
+(
+r4
+,
+r3
+);
+
+1601
+__
+
+bge
+(&
+¦ow
+);
+
+1604
+__
+
+sub
+(
+r6
+,
+r3
+,
+r4
+);
+
+1605
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r6
+,\846);
+
+1606
+__
+
+add
+(
+r6
+,
+r5
+,\846);
+
+1607
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+r6
+,
+kDi¥Ïûm\92t
+));
+
+1608
+__
+
+bÌ
+();
+
+1612
+__
+
+b\9ad
+(&
+¦ow
+);
+
+1613
+__
+
+push
+(
+r4
+);
+
+1614
+__
+
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+kG\91Argum\92tsPrÝ\94ty
+, 1, 1);
+
+1618 \1e
+ gArgum\92tsAcûssStub
+::
+G\92\94©eNewSlÝpySlow
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1624
+Lab\96
+
+ruÁime
+;
+
+1625
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+1626
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+r6
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+1627
+STATIC_ASSERT
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+ < 0x3fffu);
+
+1628
+__
+
+CmpSmiL\99\94®
+(
+r5
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+),
+r0
+);
+
+1629
+__
+
+bÃ
+(&
+ruÁime
+);
+
+1632
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+r6
+,
+Argum\92tsAdtÜF¿meCÚ¡ªts
+::
+kL\92gthOff£t
+));
+
+1633
+__
+
+StÜeP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+, 0 *
+kPo\9a\8brSize
+));
+
+1634
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r5
+,\845);
+
+1635
+__
+
+add
+(
+r6
+,\846,
+r5
+);
+
+1636
+__
+
+addi
+(
+r6
+,\846,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrSPOff£t
+));
+
+1637
+__
+
+StÜeP
+(
+r6
+,
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+1639
+__
+
+b\9ad
+(&
+ruÁime
+);
+
+1640
+__
+
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+kNewSlÝpyArgum\92ts
+, 3, 1);
+
+1644 \1e
+ gArgum\92tsAcûssStub
+::
+G\92\94©eNewSlÝpyFa¡
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1653
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, 0 *
+kPo\9a\8brSize
+));
+
+1657
+Lab\96
+
+ gruÁime
+;
+
+1658
+Lab\96
+
+ gadtÜ_äame
+,
+ g\8cy_®loÿ\8b
+;
+
+1659
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+1660
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+r6
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+1661
+STATIC_ASSERT
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+ < 0x3fffu);
+
+1662
+__
+
+CmpSmiL\99\94®
+(
+r5
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+),
+r0
+);
+
+1663
+__
+
+beq
+(&
+adtÜ_äame
+);
+
+1666
+__
+
+mr
+(
+r5
+,
+r4
+);
+
+1667
+__
+
+b
+(&
+\8cy_®loÿ\8b
+);
+
+1670
+__
+
+b\9ad
+(&
+adtÜ_äame
+);
+
+1671
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+r6
+,
+Argum\92tsAdtÜF¿meCÚ¡ªts
+::
+kL\92gthOff£t
+));
+
+1672
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r7
+,
+r5
+);
+
+1673
+__
+
+add
+(
+r6
+,\846,
+r7
+);
+
+1674
+__
+
+addi
+(
+r6
+,\846,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrSPOff£t
+));
+
+1675
+__
+
+StÜeP
+(
+r6
+,
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+1680
+Lab\96
+
+ gsk\9d
+;
+
+1681
+__
+
+cmp
+(
+r4
+,
+r5
+);
+
+1682
+__
+
+bÉ
+(&
+sk\9d
+);
+
+1683
+__
+
+mr
+(
+r4
+,
+r5
+);
+
+1684
+__
+
+b\9ad
+(&
+sk\9d
+);
+
+1686
+__
+
+b\9ad
+(&
+\8cy_®loÿ\8b
+);
+
+1690 cڡ \12
+ gkP¬am\91\94MH\97d\94Size
+ =
+
+1691
+FixedA¼ay
+::
+kH\97d\94Size
+ + 2 *
+kPo\9a\8brSize
+;
+
+1693
+Lab\96
+
+ gsk\9d2
+,
+ gsk\9d3
+;
+
+1694
+__
+
+CmpSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(0),
+r0
+);
+
+1695
+__
+
+bÃ
+(&
+sk\9d2
+);
+
+1696
+__
+
+li
+(
+r11
+,
+O³¿nd
+::
+Z\94o
+());
+
+1697
+__
+
+b
+(&
+sk\9d3
+);
+
+1698
+__
+
+b\9ad
+(&
+sk\9d2
+);
+
+1699
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r11
+,
+r4
+);
+
+1700
+__
+
+addi
+(
+r11
+,\8411,
+O³¿nd
+(
+kP¬am\91\94MH\97d\94Size
+));
+
+1701
+__
+
+b\9ad
+(&
+sk\9d3
+);
+
+1704
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r7
+,
+r5
+);
+
+1705
+__
+
+add
+(
+r11
+,\8411,
+r7
+);
+
+1706
+__
+
+addi
+(
+r11
+,\8411,
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+));
+
+1709
+__
+
+addi
+(
+r11
+,\8411,
+O³¿nd
+(
+H\97p
+::
+kSlÝpyArgum\92tsObjeùSize
+));
+
+1712
+__
+
+AÎoÿ\8b
+(
+r11
+,
+r3
+,
+r6
+,
+r7
+, &
+ruÁime
+,
+TAG_OBJECT
+);
+
+1717 cڡ \12
+ gkNÜm®Off£t
+ =
+
+1718
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+SLOPPY_ARGUMENTS_MAP_INDEX
+);
+
+1719 cڡ \12
+ gkAl\9f£dOff£t
+ =
+
+1720
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+ALIASED_ARGUMENTS_MAP_INDEX
+);
+
+1722
+__
+
+LßdP
+(
+r7
+,
+
+1723
+MemO³¿nd
+(
+ý
+,
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+GLOBAL_OBJECT_INDEX
+)));
+
+1724
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+Ô7,
+Glob®Objeù
+::
+kN©iveCÚ\8bxtOff£t
+));
+
+1725
+Lab\96
+
+ gsk\9d4
+,
+ gsk\9d5
+;
+
+1726
+__
+
+cmpi
+(
+r4
+,
+O³¿nd
+::
+Z\94o
+());
+
+1727
+__
+
+bÃ
+(&
+sk\9d4
+);
+
+1728
+__
+
+LßdP
+(
+r7
+,
+MemO³¿nd
+Ô7,
+kNÜm®Off£t
+));
+
+1729
+__
+
+b
+(&
+sk\9d5
+);
+
+1730
+__
+
+b\9ad
+(&
+sk\9d4
+);
+
+1731
+__
+
+LßdP
+(
+r7
+,
+MemO³¿nd
+Ô7,
+kAl\9f£dOff£t
+));
+
+1732
+__
+
+b\9ad
+(&
+sk\9d5
+);
+
+1738
+__
+
+StÜeP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kMOff£t
+),
+r0
+);
+
+1739
+__
+
+LßdRoÙ
+(
+r6
+,
+H\97p
+::
+kEm±yFixedA¼ayRoÙIndex
+);
+
+1740
+__
+
+StÜeP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kPrÝ\94t\9bsOff£t
+),
+r0
+);
+
+1741
+__
+
+StÜeP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+),
+r0
+);
+
+1744
+STATIC_ASSERT
+(
+H\97p
+::
+kArgum\92tsC®ËeIndex
+ == 1);
+
+1745
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+1746
+__
+
+As£¹NÙSmi
+(
+r6
+);
+
+1747 cڡ \12
+ gkC®ËeOff£t
+ =
+
+1748
+JSObjeù
+::
+kH\97d\94Size
+ +
+H\97p
+::
+kArgum\92tsC®ËeIndex
+ *
+kPo\9a\8brSize
+;
+
+1749
+__
+
+StÜeP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+kC®ËeOff£t
+),
+r0
+);
+
+1752
+__
+
+As£¹Smi
+(
+r5
+);
+
+1753
+STATIC_ASSERT
+(
+H\97p
+::
+kArgum\92tsL\92gthIndex
+ == 0);
+
+1754 cڡ \12
+ gkL\92gthOff£t
+ =
+
+1755
+JSObjeù
+::
+kH\97d\94Size
+ +
+H\97p
+::
+kArgum\92tsL\92gthIndex
+ *
+kPo\9a\8brSize
+;
+
+1756
+__
+
+StÜeP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+kL\92gthOff£t
+),
+r0
+);
+
+1761
+__
+
+addi
+(
+r7
+,
+r3
+,
+O³¿nd
+(
+H\97p
+::
+kSlÝpyArgum\92tsObjeùSize
+));
+
+1762
+__
+
+StÜeP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+),
+r0
+);
+
+1769
+Lab\96
+
+ gsk\9d_·¿m\91\94_m
+,
+ gsk\9d6
+;
+
+1770
+__
+
+CmpSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(0),
+r0
+);
+
+1771
+__
+
+bÃ
+(&
+sk\9d6
+);
+
+1774
+__
+
+mr
+(
+r6
+,
+r7
+);
+
+1775
+__
+
+b
+(&
+sk\9d_·¿m\91\94_m
+);
+
+1776
+__
+
+b\9ad
+(&
+sk\9d6
+);
+
+1778
+__
+
+LßdRoÙ
+(
+r9
+,
+H\97p
+::
+kSlÝpyArgum\92tsEËm\92tsMRoÙIndex
+);
+
+1779
+__
+
+StÜeP
+(
+r9
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+FixedA¼ay
+::
+kMOff£t
+),
+r0
+);
+
+1780
+__
+
+AddSmiL\99\94®
+(
+r9
+,
+r4
+,
+Smi
+::
+FromIÁ
+(2),
+r0
+);
+
+1781
+__
+
+StÜeP
+(
+r9
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+FixedA¼ay
+::
+kL\92gthOff£t
+),
+r0
+);
+
+1782
+__
+
+StÜeP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+FixedA¼ay
+::
+kH\97d\94Size
+ + 0 *
+kPo\9a\8brSize
+),
+
+1783
+r0
+);
+
+1784
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r9
+,
+r4
+);
+
+1785
+__
+
+add
+(
+r9
+,
+r7
+,\849);
+
+1786
+__
+
+addi
+(
+r9
+,\849,
+O³¿nd
+(
+kP¬am\91\94MH\97d\94Size
+));
+
+1787
+__
+
+StÜeP
+(
+r9
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+FixedA¼ay
+::
+kH\97d\94Size
+ + 1 *
+kPo\9a\8brSize
+),
+
+1788
+r0
+);
+
+1798
+Lab\96
+
+ g·¿m\91\94s_loÝ
+,
+ g·¿m\91\94s_\8b¡
+;
+
+1799
+__
+
+mr
+(
+r9
+,
+r4
+);
+
+1800
+__
+
+LßdP
+(
+r11
+,
+MemO³¿nd
+(
+¥
+, 0 *
+kPo\9a\8brSize
+));
+
+1801
+__
+
+AddSmiL\99\94®
+(
+r11
+,\8411,
+Smi
+::
+FromIÁ
+(
+Cڋxt
+::
+MIN_CONTEXT_SLOTS
+),
+r0
+);
+
+1802
+__
+
+sub
+(
+r11
+,\8411,
+r4
+);
+
+1803
+__
+
+LßdRoÙ
+(
+r10
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+1804
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r6
+,
+r9
+);
+
+1805
+__
+
+add
+(
+r6
+,
+r7
+,\846);
+
+1806
+__
+
+addi
+(
+r6
+,\846,
+O³¿nd
+(
+kP¬am\91\94MH\97d\94Size
+));
+
+1814
+__
+
+b
+(&
+·¿m\91\94s_\8b¡
+);
+
+1816
+__
+
+b\9ad
+(&
+·¿m\91\94s_loÝ
+);
+
+1817
+__
+
+SubSmiL\99\94®
+(
+r9
+,\849,
+Smi
+::
+FromIÁ
+(1),
+r0
+);
+
+1818
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r8
+,
+r9
+);
+
+1819
+__
+
+addi
+(
+r8
+,\848,
+O³¿nd
+(
+kP¬am\91\94MH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+1820
+__
+
+StÜePX
+(
+r11
+,
+MemO³¿nd
+(
+r8
+,
+r7
+));
+
+1821
+__
+
+subi
+(
+r8
+,\848,
+O³¿nd
+(
+kP¬am\91\94MH\97d\94Size
+ -
+FixedA¼ay
+::
+kH\97d\94Size
+));
+
+1822
+__
+
+StÜePX
+(
+r10
+,
+MemO³¿nd
+(
+r8
+,
+r6
+));
+
+1823
+__
+
+AddSmiL\99\94®
+(
+r11
+,\8411,
+Smi
+::
+FromIÁ
+(1),
+r0
+);
+
+1824
+__
+
+b\9ad
+(&
+·¿m\91\94s_\8b¡
+);
+
+1825
+__
+
+CmpSmiL\99\94®
+(
+r9
+,
+Smi
+::
+FromIÁ
+(0),
+r0
+);
+
+1826
+__
+
+bÃ
+(&
+·¿m\91\94s_loÝ
+);
+
+1828
+__
+
+b\9ad
+(&
+sk\9d_·¿m\91\94_m
+);
+
+1833
+__
+
+LßdRoÙ
+(
+r8
+,
+H\97p
+::
+kFixedA¼ayMRoÙIndex
+);
+
+1834
+__
+
+StÜeP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r6
+,
+FixedA¼ay
+::
+kMOff£t
+),
+r0
+);
+
+1835
+__
+
+StÜeP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r6
+,
+FixedA¼ay
+::
+kL\92gthOff£t
+),
+r0
+);
+
+1837
+Lab\96
+
+ g¬gum\92ts_loÝ
+,
+ g¬gum\92ts_\8b¡
+;
+
+1838
+__
+
+mr
+(
+r11
+,
+r4
+);
+
+1839
+__
+
+LßdP
+(
+r7
+,
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+1840
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r8
+,
+r11
+);
+
+1841
+__
+
+sub
+(
+r7
+,\847,
+r8
+);
+
+1842
+__
+
+b
+(&
+¬gum\92ts_\8b¡
+);
+
+1844
+__
+
+b\9ad
+(&
+¬gum\92ts_loÝ
+);
+
+1845
+__
+
+subi
+(
+r7
+,\847,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+1846
+__
+
+LßdP
+(
+r9
+,
+MemO³¿nd
+(
+r7
+, 0));
+
+1847
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r8
+,
+r11
+);
+
+1848
+__
+
+add
+(
+r8
+,
+r6
+,\848);
+
+1849
+__
+
+StÜeP
+(
+r9
+,
+F\9bldMemO³¿nd
+(
+r8
+,
+FixedA¼ay
+::
+kH\97d\94Size
+),
+r0
+);
+
+1850
+__
+
+AddSmiL\99\94®
+(
+r11
+,\8411,
+Smi
+::
+FromIÁ
+(1),
+r0
+);
+
+1852
+__
+
+b\9ad
+(&
+¬gum\92ts_\8b¡
+);
+
+1853
+__
+
+cmp
+(
+r11
+,
+r5
+);
+
+1854
+__
+
+bÉ
+(&
+¬gum\92ts_loÝ
+);
+
+1857
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(3 *
+kPo\9a\8brSize
+));
+
+1858
+__
+
+R\91
+();
+
+1862
+__
+
+b\9ad
+(&
+ruÁime
+);
+
+1863
+__
+
+StÜeP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+, 0 *
+kPo\9a\8brSize
+));
+
+1864
+__
+
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+kNewSlÝpyArgum\92ts
+, 3, 1);
+
+1868 \1e
+ gLßdIndexedIÁ\94û±ÜStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1870
+Lab\96
+
+¦ow
+;
+
+1872
+Regi¡\94
+
+ g»ûiv\94
+ =
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+();
+
+1873
+Regi¡\94
+
+ gkey
+ =
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+();
+
+1876
+__
+
+Te¡IfPos\99iveSmi
+(
+key
+,
+r0
+);
+
+1877
+__
+
+bÃ
+(&
+¦ow
+,
+ü0
+);
+
+1880
+__
+
+Push
+(
+»ûiv\94
+,
+key
+);
+
+1883
+__
+
+Ta\9eC®lEx\8bº®Reã»nû
+(
+
+1884
+Ex\8bº®Reã»nû
+(
+IC_Ut\9e\99y
+(
+IC
+::
+kLßdEËm\92tW\99hIÁ\94û±Ü
+),
+
+1885
+masm
+->
+isީe
+()),
+
+1888
+__
+
+b\9ad
+(&
+¦ow
+);
+
+1889
+ gPrÝ\94tyAcûssComp\9e\94
+::
+Ta\9eC®lBu\9et\9a
+(
+
+1890
+masm
+,
+PrÝ\94tyAcûssComp\9e\94
+::
+MissBu\9et\9a
+(
+Code
+::
+KEYED_LOAD_IC
+));
+
+1894 \1e
+ gArgum\92tsAcûssStub
+::
+G\92\94©eNewS\8ciù
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+1899
+Lab\96
+
+adtÜ_äame
+,
+ g\8cy_®loÿ\8b
+,
+ gruÁime
+;
+
+1900
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+1901
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+r5
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+1902
+STATIC_ASSERT
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+ < 0x3fffu);
+
+1903
+__
+
+CmpSmiL\99\94®
+(
+r6
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+),
+r0
+);
+
+1904
+__
+
+beq
+(&
+adtÜ_äame
+);
+
+1907
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+1908
+__
+
+b
+(&
+\8cy_®loÿ\8b
+);
+
+1911
+__
+
+b\9ad
+(&
+adtÜ_äame
+);
+
+1912
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+r5
+,
+Argum\92tsAdtÜF¿meCÚ¡ªts
+::
+kL\92gthOff£t
+));
+
+1913
+__
+
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+1914
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r6
+,
+r4
+);
+
+1915
+__
+
+add
+(
+r6
+,
+r5
+,\846);
+
+1916
+__
+
+addi
+(
+r6
+,\846,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrSPOff£t
+));
+
+1917
+__
+
+StÜeP
+(
+r6
+,
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+1921
+Lab\96
+
+ gadd_¬gum\92ts_objeù
+;
+
+1922
+__
+
+b\9ad
+(&
+\8cy_®loÿ\8b
+);
+
+1923
+__
+
+cmpi
+(
+r4
+,
+O³¿nd
+::
+Z\94o
+());
+
+1924
+__
+
+beq
+(&
+add_¬gum\92ts_objeù
+);
+
+1925
+__
+
+SmiUÁag
+(
+r4
+);
+
+1926
+__
+
+addi
+(
+r4
+,\844,
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ /
+kPo\9a\8brSize
+));
+
+1927
+__
+
+b\9ad
+(&
+add_¬gum\92ts_objeù
+);
+
+1928
+__
+
+addi
+(
+r4
+,\844,
+O³¿nd
+(
+H\97p
+::
+kS\8ciùArgum\92tsObjeùSize
+ /
+kPo\9a\8brSize
+));
+
+1931
+__
+
+AÎoÿ\8b
+(
+r4
+,
+r3
+,
+r5
+,
+r6
+, &
+ruÁime
+,
+
+1932
+¡©ic_ÿ¡
+<
+AÎoÿtiÚFÏgs
+>(
+TAG_OBJECT
+ |
+SIZE_IN_WORDS
+));
+
+1935
+__
+
+LßdP
+(
+r7
+,
+
+1936
+MemO³¿nd
+(
+ý
+,
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+GLOBAL_OBJECT_INDEX
+)));
+
+1937
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+Ô7,
+Glob®Objeù
+::
+kN©iveCÚ\8bxtOff£t
+));
+
+1938
+__
+
+LßdP
+(
+
+1939
+r7
+,
+
+1940
+MemO³¿nd
+(
+r7
+,
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+STRICT_ARGUMENTS_MAP_INDEX
+)));
+
+1942
+__
+
+StÜeP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kMOff£t
+),
+r0
+);
+
+1943
+__
+
+LßdRoÙ
+(
+r6
+,
+H\97p
+::
+kEm±yFixedA¼ayRoÙIndex
+);
+
+1944
+__
+
+StÜeP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kPrÝ\94t\9bsOff£t
+),
+r0
+);
+
+1945
+__
+
+StÜeP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+),
+r0
+);
+
+1948
+STATIC_ASSERT
+(
+H\97p
+::
+kArgum\92tsL\92gthIndex
+ == 0);
+
+1949
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, 0 *
+kPo\9a\8brSize
+));
+
+1950
+__
+
+As£¹Smi
+(
+r4
+);
+
+1951
+__
+
+StÜeP
+(
+r4
+,
+
+1952
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kH\97d\94Size
+ +
+
+1953
+H\97p
+::
+kArgum\92tsL\92gthIndex
+ *
+kPo\9a\8brSize
+),
+
+1954
+r0
+);
+
+1957
+Lab\96
+
+ gdÚe
+;
+
+1958
+__
+
+cmpi
+(
+r4
+,
+O³¿nd
+::
+Z\94o
+());
+
+1959
+__
+
+beq
+(&
+dÚe
+);
+
+1962
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+1966
+__
+
+addi
+(
+r7
+,
+r3
+,
+O³¿nd
+(
+H\97p
+::
+kS\8ciùArgum\92tsObjeùSize
+));
+
+1967
+__
+
+StÜeP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+),
+r0
+);
+
+1968
+__
+
+LßdRoÙ
+(
+r6
+,
+H\97p
+::
+kFixedA¼ayMRoÙIndex
+);
+
+1969
+__
+
+StÜeP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+FixedA¼ay
+::
+kMOff£t
+),
+r0
+);
+
+1970
+__
+
+StÜeP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+FixedA¼ay
+::
+kL\92gthOff£t
+),
+r0
+);
+
+1972
+__
+
+SmiUÁag
+(
+r4
+);
+
+1975
+Lab\96
+
+ gloÝ
+;
+
+1977
+__
+
+addi
+(
+r7
+,\847,
+
+1978
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+ -
+kPo\9a\8brSize
+));
+
+1979
+__
+
+mtùr
+(
+r4
+);
+
+1980
+__
+
+b\9ad
+(&
+loÝ
+);
+
+1983
+__
+
+LßdPU
+(
+r6
+,
+MemO³¿nd
+(
+r5
+, -
+kPo\9a\8brSize
+));
+
+1985
+__
+
+StÜePU
+(
+r6
+,
+MemO³¿nd
+(
+r7
+,
+kPo\9a\8brSize
+));
+
+1986
+__
+
+bdnz
+(&
+loÝ
+);
+
+1989
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1990
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(3 *
+kPo\9a\8brSize
+));
+
+1991
+__
+
+R\91
+();
+
+1994
+__
+
+b\9ad
+(&
+ruÁime
+);
+
+1995
+__
+
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+kNewS\8ciùArgum\92ts
+, 3, 1);
+
+1999 \1e
+ gRegExpExecStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+2003 #ifdeà
+V8_INTERPRETED_REGEXP
+
+
+2004
+__
+
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+kRegExpExecRT
+, 4, 1);
+
+2013 cڡ \12
+ gkLa¡M©chInfoOff£t
+ = 0 *
+kPo\9a\8brSize
+;
+
+2014 cڡ \12
+ gkP»viousIndexOff£t
+ = 1 *
+kPo\9a\8brSize
+;
+
+2015 cڡ \12
+ gkSubjeùOff£t
+ = 2 *
+kPo\9a\8brSize
+;
+
+2016 cڡ \12
+ gkJSRegExpOff£t
+ = 3 *
+kPo\9a\8brSize
+;
+
+2018
+Lab\96
+
+ gruÁime
+,
+ gbr_ov\94
+,
+ g\92cod\9ag_ty³_UC16
+;
+
+2025
+Regi¡\94
+
+ gsubjeù
+ =
+r14
+;
+
+2026
+Regi¡\94
+
+ g»gexp_d©a
+ =
+r15
+;
+
+2027
+Regi¡\94
+
+ gÏ¡_m©ch_\9afo_\96em\92ts
+ =
+r16
+;
+
+2028
+Regi¡\94
+
+ gcode
+ =
+r17
+;
+
+2031
+DCHECK
+(
+subjeù
+.
+b\99
+(è&
+kC®ËeSaved
+);
+
+2032
+DCHECK
+(
+»gexp_d©a
+.
+b\99
+(è&
+kC®ËeSaved
+);
+
+2033
+DCHECK
+(
+Ï¡_m©ch_\9afo_\96em\92ts
+.
+b\99
+(è&
+kC®ËeSaved
+);
+
+2034
+DCHECK
+(
+code
+.
+b\99
+(è&
+kC®ËeSaved
+);
+
+2037
+Ex\8bº®Reã»nû
+
+ gadd»ss_of_»gexp_¡ack_memÜy_add»ss
+ =
+
+2038
+Ex\8bº®Reã»nû
+::
+add»ss_of_»gexp_¡ack_memÜy_add»ss
+(
+isީe
+());
+
+2039
+Ex\8bº®Reã»nû
+
+ gadd»ss_of_»gexp_¡ack_memÜy_size
+ =
+
+2040
+Ex\8bº®Reã»nû
+::
+add»ss_of_»gexp_¡ack_memÜy_size
+(
+isީe
+());
+
+2041
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+add»ss_of_»gexp_¡ack_memÜy_size
+));
+
+2042
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(r3, 0));
+
+2043
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+2044
+__
+
+beq
+(&
+ruÁime
+);
+
+2047
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kJSRegExpOff£t
+));
+
+2048
+__
+
+JumpIfSmi
+(
+r3
+, &
+ruÁime
+);
+
+2049
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,\844,
+JS_REGEXP_TYPE
+);
+
+2050
+__
+
+bÃ
+(&
+ruÁime
+);
+
+2053
+__
+
+LßdP
+(
+»gexp_d©a
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSRegExp
+::
+kD©aOff£t
+));
+
+2054 ià(
+ gFLAG_debug_code
+) {
+
+2055
+__
+
+Te¡IfSmi
+(
+»gexp_d©a
+,
+r0
+);
+
+2056
+__
+
+Check
+(
+Ã
+,
+kUÃx³ùedTy³FÜRegExpD©aFixedA¼ayEx³ùed
+,
+ü0
+);
+
+2057
+__
+
+Com·»ObjeùTy³
+(
+»gexp_d©a
+,
+r3
+,\843,
+FIXED_ARRAY_TYPE
+);
+
+2058
+__
+
+Check
+(
+eq
+,
+kUÃx³ùedTy³FÜRegExpD©aFixedA¼ayEx³ùed
+);
+
+2063
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+(
+»gexp_d©a
+,
+JSRegExp
+::
+kD©aTagOff£t
+));
+
+2065
+__
+
+CmpSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+JSRegExp
+::
+IRREGEXP
+),
+r0
+);
+
+2066
+__
+
+bÃ
+(&
+ruÁime
+);
+
+2070
+__
+
+LßdP
+(
+r5
+,
+
+2071
+F\9bldMemO³¿nd
+(
+»gexp_d©a
+,
+JSRegExp
+::
+kI¼egexpCtu»CouÁOff£t
+));
+
+2076
+__
+
+SmiToShÜtA¼ayOff£t
+(
+r5
+,\845);
+
+2077
+STATIC_ASSERT
+(
+Isީe
+::
+kJSRegexpS\8fticOff£tsVeùÜSize
+ >= 2);
+
+2078
+__
+
+cm¶i
+(
+r5
+,
+O³¿nd
+(
+Isީe
+::
+kJSRegexpS\8fticOff£tsVeùÜSize
+ - 2));
+
+2079
+__
+
+bgt
+(&
+ruÁime
+);
+
+2082
+__
+
+li
+(
+r11
+,
+O³¿nd
+::
+Z\94o
+());
+
+2083
+__
+
+LßdP
+(
+subjeù
+,
+MemO³¿nd
+(
+¥
+,
+kSubjeùOff£t
+));
+
+2084
+__
+
+JumpIfSmi
+(
+subjeù
+, &
+ruÁime
+);
+
+2085
+__
+
+mr
+(
+r6
+,
+subjeù
+);
+
+2086
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+(
+subjeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2087
+__
+
+lbz
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+2109
+Lab\96
+
+ g£q_¡r\9ag
+ ,
+ gex\8bº®_¡r\9ag
+ ,
+ gcheck_und\94ly\9ag
+ ,
+
+2110
+ gnÙ_£q_nÜ_cÚs
+ ,
+ gnÙ_lÚg_ex\8bº®
+ ;
+
+2113
+STATIC_ASSERT
+((
+kIsNÙS\8c\9agMask
+ |
+kS\8c\9agR\95»£Á©iÚMask
+ |
+
+2114
+kShÜtEx\8bº®S\8c\9agMask
+) == 0x93);
+
+2115
+__
+
+ªdi
+(
+r4
+,
+r3
+,
+O³¿nd
+(
+kIsNÙS\8c\9agMask
+ |
+kS\8c\9agR\95»£Á©iÚMask
+ |
+
+2116
+kShÜtEx\8bº®S\8c\9agMask
+));
+
+2117
+STATIC_ASSERT
+((
+kS\8c\9agTag
+ |
+kSeqS\8c\9agTag
+) == 0);
+
+2118
+__
+
+beq
+(&
+£q_¡r\9ag
+,
+ü0
+);
+
+2121
+STATIC_ASSERT
+(
+kCÚsS\8c\9agTag
+ <
+kEx\8bº®S\8c\9agTag
+);
+
+2122
+STATIC_ASSERT
+(
+kSliûdS\8c\9agTag
+ >
+kEx\8bº®S\8c\9agTag
+);
+
+2123
+STATIC_ASSERT
+(
+kIsNÙS\8c\9agMask
+ >
+kEx\8bº®S\8c\9agTag
+);
+
+2124
+STATIC_ASSERT
+(
+kShÜtEx\8bº®S\8c\9agTag
+ >
+kEx\8bº®S\8c\9agTag
+);
+
+2125
+STATIC_ASSERT
+(
+kEx\8bº®S\8c\9agTag
+ < 0xffffu);
+
+2126
+__
+
+cmpi
+(
+r4
+,
+O³¿nd
+(
+kEx\8bº®S\8c\9agTag
+));
+
+2127
+__
+
+bge
+(&
+nÙ_£q_nÜ_cÚs
+);
+
+2131
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+(
+subjeù
+,
+CÚsS\8c\9ag
+::
+kSecÚdOff£t
+));
+
+2132
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kem±y_¡r\9agRoÙIndex
+);
+
+2133
+__
+
+bÃ
+(&
+ruÁime
+);
+
+2134
+__
+
+LßdP
+(
+subjeù
+,
+F\9bldMemO³¿nd
+(subjeù,
+CÚsS\8c\9ag
+::
+kF\9c¡Off£t
+));
+
+2137
+__
+
+b\9ad
+(&
+check_und\94ly\9ag
+);
+
+2138
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+(
+subjeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2139
+__
+
+lbz
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+2140
+STATIC_ASSERT
+(
+kSeqS\8c\9agTag
+ == 0);
+
+2141
+STATIC_ASSERT
+(
+kS\8c\9agR\95»£Á©iÚMask
+ == 3);
+
+2142
+__
+
+ªdi
+(
+r0
+,
+r3
+,
+O³¿nd
+(
+kS\8c\9agR\95»£Á©iÚMask
+));
+
+2144
+STATIC_ASSERT
+(
+Ex\8bº®S\8c\9ag
+::
+kMaxShÜtL\92gth
+ <
+CÚsS\8c\9ag
+::
+kM\9aL\92gth
+);
+
+2145
+STATIC_ASSERT
+(
+Ex\8bº®S\8c\9ag
+::
+kMaxShÜtL\92gth
+ <
+SliûdS\8c\9ag
+::
+kM\9aL\92gth
+);
+
+2146
+__
+
+bÃ
+(&
+ex\8bº®_¡r\9ag
+,
+ü0
+);
+
+2149
+__
+
+b\9ad
+(&
+£q_¡r\9ag
+);
+
+2155
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+,
+kP»viousIndexOff£t
+));
+
+2156
+__
+
+JumpIfNÙSmi
+(
+r4
+, &
+ruÁime
+);
+
+2157
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+Ô6,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+2158
+__
+
+cm¶
+(
+r6
+,
+r4
+);
+
+2159
+__
+
+bË
+(&
+ruÁime
+);
+
+2160
+__
+
+SmiUÁag
+(
+r4
+);
+
+2162
+STATIC_ASSERT
+(4 =ð
+kOÃBy\8bS\8c\9agTag
+);
+
+2163
+STATIC_ASSERT
+(
+kTwoBy\8bS\8c\9agTag
+ == 0);
+
+2164
+STATIC_ASSERT
+(
+kS\8c\9agEncod\9agMask
+ == 4);
+
+2165
+__
+
+Ex\8caùB\99Mask
+(
+r6
+,
+r3
+,
+kS\8c\9agEncod\9agMask
+,
+S\91RC
+);
+
+2166
+__
+
+beq
+(&
+\92cod\9ag_ty³_UC16
+,
+ü0
+);
+
+2167
+__
+
+LßdP
+(
+code
+,
+
+2168
+F\9bldMemO³¿nd
+(
+»gexp_d©a
+,
+JSRegExp
+::
+kD©aOÃBy\8bCodeOff£t
+));
+
+2169
+__
+
+b
+(&
+br_ov\94
+);
+
+2170
+__
+
+b\9ad
+(&
+\92cod\9ag_ty³_UC16
+);
+
+2171
+__
+
+LßdP
+(
+code
+,
+F\9bldMemO³¿nd
+(
+»gexp_d©a
+,
+JSRegExp
+::
+kD©aUC16CodeOff£t
+));
+
+2172
+__
+
+b\9ad
+(&
+br_ov\94
+);
+
+2179
+__
+
+JumpIfSmi
+(
+code
+, &
+ruÁime
+);
+
+2187
+__
+
+Inüem\92tCouÁ\94
+(
+isީe
+()->
+couÁ\94s
+()->
+»gexp_\92\8cy_Çtive
+(), 1,
+r3
+,
+r5
+);
+
+2190 cڡ \12
+ gkRegExpExecu\8bArgum\92ts
+ = 10;
+
+2191 cڡ \12
+ gkP¬am\91\94Regi¡\94s
+ = 8;
+
+2192
+__
+
+EÁ\94Ex\99F¿me
+(
+çl£
+,
+kRegExpExecu\8bArgum\92ts
+ -
+kP¬am\91\94Regi¡\94s
+);
+
+2198
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+isީe
+())));
+
+2199
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+, (
+kS\8fckF¿meEx\8caP¬amSlÙ
+ + 1è*
+kPo\9a\8brSize
+));
+
+2205
+__
+
+li
+(
+r10
+,
+O³¿nd
+(1));
+
+2208
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+add»ss_of_»gexp_¡ack_memÜy_add»ss
+));
+
+2209
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(r3, 0));
+
+2210
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+add»ss_of_»gexp_¡ack_memÜy_size
+));
+
+2211
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(r5, 0));
+
+2212
+__
+
+add
+(
+r9
+,
+r3
+,
+r5
+);
+
+2217
+__
+
+li
+(
+r8
+,
+O³¿nd
+::
+Z\94o
+());
+
+2220
+__
+
+mov
+(
+
+2221
+r7
+,
+
+2222
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+add»ss_of_¡©ic_off£ts_veùÜ
+(
+isީe
+())));
+
+2226
+__
+
+addi
+(
+r18
+,
+subjeù
+,
+O³¿nd
+(
+SeqS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+2227
+__
+
+xÜi
+(
+r6
+,\846,
+O³¿nd
+(1));
+
+2232
+__
+
+LßdP
+(
+subjeù
+,
+MemO³¿nd
+(
+å
+,
+kSubjeùOff£t
+ + 2 *
+kPo\9a\8brSize
+));
+
+2237
+__
+
+ShiáLeá_
+(
+r11
+,\8411,
+r6
+);
+
+2238
+__
+
+add
+(
+r11
+,
+r18
+,\8411);
+
+2239
+__
+
+ShiáLeá_
+(
+r5
+,
+r4
+,
+r6
+);
+
+2240
+__
+
+add
+(
+r5
+,
+r11
+,\845);
+
+2242
+__
+
+LßdP
+(
+r18
+,
+F\9bldMemO³¿nd
+(
+subjeù
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+2243
+__
+
+SmiUÁag
+(
+r18
+);
+
+2244
+__
+
+ShiáLeá_
+(
+r6
+,
+r18
+,\846);
+
+2245
+__
+
+add
+(
+r6
+,
+r11
+,\846);
+
+2251
+__
+
+mr
+(
+r3
+,
+subjeù
+);
+
+2254
+__
+
+addi
+(
+code
+, code,
+O³¿nd
+(
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+2257 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+ &&
+def\9aed
+(
+USE_SIMULATOR
+)
+
+2263
+__
+
+LßdP
+(
+code
+,
+MemO³¿nd
+(code, 0));
+
+2266
+D\9ceùCEÁryStub
+
+¡ub
+(
+isީe
+());
+
+2267
+ g¡ub
+.
+G\92\94©eC®l
+(
+masm
+,
+code
+);
+
+2269
+__
+
+L\97veEx\99F¿me
+(
+çl£
+,
+no_»g
+,
+\8cue
+);
+
+2276
+Lab\96
+
+ gsucûss
+;
+
+2277
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+(1));
+
+2280
+__
+
+beq
+(&
+sucûss
+);
+
+2281
+Lab\96
+
+ gç\9eu»
+;
+
+2282
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+(
+N©iveRegExpMaüoAs£mbËr
+::
+FAILURE
+));
+
+2283
+__
+
+beq
+(&
+ç\9eu»
+);
+
+2284
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+(
+N©iveRegExpMaüoAs£mbËr
+::
+EXCEPTION
+));
+
+2286
+__
+
+bÃ
+(&
+ruÁime
+);
+
+2291
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+the_hÞe_v®ue
+()));
+
+2292
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kP\92d\9agExû±iÚAdd»ss
+,
+
+2293
+isީe
+())));
+
+2294
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+r5
+, 0));
+
+2295
+__
+
+cmp
+(
+r3
+,
+r4
+);
+
+2296
+__
+
+beq
+(&
+ruÁime
+);
+
+2298
+__
+
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+r5
+, 0));
+
+2301
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kT\94m\9a©iÚExû±iÚRoÙIndex
+);
+
+2303
+Lab\96
+
+ g\8brm\9a©iÚ_exû±iÚ
+;
+
+2304
+__
+
+beq
+(&
+\8brm\9a©iÚ_exû±iÚ
+);
+
+2306
+__
+
+Throw
+(
+r3
+);
+
+2308
+__
+
+b\9ad
+(&
+\8brm\9a©iÚ_exû±iÚ
+);
+
+2309
+__
+
+ThrowUnÿtchabË
+(
+r3
+);
+
+2311
+__
+
+b\9ad
+(&
+ç\9eu»
+);
+
+2313
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+nuÎ_v®ue
+()));
+
+2314
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(4 *
+kPo\9a\8brSize
+));
+
+2315
+__
+
+R\91
+();
+
+2318
+__
+
+b\9ad
+(&
+sucûss
+);
+
+2319
+__
+
+LßdP
+(
+r4
+,
+
+2320
+F\9bldMemO³¿nd
+(
+»gexp_d©a
+,
+JSRegExp
+::
+kI¼egexpCtu»CouÁOff£t
+));
+
+2324
+__
+
+SmiToShÜtA¼ayOff£t
+(
+r4
+,\844);
+
+2325
+__
+
+addi
+(
+r4
+,\844,
+O³¿nd
+(2));
+
+2327
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kLa¡M©chInfoOff£t
+));
+
+2328
+__
+
+JumpIfSmi
+(
+r3
+, &
+ruÁime
+);
+
+2329
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r5
+,\845,
+JS_ARRAY_TYPE
+);
+
+2330
+__
+
+bÃ
+(&
+ruÁime
+);
+
+2332
+__
+
+LßdP
+(
+Ï¡_m©ch_\9afo_\96em\92ts
+,
+
+2333
+F\9bldMemO³¿nd
+(
+r3
+,
+JSA¼ay
+::
+kEËm\92tsOff£t
+));
+
+2334
+__
+
+LßdP
+(
+r3
+,
+
+2335
+F\9bldMemO³¿nd
+(
+Ï¡_m©ch_\9afo_\96em\92ts
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2336
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kFixedA¼ayMRoÙIndex
+);
+
+2337
+__
+
+bÃ
+(&
+ruÁime
+);
+
+2340
+__
+
+LßdP
+(
+
+2341
+r3
+,
+F\9bldMemO³¿nd
+(
+Ï¡_m©ch_\9afo_\96em\92ts
+,
+FixedA¼ay
+::
+kL\92gthOff£t
+));
+
+2342
+__
+
+addi
+(
+r5
+,
+r4
+,
+O³¿nd
+(
+RegExpIm¶
+::
+kLa¡M©chOv\94h\97d
+));
+
+2343
+__
+
+SmiUÁag
+(
+r0
+,
+r3
+);
+
+2344
+__
+
+cmp
+(
+r5
+,
+r0
+);
+
+2345
+__
+
+bgt
+(&
+ruÁime
+);
+
+2350
+__
+
+SmiTag
+(
+r5
+,
+r4
+);
+
+2351
+__
+
+StÜeP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+Ï¡_m©ch_\9afo_\96em\92ts
+,
+
+2352
+RegExpIm¶
+::
+kLa¡Ctu»CouÁOff£t
+),
+
+2353
+r0
+);
+
+2355
+__
+
+StÜeP
+(
+subjeù
+,
+F\9bldMemO³¿nd
+(
+Ï¡_m©ch_\9afo_\96em\92ts
+,
+
+2356
+RegExpIm¶
+::
+kLa¡SubjeùOff£t
+),
+
+2357
+r0
+);
+
+2358
+__
+
+mr
+(
+r5
+,
+subjeù
+);
+
+2359
+__
+
+RecÜdWr\99eF\9bld
+(
+Ï¡_m©ch_\9afo_\96em\92ts
+,
+RegExpIm¶
+::
+kLa¡SubjeùOff£t
+,
+
+2360
+subjeù
+,
+r10
+,
+kLRHasNÙB\93nSaved
+,
+kDÚtSaveFPRegs
+);
+
+2361
+__
+
+mr
+(
+subjeù
+,
+r5
+);
+
+2362
+__
+
+StÜeP
+(
+subjeù
+,
+F\9bldMemO³¿nd
+(
+Ï¡_m©ch_\9afo_\96em\92ts
+,
+
+2363
+RegExpIm¶
+::
+kLa¡IÅutOff£t
+),
+
+2364
+r0
+);
+
+2365
+__
+
+RecÜdWr\99eF\9bld
+(
+Ï¡_m©ch_\9afo_\96em\92ts
+,
+RegExpIm¶
+::
+kLa¡IÅutOff£t
+,
+
+2366
+subjeù
+,
+r10
+,
+kLRHasNÙB\93nSaved
+,
+kDÚtSaveFPRegs
+);
+
+2369
+Ex\8bº®Reã»nû
+
+ gadd»ss_of_¡©ic_off£ts_veùÜ
+ =
+
+2370
+Ex\8bº®Reã»nû
+::
+add»ss_of_¡©ic_off£ts_veùÜ
+(
+isީe
+());
+
+2371
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+add»ss_of_¡©ic_off£ts_veùÜ
+));
+
+2375
+Lab\96
+
+ gÃxt_ÿ±u»
+;
+
+2378
+__
+
+addi
+(
+
+2379
+r3
+,
+Ï¡_m©ch_\9afo_\96em\92ts
+,
+
+2380
+O³¿nd
+(
+RegExpIm¶
+::
+kF\9c¡Ctu»Off£t
+ -
+kH\97pObjeùTag
+ -
+kPo\9a\8brSize
+));
+
+2381
+__
+
+addi
+(
+r5
+,\845,
+O³¿nd
+(-
+kIÁSize
+));
+
+2382
+__
+
+mtùr
+(
+r4
+);
+
+2383
+__
+
+b\9ad
+(&
+Ãxt_ÿ±u»
+);
+
+2385
+__
+
+lwzu
+(
+r6
+,
+MemO³¿nd
+(
+r5
+,
+kIÁSize
+));
+
+2387
+__
+
+SmiTag
+(
+r6
+);
+
+2388
+__
+
+StÜePU
+(
+r6
+,
+MemO³¿nd
+(
+r3
+,
+kPo\9a\8brSize
+));
+
+2389
+__
+
+bdnz
+(&
+Ãxt_ÿ±u»
+);
+
+2392
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kLa¡M©chInfoOff£t
+));
+
+2393
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(4 *
+kPo\9a\8brSize
+));
+
+2394
+__
+
+R\91
+();
+
+2397
+__
+
+b\9ad
+(&
+ruÁime
+);
+
+2398
+__
+
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+kRegExpExecRT
+, 4, 1);
+
+2402
+__
+
+b\9ad
+(&
+nÙ_£q_nÜ_cÚs
+);
+
+2404
+__
+
+bgt
+(&
+nÙ_lÚg_ex\8bº®
+);
+
+2407
+__
+
+b\9ad
+(&
+ex\8bº®_¡r\9ag
+);
+
+2408
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+(
+subjeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2409
+__
+
+lbz
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+2410 ià(
+ gFLAG_debug_code
+) {
+
+2413
+STATIC_ASSERT
+(
+kIsInd\9ceùS\8c\9agMask
+ == 1);
+
+2414
+__
+
+ªdi
+(
+r0
+,
+r3
+,
+O³¿nd
+(
+kIsInd\9ceùS\8c\9agMask
+));
+
+2415
+__
+
+As£¹
+(
+eq
+,
+kEx\8bº®S\8c\9agEx³ùedButNÙFound
+,
+ü0
+);
+
+2417
+__
+
+LßdP
+(
+subjeù
+,
+
+2418
+F\9bldMemO³¿nd
+(
+subjeù
+,
+Ex\8bº®S\8c\9ag
+::
+kResourûD©aOff£t
+));
+
+2420
+STATIC_ASSERT
+(
+SeqTwoBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ =ð
+SeqOÃBy\8bS\8c\9ag
+::kHeaderSize);
+
+2421
+__
+
+subi
+(
+subjeù
+, subject,
+
+2422
+O³¿nd
+(
+SeqTwoBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+2423
+__
+
+b
+(&
+£q_¡r\9ag
+);
+
+2426
+__
+
+b\9ad
+(&
+nÙ_lÚg_ex\8bº®
+);
+
+2427
+STATIC_ASSERT
+(
+kNÙS\8c\9agTag
+ !ð0 &&
+kShÜtEx\8bº®S\8c\9agTag
+ != 0);
+
+2428
+__
+
+ªdi
+(
+r0
+,
+r4
+,
+O³¿nd
+(
+kIsNÙS\8c\9agMask
+ |
+kShÜtEx\8bº®S\8c\9agMask
+));
+
+2429
+__
+
+bÃ
+(&
+ruÁime
+,
+ü0
+);
+
+2433
+__
+
+LßdP
+(
+r11
+,
+F\9bldMemO³¿nd
+(
+subjeù
+,
+SliûdS\8c\9ag
+::
+kOff£tOff£t
+));
+
+2434
+__
+
+SmiUÁag
+(
+r11
+);
+
+2435
+__
+
+LßdP
+(
+subjeù
+,
+F\9bldMemO³¿nd
+(subjeù,
+SliûdS\8c\9ag
+::
+kP¬\92tOff£t
+));
+
+2436
+__
+
+b
+(&
+check_und\94ly\9ag
+);
+
+2441 \18\1e
+G\92\94©eRecÜdC®lT¬g\91
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+2449
+Lab\96
+
+ g\9a\99\9flize
+,
+ gdÚe
+,
+ gmiss
+,
+ gmegamÜphic
+,
+ gnÙ_¬¿y_funùiÚ
+;
+
+2451
+DCHECK_EQ
+(*
+Ty³F\93dbackVeùÜ
+::
+MegamÜphicS\92t\9a\96
+(
+masm
+->
+isީe
+()),
+
+2452
+masm
+->
+isީe
+()->
+h\97p
+()->
+megamÜphic_symbÞ
+());
+
+2453
+DCHECK_EQ
+(*
+Ty³F\93dbackVeùÜ
+::
+Un\9a\99\9flizedS\92t\9a\96
+(
+masm
+->
+isީe
+()),
+
+2454
+masm
+->
+isީe
+()->
+h\97p
+()->
+un\9a\99\9flized_symbÞ
+());
+
+2457
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r7
+,
+r6
+);
+
+2458
+__
+
+add
+(
+r7
+,
+r5
+,\847);
+
+2459
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+Ô7,
+FixedA¼ay
+::
+kH\97d\94Size
+));
+
+2463
+__
+
+cmp
+(
+r7
+,
+r4
+);
+
+2464
+__
+
+b
+(
+eq
+, &
+dÚe
+);
+
+2466 ià(!
+ gFLAG_´\91\92ur\9ag_ÿÎ_Ãw
+) {
+
+2471
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r7
+, 0));
+
+2472
+__
+
+Com·»RoÙ
+(
+r8
+,
+H\97p
+::
+kAÎoÿtiÚS\99eMRoÙIndex
+);
+
+2473
+__
+
+bÃ
+(&
+miss
+);
+
+2476
+__
+
+LßdGlob®FunùiÚ
+(
+Cڋxt
+::
+ARRAY_FUNCTION_INDEX
+,
+r7
+);
+
+2477
+__
+
+cmp
+(
+r4
+,
+r7
+);
+
+2478
+__
+
+bÃ
+(&
+megamÜphic
+);
+
+2479
+__
+
+b
+(&
+dÚe
+);
+
+2482
+__
+
+b\9ad
+(&
+miss
+);
+
+2486
+__
+
+Com·»RoÙ
+(
+r7
+,
+H\97p
+::
+kun\9a\99\9flized_symbÞRoÙIndex
+);
+
+2487
+__
+
+beq
+(&
+\9a\99\9flize
+);
+
+2490
+__
+
+b\9ad
+(&
+megamÜphic
+);
+
+2491
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r7
+,
+r6
+);
+
+2492
+__
+
+add
+(
+r7
+,
+r5
+,\847);
+
+2493
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kmegamÜphic_symbÞRoÙIndex
+);
+
+2494
+__
+
+StÜeP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+FixedA¼ay
+::
+kH\97d\94Size
+),
+r0
+);
+
+2495
+__
+
+jmp
+(&
+dÚe
+);
+
+2498
+__
+
+b\9ad
+(&
+\9a\99\9flize
+);
+
+2500 ià(!
+ gFLAG_´\91\92ur\9ag_ÿÎ_Ãw
+) {
+
+2502
+__
+
+LßdGlob®FunùiÚ
+(
+Cڋxt
+::
+ARRAY_FUNCTION_INDEX
+,
+r7
+);
+
+2503
+__
+
+cmp
+(
+r4
+,
+r7
+);
+
+2504
+__
+
+bÃ
+(&
+nÙ_¬¿y_funùiÚ
+);
+
+2510
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+2513
+__
+
+SmiTag
+(
+r3
+);
+
+2514
+__
+
+Push
+(
+r6
+,
+r5
+,
+r4
+,
+r3
+);
+
+2516
+C»©eAÎoÿtiÚS\99eStub
+
+ü\97\8b_¡ub
+(
+masm
+->
+isީe
+());
+
+2517
+__
+
+C®lStub
+(&
+ü\97\8b_¡ub
+);
+
+2519
+__
+
+PÝ
+(
+r6
+,
+r5
+,
+r4
+,
+r3
+);
+
+2520
+__
+
+SmiUÁag
+(
+r3
+);
+
+2522
+__
+
+b
+(&
+dÚe
+);
+
+2524
+__
+
+b\9ad
+(&
+nÙ_¬¿y_funùiÚ
+);
+
+2527
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r7
+,
+r6
+);
+
+2528
+__
+
+add
+(
+r7
+,
+r5
+,\847);
+
+2529
+__
+
+addi
+(
+r7
+,\847,
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+2530
+__
+
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+r7
+, 0));
+
+2532
+__
+
+Push
+(
+r7
+,
+r5
+,
+r4
+);
+
+2533
+__
+
+RecÜdWr\99e
+(
+r5
+,
+r7
+,
+r4
+,
+kLRHasNÙB\93nSaved
+,
+kDÚtSaveFPRegs
+,
+
+2534
+EMIT_REMEMBERED_SET
+,
+OMIT_SMI_CHECK
+);
+
+2535
+__
+
+PÝ
+(
+r7
+,
+r5
+,
+r4
+);
+
+2537
+__
+
+b\9ad
+(&
+dÚe
+);
+
+2541 \18\1e
+Em\99CÚt\9aueIfS\8ciùOrN©ive
+(
+MaüoAs£mbËr
+*
+masm
+,
+Lab\96
+*
+cÚt
+) {
+
+2543
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+2544
+__
+
+lwz
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r6
+,
+Sh¬edFunùiÚInfo
+::
+kComp\9e\94H\9atsOff£t
+));
+
+2545
+__
+
+Te¡B\99
+(
+r7
+,
+
+2546 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2547
+Sh¬edFunùiÚInfo
+::
+kS\8ciùModeFunùiÚ
+,
+
+2549
+Sh¬edFunùiÚInfo
+::
+kS\8ciùModeFunùiÚ
+ +
+kSmiTagSize
+,
+
+2551
+r0
+);
+
+2552
+__
+
+bÃ
+(
+cÚt
+,
+ü0
+);
+
+2555
+__
+
+Te¡B\99
+(
+r7
+,
+
+2556 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2557
+Sh¬edFunùiÚInfo
+::
+kN©ive
+,
+
+2559
+Sh¬edFunùiÚInfo
+::
+kN©ive
+ +
+kSmiTagSize
+,
+
+2561
+r0
+);
+
+2562
+__
+
+bÃ
+(
+cÚt
+,
+ü0
+);
+
+2566 \18\1e
+Em\99SlowCa£
+(
+MaüoAs£mbËr
+*
+masm
+, \12
+¬gc
+,
+Lab\96
+*
+nÚ_funùiÚ
+) {
+
+2568
+STATIC_ASSERT
+(
+JS_FUNCTION_PROXY_TYPE
+ < 0xffffu);
+
+2569
+__
+
+cmpi
+(
+r7
+,
+O³¿nd
+(
+JS_FUNCTION_PROXY_TYPE
+));
+
+2570
+__
+
+bÃ
+(
+nÚ_funùiÚ
+);
+
+2571
+__
+
+push
+(
+r4
+);
+
+2572
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+¬gc
+ + 1));
+
+2573
+__
+
+li
+(
+r5
+,
+O³¿nd
+::
+Z\94o
+());
+
+2574
+__
+
+G\91Bu\9et\9aFunùiÚ
+(
+r4
+,
+Bu\9et\9as
+::
+CALL_FUNCTION_PROXY
+);
+
+2576
+ gHªdË
+<
+ gCode
+>
+ gadtÜ
+ =
+
+2577
+masm
+->
+isީe
+()->
+bu\9et\9as
+()->
+Argum\92tsAdtÜT¿mpÞ\9ae
+();
+
+2578
+__
+
+Jump
+(
+adtÜ
+,
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+2583
+__
+
+b\9ad
+(
+nÚ_funùiÚ
+);
+
+2584
+__
+
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+,
+¬gc
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+2585
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+¬gc
+));
+
+2586
+__
+
+li
+(
+r5
+,
+O³¿nd
+::
+Z\94o
+());
+
+2587
+__
+
+G\91Bu\9et\9aFunùiÚ
+(
+r4
+,
+Bu\9et\9as
+::
+CALL_NON_FUNCTION
+);
+
+2588
+__
+
+Jump
+(
+masm
+->
+isީe
+()->
+bu\9et\9as
+()->
+Argum\92tsAdtÜT¿mpÞ\9ae
+(),
+
+2589
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+2593 \18\1e
+Em\99W¿pCa£
+(
+MaüoAs£mbËr
+*
+masm
+, \12
+¬gc
+,
+Lab\96
+*
+cÚt
+) {
+
+2596
+F¿meAndCÚ¡ªtPoÞScÝe
+
+äame_scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+2597
+__
+
+Push
+(
+r4
+,
+r6
+);
+
+2598
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+TO_OBJECT
+,
+CALL_FUNCTION
+);
+
+2599
+__
+
+pÝ
+(
+r4
+);
+
+2601
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+¬gc
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+2602
+__
+
+b
+(
+cÚt
+);
+
+2606 \18\1e
+C®lFunùiÚNoF\93dback
+(
+MaüoAs£mbËr
+*
+masm
+, \12
+¬gc
+,
+
+2607
+boÞ
+
+Ãeds_checks
+, boÞ
+ÿÎ_as_m\91hod
+) {
+
+2609
+Lab\96
+
+ g¦ow
+,
+ gnÚ_funùiÚ
+,
+ gw¿p
+,
+ gcÚt
+;
+
+2611 ià(
+ gÃeds_checks
+) {
+
+2614
+__
+
+JumpIfSmi
+(
+r4
+, &
+nÚ_funùiÚ
+);
+
+2617
+__
+
+Com·»ObjeùTy³
+(
+r4
+,
+r7
+,\847,
+JS_FUNCTION_TYPE
+);
+
+2618
+__
+
+bÃ
+(&
+¦ow
+);
+
+2623
+P¬am\91\94CouÁ
+
+aùu®
+(
+¬gc
+);
+
+2625 ià(
+ gÿÎ_as_m\91hod
+) {
+
+2626 ià(
+ gÃeds_checks
+) {
+
+2627
+Em\99CÚt\9aueIfS\8ciùOrN©ive
+(
+masm
+, &
+cÚt
+);
+
+2631
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+¥
+,
+¬gc
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+2633 ià(
+ gÃeds_checks
+) {
+
+2634
+__
+
+JumpIfSmi
+(
+r6
+, &
+w¿p
+);
+
+2635
+__
+
+Com·»ObjeùTy³
+(
+r6
+,
+r7
+,\847,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+2636
+__
+
+bÉ
+(&
+w¿p
+);
+
+2638
+__
+
+b
+(&
+w¿p
+);
+
+2641
+__
+
+b\9ad
+(&
+cÚt
+);
+
+2644
+__
+
+InvokeFunùiÚ
+(
+r4
+,
+aùu®
+,
+JUMP_FUNCTION
+,
+NuÎC®lW¿µ\94
+());
+
+2646 ià(
+ gÃeds_checks
+) {
+
+2648
+__
+
+b\9ad
+(&
+¦ow
+);
+
+2649
+Em\99SlowCa£
+(
+masm
+,
+¬gc
+, &
+nÚ_funùiÚ
+);
+
+2652 ià(
+ gÿÎ_as_m\91hod
+) {
+
+2653
+__
+
+b\9ad
+(&
+w¿p
+);
+
+2654
+Em\99W¿pCa£
+(
+masm
+,
+¬gc
+, &
+cÚt
+);
+
+2659 \1e
+ gC®lFunùiÚStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+2660
+C®lFunùiÚNoF\93dback
+(
+masm
+,
+¬gc
+(),
+N\93dsChecks
+(),
+C®lAsM\91hod
+());
+
+2664 \1e
+ gC®lCÚ¡ruùStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+2670
+Lab\96
+
+¦ow
+,
+ gnÚ_funùiÚ_ÿÎ
+;
+
+2673
+__
+
+JumpIfSmi
+(
+r4
+, &
+nÚ_funùiÚ_ÿÎ
+);
+
+2675
+__
+
+Com·»ObjeùTy³
+(
+r4
+,
+r7
+,\847,
+JS_FUNCTION_TYPE
+);
+
+2676
+__
+
+bÃ
+(&
+¦ow
+);
+
+2678 ià(
+RecÜdC®lT¬g\91
+()) {
+
+2679
+G\92\94©eRecÜdC®lT¬g\91
+(
+masm
+);
+
+2681
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r8
+,
+r6
+);
+
+2682
+__
+
+add
+(
+r8
+,
+r5
+,\848);
+
+2683 ià(
+ gFLAG_´\91\92ur\9ag_ÿÎ_Ãw
+) {
+
+2687
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r8
+,
+FixedA¼ay
+::
+kH\97d\94Size
+ +
+kPo\9a\8brSize
+));
+
+2689
+Lab\96
+
+ gãedback_»gi¡\94_\9a\99\9flized
+;
+
+2691
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r8
+,
+FixedA¼ay
+::
+kH\97d\94Size
+));
+
+2692
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+AÎoÿtiÚS\99e
+::
+kMOff£t
+));
+
+2693
+__
+
+Com·»RoÙ
+(
+r8
+,
+H\97p
+::
+kAÎoÿtiÚS\99eMRoÙIndex
+);
+
+2694
+__
+
+beq
+(&
+ãedback_»gi¡\94_\9a\99\9flized
+);
+
+2695
+__
+
+LßdRoÙ
+(
+r5
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+2696
+__
+
+b\9ad
+(&
+ãedback_»gi¡\94_\9a\99\9flized
+);
+
+2699
+__
+
+As£¹Undef\9aedOrAÎoÿtiÚS\99e
+(
+r5
+,
+r8
+);
+
+2703
+Regi¡\94
+
+ gjmp_»g
+ =
+r7
+;
+
+2704
+__
+
+LßdP
+(
+jmp_»g
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+2705
+__
+
+LßdP
+(
+jmp_»g
+,
+
+2706
+F\9bldMemO³¿nd
+(
+jmp_»g
+,
+Sh¬edFunùiÚInfo
+::
+kCÚ¡ruùStubOff£t
+));
+
+2707
+__
+
+addi
+(
+\9d
+,
+jmp_»g
+,
+O³¿nd
+(
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+2708
+__
+
+JumpToJSEÁry
+(
+\9d
+);
+
+2713
+Lab\96
+
+ gdo_ÿÎ
+;
+
+2714
+__
+
+b\9ad
+(&
+¦ow
+);
+
+2715
+STATIC_ASSERT
+(
+JS_FUNCTION_PROXY_TYPE
+ < 0xffffu);
+
+2716
+__
+
+cmpi
+(
+r7
+,
+O³¿nd
+(
+JS_FUNCTION_PROXY_TYPE
+));
+
+2717
+__
+
+bÃ
+(&
+nÚ_funùiÚ_ÿÎ
+);
+
+2718
+__
+
+G\91Bu\9et\9aFunùiÚ
+(
+r4
+,
+Bu\9et\9as
+::
+CALL_FUNCTION_PROXY_AS_CONSTRUCTOR
+);
+
+2719
+__
+
+b
+(&
+do_ÿÎ
+);
+
+2721
+__
+
+b\9ad
+(&
+nÚ_funùiÚ_ÿÎ
+);
+
+2722
+__
+
+G\91Bu\9et\9aFunùiÚ
+(
+r4
+,
+Bu\9et\9as
+::
+CALL_NON_FUNCTION_AS_CONSTRUCTOR
+);
+
+2723
+__
+
+b\9ad
+(&
+do_ÿÎ
+);
+
+2725
+__
+
+li
+(
+r5
+,
+O³¿nd
+::
+Z\94o
+());
+
+2726
+__
+
+Jump
+(
+masm
+->
+isީe
+()->
+bu\9et\9as
+()->
+Argum\92tsAdtÜT¿mpÞ\9ae
+(),
+
+2727
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+2731 \18\1e
+Em\99LßdTy³F\93dbackVeùÜ
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+veùÜ
+) {
+
+2732
+__
+
+LßdP
+(
+veùÜ
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+2733
+__
+
+LßdP
+(
+veùÜ
+,
+
+2734
+F\9bldMemO³¿nd
+(
+veùÜ
+,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+2735
+__
+
+LßdP
+(
+veùÜ
+,
+
+2736
+F\9bldMemO³¿nd
+(
+veùÜ
+,
+Sh¬edFunùiÚInfo
+::
+kF\93dbackVeùÜOff£t
+));
+
+2740 \1e
+ gC®lIC_A¼ayStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+2743
+Lab\96
+
+miss
+;
+
+2744 \12
+ g¬gc
+ =
+¬g_couÁ
+();
+
+2745
+P¬am\91\94CouÁ
+
+aùu®
+(
+¬gc
+);
+
+2747
+Em\99LßdTy³F\93dbackVeùÜ
+(
+masm
+,
+r5
+);
+
+2749
+__
+
+LßdGlob®FunùiÚ
+(
+Cڋxt
+::
+ARRAY_FUNCTION_INDEX
+,
+r7
+);
+
+2750
+__
+
+cmp
+(
+r4
+,
+r7
+);
+
+2751
+__
+
+bÃ
+(&
+miss
+);
+
+2753
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+¬g_couÁ
+()));
+
+2754
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r7
+,
+r6
+);
+
+2755
+__
+
+add
+(
+r7
+,
+r5
+,\847);
+
+2756
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+Ô7,
+FixedA¼ay
+::
+kH\97d\94Size
+));
+
+2759
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2760
+__
+
+Com·»RoÙ
+(
+r8
+,
+H\97p
+::
+kAÎoÿtiÚS\99eMRoÙIndex
+);
+
+2761
+__
+
+bÃ
+(&
+miss
+);
+
+2763
+__
+
+mr
+(
+r5
+,
+r7
+);
+
+2764
+A¼ayCÚ¡ruùÜStub
+
+¡ub
+(
+masm
+->
+isީe
+(),
+¬g_couÁ
+());
+
+2765
+__
+
+Ta\9eC®lStub
+(&
+¡ub
+);
+
+2767
+__
+
+b\9ad
+(&
+miss
+);
+
+2768
+G\92\94©eMiss
+(
+masm
+);
+
+2771
+C®lFunùiÚNoF\93dback
+(
+masm
+,
+¬g_couÁ
+(),
+\8cue
+,
+C®lAsM\91hod
+());
+
+2774
+__
+
+¡Ý
+("Unexpected code\87ddress");
+
+2778 \1e
+ gC®lICStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+2781
+Lab\96
+
+ex\8ca_checks_Ü_miss
+,
+ g¦ow_¡¬t
+;
+
+2782
+Lab\96
+
+ g¦ow
+,
+ gnÚ_funùiÚ
+,
+ gw¿p
+,
+ gcÚt
+;
+
+2783
+Lab\96
+
+ ghave_js_funùiÚ
+;
+
+2784 \12
+ g¬gc
+ =
+¬g_couÁ
+();
+
+2785
+P¬am\91\94CouÁ
+
+aùu®
+(
+¬gc
+);
+
+2787
+Em\99LßdTy³F\93dbackVeùÜ
+(
+masm
+,
+r5
+);
+
+2790
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r7
+,
+r6
+);
+
+2791
+__
+
+add
+(
+r7
+,
+r5
+,\847);
+
+2792
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+Ô7,
+FixedA¼ay
+::
+kH\97d\94Size
+));
+
+2793
+__
+
+cmp
+(
+r4
+,
+r7
+);
+
+2794
+__
+
+bÃ
+(&
+ex\8ca_checks_Ü_miss
+);
+
+2796
+__
+
+b\9ad
+(&
+have_js_funùiÚ
+);
+
+2797 ià(
+C®lAsM\91hod
+()) {
+
+2798
+Em\99CÚt\9aueIfS\8ciùOrN©ive
+(
+masm
+, &
+cÚt
+);
+
+2800
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+¥
+,
+¬gc
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+2802
+__
+
+JumpIfSmi
+(
+r6
+, &
+w¿p
+);
+
+2803
+__
+
+Com·»ObjeùTy³
+(
+r6
+,
+r7
+,\847,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+2804
+__
+
+bÉ
+(&
+w¿p
+);
+
+2806
+__
+
+b\9ad
+(&
+cÚt
+);
+
+2809
+__
+
+InvokeFunùiÚ
+(
+r4
+,
+aùu®
+,
+JUMP_FUNCTION
+,
+NuÎC®lW¿µ\94
+());
+
+2811
+__
+
+b\9ad
+(&
+¦ow
+);
+
+2812
+Em\99SlowCa£
+(
+masm
+,
+¬gc
+, &
+nÚ_funùiÚ
+);
+
+2814 ià(
+C®lAsM\91hod
+()) {
+
+2815
+__
+
+b\9ad
+(&
+w¿p
+);
+
+2816
+Em\99W¿pCa£
+(
+masm
+,
+¬gc
+, &
+cÚt
+);
+
+2819
+__
+
+b\9ad
+(&
+ex\8ca_checks_Ü_miss
+);
+
+2820
+Lab\96
+
+ gmiss
+;
+
+2822
+__
+
+Com·»RoÙ
+(
+r7
+,
+H\97p
+::
+kmegamÜphic_symbÞRoÙIndex
+);
+
+2823
+__
+
+beq
+(&
+¦ow_¡¬t
+);
+
+2824
+__
+
+Com·»RoÙ
+(
+r7
+,
+H\97p
+::
+kun\9a\99\9flized_symbÞRoÙIndex
+);
+
+2825
+__
+
+beq
+(&
+miss
+);
+
+2827 ià(!
+ gFLAG_\8caû_ic
+) {
+
+2830
+__
+
+As£¹NÙSmi
+(
+r7
+);
+
+2831
+__
+
+Com·»ObjeùTy³
+(
+r7
+,
+r8
+,\848,
+JS_FUNCTION_TYPE
+);
+
+2832
+__
+
+bÃ
+(&
+miss
+);
+
+2833
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r7
+,
+r6
+);
+
+2834
+__
+
+add
+(
+r7
+,
+r5
+,\847);
+
+2835
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kmegamÜphic_symbÞRoÙIndex
+);
+
+2836
+__
+
+StÜeP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+FixedA¼ay
+::
+kH\97d\94Size
+),
+r0
+);
+
+2838 cڡ \12
+ gw\99h_ty³s_off£t
+ =
+
+2839
+FixedA¼ay
+::
+Off£tOfEËm\92tAt
+(
+Ty³F\93dbackVeùÜ
+::
+kW\99hTy³sIndex
+);
+
+2840
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+w\99h_ty³s_off£t
+));
+
+2841
+__
+
+SubSmiL\99\94®
+(
+r7
+,\847,
+Smi
+::
+FromIÁ
+(1),
+r0
+);
+
+2842
+__
+
+StÜeP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+w\99h_ty³s_off£t
+),
+r0
+);
+
+2843 cڡ \12
+ gg\92\94ic_off£t
+ =
+
+2844
+FixedA¼ay
+::
+Off£tOfEËm\92tAt
+(
+Ty³F\93dbackVeùÜ
+::
+kG\92\94icCouÁIndex
+);
+
+2845
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+g\92\94ic_off£t
+));
+
+2846
+__
+
+AddSmiL\99\94®
+(
+r7
+,\847,
+Smi
+::
+FromIÁ
+(1),
+r0
+);
+
+2847
+__
+
+StÜeP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+g\92\94ic_off£t
+),
+r0
+);
+
+2848
+__
+
+jmp
+(&
+¦ow_¡¬t
+);
+
+2852
+__
+
+b\9ad
+(&
+miss
+);
+
+2853
+G\92\94©eMiss
+(
+masm
+);
+
+2856
+__
+
+b\9ad
+(&
+¦ow_¡¬t
+);
+
+2859
+__
+
+JumpIfSmi
+(
+r4
+, &
+nÚ_funùiÚ
+);
+
+2862
+__
+
+Com·»ObjeùTy³
+(
+r4
+,
+r7
+,\847,
+JS_FUNCTION_TYPE
+);
+
+2863
+__
+
+bÃ
+(&
+¦ow
+);
+
+2864
+__
+
+b
+(&
+have_js_funùiÚ
+);
+
+2868 \1e
+ gC®lICStub
+::
+G\92\94©eMiss
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+2870
+__
+
+LßdP
+(
+r7
+,
+MemO³¿nd
+(
+¥
+, (
+¬g_couÁ
+(è+ 1è*
+kPo\9a\8brSize
+),
+r0
+);
+
+2873
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+2876
+__
+
+Push
+(
+r7
+,
+r4
+,
+r5
+,
+r6
+);
+
+2879
+ gIC
+::
+Ut\9e\99yId
+
+id
+ =
+G\91ICS\8f\8b
+(è=ð
+DEFAULT
+ ?
+IC
+::
+kC®lIC_Miss
+
+
+2880 :
+IC
+::
+kC®lIC_Cu¡omiz©iÚ_Miss
+;
+
+2882
+Ex\8bº®Reã»nû
+
+ gmiss
+ = Ex\8bº®Reã»nû(
+IC_Ut\9e\99y
+(
+id
+),
+masm
+->
+isީe
+());
+
+2883
+__
+
+C®lEx\8bº®Reã»nû
+(
+miss
+, 4);
+
+2886
+__
+
+mr
+(
+r4
+,
+r3
+);
+
+2892 \1e
+ gS\8c\9agCh¬CodeAtG\92\94©Ü
+::
+G\92\94©eFa¡
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+2894 ià(
+check_mode_
+ =ð
+RECEIVER_IS_UNKNOWN
+) {
+
+2895
+__
+
+JumpIfSmi
+(
+objeù_
+,
+»ûiv\94_nÙ_¡r\9ag_
+);
+
+2898
+__
+
+LßdP
+(
+»suÉ_
+,
+F\9bldMemO³¿nd
+(
+objeù_
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2899
+__
+
+lbz
+(
+»suÉ_
+,
+F\9bldMemO³¿nd
+ÔesuÉ_,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+2901
+__
+
+ªdi
+(
+r0
+,
+»suÉ_
+,
+O³¿nd
+(
+kIsNÙS\8c\9agMask
+));
+
+2902
+__
+
+bÃ
+(
+»ûiv\94_nÙ_¡r\9ag_
+,
+ü0
+);
+
+2906
+__
+
+JumpIfNÙSmi
+(
+\9adex_
+, &
+\9adex_nÙ_smi_
+);
+
+2907
+__
+
+b\9ad
+(&
+gÙ_smi_\9adex_
+);
+
+2910
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+objeù_
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+2911
+__
+
+cm¶
+(
+\9d
+,
+\9adex_
+);
+
+2912
+__
+
+bË
+(
+\9adex_out_of_¿nge_
+);
+
+2914
+__
+
+SmiUÁag
+(
+\9adex_
+);
+
+2916
+ gS\8c\9agCh¬LßdG\92\94©Ü
+::
+G\92\94©e
+(
+masm
+,
+objeù_
+,
+\9adex_
+,
+»suÉ_
+,
+
+2917 &
+ÿÎ_ruÁime_
+);
+
+2919
+__
+
+SmiTag
+(
+»suÉ_
+);
+
+2920
+__
+
+b\9ad
+(&
+ex\99_
+);
+
+2924 \1e
+ gS\8c\9agCh¬CodeAtG\92\94©Ü
+::
+G\92\94©eSlow
+(
+
+2925
+MaüoAs£mbËr
+*
+masm
+, cڡ
+RuÁimeC®lH\96³r
+&
+ÿÎ_h\96³r
+) {
+
+2926
+__
+
+AbÜt
+(
+kUÃx³ùedF®ÉhroughToCh¬CodeAtSlowCa£
+);
+
+2929
+__
+
+b\9ad
+(&
+\9adex_nÙ_smi_
+);
+
+2931
+__
+
+CheckM
+(
+\9adex_
+,
+»suÉ_
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+,
+\9adex_nÙ_numb\94_
+,
+
+2932
+DONT_DO_SMI_CHECK
+);
+
+2933
+ gÿÎ_h\96³r
+.
+BefÜeC®l
+(
+masm
+);
+
+2934
+__
+
+push
+(
+objeù_
+);
+
+2935
+__
+
+push
+(
+\9adex_
+);
+
+2936 ià(
+ g\9adex_æags_
+ =ð
+STRING_INDEX_IS_NUMBER
+) {
+
+2937
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kNumb\94ToIÁeg\94MM\9ausZ\94o
+, 1);
+
+2939
+DCHECK
+(
+\9adex_æags_
+ =ð
+STRING_INDEX_IS_ARRAY_INDEX
+);
+
+2941
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kNumb\94ToSmi
+, 1);
+
+2945
+__
+
+Move
+(
+\9adex_
+,
+r3
+);
+
+2946
+__
+
+pÝ
+(
+objeù_
+);
+
+2948
+__
+
+LßdP
+(
+»suÉ_
+,
+F\9bldMemO³¿nd
+(
+objeù_
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2949
+__
+
+lbz
+(
+»suÉ_
+,
+F\9bldMemO³¿nd
+ÔesuÉ_,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+2950
+ gÿÎ_h\96³r
+.
+Aá\94C®l
+(
+masm
+);
+
+2952
+__
+
+JumpIfNÙSmi
+(
+\9adex_
+,
+\9adex_out_of_¿nge_
+);
+
+2954
+__
+
+b
+(&
+gÙ_smi_\9adex_
+);
+
+2959
+__
+
+b\9ad
+(&
+ÿÎ_ruÁime_
+);
+
+2960
+ gÿÎ_h\96³r
+.
+BefÜeC®l
+(
+masm
+);
+
+2961
+__
+
+SmiTag
+(
+\9adex_
+);
+
+2962
+__
+
+Push
+(
+objeù_
+,
+\9adex_
+);
+
+2963
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kS\8c\9agCh¬CodeAtRT
+, 2);
+
+2964
+__
+
+Move
+(
+»suÉ_
+,
+r3
+);
+
+2965
+ gÿÎ_h\96³r
+.
+Aá\94C®l
+(
+masm
+);
+
+2966
+__
+
+b
+(&
+ex\99_
+);
+
+2968
+__
+
+AbÜt
+(
+kUÃx³ùedF®ÉhroughFromCh¬CodeAtSlowCa£
+);
+
+2975 \1e
+ gS\8c\9agCh¬FromCodeG\92\94©Ü
+::
+G\92\94©eFa¡
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+2977
+DCHECK
+(
+ba£
+::
+b\99s
+::
+IsPow\94OfTwo32
+(
+S\8c\9ag
+::
+kMaxOÃBy\8bCh¬Code
+ + 1));
+
+2978
+__
+
+LßdSmiL\99\94®
+(
+r0
+,
+Smi
+::
+FromIÁ
+(~
+S\8c\9ag
+::
+kMaxOÃBy\8bCh¬Code
+));
+
+2979
+__
+
+Üi
+(
+r0
+,\840,
+O³¿nd
+(
+kSmiTagMask
+));
+
+2980
+__
+
+ªd_
+(
+r0
+,
+code_
+,\840);
+
+2981
+__
+
+cmpi
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+2982
+__
+
+bÃ
+(&
+¦ow_ÿ£_
+);
+
+2984
+__
+
+LßdRoÙ
+(
+»suÉ_
+,
+H\97p
+::
+kS\9agËCh¬aù\94S\8c\9agCacheRoÙIndex
+);
+
+2986
+__
+
+mr
+(
+r0
+,
+code_
+);
+
+2987
+__
+
+SmiToP\8cA¼ayOff£t
+(
+code_
+, code_);
+
+2988
+__
+
+add
+(
+»suÉ_
+,\84esuÉ_,
+code_
+);
+
+2989
+__
+
+mr
+(
+code_
+,
+r0
+);
+
+2990
+__
+
+LßdP
+(
+»suÉ_
+,
+F\9bldMemO³¿nd
+ÔesuÉ_,
+FixedA¼ay
+::
+kH\97d\94Size
+));
+
+2991
+__
+
+Com·»RoÙ
+(
+»suÉ_
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+2992
+__
+
+beq
+(&
+¦ow_ÿ£_
+);
+
+2993
+__
+
+b\9ad
+(&
+ex\99_
+);
+
+2997 \1e
+ gS\8c\9agCh¬FromCodeG\92\94©Ü
+::
+G\92\94©eSlow
+(
+
+2998
+MaüoAs£mbËr
+*
+masm
+, cڡ
+RuÁimeC®lH\96³r
+&
+ÿÎ_h\96³r
+) {
+
+2999
+__
+
+AbÜt
+(
+kUÃx³ùedF®ÉhroughToCh¬FromCodeSlowCa£
+);
+
+3001
+__
+
+b\9ad
+(&
+¦ow_ÿ£_
+);
+
+3002
+ gÿÎ_h\96³r
+.
+BefÜeC®l
+(
+masm
+);
+
+3003
+__
+
+push
+(
+code_
+);
+
+3004
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kCh¬FromCode
+, 1);
+
+3005
+__
+
+Move
+(
+»suÉ_
+,
+r3
+);
+
+3006
+ gÿÎ_h\96³r
+.
+Aá\94C®l
+(
+masm
+);
+
+3007
+__
+
+b
+(&
+ex\99_
+);
+
+3009
+__
+
+AbÜt
+(
+kUÃx³ùedF®ÉhroughFromCh¬FromCodeSlowCa£
+);
+
+3013 \f
+ eCÝyCh¬aù\94sFÏgs
+ {
+ gCOPY_ONE_BYTE
+ = 1,
+ gDEST_ALWAYS_ALIGNED
+ = 2 };
+
+3016 \1e
+ gS\8c\9agH\96³r
+::
+G\92\94©eCÝyCh¬aù\94s
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+de¡
+,
+
+3017
+Regi¡\94
+
+¤c
+, Regi¡\94
+couÁ
+,
+
+3018
+Regi¡\94
+
+sü©ch
+,
+
+3019
+S\8c\9ag
+::
+Encod\9ag
+
+\92cod\9ag
+) {
+
+3020 ià(
+FLAG_debug_code
+) {
+
+3022
+__
+
+ªdi
+(
+r0
+,
+de¡
+,
+O³¿nd
+(
+kPo\9a\8brAlignm\92tMask
+));
+
+3023
+__
+
+Check
+(
+eq
+,
+kDe¡\9a©iÚOfCÝyNÙAligÃd
+,
+ü0
+);
+
+3027
+Lab\96
+
+ gdÚe
+;
+
+3028 ià(
+ g\92cod\9ag
+ =ð
+S\8c\9ag
+::
+TWO_BYTE_ENCODING
+) {
+
+3030
+__
+
+add
+(
+couÁ
+, couÁ, couÁ,
+L\97veOE
+,
+S\91RC
+);
+
+3031
+__
+
+beq
+(&
+dÚe
+,
+ü0
+);
+
+3033
+__
+
+cmpi
+(
+couÁ
+,
+O³¿nd
+::
+Z\94o
+());
+
+3034
+__
+
+beq
+(&
+dÚe
+);
+
+3038
+Lab\96
+
+ gby\8b_loÝ
+;
+
+3039
+__
+
+mtùr
+(
+couÁ
+);
+
+3040
+__
+
+b\9ad
+(&
+by\8b_loÝ
+);
+
+3041
+__
+
+lbz
+(
+sü©ch
+,
+MemO³¿nd
+(
+¤c
+));
+
+3042
+__
+
+addi
+(
+¤c
+, src,
+O³¿nd
+(1));
+
+3043
+__
+
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+de¡
+));
+
+3044
+__
+
+addi
+(
+de¡
+, de¡,
+O³¿nd
+(1));
+
+3045
+__
+
+bdnz
+(&
+by\8b_loÝ
+);
+
+3047
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3051 \1e
+ gSubS\8c\9agStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3052
+Lab\96
+
+ruÁime
+;
+
+3067 cڡ \12
+ gkToOff£t
+ = 0 *
+kPo\9a\8brSize
+;
+
+3068 cڡ \12
+ gkFromOff£t
+ = 1 *
+kPo\9a\8brSize
+;
+
+3069 cڡ \12
+ gkS\8c\9agOff£t
+ = 2 *
+kPo\9a\8brSize
+;
+
+3071
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+,
+kToOff£t
+));
+
+3072
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+¥
+,
+kFromOff£t
+));
+
+3075
+__
+
+JumpIfNÙSmi
+(
+r5
+, &
+ruÁime
+);
+
+3076
+__
+
+JumpIfNÙSmi
+(
+r6
+, &
+ruÁime
+);
+
+3077
+__
+
+SmiUÁag
+(
+r5
+);
+
+3078
+__
+
+SmiUÁag
+(
+r6
+,
+S\91RC
+);
+
+3082
+__
+
+bÉ
+(&
+ruÁime
+,
+ü0
+);
+
+3084
+__
+
+cm¶
+(
+r6
+,
+r5
+);
+
+3085
+__
+
+bgt
+(&
+ruÁime
+);
+
+3086
+__
+
+sub
+(
+r5
+,\845,
+r6
+);
+
+3089
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kS\8c\9agOff£t
+));
+
+3090
+__
+
+JumpIfSmi
+(
+r3
+, &
+ruÁime
+);
+
+3091
+CÚd\99iÚ
+
+ gis_¡r\9ag
+ =
+masm
+->
+IsObjeùS\8c\9agTy³
+(
+r3
+,
+r4
+);
+
+3092
+__
+
+b
+(
+Neg©eCÚd\99iÚ
+(
+is_¡r\9ag
+), &
+ruÁime
+,
+ü0
+);
+
+3094
+Lab\96
+
+ gs\9agË_ch¬
+;
+
+3095
+__
+
+cmpi
+(
+r5
+,
+O³¿nd
+(1));
+
+3096
+__
+
+b
+(
+eq
+, &
+s\9agË_ch¬
+);
+
+3099
+Lab\96
+
+ g»tuº_r3
+;
+
+3102
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+3103
+__
+
+SmiUÁag
+(
+r0
+,
+r7
+);
+
+3104
+__
+
+cm¶
+(
+r5
+,
+r0
+);
+
+3106
+__
+
+beq
+(&
+»tuº_r3
+);
+
+3108
+__
+
+bgt
+(&
+ruÁime
+);
+
+3117
+Lab\96
+
+ gund\94ly\9ag_uÅacked
+,
+ g¦iûd_¡r\9ag
+,
+ g£q_Ü_ex\8bº®_¡r\9ag
+;
+
+3119
+STATIC_ASSERT
+(
+kIsInd\9ceùS\8c\9agMask
+ =ð(
+kSliûdS\8c\9agTag
+ &
+kCÚsS\8c\9agTag
+));
+
+3120
+STATIC_ASSERT
+(
+kIsInd\9ceùS\8c\9agMask
+ != 0);
+
+3121
+__
+
+ªdi
+(
+r0
+,
+r4
+,
+O³¿nd
+(
+kIsInd\9ceùS\8c\9agMask
+));
+
+3122
+__
+
+beq
+(&
+£q_Ü_ex\8bº®_¡r\9ag
+,
+ü0
+);
+
+3124
+__
+
+ªdi
+(
+r0
+,
+r4
+,
+O³¿nd
+(
+kSliûdNÙCÚsMask
+));
+
+3125
+__
+
+bÃ
+(&
+¦iûd_¡r\9ag
+,
+ü0
+);
+
+3127
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+CÚsS\8c\9ag
+::
+kSecÚdOff£t
+));
+
+3128
+__
+
+Com·»RoÙ
+(
+r8
+,
+H\97p
+::
+kem±y_¡r\9agRoÙIndex
+);
+
+3129
+__
+
+bÃ
+(&
+ruÁime
+);
+
+3130
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+CÚsS\8c\9ag
+::
+kF\9c¡Off£t
+));
+
+3132
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r8
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3133
+__
+
+lbz
+(
+r4
+,
+F\9bldMemO³¿nd
+Ô4,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3134
+__
+
+b
+(&
+und\94ly\9ag_uÅacked
+);
+
+3136
+__
+
+b\9ad
+(&
+¦iûd_¡r\9ag
+);
+
+3138
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+SliûdS\8c\9ag
+::
+kP¬\92tOff£t
+));
+
+3139
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+SliûdS\8c\9ag
+::
+kOff£tOff£t
+));
+
+3140
+__
+
+SmiUÁag
+(
+r4
+,
+r7
+);
+
+3141
+__
+
+add
+(
+r6
+,\846,
+r4
+);
+
+3143
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r8
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3144
+__
+
+lbz
+(
+r4
+,
+F\9bldMemO³¿nd
+Ô4,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3145
+__
+
+b
+(&
+und\94ly\9ag_uÅacked
+);
+
+3147
+__
+
+b\9ad
+(&
+£q_Ü_ex\8bº®_¡r\9ag
+);
+
+3149
+__
+
+mr
+(
+r8
+,
+r3
+);
+
+3151
+__
+
+b\9ad
+(&
+und\94ly\9ag_uÅacked
+);
+
+3153 ià(
+ gFLAG_¡r\9ag_¦iûs
+) {
+
+3154
+Lab\96
+
+ gcÝy_rout\9ae
+;
+
+3159
+__
+
+cmpi
+(
+r5
+,
+O³¿nd
+(
+SliûdS\8c\9ag
+::
+kM\9aL\92gth
+));
+
+3161
+__
+
+bÉ
+(&
+cÝy_rout\9ae
+);
+
+3167
+Lab\96
+
+ gtwo_by\8b_¦iû
+,
+ g£t_¦iû_h\97d\94
+;
+
+3168
+STATIC_ASSERT
+((
+kS\8c\9agEncod\9agMask
+ &
+kOÃBy\8bS\8c\9agTag
+) != 0);
+
+3169
+STATIC_ASSERT
+((
+kS\8c\9agEncod\9agMask
+ &
+kTwoBy\8bS\8c\9agTag
+) == 0);
+
+3170
+__
+
+ªdi
+(
+r0
+,
+r4
+,
+O³¿nd
+(
+kS\8c\9agEncod\9agMask
+));
+
+3171
+__
+
+beq
+(&
+two_by\8b_¦iû
+,
+ü0
+);
+
+3172
+__
+
+AÎoÿ\8bOÃBy\8bSliûdS\8c\9ag
+(
+r3
+,
+r5
+,
+r9
+,
+r10
+, &
+ruÁime
+);
+
+3173
+__
+
+b
+(&
+£t_¦iû_h\97d\94
+);
+
+3174
+__
+
+b\9ad
+(&
+two_by\8b_¦iû
+);
+
+3175
+__
+
+AÎoÿ\8bTwoBy\8bSliûdS\8c\9ag
+(
+r3
+,
+r5
+,
+r9
+,
+r10
+, &
+ruÁime
+);
+
+3176
+__
+
+b\9ad
+(&
+£t_¦iû_h\97d\94
+);
+
+3177
+__
+
+SmiTag
+(
+r6
+);
+
+3178
+__
+
+StÜeP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+SliûdS\8c\9ag
+::
+kP¬\92tOff£t
+),
+r0
+);
+
+3179
+__
+
+StÜeP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+SliûdS\8c\9ag
+::
+kOff£tOff£t
+),
+r0
+);
+
+3180
+__
+
+b
+(&
+»tuº_r3
+);
+
+3182
+__
+
+b\9ad
+(&
+cÝy_rout\9ae
+);
+
+3189
+Lab\96
+
+ gtwo_by\8b_£qu\92t\9fl
+,
+ g£qu\92t\9fl_¡r\9ag
+,
+ g®loÿ\8b_»suÉ
+;
+
+3190
+STATIC_ASSERT
+(
+kEx\8bº®S\8c\9agTag
+ != 0);
+
+3191
+STATIC_ASSERT
+(
+kSeqS\8c\9agTag
+ == 0);
+
+3192
+__
+
+ªdi
+(
+r0
+,
+r4
+,
+O³¿nd
+(
+kEx\8bº®S\8c\9agTag
+));
+
+3193
+__
+
+beq
+(&
+£qu\92t\9fl_¡r\9ag
+,
+ü0
+);
+
+3197
+STATIC_ASSERT
+(
+kShÜtEx\8bº®S\8c\9agTag
+ != 0);
+
+3198
+__
+
+ªdi
+(
+r0
+,
+r4
+,
+O³¿nd
+(
+kShÜtEx\8bº®S\8c\9agTag
+));
+
+3199
+__
+
+bÃ
+(&
+ruÁime
+,
+ü0
+);
+
+3200
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+Ô8,
+Ex\8bº®S\8c\9ag
+::
+kResourûD©aOff£t
+));
+
+3202
+__
+
+b
+(&
+®loÿ\8b_»suÉ
+);
+
+3204
+__
+
+b\9ad
+(&
+£qu\92t\9fl_¡r\9ag
+);
+
+3206
+STATIC_ASSERT
+(
+SeqTwoBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ =ð
+SeqOÃBy\8bS\8c\9ag
+::kHeaderSize);
+
+3207
+__
+
+addi
+(
+r8
+,\848,
+O³¿nd
+(
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+3209
+__
+
+b\9ad
+(&
+®loÿ\8b_»suÉ
+);
+
+3211
+STATIC_ASSERT
+((
+kOÃBy\8bS\8c\9agTag
+ &
+kS\8c\9agEncod\9agMask
+) != 0);
+
+3212
+__
+
+ªdi
+(
+r0
+,
+r4
+,
+O³¿nd
+(
+kS\8c\9agEncod\9agMask
+));
+
+3213
+__
+
+beq
+(&
+two_by\8b_£qu\92t\9fl
+,
+ü0
+);
+
+3216
+__
+
+AÎoÿ\8bOÃBy\8bS\8c\9ag
+(
+r3
+,
+r5
+,
+r7
+,
+r9
+,
+r10
+, &
+ruÁime
+);
+
+3219
+__
+
+add
+(
+r8
+,\848,
+r6
+);
+
+3221
+__
+
+addi
+(
+r4
+,
+r3
+,
+O³¿nd
+(
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+3227
+STATIC_ASSERT
+((
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ &
+kObjeùAlignm\92tMask
+) == 0);
+
+3228
+ gS\8c\9agH\96³r
+::
+G\92\94©eCÝyCh¬aù\94s
+(
+masm
+,
+r4
+,
+r8
+,
+r5
+,
+r6
+,
+
+3229
+S\8c\9ag
+::
+ONE_BYTE_ENCODING
+);
+
+3230
+__
+
+b
+(&
+»tuº_r3
+);
+
+3233
+__
+
+b\9ad
+(&
+two_by\8b_£qu\92t\9fl
+);
+
+3234
+__
+
+AÎoÿ\8bTwoBy\8bS\8c\9ag
+(
+r3
+,
+r5
+,
+r7
+,
+r9
+,
+r10
+, &
+ruÁime
+);
+
+3237
+__
+
+ShiáLeáImm
+(
+r4
+,
+r6
+,
+O³¿nd
+(1));
+
+3238
+__
+
+add
+(
+r8
+,\848,
+r4
+);
+
+3240
+__
+
+addi
+(
+r4
+,
+r3
+,
+O³¿nd
+(
+SeqTwoBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+3246
+STATIC_ASSERT
+((
+SeqTwoBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ &
+kObjeùAlignm\92tMask
+) == 0);
+
+3247
+ gS\8c\9agH\96³r
+::
+G\92\94©eCÝyCh¬aù\94s
+(
+masm
+,
+r4
+,
+r8
+,
+r5
+,
+r6
+,
+
+3248
+S\8c\9ag
+::
+TWO_BYTE_ENCODING
+);
+
+3250
+__
+
+b\9ad
+(&
+»tuº_r3
+);
+
+3251
+CouÁ\94s
+*
+ gcouÁ\94s
+ =
+isީe
+()->
+couÁ\94s
+();
+
+3252
+__
+
+Inüem\92tCouÁ\94
+(
+couÁ\94s
+->
+sub_¡r\9ag_Çtive
+(), 1,
+r6
+,
+r7
+);
+
+3253
+__
+
+DrÝ
+(3);
+
+3254
+__
+
+R\91
+();
+
+3257
+__
+
+b\9ad
+(&
+ruÁime
+);
+
+3258
+__
+
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+kSubS\8c\9ag
+, 3, 1);
+
+3260
+__
+
+b\9ad
+(&
+s\9agË_ch¬
+);
+
+3265
+__
+
+SmiTag
+(
+r6
+,\846);
+
+3266
+S\8c\9agCh¬AtG\92\94©Ü
+
+g\92\94©Ü
+(
+r3
+,
+r6
+,
+r5
+,\843, &
+ruÁime
+, &runtime, &runtime,
+
+3267
+STRING_INDEX_IS_NUMBER
+,
+RECEIVER_IS_STRING
+);
+
+3268
+ gg\92\94©Ü
+.
+G\92\94©eFa¡
+(
+masm
+);
+
+3269
+__
+
+DrÝ
+(3);
+
+3270
+__
+
+R\91
+();
+
+3271
+ gg\92\94©Ü
+.
+Sk\9dSlow
+(
+masm
+, &
+ruÁime
+);
+
+3275 \1e
+ gS\8c\9agH\96³r
+::
+G\92\94©eFÏtOÃBy\8bS\8c\9agEqu®s
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+3276
+Regi¡\94
+
+Ëá
+,
+
+3277
+Regi¡\94
+
+right
+,
+
+3278
+Regi¡\94
+
+sü©ch1
+,
+
+3279
+Regi¡\94
+
+sü©ch2
+) {
+
+3280
+Regi¡\94
+
+ gËngth
+ =
+sü©ch1
+;
+
+3283
+Lab\96
+
+ g¡r\9ags_nÙ_equ®
+,
+ gcheck_z\94o_Ëngth
+;
+
+3284
+__
+
+LßdP
+(
+Ëngth
+,
+F\9bldMemO³¿nd
+(
+Ëá
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+3285
+__
+
+LßdP
+(
+sü©ch2
+,
+F\9bldMemO³¿nd
+(
+right
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+3286
+__
+
+cmp
+(
+Ëngth
+,
+sü©ch2
+);
+
+3287
+__
+
+beq
+(&
+check_z\94o_Ëngth
+);
+
+3288
+__
+
+b\9ad
+(&
+¡r\9ags_nÙ_equ®
+);
+
+3289
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+NOT_EQUAL
+));
+
+3290
+__
+
+R\91
+();
+
+3293
+Lab\96
+
+ gcom·»_ch¬s
+;
+
+3294
+__
+
+b\9ad
+(&
+check_z\94o_Ëngth
+);
+
+3295
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+3296
+__
+
+cmpi
+(
+Ëngth
+,
+O³¿nd
+::
+Z\94o
+());
+
+3297
+__
+
+bÃ
+(&
+com·»_ch¬s
+);
+
+3298
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+EQUAL
+));
+
+3299
+__
+
+R\91
+();
+
+3302
+__
+
+b\9ad
+(&
+com·»_ch¬s
+);
+
+3303
+G\92\94©eOÃBy\8bCh¬sCom·»LoÝ
+(
+masm
+,
+Ëá
+,
+right
+,
+Ëngth
+,
+sü©ch2
+,
+
+3304 &
+¡r\9ags_nÙ_equ®
+);
+
+3307
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+EQUAL
+));
+
+3308
+__
+
+R\91
+();
+
+3312 \1e
+ gS\8c\9agH\96³r
+::
+G\92\94©eCom·»FÏtOÃBy\8bS\8c\9ags
+(
+
+3313
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+Ëá
+, Regi¡\94
+right
+, Regi¡\94
+sü©ch1
+,
+
+3314
+Regi¡\94
+
+sü©ch2
+, Regi¡\94
+sü©ch3
+) {
+
+3315
+Lab\96
+
+ gsk\9d
+,
+ g»suÉ_nÙ_equ®
+,
+ gcom·»_Ëngths
+;
+
+3317
+__
+
+LßdP
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(
+Ëá
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+3318
+__
+
+LßdP
+(
+sü©ch2
+,
+F\9bldMemO³¿nd
+(
+right
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+3319
+__
+
+sub
+(
+sü©ch3
+,
+sü©ch1
+,
+sü©ch2
+,
+L\97veOE
+,
+S\91RC
+);
+
+3320
+Regi¡\94
+
+ gËngth_d\96\8f
+ =
+sü©ch3
+;
+
+3321
+__
+
+bË
+(&
+sk\9d
+,
+ü0
+);
+
+3322
+__
+
+mr
+(
+sü©ch1
+,
+sü©ch2
+);
+
+3323
+__
+
+b\9ad
+(&
+sk\9d
+);
+
+3324
+Regi¡\94
+
+ gm\9a_Ëngth
+ =
+sü©ch1
+;
+
+3325
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+3326
+__
+
+cmpi
+(
+m\9a_Ëngth
+,
+O³¿nd
+::
+Z\94o
+());
+
+3327
+__
+
+beq
+(&
+com·»_Ëngths
+);
+
+3330
+G\92\94©eOÃBy\8bCh¬sCom·»LoÝ
+(
+masm
+,
+Ëá
+,
+right
+,
+m\9a_Ëngth
+,
+sü©ch2
+,
+
+3331 &
+»suÉ_nÙ_equ®
+);
+
+3334
+__
+
+b\9ad
+(&
+com·»_Ëngths
+);
+
+3335
+DCHECK
+(
+Smi
+::
+FromIÁ
+(
+EQUAL
+è=ð
+¡©ic_ÿ¡
+<Smi*>(0));
+
+3337
+__
+
+mr
+(
+r3
+,
+Ëngth_d\96\8f
+);
+
+3338
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+3339
+__
+
+b\9ad
+(&
+»suÉ_nÙ_equ®
+);
+
+3342
+Lab\96
+
+ gËss_equ®
+,
+ gequ®
+;
+
+3343
+__
+
+bË
+(&
+Ëss_equ®
+);
+
+3344
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+GREATER
+));
+
+3345
+__
+
+R\91
+();
+
+3346
+__
+
+b\9ad
+(&
+Ëss_equ®
+);
+
+3347
+__
+
+beq
+(&
+equ®
+);
+
+3348
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+LESS
+));
+
+3349
+__
+
+b\9ad
+(&
+equ®
+);
+
+3350
+__
+
+R\91
+();
+
+3354 \1e
+ gS\8c\9agH\96³r
+::
+G\92\94©eOÃBy\8bCh¬sCom·»LoÝ
+(
+
+3355
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+Ëá
+, Regi¡\94
+right
+, Regi¡\94
+Ëngth
+,
+
+3356
+Regi¡\94
+
+sü©ch1
+,
+Lab\96
+*
+ch¬s_nÙ_equ®
+) {
+
+3360
+__
+
+SmiUÁag
+(
+Ëngth
+);
+
+3361
+__
+
+addi
+(
+sü©ch1
+,
+Ëngth
+,
+
+3362
+O³¿nd
+(
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+3363
+__
+
+add
+(
+Ëá
+,\86eá,
+sü©ch1
+);
+
+3364
+__
+
+add
+(
+right
+,\84ight,
+sü©ch1
+);
+
+3365
+__
+
+subfic
+(
+Ëngth
+,\86\92gth,
+O³¿nd
+::
+Z\94o
+());
+
+3366
+Regi¡\94
+
+ g\9adex
+ =
+Ëngth
+;
+
+3369
+Lab\96
+
+ gloÝ
+;
+
+3370
+__
+
+b\9ad
+(&
+loÝ
+);
+
+3371
+__
+
+lbzx
+(
+sü©ch1
+,
+MemO³¿nd
+(
+Ëá
+,
+\9adex
+));
+
+3372
+__
+
+lbzx
+(
+r0
+,
+MemO³¿nd
+(
+right
+,
+\9adex
+));
+
+3373
+__
+
+cmp
+(
+sü©ch1
+,
+r0
+);
+
+3374
+__
+
+bÃ
+(
+ch¬s_nÙ_equ®
+);
+
+3375
+__
+
+addi
+(
+\9adex
+, index,
+O³¿nd
+(1));
+
+3376
+__
+
+cmpi
+(
+\9adex
+,
+O³¿nd
+::
+Z\94o
+());
+
+3377
+__
+
+bÃ
+(&
+loÝ
+);
+
+3381 \1e
+ gS\8c\9agCom·»Stub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3382
+Lab\96
+
+ruÁime
+;
+
+3384
+CouÁ\94s
+*
+ gcouÁ\94s
+ =
+isީe
+()->
+couÁ\94s
+();
+
+3389
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+));
+
+3390
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+3392
+Lab\96
+
+ gnÙ_§me
+;
+
+3393
+__
+
+cmp
+(
+r3
+,
+r4
+);
+
+3394
+__
+
+bÃ
+(&
+nÙ_§me
+);
+
+3395
+STATIC_ASSERT
+(
+EQUAL
+ == 0);
+
+3396
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+3397
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+EQUAL
+));
+
+3398
+__
+
+Inüem\92tCouÁ\94
+(
+couÁ\94s
+->
+¡r\9ag_com·»_Çtive
+(), 1,
+r4
+,
+r5
+);
+
+3399
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(2 *
+kPo\9a\8brSize
+));
+
+3400
+__
+
+R\91
+();
+
+3402
+__
+
+b\9ad
+(&
+nÙ_§me
+);
+
+3405
+__
+
+JumpIfNÙBÙhSequ\92t\9flOÃBy\8bS\8c\9ags
+(
+r4
+,
+r3
+,
+r5
+,
+r6
+, &
+ruÁime
+);
+
+3408
+__
+
+Inüem\92tCouÁ\94
+(
+couÁ\94s
+->
+¡r\9ag_com·»_Çtive
+(), 1,
+r5
+,
+r6
+);
+
+3409
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(2 *
+kPo\9a\8brSize
+));
+
+3410
+ gS\8c\9agH\96³r
+::
+G\92\94©eCom·»FÏtOÃBy\8bS\8c\9ags
+(
+masm
+,
+r4
+,
+r3
+,
+r5
+,
+r6
+,
+r7
+);
+
+3414
+__
+
+b\9ad
+(&
+ruÁime
+);
+
+3415
+__
+
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+kS\8c\9agCom·»
+, 2, 1);
+
+3419 \1e
+ gB\9a¬yOpICW\99hAÎoÿtiÚS\99eStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3429
+__
+
+Move
+(
+r5
+,
+hªdË
+(
+isީe
+()->
+h\97p
+()->
+undef\9aed_v®ue
+()));
+
+3432 ià(
+ gFLAG_debug_code
+) {
+
+3433
+__
+
+Te¡IfSmi
+(
+r5
+,
+r0
+);
+
+3434
+__
+
+As£¹
+(
+Ã
+,
+kEx³ùedAÎoÿtiÚS\99e
+,
+ü0
+);
+
+3435
+__
+
+push
+(
+r5
+);
+
+3436
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+Ô5,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3437
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kAÎoÿtiÚS\99eMRoÙIndex
+);
+
+3438
+__
+
+cmp
+(
+r5
+,
+\9d
+);
+
+3439
+__
+
+pÝ
+(
+r5
+);
+
+3440
+__
+
+As£¹
+(
+eq
+,
+kEx³ùedAÎoÿtiÚS\99e
+);
+
+3445
+B\9a¬yOpW\99hAÎoÿtiÚS\99eStub
+
+¡ub
+(
+isީe
+(),
+¡©e
+());
+
+3446
+__
+
+Ta\9eC®lStub
+(&
+¡ub
+);
+
+3450 \1e
+ gCom·»ICStub
+::
+G\92\94©eSmis
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3451
+DCHECK
+(
+¡©e
+(è=ð
+Com·»ICS\8f\8b
+::
+SMI
+);
+
+3452
+Lab\96
+
+ gmiss
+;
+
+3453
+__
+
+Üx
+(
+r5
+,
+r4
+,
+r3
+);
+
+3454
+__
+
+JumpIfNÙSmi
+(
+r5
+, &
+miss
+);
+
+3456 ià(
+G\91CÚd\99iÚ
+(è=ð
+eq
+) {
+
+3459
+__
+
+sub
+(
+r3
+,\843,
+r4
+);
+
+3462
+__
+
+SmiUÁag
+(
+r4
+);
+
+3463
+__
+
+SmiUÁag
+(
+r3
+);
+
+3464
+__
+
+sub
+(
+r3
+,
+r4
+,\843);
+
+3466
+__
+
+R\91
+();
+
+3468
+__
+
+b\9ad
+(&
+miss
+);
+
+3469
+G\92\94©eMiss
+(
+masm
+);
+
+3473 \1e
+ gCom·»ICStub
+::
+G\92\94©eNumb\94s
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3474
+DCHECK
+(
+¡©e
+(è=ð
+Com·»ICS\8f\8b
+::
+NUMBER
+);
+
+3476
+Lab\96
+
+ gg\92\94ic_¡ub
+;
+
+3477
+Lab\96
+
+ gunÜd\94ed
+,
+ gmaybe_undef\9aed1
+,
+ gmaybe_undef\9aed2
+;
+
+3478
+Lab\96
+
+ gmiss
+;
+
+3479
+Lab\96
+
+ gequ®
+,
+ gËss_thª
+;
+
+3481 ià(
+Ëá
+(è=ð
+Com·»ICS\8f\8b
+::
+SMI
+) {
+
+3482
+__
+
+JumpIfNÙSmi
+(
+r4
+, &
+miss
+);
+
+3484 ià(
+right
+(è=ð
+Com·»ICS\8f\8b
+::
+SMI
+) {
+
+3485
+__
+
+JumpIfNÙSmi
+(
+r3
+, &
+miss
+);
+
+3491
+Lab\96
+
+ gdÚe
+,
+ gËá
+,
+ gËá_smi
+,
+ gright_smi
+;
+
+3492
+__
+
+JumpIfSmi
+(
+r3
+, &
+right_smi
+);
+
+3493
+__
+
+CheckM
+(
+r3
+,
+r5
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+, &
+maybe_undef\9aed1
+,
+
+3494
+DONT_DO_SMI_CHECK
+);
+
+3495
+__
+
+lfd
+(
+d1
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+3496
+__
+
+b
+(&
+Ëá
+);
+
+3497
+__
+
+b\9ad
+(&
+right_smi
+);
+
+3498
+__
+
+SmiToDoubË
+(
+d1
+,
+r3
+);
+
+3500
+__
+
+b\9ad
+(&
+Ëá
+);
+
+3501
+__
+
+JumpIfSmi
+(
+r4
+, &
+Ëá_smi
+);
+
+3502
+__
+
+CheckM
+(
+r4
+,
+r5
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+, &
+maybe_undef\9aed2
+,
+
+3503
+DONT_DO_SMI_CHECK
+);
+
+3504
+__
+
+lfd
+(
+d0
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+3505
+__
+
+b
+(&
+dÚe
+);
+
+3506
+__
+
+b\9ad
+(&
+Ëá_smi
+);
+
+3507
+__
+
+SmiToDoubË
+(
+d0
+,
+r4
+);
+
+3509
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3512
+__
+
+fcmpu
+(
+d0
+,
+d1
+);
+
+3515
+__
+
+bunÜd\94ed
+(&
+unÜd\94ed
+);
+
+3518
+__
+
+beq
+(&
+equ®
+);
+
+3519
+__
+
+bÉ
+(&
+Ëss_thª
+);
+
+3521
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+GREATER
+));
+
+3522
+__
+
+R\91
+();
+
+3523
+__
+
+b\9ad
+(&
+equ®
+);
+
+3524
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+EQUAL
+));
+
+3525
+__
+
+R\91
+();
+
+3526
+__
+
+b\9ad
+(&
+Ëss_thª
+);
+
+3527
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+LESS
+));
+
+3528
+__
+
+R\91
+();
+
+3530
+__
+
+b\9ad
+(&
+unÜd\94ed
+);
+
+3531
+__
+
+b\9ad
+(&
+g\92\94ic_¡ub
+);
+
+3532
+Com·»ICStub
+
+¡ub
+(
+isީe
+(),
+Ý
+(),
+Com·»ICS\8f\8b
+::
+GENERIC
+,
+
+3533
+Com·»ICS\8f\8b
+::
+GENERIC
+, CompareICState::GENERIC);
+
+3534
+__
+
+Jump
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+3536
+__
+
+b\9ad
+(&
+maybe_undef\9aed1
+);
+
+3537 ià(
+ gTok\92
+::
+IsOrd\94edR\96©iÚ®Com·»Op
+(
+Ý
+())) {
+
+3538
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+3539
+__
+
+bÃ
+(&
+miss
+);
+
+3540
+__
+
+JumpIfSmi
+(
+r4
+, &
+unÜd\94ed
+);
+
+3541
+__
+
+Com·»ObjeùTy³
+(
+r4
+,
+r5
+,\845,
+HEAP_NUMBER_TYPE
+);
+
+3542
+__
+
+bÃ
+(&
+maybe_undef\9aed2
+);
+
+3543
+__
+
+b
+(&
+unÜd\94ed
+);
+
+3546
+__
+
+b\9ad
+(&
+maybe_undef\9aed2
+);
+
+3547 ià(
+ gTok\92
+::
+IsOrd\94edR\96©iÚ®Com·»Op
+(
+Ý
+())) {
+
+3548
+__
+
+Com·»RoÙ
+(
+r4
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+3549
+__
+
+beq
+(&
+unÜd\94ed
+);
+
+3552
+__
+
+b\9ad
+(&
+miss
+);
+
+3553
+G\92\94©eMiss
+(
+masm
+);
+
+3557 \1e
+ gCom·»ICStub
+::
+G\92\94©eIÁ\94ÇlizedS\8c\9ags
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3558
+DCHECK
+(
+¡©e
+(è=ð
+Com·»ICS\8f\8b
+::
+INTERNALIZED_STRING
+);
+
+3559
+Lab\96
+
+ gmiss
+,
+ gnÙ_equ®
+;
+
+3562
+Regi¡\94
+
+ gËá
+ =
+r4
+;
+
+3563
+Regi¡\94
+
+ gright
+ =
+r3
+;
+
+3564
+Regi¡\94
+
+ gtmp1
+ =
+r5
+;
+
+3565
+Regi¡\94
+
+ gtmp2
+ =
+r6
+;
+
+3568
+__
+
+JumpIfE\99h\94Smi
+(
+Ëá
+,
+right
+, &
+miss
+);
+
+3571
+__
+
+LßdP
+(
+tmp1
+,
+F\9bldMemO³¿nd
+(
+Ëá
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3572
+__
+
+LßdP
+(
+tmp2
+,
+F\9bldMemO³¿nd
+(
+right
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3573
+__
+
+lbz
+(
+tmp1
+,
+F\9bldMemO³¿nd
+Ñmp1,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3574
+__
+
+lbz
+(
+tmp2
+,
+F\9bldMemO³¿nd
+Ñmp2,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3575
+STATIC_ASSERT
+(
+kIÁ\94ÇlizedTag
+ =ð0 &&
+kS\8c\9agTag
+ == 0);
+
+3576
+__
+
+Üx
+(
+tmp1
+,\81mp1,
+tmp2
+);
+
+3577
+__
+
+ªdi
+(
+r0
+,
+tmp1
+,
+O³¿nd
+(
+kIsNÙS\8c\9agMask
+ |
+kIsNÙIÁ\94ÇlizedMask
+));
+
+3578
+__
+
+bÃ
+(&
+miss
+,
+ü0
+);
+
+3581
+__
+
+cmp
+(
+Ëá
+,
+right
+);
+
+3582
+__
+
+bÃ
+(&
+nÙ_equ®
+);
+
+3585
+DCHECK
+(
+right
+.
+is
+(
+r3
+));
+
+3586
+STATIC_ASSERT
+(
+EQUAL
+ == 0);
+
+3587
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+3588
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+EQUAL
+));
+
+3589
+__
+
+b\9ad
+(&
+nÙ_equ®
+);
+
+3590
+__
+
+R\91
+();
+
+3592
+__
+
+b\9ad
+(&
+miss
+);
+
+3593
+G\92\94©eMiss
+(
+masm
+);
+
+3597 \1e
+ gCom·»ICStub
+::
+G\92\94©eUniqueNames
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3598
+DCHECK
+(
+¡©e
+(è=ð
+Com·»ICS\8f\8b
+::
+UNIQUE_NAME
+);
+
+3599
+DCHECK
+(
+G\91CÚd\99iÚ
+(è=ð
+eq
+);
+
+3600
+Lab\96
+
+ gmiss
+;
+
+3603
+Regi¡\94
+
+ gËá
+ =
+r4
+;
+
+3604
+Regi¡\94
+
+ gright
+ =
+r3
+;
+
+3605
+Regi¡\94
+
+ gtmp1
+ =
+r5
+;
+
+3606
+Regi¡\94
+
+ gtmp2
+ =
+r6
+;
+
+3609
+__
+
+JumpIfE\99h\94Smi
+(
+Ëá
+,
+right
+, &
+miss
+);
+
+3613
+__
+
+LßdP
+(
+tmp1
+,
+F\9bldMemO³¿nd
+(
+Ëá
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3614
+__
+
+LßdP
+(
+tmp2
+,
+F\9bldMemO³¿nd
+(
+right
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3615
+__
+
+lbz
+(
+tmp1
+,
+F\9bldMemO³¿nd
+Ñmp1,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3616
+__
+
+lbz
+(
+tmp2
+,
+F\9bldMemO³¿nd
+Ñmp2,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3618
+__
+
+JumpIfNÙUniqueNameIn¡ªûTy³
+(
+tmp1
+, &
+miss
+);
+
+3619
+__
+
+JumpIfNÙUniqueNameIn¡ªûTy³
+(
+tmp2
+, &
+miss
+);
+
+3622
+__
+
+cmp
+(
+Ëá
+,
+right
+);
+
+3623
+__
+
+bÃ
+(&
+miss
+);
+
+3626
+DCHECK
+(
+right
+.
+is
+(
+r3
+));
+
+3627
+STATIC_ASSERT
+(
+EQUAL
+ == 0);
+
+3628
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+3629
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+EQUAL
+));
+
+3630
+__
+
+R\91
+();
+
+3632
+__
+
+b\9ad
+(&
+miss
+);
+
+3633
+G\92\94©eMiss
+(
+masm
+);
+
+3637 \1e
+ gCom·»ICStub
+::
+G\92\94©eS\8c\9ags
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3638
+DCHECK
+(
+¡©e
+(è=ð
+Com·»ICS\8f\8b
+::
+STRING
+);
+
+3639
+Lab\96
+
+ gmiss
+,
+ gnÙ_id\92tiÿl
+,
+ gis_symbÞ
+;
+
+3641
+boÞ
+
+ gequ®\99y
+ =
+Tok\92
+::
+IsEqu®\99yOp
+(
+Ý
+());
+
+3644
+Regi¡\94
+
+ gËá
+ =
+r4
+;
+
+3645
+Regi¡\94
+
+ gright
+ =
+r3
+;
+
+3646
+Regi¡\94
+
+ gtmp1
+ =
+r5
+;
+
+3647
+Regi¡\94
+
+ gtmp2
+ =
+r6
+;
+
+3648
+Regi¡\94
+
+ gtmp3
+ =
+r7
+;
+
+3649
+Regi¡\94
+
+ gtmp4
+ =
+r8
+;
+
+3652
+__
+
+JumpIfE\99h\94Smi
+(
+Ëá
+,
+right
+, &
+miss
+);
+
+3656
+__
+
+LßdP
+(
+tmp1
+,
+F\9bldMemO³¿nd
+(
+Ëá
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3657
+__
+
+LßdP
+(
+tmp2
+,
+F\9bldMemO³¿nd
+(
+right
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3658
+__
+
+lbz
+(
+tmp1
+,
+F\9bldMemO³¿nd
+Ñmp1,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3659
+__
+
+lbz
+(
+tmp2
+,
+F\9bldMemO³¿nd
+Ñmp2,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3660
+STATIC_ASSERT
+(
+kNÙS\8c\9agTag
+ != 0);
+
+3661
+__
+
+Üx
+(
+tmp3
+,
+tmp1
+,
+tmp2
+);
+
+3662
+__
+
+ªdi
+(
+r0
+,
+tmp3
+,
+O³¿nd
+(
+kIsNÙS\8c\9agMask
+));
+
+3663
+__
+
+bÃ
+(&
+miss
+,
+ü0
+);
+
+3666
+__
+
+cmp
+(
+Ëá
+,
+right
+);
+
+3667
+STATIC_ASSERT
+(
+EQUAL
+ == 0);
+
+3668
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+3669
+__
+
+bÃ
+(&
+nÙ_id\92tiÿl
+);
+
+3670
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+EQUAL
+));
+
+3671
+__
+
+R\91
+();
+
+3672
+__
+
+b\9ad
+(&
+nÙ_id\92tiÿl
+);
+
+3679 ià(
+ gequ®\99y
+) {
+
+3680
+DCHECK
+(
+G\91CÚd\99iÚ
+(è=ð
+eq
+);
+
+3681
+STATIC_ASSERT
+(
+kIÁ\94ÇlizedTag
+ == 0);
+
+3682
+__
+
+Üx
+(
+tmp3
+,
+tmp1
+,
+tmp2
+);
+
+3683
+__
+
+ªdi
+(
+r0
+,
+tmp3
+,
+O³¿nd
+(
+kIsNÙIÁ\94ÇlizedMask
+));
+
+3684
+__
+
+bÃ
+(&
+is_symbÞ
+,
+ü0
+);
+
+3687
+DCHECK
+(
+right
+.
+is
+(
+r3
+));
+
+3688
+__
+
+R\91
+();
+
+3689
+__
+
+b\9ad
+(&
+is_symbÞ
+);
+
+3693
+Lab\96
+
+ gruÁime
+;
+
+3694
+__
+
+JumpIfBÙhIn¡ªûTy³sA»NÙSequ\92t\9flOÃBy\8b
+(
+tmp1
+,
+tmp2
+,
+tmp3
+,
+tmp4
+,
+
+3695 &
+ruÁime
+);
+
+3698 ià(
+ gequ®\99y
+) {
+
+3699
+ gS\8c\9agH\96³r
+::
+G\92\94©eFÏtOÃBy\8bS\8c\9agEqu®s
+(
+masm
+,
+Ëá
+,
+right
+,
+tmp1
+,
+
+3700
+tmp2
+);
+
+3702
+ gS\8c\9agH\96³r
+::
+G\92\94©eCom·»FÏtOÃBy\8bS\8c\9ags
+(
+masm
+,
+Ëá
+,
+right
+,
+tmp1
+,
+
+3703
+tmp2
+,
+tmp3
+);
+
+3707
+__
+
+b\9ad
+(&
+ruÁime
+);
+
+3708
+__
+
+Push
+(
+Ëá
+,
+right
+);
+
+3709 ià(
+ gequ®\99y
+) {
+
+3710
+__
+
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+kS\8c\9agEqu®s
+, 2, 1);
+
+3712
+__
+
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+kS\8c\9agCom·»
+, 2, 1);
+
+3715
+__
+
+b\9ad
+(&
+miss
+);
+
+3716
+G\92\94©eMiss
+(
+masm
+);
+
+3720 \1e
+ gCom·»ICStub
+::
+G\92\94©eObjeùs
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3721
+DCHECK
+(
+¡©e
+(è=ð
+Com·»ICS\8f\8b
+::
+OBJECT
+);
+
+3722
+Lab\96
+
+ gmiss
+;
+
+3723
+__
+
+ªd_
+(
+r5
+,
+r4
+,
+r3
+);
+
+3724
+__
+
+JumpIfSmi
+(
+r5
+, &
+miss
+);
+
+3726
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r5
+,\845,
+JS_OBJECT_TYPE
+);
+
+3727
+__
+
+bÃ
+(&
+miss
+);
+
+3728
+__
+
+Com·»ObjeùTy³
+(
+r4
+,
+r5
+,\845,
+JS_OBJECT_TYPE
+);
+
+3729
+__
+
+bÃ
+(&
+miss
+);
+
+3731
+DCHECK
+(
+G\91CÚd\99iÚ
+(è=ð
+eq
+);
+
+3732
+__
+
+sub
+(
+r3
+,\843,
+r4
+);
+
+3733
+__
+
+R\91
+();
+
+3735
+__
+
+b\9ad
+(&
+miss
+);
+
+3736
+G\92\94©eMiss
+(
+masm
+);
+
+3740 \1e
+ gCom·»ICStub
+::
+G\92\94©eKnownObjeùs
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3741
+Lab\96
+
+miss
+;
+
+3742
+__
+
+ªd_
+(
+r5
+,
+r4
+,
+r3
+);
+
+3743
+__
+
+JumpIfSmi
+(
+r5
+, &
+miss
+);
+
+3744
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3745
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3746
+__
+
+Cmpi
+(
+r5
+,
+O³¿nd
+(
+known_m_
+),
+r0
+);
+
+3747
+__
+
+bÃ
+(&
+miss
+);
+
+3748
+__
+
+Cmpi
+(
+r6
+,
+O³¿nd
+(
+known_m_
+),
+r0
+);
+
+3749
+__
+
+bÃ
+(&
+miss
+);
+
+3751
+__
+
+sub
+(
+r3
+,\843,
+r4
+);
+
+3752
+__
+
+R\91
+();
+
+3754
+__
+
+b\9ad
+(&
+miss
+);
+
+3755
+G\92\94©eMiss
+(
+masm
+);
+
+3759 \1e
+ gCom·»ICStub
+::
+G\92\94©eMiss
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3762
+Ex\8bº®Reã»nû
+
+miss
+ =
+
+3763
+Ex\8bº®Reã»nû
+(
+IC_Ut\9e\99y
+(
+IC
+::
+kCom·»IC_Miss
+),
+isީe
+());
+
+3765
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+3766
+__
+
+Push
+(
+r4
+,
+r3
+);
+
+3767
+__
+
+Push
+(
+r4
+,
+r3
+);
+
+3768
+__
+
+LßdSmiL\99\94®
+(
+r0
+,
+Smi
+::
+FromIÁ
+(
+Ý
+()));
+
+3769
+__
+
+push
+(
+r0
+);
+
+3770
+__
+
+C®lEx\8bº®Reã»nû
+(
+miss
+, 3);
+
+3772
+__
+
+addi
+(
+r5
+,
+r3
+,
+O³¿nd
+(
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+3774
+__
+
+PÝ
+(
+r4
+,
+r3
+);
+
+3777
+__
+
+JumpToJSEÁry
+(
+r5
+);
+
+3782 \1e
+ gD\9ceùCEÁryStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3785
+__
+
+mær
+(
+r0
+);
+
+3786
+__
+
+StÜeP
+(
+r0
+,
+MemO³¿nd
+(
+¥
+,
+kS\8fckF¿meEx\8caP¬amSlÙ
+ *
+kPo\9a\8brSize
+));
+
+3787
+__
+
+C®l
+(
+\9d
+);
+
+3788
+__
+
+LßdP
+(
+r0
+,
+MemO³¿nd
+(
+¥
+,
+kS\8fckF¿meEx\8caP¬amSlÙ
+ *
+kPo\9a\8brSize
+));
+
+3789
+__
+
+m\8er
+(
+r0
+);
+
+3790
+__
+
+bÌ
+();
+
+3794 \1e
+ gD\9ceùCEÁryStub
+::
+G\92\94©eC®l
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+\8frg\91
+) {
+
+3795 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+ && !
+def\9aed
+(
+USE_SIMULATOR
+)
+
+3797
+__
+
+LßdP
+(
+ToRegi¡\94
+(
+ABI_TOC_REGISTER
+),
+MemO³¿nd
+(
+\8frg\91
+,
+kPo\9a\8brSize
+));
+
+3798
+__
+
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+\8frg\91
+, 0));
+
+3802
+__
+
+Move
+(
+\9d
+,
+\8frg\91
+);
+
+3805
+\9a\8d\8c_t
+
+ gcode
+ =
+»\9a\8b½»t_ÿ¡
+<\9a\8d\8c_t>(
+G\91Code
+().
+loÿtiÚ
+());
+
+3806
+__
+
+mov
+(
+r0
+,
+O³¿nd
+(
+code
+,
+R\96ocInfo
+::
+CODE_TARGET
+));
+
+3807
+__
+
+C®l
+(
+r0
+);
+
+3811 \1e
+ gNameDiùiÚ¬yLookupStub
+::
+G\92\94©eNeg©iveLookup
+(
+
+3812
+MaüoAs£mbËr
+*
+masm
+,
+Lab\96
+*
+miss
+, Lab\96*
+dÚe
+,
+Regi¡\94
+
+»ûiv\94
+,
+
+3813
+Regi¡\94
+
+´Ý\94t\9bs
+,
+HªdË
+<
+Name
+>
+Çme
+, Regi¡\94
+sü©ch0
+) {
+
+3814
+DCHECK
+(
+Çme
+->
+IsUniqueName
+());
+
+3820 \ f\12
+ gi
+ = 0; i <
+ gkIƚedProbes
+; i++) {
+
+3823
+Regi¡\94
+
+ g\9adex
+ =
+sü©ch0
+;
+
+3825
+__
+
+LßdP
+(
+\9adex
+,
+F\9bldMemO³¿nd
+(
+´Ý\94t\9bs
+,
+kCac\99yOff£t
+));
+
+3826
+__
+
+subi
+(
+\9adex
+, index,
+O³¿nd
+(1));
+
+3827
+__
+
+LßdSmiL\99\94®
+(
+
+3828
+\9d
+,
+Smi
+::
+FromIÁ
+(
+Çme
+->
+Hash
+(è+
+NameDiùiÚ¬y
+::
+G\91ProbeOff£t
+(
+i
+)));
+
+3829
+__
+
+ªd_
+(
+\9adex
+, index,
+\9d
+);
+
+3832
+DCHECK
+(
+NameDiùiÚ¬y
+::
+kEÁrySize
+ == 3);
+
+3833
+__
+
+ShiáLeáImm
+(
+\9d
+,
+\9adex
+,
+O³¿nd
+(1));
+
+3834
+__
+
+add
+(
+\9adex
+, index,
+\9d
+);
+
+3836
+Regi¡\94
+
+ g\92t\99y_Çme
+ =
+sü©ch0
+;
+
+3838
+Regi¡\94
+
+ gtmp
+ =
+´Ý\94t\9bs
+;
+
+3839
+__
+
+SmiToP\8cA¼ayOff£t
+(
+\9d
+,
+\9adex
+);
+
+3840
+__
+
+add
+(
+tmp
+,
+´Ý\94t\9bs
+,
+\9d
+);
+
+3841
+__
+
+LßdP
+(
+\92t\99y_Çme
+,
+F\9bldMemO³¿nd
+(
+tmp
+,
+kEËm\92tsS\8f¹Off£t
+));
+
+3843
+DCHECK
+(!
+tmp
+.
+is
+(
+\92t\99y_Çme
+));
+
+3844
+__
+
+LßdRoÙ
+(
+tmp
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+3845
+__
+
+cmp
+(
+\92t\99y_Çme
+,
+tmp
+);
+
+3846
+__
+
+beq
+(
+dÚe
+);
+
+3849
+__
+
+LßdRoÙ
+(
+tmp
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+3852
+__
+
+Cmpi
+(
+\92t\99y_Çme
+,
+O³¿nd
+(
+HªdË
+<
+Name
+>(
+Çme
+)),
+r0
+);
+
+3853
+__
+
+beq
+(
+miss
+);
+
+3855
+Lab\96
+
+ ggood
+;
+
+3856
+__
+
+cmp
+(
+\92t\99y_Çme
+,
+tmp
+);
+
+3857
+__
+
+beq
+(&
+good
+);
+
+3860
+__
+
+LßdP
+(
+\92t\99y_Çme
+,
+F\9bldMemO³¿nd
+ÓÁ\99y_Çme,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3861
+__
+
+lbz
+(
+\92t\99y_Çme
+,
+F\9bldMemO³¿nd
+ÓÁ\99y_Çme,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3862
+__
+
+JumpIfNÙUniqueNameIn¡ªûTy³
+(
+\92t\99y_Çme
+,
+miss
+);
+
+3863
+__
+
+b\9ad
+(&
+good
+);
+
+3866
+__
+
+LßdP
+(
+´Ý\94t\9bs
+,
+
+3867
+F\9bldMemO³¿nd
+(
+»ûiv\94
+,
+JSObjeù
+::
+kPrÝ\94t\9bsOff£t
+));
+
+3870 cڡ \12
+ g¥\9el_mask
+ = (
+r0
+.
+b\99
+(è|
+r9
+.b\99(è|
+r8
+.b\99(è|
+r7
+.b\99(è|
+r6
+.bit() |
+
+3871
+r5
+.
+b\99
+(è|
+r4
+.b\99(è|
+r3
+.bit());
+
+3873
+__
+
+mær
+(
+r0
+);
+
+3874
+__
+
+MuÉiPush
+(
+¥\9el_mask
+);
+
+3876
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+(
+»ûiv\94
+,
+JSObjeù
+::
+kPrÝ\94t\9bsOff£t
+));
+
+3877
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+HªdË
+<
+Name
+>(
+Çme
+)));
+
+3878
+NameDiùiÚ¬yLookupStub
+
+¡ub
+(
+masm
+->
+isީe
+(),
+NEGATIVE_LOOKUP
+);
+
+3879
+__
+
+C®lStub
+(&
+¡ub
+);
+
+3880
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+3882
+__
+
+MuÉiPÝ
+(
+¥\9el_mask
+);
+
+3883
+__
+
+m\8er
+(
+r0
+);
+
+3885
+__
+
+beq
+(
+dÚe
+);
+
+3886
+__
+
+bÃ
+(
+miss
+);
+
+3894 \1e
+ gNameDiùiÚ¬yLookupStub
+::
+G\92\94©ePos\99iveLookup
+(
+
+3895
+MaüoAs£mbËr
+*
+masm
+,
+Lab\96
+*
+miss
+, Lab\96*
+dÚe
+,
+Regi¡\94
+
+\96em\92ts
+,
+
+3896
+Regi¡\94
+
+Çme
+, Regi¡\94
+sü©ch1
+, Regi¡\94
+sü©ch2
+) {
+
+3897
+DCHECK
+(!
+\96em\92ts
+.
+is
+(
+sü©ch1
+));
+
+3898
+DCHECK
+(!
+\96em\92ts
+.
+is
+(
+sü©ch2
+));
+
+3899
+DCHECK
+(!
+Çme
+.
+is
+(
+sü©ch1
+));
+
+3900
+DCHECK
+(!
+Çme
+.
+is
+(
+sü©ch2
+));
+
+3902
+__
+
+As£¹Name
+(
+Çme
+);
+
+3905
+__
+
+LßdP
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(
+\96em\92ts
+,
+kCac\99yOff£t
+));
+
+3906
+__
+
+SmiUÁag
+(
+sü©ch1
+);
+
+3907
+__
+
+subi
+(
+sü©ch1
+, sü©ch1,
+O³¿nd
+(1));
+
+3912 \ f\12
+ gi
+ = 0; i <
+ gkIƚedProbes
+; i++) {
+
+3914
+__
+
+lwz
+(
+sü©ch2
+,
+F\9bldMemO³¿nd
+(
+Çme
+,
+Name
+::
+kHashF\9bldOff£t
+));
+
+3915 ià(
+ gi
+ > 0) {
+
+3919
+DCHECK
+(
+NameDiùiÚ¬y
+::
+G\91ProbeOff£t
+(
+i
+) <
+
+3920 1 << (32 -
+Name
+::
+kHashF\9bldOff£t
+));
+
+3921
+__
+
+addi
+(
+sü©ch2
+, scratch2,
+
+3922
+O³¿nd
+(
+NameDiùiÚ¬y
+::
+G\91ProbeOff£t
+(
+i
+è<<
+Name
+::
+kHashShiá
+));
+
+3924
+__
+
+¤wi
+(
+sü©ch2
+, sü©ch2,
+O³¿nd
+(
+Name
+::
+kHashShiá
+));
+
+3925
+__
+
+ªd_
+(
+sü©ch2
+,
+sü©ch1
+, scratch2);
+
+3928
+DCHECK
+(
+NameDiùiÚ¬y
+::
+kEÁrySize
+ == 3);
+
+3930
+__
+
+ShiáLeáImm
+(
+\9d
+,
+sü©ch2
+,
+O³¿nd
+(1));
+
+3931
+__
+
+add
+(
+sü©ch2
+, sü©ch2,
+\9d
+);
+
+3934
+__
+
+ShiáLeáImm
+(
+\9d
+,
+sü©ch2
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+3935
+__
+
+add
+(
+sü©ch2
+,
+\96em\92ts
+,
+\9d
+);
+
+3936
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+sü©ch2
+,
+kEËm\92tsS\8f¹Off£t
+));
+
+3937
+__
+
+cmp
+(
+Çme
+,
+\9d
+);
+
+3938
+__
+
+beq
+(
+dÚe
+);
+
+3941 cڡ \12
+ g¥\9el_mask
+ = (
+r0
+.
+b\99
+(è|
+r9
+.b\99(è|
+r8
+.b\99(è|
+r7
+.b\99(è|
+r6
+.bit() |
+
+3942
+r5
+.
+b\99
+(è|
+r4
+.b\99(è|
+r3
+.bit()) &
+
+3943 ~(
+sü©ch1
+.
+b\99
+(è|
+sü©ch2
+.bit());
+
+3945
+__
+
+mær
+(
+r0
+);
+
+3946
+__
+
+MuÉiPush
+(
+¥\9el_mask
+);
+
+3947 ià(
+ gÇme
+.
+is
+(
+r3
+)) {
+
+3948
+DCHECK
+(!
+\96em\92ts
+.
+is
+(
+r4
+));
+
+3949
+__
+
+mr
+(
+r4
+,
+Çme
+);
+
+3950
+__
+
+mr
+(
+r3
+,
+\96em\92ts
+);
+
+3952
+__
+
+mr
+(
+r3
+,
+\96em\92ts
+);
+
+3953
+__
+
+mr
+(
+r4
+,
+Çme
+);
+
+3955
+NameDiùiÚ¬yLookupStub
+
+¡ub
+(
+masm
+->
+isީe
+(),
+POSITIVE_LOOKUP
+);
+
+3956
+__
+
+C®lStub
+(&
+¡ub
+);
+
+3957
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+3958
+__
+
+mr
+(
+sü©ch2
+,
+r5
+);
+
+3959
+__
+
+MuÉiPÝ
+(
+¥\9el_mask
+);
+
+3960
+__
+
+m\8er
+(
+r0
+);
+
+3962
+__
+
+bÃ
+(
+dÚe
+);
+
+3963
+__
+
+beq
+(
+miss
+);
+
+3967 \1e
+ gNameDiùiÚ¬yLookupStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+3979
+Regi¡\94
+
+»suÉ
+ =
+r3
+;
+
+3980
+Regi¡\94
+
+ gdiùiÚ¬y
+ =
+r3
+;
+
+3981
+Regi¡\94
+
+ gkey
+ =
+r4
+;
+
+3982
+Regi¡\94
+
+ g\9adex
+ =
+r5
+;
+
+3983
+Regi¡\94
+
+ gmask
+ =
+r6
+;
+
+3984
+Regi¡\94
+
+ ghash
+ =
+r7
+;
+
+3985
+Regi¡\94
+
+ gundef\9aed
+ =
+r8
+;
+
+3986
+Regi¡\94
+
+ g\92\8cy_key
+ =
+r9
+;
+
+3987
+Regi¡\94
+
+ gsü©ch
+ =
+r9
+;
+
+3989
+Lab\96
+
+ g\9a_diùiÚ¬y
+,
+ gmaybe_\9a_diùiÚ¬y
+,
+ gnÙ_\9a_diùiÚ¬y
+;
+
+3991
+__
+
+LßdP
+(
+mask
+,
+F\9bldMemO³¿nd
+(
+diùiÚ¬y
+,
+kCac\99yOff£t
+));
+
+3992
+__
+
+SmiUÁag
+(
+mask
+);
+
+3993
+__
+
+subi
+(
+mask
+, mask,
+O³¿nd
+(1));
+
+3995
+__
+
+lwz
+(
+hash
+,
+F\9bldMemO³¿nd
+(
+key
+,
+Name
+::
+kHashF\9bldOff£t
+));
+
+3997
+__
+
+LßdRoÙ
+(
+undef\9aed
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+3999 \ f\12
+ gi
+ =
+kIƚedProbes
+; i <
+ gkTٮProbes
+; i++) {
+
+4002 ià(
+ gi
+ > 0) {
+
+4006
+DCHECK
+(
+NameDiùiÚ¬y
+::
+G\91ProbeOff£t
+(
+i
+) <
+
+4007 1 << (32 -
+Name
+::
+kHashF\9bldOff£t
+));
+
+4008
+__
+
+addi
+(
+\9adex
+,
+hash
+,
+
+4009
+O³¿nd
+(
+NameDiùiÚ¬y
+::
+G\91ProbeOff£t
+(
+i
+è<<
+Name
+::
+kHashShiá
+));
+
+4011
+__
+
+mr
+(
+\9adex
+,
+hash
+);
+
+4013
+__
+
+¤wi
+(
+r0
+,
+\9adex
+,
+O³¿nd
+(
+Name
+::
+kHashShiá
+));
+
+4014
+__
+
+ªd_
+(
+\9adex
+,
+mask
+,
+r0
+);
+
+4017
+DCHECK
+(
+NameDiùiÚ¬y
+::
+kEÁrySize
+ == 3);
+
+4018
+__
+
+ShiáLeáImm
+(
+sü©ch
+,
+\9adex
+,
+O³¿nd
+(1));
+
+4019
+__
+
+add
+(
+\9adex
+, index,
+sü©ch
+);
+
+4021
+DCHECK_EQ
+(
+kSmiTagSize
+, 1);
+
+4022
+__
+
+ShiáLeáImm
+(
+sü©ch
+,
+\9adex
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+4023
+__
+
+add
+(
+\9adex
+,
+diùiÚ¬y
+,
+sü©ch
+);
+
+4024
+__
+
+LßdP
+(
+\92\8cy_key
+,
+F\9bldMemO³¿nd
+(
+\9adex
+,
+kEËm\92tsS\8f¹Off£t
+));
+
+4027
+__
+
+cmp
+(
+\92\8cy_key
+,
+undef\9aed
+);
+
+4028
+__
+
+beq
+(&
+nÙ_\9a_diùiÚ¬y
+);
+
+4031
+__
+
+cmp
+(
+\92\8cy_key
+,
+key
+);
+
+4032
+__
+
+beq
+(&
+\9a_diùiÚ¬y
+);
+
+4034 ià(
+ gi
+ !ð
+kTٮProbes
+ - 1 &&
+mode
+(è=ð
+NEGATIVE_LOOKUP
+) {
+
+4036
+__
+
+LßdP
+(
+\92\8cy_key
+,
+F\9bldMemO³¿nd
+ÓÁry_key,
+H\97pObjeù
+::
+kMOff£t
+));
+
+4037
+__
+
+lbz
+(
+\92\8cy_key
+,
+F\9bldMemO³¿nd
+ÓÁry_key,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+4038
+__
+
+JumpIfNÙUniqueNameIn¡ªûTy³
+(
+\92\8cy_key
+, &
+maybe_\9a_diùiÚ¬y
+);
+
+4042
+__
+
+b\9ad
+(&
+maybe_\9a_diùiÚ¬y
+);
+
+4046 ià(
+mode
+(è=ð
+POSITIVE_LOOKUP
+) {
+
+4047
+__
+
+li
+(
+»suÉ
+,
+O³¿nd
+::
+Z\94o
+());
+
+4048
+__
+
+R\91
+();
+
+4051
+__
+
+b\9ad
+(&
+\9a_diùiÚ¬y
+);
+
+4052
+__
+
+li
+(
+»suÉ
+,
+O³¿nd
+(1));
+
+4053
+__
+
+R\91
+();
+
+4055
+__
+
+b\9ad
+(&
+nÙ_\9a_diùiÚ¬y
+);
+
+4056
+__
+
+li
+(
+»suÉ
+,
+O³¿nd
+::
+Z\94o
+());
+
+4057
+__
+
+R\91
+();
+
+4061 \1e
+ gStÜeBufãrOv\94æowStub
+::
+G\92\94©eFixedRegStubsAh\97dOfTime
+(
+
+4062
+Isީe
+*
+isީe
+) {
+
+4063
+StÜeBufãrOv\94æowStub
+
+¡ub1
+(
+isީe
+,
+kDÚtSaveFPRegs
+);
+
+4064
+ g¡ub1
+.
+G\91Code
+();
+
+4066
+StÜeBufãrOv\94æowStub
+
+¡ub2
+(
+isީe
+,
+kSaveFPRegs
+);
+
+4067
+ g¡ub2
+.
+G\91Code
+();
+
+4075 \1e
+ gRecÜdWr\99eStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+4076
+Lab\96
+
+sk\9d_to_\9aüem\92\8fl_nÚcom·ù\9ag
+;
+
+4077
+Lab\96
+
+ gsk\9d_to_\9aüem\92\8fl_com·ù\9ag
+;
+
+4086
+__
+
+üþr
+(
+As£mbËr
+::
+\92code_üb\99
+(
+ü2
+,
+CR_LT
+));
+
+4087
+__
+
+bÉ
+(&
+sk\9d_to_\9aüem\92\8fl_nÚcom·ù\9ag
+,
+ü2
+);
+
+4088
+__
+
+bÉ
+(&
+sk\9d_to_\9aüem\92\8fl_com·ù\9ag
+,
+ü2
+);
+
+4090 ià(
+»memb\94ed_£t_aùiÚ
+(è=ð
+EMIT_REMEMBERED_SET
+) {
+
+4091
+__
+
+Rememb\94edS\91H\96³r
+(
+objeù
+(),
+add»ss
+(),
+v®ue
+(),
+§ve_å_»gs_mode
+(),
+
+4092
+MaüoAs£mbËr
+::
+kR\91uºAtEnd
+);
+
+4094
+__
+
+R\91
+();
+
+4096
+__
+
+b\9ad
+(&
+sk\9d_to_\9aüem\92\8fl_nÚcom·ù\9ag
+);
+
+4097
+G\92\94©eInüem\92\8fl
+(
+masm
+,
+INCREMENTAL
+);
+
+4099
+__
+
+b\9ad
+(&
+sk\9d_to_\9aüem\92\8fl_com·ù\9ag
+);
+
+4100
+G\92\94©eInüem\92\8fl
+(
+masm
+,
+INCREMENTAL_COMPACTION
+);
+
+4108 \1e
+ gRecÜdWr\99eStub
+::
+G\92\94©eInüem\92\8fl
+(
+MaüoAs£mbËr
+*
+masm
+,
+Mode
+
+mode
+) {
+
+4109
+ g»gs_
+.
+Save
+(
+masm
+);
+
+4111 ià(
+»memb\94ed_£t_aùiÚ
+(è=ð
+EMIT_REMEMBERED_SET
+) {
+
+4112
+Lab\96
+
+dÚt_Ãed_»memb\94ed_£t
+;
+
+4114
+__
+
+LßdP
+(
+»gs_
+.
+sü©ch0
+(),
+MemO³¿nd
+Ôegs_.
+add»ss
+(), 0));
+
+4115
+__
+
+JumpIfNÙInNewS·û
+(
+»gs_
+.
+sü©ch0
+(),
+
+4116
+»gs_
+.
+sü©ch0
+(), &
+dÚt_Ãed_»memb\94ed_£t
+);
+
+4118
+__
+
+CheckPageFÏg
+(
+»gs_
+.
+objeù
+(),\84egs_.
+sü©ch0
+(),
+
+4119 1 <<
+MemÜyChunk
+::
+SCAN_ON_SCAVENGE
+,
+Ã
+,
+
+4120 &
+dÚt_Ãed_»memb\94ed_£t
+);
+
+4124
+CheckN\93dsToInfÜmInüem\92\8flM¬k\94
+(
+
+4125
+masm
+,
+kUpd©eRememb\94edS\91OnNoN\93dToInfÜmInüem\92\8flM¬k\94
+,
+mode
+);
+
+4126
+InfÜmInüem\92\8flM¬k\94
+(
+masm
+);
+
+4127
+ g»gs_
+.
+Re¡Üe
+(
+masm
+);
+
+4128
+__
+
+Rememb\94edS\91H\96³r
+(
+objeù
+(),
+add»ss
+(),
+v®ue
+(),
+§ve_å_»gs_mode
+(),
+
+4129
+MaüoAs£mbËr
+::
+kR\91uºAtEnd
+);
+
+4131
+__
+
+b\9ad
+(&
+dÚt_Ãed_»memb\94ed_£t
+);
+
+4134
+CheckN\93dsToInfÜmInüem\92\8flM¬k\94
+(
+
+4135
+masm
+,
+kR\91uºOnNoN\93dToInfÜmInüem\92\8flM¬k\94
+,
+mode
+);
+
+4136
+InfÜmInüem\92\8flM¬k\94
+(
+masm
+);
+
+4137
+ g»gs_
+.
+Re¡Üe
+(
+masm
+);
+
+4138
+__
+
+R\91
+();
+
+4142 \1e
+ gRecÜdWr\99eStub
+::
+InfÜmInüem\92\8flM¬k\94
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+4143
+»gs_
+.
+SaveC®ËrSaveRegi¡\94s
+(
+masm
+,
+§ve_å_»gs_mode
+());
+
+4144 \12
+ g¬gum\92t_couÁ
+ = 3;
+
+4145
+__
+
+P»·»C®lCFunùiÚ
+(
+¬gum\92t_couÁ
+,
+»gs_
+.
+sü©ch0
+());
+
+4146
+Regi¡\94
+
+ gadd»ss
+ =
+
+4147
+r3
+.
+is
+(
+»gs_
+.
+add»ss
+()è?\84egs_.
+sü©ch0
+() :\84egs_.address();
+
+4148
+DCHECK
+(!
+add»ss
+.
+is
+(
+»gs_
+.
+objeù
+()));
+
+4149
+DCHECK
+(!
+add»ss
+.
+is
+(
+r3
+));
+
+4150
+__
+
+mr
+(
+add»ss
+,
+»gs_
+.address());
+
+4151
+__
+
+mr
+(
+r3
+,
+»gs_
+.
+objeù
+());
+
+4152
+__
+
+mr
+(
+r4
+,
+add»ss
+);
+
+4153
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+isީe
+())));
+
+4155
+AÎowEx\8bº®C®lTh©CªtCau£GC
+
+scÝe
+(
+masm
+);
+
+4156
+__
+
+C®lCFunùiÚ
+(
+
+4157
+Ex\8bº®Reã»nû
+::
+\9aüem\92\8fl_m¬k\9ag_»cÜd_wr\99e_funùiÚ
+(
+isީe
+()),
+
+4158
+¬gum\92t_couÁ
+);
+
+4159
+ g»gs_
+.
+Re¡ÜeC®ËrSaveRegi¡\94s
+(
+masm
+,
+§ve_å_»gs_mode
+());
+
+4163 \1e
+ gRecÜdWr\99eStub
+::
+CheckN\93dsToInfÜmInüem\92\8flM¬k\94
+(
+
+4164
+MaüoAs£mbËr
+*
+masm
+,
+OnNoN\93dToInfÜmInüem\92\8flM¬k\94
+
+Ú_no_Ãed
+,
+
+4165
+Mode
+
+mode
+) {
+
+4166
+Lab\96
+
+ gÚ_bÏck
+;
+
+4167
+Lab\96
+
+ gÃed_\9aüem\92\8fl
+;
+
+4168
+Lab\96
+
+ gÃed_\9aüem\92\8fl_pÝ_sü©ch
+;
+
+4170
+DCHECK
+((~
+Page
+::
+kPageAlignm\92tMask
+ & 0xffff) == 0);
+
+4171
+__
+
+lis
+(
+r0
+,
+O³¿nd
+((~
+Page
+::
+kPageAlignm\92tMask
+ >> 16)));
+
+4172
+__
+
+ªd_
+(
+»gs_
+.
+sü©ch0
+(),\84egs_.
+objeù
+(),
+r0
+);
+
+4173
+__
+
+LßdP
+(
+
+4174
+»gs_
+.
+sü©ch1
+(),
+
+4175
+MemO³¿nd
+(
+»gs_
+.
+sü©ch0
+(),
+MemÜyChunk
+::
+kWr\99eB¬r\9brCouÁ\94Off£t
+));
+
+4176
+__
+
+subi
+(
+»gs_
+.
+sü©ch1
+(),\84egs_.sü©ch1(),
+O³¿nd
+(1));
+
+4177
+__
+
+StÜeP
+(
+
+4178
+»gs_
+.
+sü©ch1
+(),
+
+4179
+MemO³¿nd
+(
+»gs_
+.
+sü©ch0
+(),
+MemÜyChunk
+::
+kWr\99eB¬r\9brCouÁ\94Off£t
+));
+
+4180
+__
+
+cmpi
+(
+»gs_
+.
+sü©ch1
+(),
+O³¿nd
+::
+Z\94o
+());
+
+4181
+__
+
+bÉ
+(&
+Ãed_\9aüem\92\8fl
+);
+
+4185
+__
+
+JumpIfBÏck
+(
+»gs_
+.
+objeù
+(),\84egs_.
+sü©ch0
+(),\84egs_.
+sü©ch1
+(), &
+Ú_bÏck
+);
+
+4187
+ g»gs_
+.
+Re¡Üe
+(
+masm
+);
+
+4188 ià(
+ gÚ_no_Ãed
+ =ð
+kUpd©eRememb\94edS\91OnNoN\93dToInfÜmInüem\92\8flM¬k\94
+) {
+
+4189
+__
+
+Rememb\94edS\91H\96³r
+(
+objeù
+(),
+add»ss
+(),
+v®ue
+(),
+§ve_å_»gs_mode
+(),
+
+4190
+MaüoAs£mbËr
+::
+kR\91uºAtEnd
+);
+
+4192
+__
+
+R\91
+();
+
+4195
+__
+
+b\9ad
+(&
+Ú_bÏck
+);
+
+4198
+__
+
+LßdP
+(
+»gs_
+.
+sü©ch0
+(),
+MemO³¿nd
+Ôegs_.
+add»ss
+(), 0));
+
+4200 ià(
+ gmode
+ =ð
+INCREMENTAL_COMPACTION
+) {
+
+4201
+Lab\96
+
+\92su»_nÙ_wh\99e
+;
+
+4203
+__
+
+CheckPageFÏg
+(
+»gs_
+.
+sü©ch0
+(),
+
+4204
+»gs_
+.
+sü©ch1
+(),
+
+4205
+MemÜyChunk
+::
+kEvacu©iÚCªdid©eMask
+,
+eq
+,
+
+4206 &
+\92su»_nÙ_wh\99e
+);
+
+4208
+__
+
+CheckPageFÏg
+(
+»gs_
+.
+objeù
+(),
+
+4209
+»gs_
+.
+sü©ch1
+(),
+
+4210
+MemÜyChunk
+::
+kSk\9dEvacu©iÚSlÙsRecÜd\9agMask
+,
+eq
+,
+
+4211 &
+Ãed_\9aüem\92\8fl
+);
+
+4213
+__
+
+b\9ad
+(&
+\92su»_nÙ_wh\99e
+);
+
+4218
+__
+
+Push
+(
+»gs_
+.
+objeù
+(),\84egs_.
+add»ss
+());
+
+4219
+__
+
+Ensu»NÙWh\99e
+(
+»gs_
+.
+sü©ch0
+(),
+
+4220
+»gs_
+.
+sü©ch1
+(),
+
+4221
+»gs_
+.
+objeù
+(),
+
+4222
+»gs_
+.
+add»ss
+(),
+
+4223 &
+Ãed_\9aüem\92\8fl_pÝ_sü©ch
+);
+
+4224
+__
+
+PÝ
+(
+»gs_
+.
+objeù
+(),\84egs_.
+add»ss
+());
+
+4226
+ g»gs_
+.
+Re¡Üe
+(
+masm
+);
+
+4227 ià(
+ gÚ_no_Ãed
+ =ð
+kUpd©eRememb\94edS\91OnNoN\93dToInfÜmInüem\92\8flM¬k\94
+) {
+
+4228
+__
+
+Rememb\94edS\91H\96³r
+(
+objeù
+(),
+add»ss
+(),
+v®ue
+(),
+§ve_å_»gs_mode
+(),
+
+4229
+MaüoAs£mbËr
+::
+kR\91uºAtEnd
+);
+
+4231
+__
+
+R\91
+();
+
+4234
+__
+
+b\9ad
+(&
+Ãed_\9aüem\92\8fl_pÝ_sü©ch
+);
+
+4235
+__
+
+PÝ
+(
+»gs_
+.
+objeù
+(),\84egs_.
+add»ss
+());
+
+4237
+__
+
+b\9ad
+(&
+Ãed_\9aüem\92\8fl
+);
+
+4243 \1e
+ gStÜeA¼ayL\99\94®EËm\92tStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+4252
+Lab\96
+
+\96em\92t_dÚe
+;
+
+4253
+Lab\96
+
+ gdoubË_\96em\92ts
+;
+
+4254
+Lab\96
+
+ gsmi_\96em\92t
+;
+
+4255
+Lab\96
+
+ g¦ow_\96em\92ts
+;
+
+4256
+Lab\96
+
+ gç¡_\96em\92ts
+;
+
+4259
+__
+
+LßdP
+(
+r7
+,
+MemO³¿nd
+(
+¥
+, 0 *
+kPo\9a\8brSize
+));
+
+4260
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+4261
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSObjeù
+::
+kMOff£t
+));
+
+4263
+__
+
+CheckFa¡EËm\92ts
+(
+r5
+,
+r8
+, &
+doubË_\96em\92ts
+);
+
+4265
+__
+
+JumpIfSmi
+(
+r3
+, &
+smi_\96em\92t
+);
+
+4266
+__
+
+CheckFa¡SmiEËm\92ts
+(
+r5
+,
+r8
+, &
+ç¡_\96em\92ts
+);
+
+4270
+__
+
+b\9ad
+(&
+¦ow_\96em\92ts
+);
+
+4272
+__
+
+Push
+(
+r4
+,
+r6
+,
+r3
+);
+
+4273
+__
+
+LßdP
+(
+r8
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+4274
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+Ô8,
+JSFunùiÚ
+::
+kL\99\94®sOff£t
+));
+
+4275
+__
+
+Push
+(
+r8
+,
+r7
+);
+
+4276
+__
+
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+kStÜeA¼ayL\99\94®EËm\92t
+, 5, 1);
+
+4279
+__
+
+b\9ad
+(&
+ç¡_\96em\92ts
+);
+
+4280
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+));
+
+4281
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r9
+,
+r6
+);
+
+4282
+__
+
+add
+(
+r9
+,
+r8
+,\849);
+
+4283 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4285
+__
+
+addi
+(
+r9
+,\849,
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+4286
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+r9
+));
+
+4288
+__
+
+StÜePU
+(
+r3
+,
+MemO³¿nd
+(
+r9
+,
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+4291
+__
+
+RecÜdWr\99e
+(
+r8
+,
+r9
+,
+r3
+,
+kLRHasNÙB\93nSaved
+,
+kDÚtSaveFPRegs
+,
+
+4292
+EMIT_REMEMBERED_SET
+,
+OMIT_SMI_CHECK
+);
+
+4293
+__
+
+R\91
+();
+
+4297
+__
+
+b\9ad
+(&
+smi_\96em\92t
+);
+
+4298
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+));
+
+4299
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r9
+,
+r6
+);
+
+4300
+__
+
+add
+(
+r9
+,
+r8
+,\849);
+
+4301
+__
+
+StÜeP
+(
+r3
+,
+F\9bldMemO³¿nd
+(
+r9
+,
+FixedA¼ay
+::
+kH\97d\94Size
+),
+r0
+);
+
+4302
+__
+
+R\91
+();
+
+4305
+__
+
+b\9ad
+(&
+doubË_\96em\92ts
+);
+
+4306
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+));
+
+4307
+__
+
+StÜeNumb\94ToDoubËEËm\92ts
+(
+r3
+,
+r6
+,
+r8
+,
+r9
+,
+d0
+, &
+¦ow_\96em\92ts
+);
+
+4308
+__
+
+R\91
+();
+
+4312 \1e
+ gStubFa\9eu»T¿mpÞ\9aeStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+4313
+CEÁryStub
+
+ûs
+(
+isީe
+(), 1,
+kSaveFPRegs
+);
+
+4314
+__
+
+C®l
+(
+ûs
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+4315 \12
+ g·¿m\91\94_couÁ_off£t
+ =
+
+4316
+StubFa\9eu»T¿mpÞ\9aeF¿me
+::
+kC®ËrS\8fckP¬am\91\94CouÁF¿meOff£t
+;
+
+4317
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+å
+,
+·¿m\91\94_couÁ_off£t
+));
+
+4318 ià(
+funùiÚ_mode
+(è=ð
+JS_FUNCTION_STUB_MODE
+) {
+
+4319
+__
+
+addi
+(
+r4
+,\844,
+O³¿nd
+(1));
+
+4321
+ gmasm
+->
+L\97veF¿me
+(
+S\8fckF¿me
+::
+STUB_FAILURE_TRAMPOLINE
+);
+
+4322
+__
+
+¦wi
+(
+r4
+,\844,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+4323
+__
+
+add
+(
+¥
+, sp,
+r4
+);
+
+4324
+__
+
+R\91
+();
+
+4328 \1e
+ gLßdICT¿mpÞ\9aeStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+4329
+Em\99LßdTy³F\93dbackVeùÜ
+(
+masm
+,
+VeùÜLßdICDesü\9dtÜ
+::
+VeùÜRegi¡\94
+());
+
+4330
+VeùÜLßdStub
+
+¡ub
+(
+isީe
+(),
+¡©e
+());
+
+4331
+__
+
+Jump
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+4335 \1e
+ gKeyedLßdICT¿mpÞ\9aeStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+4336
+Em\99LßdTy³F\93dbackVeùÜ
+(
+masm
+,
+VeùÜLßdICDesü\9dtÜ
+::
+VeùÜRegi¡\94
+());
+
+4337
+VeùÜKeyedLßdStub
+
+¡ub
+(
+isީe
+());
+
+4338
+__
+
+Jump
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+4342 \1e
+ gProf\9eeEÁryHookStub
+::
+MaybeC®lEÁryHook
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+4343 ià(
+masm
+->
+isީe
+()->
+funùiÚ_\92\8cy_hook
+(è!ð
+NULL
+) {
+
+4344
+P»diùabËCodeSizeScÝe
+
+´ediùabË
+(
+masm
+,
+
+4345 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4346 14 *
+As£mbËr
+::
+kIn¡rSize
+);
+
+4348 11 *
+ gAs£mbËr
+::
+kIn¡rSize
+);
+
+4350
+Prof\9eeEÁryHookStub
+
+¡ub
+(
+masm
+->
+isީe
+());
+
+4351
+__
+
+mær
+(
+r0
+);
+
+4352
+__
+
+Push
+(
+r0
+,
+\9d
+);
+
+4353
+__
+
+C®lStub
+(&
+¡ub
+);
+
+4354
+__
+
+PÝ
+(
+r0
+,
+\9d
+);
+
+4355
+__
+
+m\8er
+(
+r0
+);
+
+4360 \1e
+ gProf\9eeEÁryHookStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+4362 cڡ
+\9at32_t
+
+kR\91uºAdd»ssDi¡ªûFromFunùiÚS\8f¹
+ =
+
+4363
+As£mbËr
+::
+kC®lT¬g\91Add»ssOff£t
+ + 3 * As£mbËr::
+kIn¡rSize
+;
+
+4366 cڡ
+RegLi¡
+
+ gkSavedRegs
+ =
+kJSC®ËrSaved
+ |
+
+4367
+r15
+.
+b\99
+();
+
+4370 cڡ
+\9at32_t
+
+ gkNumSavedRegs
+ =
+kNumJSC®ËrSaved
+ + 2;
+
+4373
+__
+
+mær
+(
+\9d
+);
+
+4374
+__
+
+MuÉiPush
+(
+kSavedRegs
+ |
+\9d
+.
+b\99
+());
+
+4377
+__
+
+subi
+(
+r3
+,
+\9d
+,
+O³¿nd
+(
+kR\91uºAdd»ssDi¡ªûFromFunùiÚS\8f¹
+));
+
+4381
+__
+
+addi
+(
+r4
+,
+¥
+,
+O³¿nd
+((
+kNumSavedRegs
+ + 1è*
+kPo\9a\8brSize
+));
+
+4384 \12
+ gäame_®ignm\92t
+ =
+masm
+->
+Aùiv©iÚF¿meAlignm\92t
+();
+
+4385 ià(
+ gäame_®ignm\92t
+ >
+ gkPo\9a\8brSize
+) {
+
+4386
+__
+
+mr
+(
+r15
+,
+¥
+);
+
+4387
+DCHECK
+(
+ba£
+::
+b\99s
+::
+IsPow\94OfTwo32
+(
+äame_®ignm\92t
+));
+
+4388
+__
+
+CˬRightImm
+(
+¥
+, sp,
+O³¿nd
+(
+WhichPow\94Of2
+(
+äame_®ignm\92t
+)));
+
+4391 #ià!
+def\9aed
+(
+USE_SIMULATOR
+)
+
+4392
+u\9a\8d\8c_t
+
+ g\92\8cy_hook
+ =
+
+4393
+»\9a\8b½»t_ÿ¡
+<
+u\9a\8d\8c_t
+>(
+isީe
+()->
+funùiÚ_\92\8cy_hook
+());
+
+4394
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+\92\8cy_hook
+));
+
+4396 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+
+
+4398
+__
+
+LßdP
+(
+ToRegi¡\94
+(
+ABI_TOC_REGISTER
+),
+MemO³¿nd
+(
+\9d
+,
+kPo\9a\8brSize
+));
+
+4399
+__
+
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(ip, 0));
+
+4400 #\96ià
+ABI_TOC_ADDRESSABILITY_VIA_IP
+
+
+4405
+__
+
+li
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+4406
+__
+
+StÜePU
+(
+r0
+,
+MemO³¿nd
+(
+¥
+, -
+kNumRequ\9cedS\8fckF¿meSlÙs
+ *
+kPo\9a\8brSize
+));
+
+4411
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+isީe
+())));
+
+4413
+ApiFunùiÚ
+
+di¥©ch\94
+(
+FUNCTION_ADDR
+(
+EÁryHookT¿mpÞ\9ae
+));
+
+4414
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+
+4415 &
+di¥©ch\94
+,
+Ex\8bº®Reã»nû
+::
+BUILTIN_CALL
+,
+isީe
+())));
+
+4417
+__
+
+C®l
+(
+\9d
+);
+
+4419 #ià!
+def\9aed
+(
+USE_SIMULATOR
+)
+
+4420
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kNumRequ\9cedS\8fckF¿meSlÙs
+ *
+kPo\9a\8brSize
+));
+
+4424 ià(
+ gäame_®ignm\92t
+ >
+ gkPo\9a\8brSize
+) {
+
+4425
+__
+
+mr
+(
+¥
+,
+r15
+);
+
+4429
+__
+
+MuÉiPÝ
+(
+kSavedRegs
+ |
+\9d
+.
+b\99
+());
+
+4430
+__
+
+m\8er
+(
+\9d
+);
+
+4431
+__
+
+R\91
+();
+
+4435
+ g\8bm¶©e
+ <
+þass
+
+ gT
+>
+
+4436 \18\1e
+C»©eA¼ayDi¥©ch
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+4437
+AÎoÿtiÚS\99eOv\94rideMode
+
+mode
+) {
+
+4438 ià(
+ gmode
+ =ð
+DISABLE_ALLOCATION_SITES
+) {
+
+4439
+T
+
+¡ub
+(
+masm
+->
+isީe
+(),
+G\91In\99\9flFa¡EËm\92tsK\9ad
+(),
+mode
+);
+
+4440
+__
+
+Ta\9eC®lStub
+(&
+¡ub
+);
+
+4441 } \vià(
+ gmode
+ =ð
+DONT_OVERRIDE
+) {
+
+4442 \12
+Ï¡_\9adex
+ =
+
+4443
+G\91Sequ\92ûIndexFromFa¡EËm\92tsK\9ad
+(
+TERMINAL_FAST_ELEMENTS_KIND
+);
+
+4444 \ f\12
+ gi
+ = 0; i <ð
+Ï¡_\9adex
+; ++i) {
+
+4445
+EËm\92tsK\9ad
+
+ gk\9ad
+ =
+G\91Fa¡EËm\92tsK\9adFromSequ\92ûIndex
+(
+i
+);
+
+4446
+__
+
+Cmpi
+(
+r6
+,
+O³¿nd
+(
+k\9ad
+),
+r0
+);
+
+4447
+T
+
+¡ub
+(
+masm
+->
+isީe
+(),
+k\9ad
+);
+
+4448
+__
+
+Ta\9eC®lStub
+(&
+¡ub
+,
+eq
+);
+
+4452
+__
+
+AbÜt
+(
+kUÃx³ùedEËm\92tsK\9adInA¼ayCÚ¡ruùÜ
+);
+
+4454
+UNREACHABLE
+();
+
+4459 \18\1e
+C»©eA¼ayDi¥©chOÃArgum\92t
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+4460
+AÎoÿtiÚS\99eOv\94rideMode
+
+mode
+) {
+
+4466
+Lab\96
+
+ gnÜm®_£qu\92û
+;
+
+4467 ià(
+ gmode
+ =ð
+DONT_OVERRIDE
+) {
+
+4468
+DCHECK
+(
+FAST_SMI_ELEMENTS
+ == 0);
+
+4469
+DCHECK
+(
+FAST_HOLEY_SMI_ELEMENTS
+ == 1);
+
+4470
+DCHECK
+(
+FAST_ELEMENTS
+ == 2);
+
+4471
+DCHECK
+(
+FAST_HOLEY_ELEMENTS
+ == 3);
+
+4472
+DCHECK
+(
+FAST_DOUBLE_ELEMENTS
+ == 4);
+
+4473
+DCHECK
+(
+FAST_HOLEY_DOUBLE_ELEMENTS
+ == 5);
+
+4476
+__
+
+ªdi
+(
+r0
+,
+r6
+,
+O³¿nd
+(1));
+
+4477
+__
+
+bÃ
+(&
+nÜm®_£qu\92û
+,
+ü0
+);
+
+4481
+__
+
+LßdP
+(
+r8
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4482
+__
+
+cmpi
+(
+r8
+,
+O³¿nd
+::
+Z\94o
+());
+
+4483
+__
+
+beq
+(&
+nÜm®_£qu\92û
+);
+
+4485 ià(
+ gmode
+ =ð
+DISABLE_ALLOCATION_SITES
+) {
+
+4486
+EËm\92tsK\9ad
+
+\9a\99\9fl
+ =
+G\91In\99\9flFa¡EËm\92tsK\9ad
+();
+
+4487
+EËm\92tsK\9ad
+
+ ghÞey_\9a\99\9fl
+ =
+G\91HÞeyEËm\92tsK\9ad
+(
+\9a\99\9fl
+);
+
+4489
+A¼ayS\9agËArgum\92tCÚ¡ruùÜStub
+
+¡ub_hÞey
+(
+
+4490
+masm
+->
+isީe
+(),
+hÞey_\9a\99\9fl
+,
+DISABLE_ALLOCATION_SITES
+);
+
+4491
+__
+
+Ta\9eC®lStub
+(&
+¡ub_hÞey
+);
+
+4493
+__
+
+b\9ad
+(&
+nÜm®_£qu\92û
+);
+
+4494
+A¼ayS\9agËArgum\92tCÚ¡ruùÜStub
+
+¡ub
+(
+masm
+->
+isީe
+(),
+\9a\99\9fl
+,
+
+4495
+DISABLE_ALLOCATION_SITES
+);
+
+4496
+__
+
+Ta\9eC®lStub
+(&
+¡ub
+);
+
+4497 } \vià(
+ gmode
+ =ð
+DONT_OVERRIDE
+) {
+
+4500
+__
+
+addi
+(
+r6
+,\846,
+O³¿nd
+(1));
+
+4502 ià(
+ gFLAG_debug_code
+) {
+
+4503
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r5
+, 0));
+
+4504
+__
+
+Com·»RoÙ
+(
+r8
+,
+H\97p
+::
+kAÎoÿtiÚS\99eMRoÙIndex
+);
+
+4505
+__
+
+As£¹
+(
+eq
+,
+kEx³ùedAÎoÿtiÚS\99e
+);
+
+4511
+STATIC_ASSERT
+(
+AÎoÿtiÚS\99e
+::
+EËm\92tsK\9adB\99s
+::
+kShiá
+ == 0);
+
+4512
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+AÎoÿtiÚS\99e
+::
+kT¿ns\99iÚInfoOff£t
+));
+
+4513
+__
+
+AddSmiL\99\94®
+(
+r7
+,\847,
+Smi
+::
+FromIÁ
+(
+kFa¡EËm\92tsK\9adPackedToHÞey
+),
+r0
+);
+
+4514
+__
+
+StÜeP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+AÎoÿtiÚS\99e
+::
+kT¿ns\99iÚInfoOff£t
+),
+
+4515
+r0
+);
+
+4517
+__
+
+b\9ad
+(&
+nÜm®_£qu\92û
+);
+
+4518 \12
+ gϡ_\9adex
+ =
+
+4519
+G\91Sequ\92ûIndexFromFa¡EËm\92tsK\9ad
+(
+TERMINAL_FAST_ELEMENTS_KIND
+);
+
+4520 \ f\12
+ gi
+ = 0; i <ð
+Ï¡_\9adex
+; ++i) {
+
+4521
+EËm\92tsK\9ad
+
+ gk\9ad
+ =
+G\91Fa¡EËm\92tsK\9adFromSequ\92ûIndex
+(
+i
+);
+
+4522
+__
+
+mov
+(
+r0
+,
+O³¿nd
+(
+k\9ad
+));
+
+4523
+__
+
+cmp
+(
+r6
+,
+r0
+);
+
+4524
+A¼ayS\9agËArgum\92tCÚ¡ruùÜStub
+
+¡ub
+(
+masm
+->
+isީe
+(),
+k\9ad
+);
+
+4525
+__
+
+Ta\9eC®lStub
+(&
+¡ub
+,
+eq
+);
+
+4529
+__
+
+AbÜt
+(
+kUÃx³ùedEËm\92tsK\9adInA¼ayCÚ¡ruùÜ
+);
+
+4531
+UNREACHABLE
+();
+
+4536
+ g\8bm¶©e
+ <
+þass
+
+ gT
+>
+
+4537 \18\1e
+A¼ayCÚ¡ruùÜStubAh\97dOfTimeH\96³r
+(
+Isީe
+*
+isީe
+) {
+
+4538 \12
+ gto_\9adex
+ =
+
+4539
+G\91Sequ\92ûIndexFromFa¡EËm\92tsK\9ad
+(
+TERMINAL_FAST_ELEMENTS_KIND
+);
+
+4540 \ f\12
+ gi
+ = 0; i <ð
+to_\9adex
+; ++i) {
+
+4541
+EËm\92tsK\9ad
+
+ gk\9ad
+ =
+G\91Fa¡EËm\92tsK\9adFromSequ\92ûIndex
+(
+i
+);
+
+4542
+T
+
+¡ub
+(
+isީe
+,
+k\9ad
+);
+
+4543
+ g¡ub
+.
+G\91Code
+();
+
+4544 ià(
+ gAÎoÿtiÚS\99e
+::
+G\91Mode
+(
+k\9ad
+è!ð
+DONT_TRACK_ALLOCATION_SITE
+) {
+
+4545
+T
+
+¡ub1
+(
+isީe
+,
+k\9ad
+,
+DISABLE_ALLOCATION_SITES
+);
+
+4546
+ g¡ub1
+.
+G\91Code
+();
+
+4552 \1e
+ gA¼ayCÚ¡ruùÜStubBa£
+::
+G\92\94©eStubsAh\97dOfTime
+(
+Isީe
+*
+isީe
+) {
+
+4553
+A¼ayCÚ¡ruùÜStubAh\97dOfTimeH\96³r
+<
+A¼ayNoArgum\92tCÚ¡ruùÜStub
+>(
+
+4554
+isީe
+);
+
+4555
+ gA¼ayCÚ¡ruùÜStubAh\97dOfTimeH\96³r
+<
+ gA¼ayS\9agËArgum\92tCÚ¡ruùÜStub
+>(
+
+4556
+ gisީe
+);
+
+4557
+ gA¼ayCÚ¡ruùÜStubAh\97dOfTimeH\96³r
+<
+ gA¼ayNArgum\92tsCÚ¡ruùÜStub
+>(
+
+4558
+ gisީe
+);
+
+4562 \1e
+ gIÁ\94ÇlA¼ayCÚ¡ruùÜStubBa£
+::
+G\92\94©eStubsAh\97dOfTime
+(
+
+4563
+Isީe
+*
+isީe
+) {
+
+4564
+EËm\92tsK\9ad
+
+k\9ads
+[2] = {
+FAST_ELEMENTS
+,
+FAST_HOLEY_ELEMENTS
+};
+
+4565 \ f\12
+ gi
+ = 0; i < 2; i++) {
+
+4567
+IÁ\94ÇlA¼ayNoArgum\92tCÚ¡ruùÜStub
+
+¡ubh1
+(
+isީe
+,
+k\9ads
+[
+i
+]);
+
+4568
+ g¡ubh1
+.
+G\91Code
+();
+
+4569
+IÁ\94ÇlA¼ayS\9agËArgum\92tCÚ¡ruùÜStub
+
+¡ubh2
+(
+isީe
+,
+k\9ads
+[
+i
+]);
+
+4570
+ g¡ubh2
+.
+G\91Code
+();
+
+4571
+IÁ\94ÇlA¼ayNArgum\92tsCÚ¡ruùÜStub
+
+¡ubh3
+(
+isީe
+,
+k\9ads
+[
+i
+]);
+
+4572
+ g¡ubh3
+.
+G\91Code
+();
+
+4577 \1e
+ gA¼ayCÚ¡ruùÜStub
+::
+G\92\94©eDi¥©chToA¼ayStub
+(
+
+4578
+MaüoAs£mbËr
+*
+masm
+,
+AÎoÿtiÚS\99eOv\94rideMode
+
+mode
+) {
+
+4579 ià(
+¬gum\92t_couÁ
+(è=ð
+ANY
+) {
+
+4580
+Lab\96
+
+nÙ_z\94o_ÿ£
+,
+nÙ_Úe_ÿ£
+;
+
+4581
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+4582
+__
+
+bÃ
+(&
+nÙ_z\94o_ÿ£
+);
+
+4583
+ gC»©eA¼ayDi¥©ch
+<
+ gA¼ayNoArgum\92tCÚ¡ruùÜStub
+>(
+ gmasm
+,
+ gmode
+);
+
+4585
+__
+
+b\9ad
+(&
+nÙ_z\94o_ÿ£
+);
+
+4586
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+(1));
+
+4587
+__
+
+bgt
+(&
+nÙ_Úe_ÿ£
+);
+
+4588
+C»©eA¼ayDi¥©chOÃArgum\92t
+(
+masm
+,
+mode
+);
+
+4590
+__
+
+b\9ad
+(&
+nÙ_Úe_ÿ£
+);
+
+4591
+ gC»©eA¼ayDi¥©ch
+<
+ gA¼ayNArgum\92tsCÚ¡ruùÜStub
+>(
+ gmasm
+,
+ gmode
+);
+
+4592 } \vià(
+¬gum\92t_couÁ
+(è=ð
+NONE
+) {
+
+4593
+C»©eA¼ayDi¥©ch
+<
+A¼ayNoArgum\92tCÚ¡ruùÜStub
+>(
+masm
+,
+mode
+);
+
+4594 } \vià(
+¬gum\92t_couÁ
+(è=ð
+ONE
+) {
+
+4595
+C»©eA¼ayDi¥©chOÃArgum\92t
+(
+masm
+,
+mode
+);
+
+4596 } \vià(
+¬gum\92t_couÁ
+(è=ð
+MORE_THAN_ONE
+) {
+
+4597
+C»©eA¼ayDi¥©ch
+<
+A¼ayNArgum\92tsCÚ¡ruùÜStub
+>(
+masm
+,
+mode
+);
+
+4599
+UNREACHABLE
+();
+
+4604 \1e
+ gA¼ayCÚ¡ruùÜStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+4613 ià(
+FLAG_debug_code
+) {
+
+4618
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kPrÙÙy³OrIn\99\9flMOff£t
+));
+
+4620
+__
+
+Te¡IfSmi
+(
+r7
+,
+r0
+);
+
+4621
+__
+
+As£¹
+(
+Ã
+,
+kUÃx³ùedIn\99\9flMFÜA¼ayFunùiÚ
+,
+ü0
+);
+
+4622
+__
+
+Com·»ObjeùTy³
+(
+r7
+,\847,
+r8
+,
+MAP_TYPE
+);
+
+4623
+__
+
+As£¹
+(
+eq
+,
+kUÃx³ùedIn\99\9flMFÜA¼ayFunùiÚ
+);
+
+4626
+__
+
+As£¹Undef\9aedOrAÎoÿtiÚS\99e
+(
+r5
+,
+r7
+);
+
+4629
+Lab\96
+
+ gno_\9afo
+;
+
+4631
+__
+
+Com·»RoÙ
+(
+r5
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+4632
+__
+
+beq
+(&
+no_\9afo
+);
+
+4634
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+AÎoÿtiÚS\99e
+::
+kT¿ns\99iÚInfoOff£t
+));
+
+4635
+__
+
+SmiUÁag
+(
+r6
+);
+
+4636
+STATIC_ASSERT
+(
+AÎoÿtiÚS\99e
+::
+EËm\92tsK\9adB\99s
+::
+kShiá
+ == 0);
+
+4637
+__
+
+And
+(
+r6
+,\846,
+O³¿nd
+(
+AÎoÿtiÚS\99e
+::
+EËm\92tsK\9adB\99s
+::
+kMask
+));
+
+4638
+G\92\94©eDi¥©chToA¼ayStub
+(
+masm
+,
+DONT_OVERRIDE
+);
+
+4640
+__
+
+b\9ad
+(&
+no_\9afo
+);
+
+4641
+G\92\94©eDi¥©chToA¼ayStub
+(
+masm
+,
+DISABLE_ALLOCATION_SITES
+);
+
+4645 \1e
+ gIÁ\94ÇlA¼ayCÚ¡ruùÜStub
+::
+G\92\94©eCa£
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+4646
+EËm\92tsK\9ad
+
+k\9ad
+) {
+
+4647
+__
+
+cm¶i
+(
+r3
+,
+O³¿nd
+(1));
+
+4649
+IÁ\94ÇlA¼ayNoArgum\92tCÚ¡ruùÜStub
+
+¡ub0
+(
+isީe
+(),
+k\9ad
+);
+
+4650
+__
+
+Ta\9eC®lStub
+(&
+¡ub0
+,
+É
+);
+
+4652
+IÁ\94ÇlA¼ayNArgum\92tsCÚ¡ruùÜStub
+
+¡ubN
+(
+isީe
+(),
+k\9ad
+);
+
+4653
+__
+
+Ta\9eC®lStub
+(&
+¡ubN
+,
+gt
+);
+
+4655 ià(
+IsFa¡PackedEËm\92tsK\9ad
+(
+k\9ad
+)) {
+
+4658
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4659
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+::
+Z\94o
+());
+
+4661
+IÁ\94ÇlA¼ayS\9agËArgum\92tCÚ¡ruùÜStub
+
+¡ub1_hÞey
+(
+
+4662
+isީe
+(),
+G\91HÞeyEËm\92tsK\9ad
+(
+k\9ad
+));
+
+4663
+__
+
+Ta\9eC®lStub
+(&
+¡ub1_hÞey
+,
+Ã
+);
+
+4666
+IÁ\94ÇlA¼ayS\9agËArgum\92tCÚ¡ruùÜStub
+
+¡ub1
+(
+isީe
+(),
+k\9ad
+);
+
+4667
+__
+
+Ta\9eC®lStub
+(&
+¡ub1
+);
+
+4671 \1e
+ gIÁ\94ÇlA¼ayCÚ¡ruùÜStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+4679 ià(
+FLAG_debug_code
+) {
+
+4684
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kPrÙÙy³OrIn\99\9flMOff£t
+));
+
+4686
+__
+
+Te¡IfSmi
+(
+r6
+,
+r0
+);
+
+4687
+__
+
+As£¹
+(
+Ã
+,
+kUÃx³ùedIn\99\9flMFÜA¼ayFunùiÚ
+,
+ü0
+);
+
+4688
+__
+
+Com·»ObjeùTy³
+(
+r6
+,\846,
+r7
+,
+MAP_TYPE
+);
+
+4689
+__
+
+As£¹
+(
+eq
+,
+kUÃx³ùedIn\99\9flMFÜA¼ayFunùiÚ
+);
+
+4693
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kPrÙÙy³OrIn\99\9flMOff£t
+));
+
+4695
+__
+
+lbz
+(
+r6
+,
+F\9bldMemO³¿nd
+Ô6,
+M
+::
+kB\99F\9bld2Off£t
+));
+
+4697
+__
+
+ gDecodeF\9bld
+<
+ gM
+::
+EËm\92tsK\9adB\99s
+>(
+r6
+);
+
+4699 ià(
+ gFLAG_debug_code
+) {
+
+4700
+Lab\96
+
+ gdÚe
+;
+
+4701
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+(
+FAST_ELEMENTS
+));
+
+4702
+__
+
+beq
+(&
+dÚe
+);
+
+4703
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+(
+FAST_HOLEY_ELEMENTS
+));
+
+4704
+__
+
+As£¹
+(
+eq
+,
+kInv®idEËm\92tsK\9adFÜIÁ\94ÇlA¼ayOrIÁ\94ÇlPackedA¼ay
+);
+
+4705
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4708
+Lab\96
+
+ gç¡_\96em\92ts_ÿ£
+;
+
+4709
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+(
+FAST_ELEMENTS
+));
+
+4710
+__
+
+beq
+(&
+ç¡_\96em\92ts_ÿ£
+);
+
+4711
+G\92\94©eCa£
+(
+masm
+,
+FAST_HOLEY_ELEMENTS
+);
+
+4713
+__
+
+b\9ad
+(&
+ç¡_\96em\92ts_ÿ£
+);
+
+4714
+G\92\94©eCa£
+(
+masm
+,
+FAST_ELEMENTS
+);
+
+4718 \1e
+ gC®lApiFunùiÚStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+4732
+Regi¡\94
+
+ÿÎ\93
+ =
+r3
+;
+
+4733
+Regi¡\94
+
+ gÿÎ_d©a
+ =
+r7
+;
+
+4734
+Regi¡\94
+
+ ghÞd\94
+ =
+r5
+;
+
+4735
+Regi¡\94
+
+ gi_funùiÚ_add»ss
+ =
+r4
+;
+
+4736
+Regi¡\94
+
+ gcڋxt
+ =
+ý
+;
+
+4738 \12
+ g¬gc
+ =
+this
+->
+¬gc
+();
+
+4739
+boÞ
+
+ gis_¡Üe
+ =
+this
+->
+is_¡Üe
+();
+
+4740
+boÞ
+
+ gÿÎ_d©a_undef\9aed
+ =
+this
+->
+ÿÎ_d©a_undef\9aed
+();
+
+4742 \e
+FunùiÚC®lbackArgum\92ts
+
+ tFCA
+;
+
+4744
+STATIC_ASSERT
+(
+FCA
+::
+kCڋxtSaveIndex
+ == 6);
+
+4745
+STATIC_ASSERT
+(
+FCA
+::
+kC®ËeIndex
+ == 5);
+
+4746
+STATIC_ASSERT
+(
+FCA
+::
+kD©aIndex
+ == 4);
+
+4747
+STATIC_ASSERT
+(
+FCA
+::
+kR\91uºV®ueOff£t
+ == 3);
+
+4748
+STATIC_ASSERT
+(
+FCA
+::
+kR\91uºV®ueDeçuÉV®ueIndex
+ == 2);
+
+4749
+STATIC_ASSERT
+(
+FCA
+::
+kIsީeIndex
+ == 1);
+
+4750
+STATIC_ASSERT
+(
+FCA
+::
+kHÞd\94Index
+ == 0);
+
+4751
+STATIC_ASSERT
+(
+FCA
+::
+kArgsL\92gth
+ == 7);
+
+4754
+__
+
+push
+(
+cڋxt
+);
+
+4756
+__
+
+LßdP
+(
+cڋxt
+,
+F\9bldMemO³¿nd
+(
+ÿÎ\93
+,
+JSFunùiÚ
+::
+kCÚ\8bxtOff£t
+));
+
+4759
+__
+
+push
+(
+ÿÎ\93
+);
+
+4762
+__
+
+push
+(
+ÿÎ_d©a
+);
+
+4764
+Regi¡\94
+
+ gsü©ch
+ =
+ÿÎ_d©a
+;
+
+4765 ià(!
+ gÿÎ_d©a_undef\9aed
+) {
+
+4766
+__
+
+LßdRoÙ
+(
+sü©ch
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+4769
+__
+
+push
+(
+sü©ch
+);
+
+4771
+__
+
+push
+(
+sü©ch
+);
+
+4773
+__
+
+mov
+(
+sü©ch
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+isީe
+())));
+
+4774
+__
+
+push
+(
+sü©ch
+);
+
+4776
+__
+
+push
+(
+hÞd\94
+);
+
+4779
+__
+
+mr
+(
+sü©ch
+,
+¥
+);
+
+4788 cڡ \12
+ gkApiS\8fckS·û
+ = 5;
+
+4790
+F¿meScÝe
+
+äame_scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+MANUAL
+);
+
+4791
+__
+
+EÁ\94Ex\99F¿me
+(
+çl£
+,
+kApiS\8fckS·û
+);
+
+4793
+DCHECK
+(!
+i_funùiÚ_add»ss
+.
+is
+(
+r3
+è&& !
+sü©ch
+.is(r3));
+
+4796
+__
+
+addi
+(
+r3
+,
+¥
+,
+O³¿nd
+((
+kS\8fckF¿meEx\8caP¬amSlÙ
+ + 1è*
+kPo\9a\8brSize
+));
+
+4798
+__
+
+StÜeP
+(
+sü©ch
+,
+MemO³¿nd
+(
+r3
+, 0 *
+kPo\9a\8brSize
+));
+
+4800
+__
+
+addi
+(
+\9d
+,
+sü©ch
+,
+O³¿nd
+((
+FCA
+::
+kArgsL\92gth
+ - 1 +
+¬gc
+è*
+kPo\9a\8brSize
+));
+
+4801
+__
+
+StÜeP
+(
+\9d
+,
+MemO³¿nd
+(
+r3
+, 1 *
+kPo\9a\8brSize
+));
+
+4803
+__
+
+li
+(
+\9d
+,
+O³¿nd
+(
+¬gc
+));
+
+4804
+__
+
+¡w
+(
+\9d
+,
+MemO³¿nd
+(
+r3
+, 2 *
+kPo\9a\8brSize
+));
+
+4806
+__
+
+li
+(
+\9d
+,
+O³¿nd
+::
+Z\94o
+());
+
+4807
+__
+
+¡w
+(
+\9d
+,
+MemO³¿nd
+(
+r3
+, 2 *
+kPo\9a\8brSize
+ +
+kIÁSize
+));
+
+4809 cڡ \12
+ gkS\8fckUnw\9adS·û
+ =
+¬gc
+ +
+FCA
+::
+kArgsL\92gth
+ + 1;
+
+4810
+Ex\8bº®Reã»nû
+
+ gthunk_»f
+ =
+
+4811
+Ex\8bº®Reã»nû
+::
+\9avoke_funùiÚ_ÿÎback
+(
+isީe
+());
+
+4813
+AÎowEx\8bº®C®lTh©CªtCau£GC
+
+scÝe
+(
+masm
+);
+
+4814
+MemO³¿nd
+
+cÚ\8bxt_»¡Üe_Ý\94ªd
+(
+
+4815
+å
+, (2 +
+FCA
+::
+kCڋxtSaveIndex
+è*
+kPo\9a\8brSize
+);
+
+4817 \12
+ g»tuº_v®ue_off£t
+ = 0;
+
+4818 ià(
+ gis_¡Üe
+) {
+
+4819
+ g»tuº_v®ue_off£t
+ = 2 +
+FCA
+::
+kArgsL\92gth
+;
+
+4821
+ g»tuº_v®ue_off£t
+ = 2 +
+FCA
+::
+kR\91uºV®ueOff£t
+;
+
+4823
+MemO³¿nd
+
+»tuº_v®ue_Ý\94ªd
+(
+å
+,
+»tuº_v®ue_off£t
+ *
+kPo\9a\8brSize
+);
+
+4825
+__
+
+C®lApiFunùiÚAndR\91uº
+(
+i_funùiÚ_add»ss
+,
+thunk_»f
+,
+
+4826
+kS\8fckUnw\9adS·û
+,
+»tuº_v®ue_Ý\94ªd
+,
+
+4827 &
+cÚ\8bxt_»¡Üe_Ý\94ªd
+);
+
+4831 \1e
+ gC®lApiG\91\8brStub
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+4839
+Regi¡\94
+
+i_funùiÚ_add»ss
+ =
+ApiG\91\8brDesü\9dtÜ
+::
+funùiÚ_add»ss
+();
+
+4840
+DCHECK
+(
+i_funùiÚ_add»ss
+.
+is
+(
+r5
+));
+
+4842
+__
+
+mr
+(
+r3
+,
+¥
+);
+
+4843
+__
+
+addi
+(
+r4
+,
+r3
+,
+O³¿nd
+(1 *
+kPo\9a\8brSize
+));
+
+4857 #ià
+ABI_PASSES_HANDLES_IN_REGS
+
+
+4858 cڡ \12
+ gkAcûssÜInfoSlÙ
+ =
+kS\8fckF¿meEx\8caP¬amSlÙ
+ + 1;
+
+4859 cڡ \12
+ gkApiS\8fckS·û
+ = 2;
+
+4861 cڡ \12
+ gkArg0SlÙ
+ =
+kS\8fckF¿meEx\8caP¬amSlÙ
+ + 1;
+
+4862 cڡ \12
+ gkAcûssÜInfoSlÙ
+ =
+kArg0SlÙ
+ + 1;
+
+4863 cڡ \12
+ gkApiS\8fckS·û
+ = 3;
+
+4866
+F¿meScÝe
+
+äame_scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+MANUAL
+);
+
+4867
+__
+
+EÁ\94Ex\99F¿me
+(
+çl£
+,
+kApiS\8fckS·û
+);
+
+4869 #ià!
+ABI_PASSES_HANDLES_IN_REGS
+
+
+4871
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kArg0SlÙ
+ *
+kPo\9a\8brSize
+));
+
+4872
+__
+
+addi
+(
+r3
+,
+¥
+,
+O³¿nd
+(
+kArg0SlÙ
+ *
+kPo\9a\8brSize
+));
+
+4877
+__
+
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+,
+kAcûssÜInfoSlÙ
+ *
+kPo\9a\8brSize
+));
+
+4879
+__
+
+addi
+(
+r4
+,
+¥
+,
+O³¿nd
+(
+kAcûssÜInfoSlÙ
+ *
+kPo\9a\8brSize
+));
+
+4881 cڡ \12
+ gkS\8fckUnw\9adS·û
+ =
+PrÝ\94tyC®lbackArgum\92ts
+::
+kArgsL\92gth
+ + 1;
+
+4883
+Ex\8bº®Reã»nû
+
+ gthunk_»f
+ =
+
+4884
+Ex\8bº®Reã»nû
+::
+\9avoke_acûssÜ_g\91\8br_ÿÎback
+(
+isީe
+());
+
+4885
+__
+
+C®lApiFunùiÚAndR\91uº
+(
+i_funùiÚ_add»ss
+,
+thunk_»f
+,
+
+4886
+kS\8fckUnw\9adS·û
+,
+
+4887
+MemO³¿nd
+(
+å
+, 6 *
+kPo\9a\8brSize
+),
+NULL
+);
+
+4891 #undeà
+__
+
+
+ @code-stubs-ppc.h
+
+5 #iâdeà
+V8_PPC_CODE_STUBS_PPC_H_
+
+
+6 \ 1
+ #V8_PPC_CODE_STUBS_PPC_H_
+
+
+ )
+
+8
+Çme¥aû
+
+ gv8
+ {
+
+9
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+12 \1e
+A¼ayN©iveCode
+(
+MaüoAs£mbËr
+*
+masm
+,
+Lab\96
+*
+ÿÎ_g\92\94ic_code
+);
+
+15 þas
+ cS\8c\9agH\96³r
+ :
+public
+
+AÎS\8ftic
+ {
+
+16
+public
+:
+
+21 \18\1e
+G\92\94©eCÝyCh¬aù\94s
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+de¡
+,
+
+22
+Regi¡\94
+
+¤c
+, Regi¡\94
+couÁ
+,
+
+23
+Regi¡\94
+
+sü©ch
+,
+
+24
+S\8c\9ag
+::
+Encod\9ag
+
+\92cod\9ag
+);
+
+27 \18\1e
+G\92\94©eCom·»FÏtOÃBy\8bS\8c\9ags
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+28
+Regi¡\94
+
+Ëá
+, Regi¡\94
+right
+,
+
+29
+Regi¡\94
+
+sü©ch1
+,
+
+30
+Regi¡\94
+
+sü©ch2
+,
+
+31
+Regi¡\94
+
+sü©ch3
+);
+
+34 \18\1e
+G\92\94©eFÏtOÃBy\8bS\8c\9agEqu®s
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+35
+Regi¡\94
+
+Ëá
+, Regi¡\94
+right
+,
+
+36
+Regi¡\94
+
+sü©ch1
+,
+
+37
+Regi¡\94
+
+sü©ch2
+);
+
+39
+ g´iv©e
+:
+
+40 \18\1e
+G\92\94©eOÃBy\8bCh¬sCom·»LoÝ
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+41
+Regi¡\94
+
+Ëá
+, Regi¡\94
+right
+,
+
+42
+Regi¡\94
+
+Ëngth
+,
+
+43
+Regi¡\94
+
+sü©ch1
+,
+
+44
+Lab\96
+*
+ch¬s_nÙ_equ®
+);
+
+46
+DISALLOW_IMPLICIT_CONSTRUCTORS
+(
+S\8c\9agH\96³r
+);
+
+50 þas
+ cStÜeRegi¡\94sS\8f\8bStub
+ :
+public
+
+PÏtfÜmCodeStub
+ {
+
+51
+public
+:
+
+52
+ex¶ic\99
+
+StÜeRegi¡\94sS\8f\8bStub
+(
+Isީe
+*
+isީe
+)
+
+53 :
+PÏtfÜmCodeStub
+(
+isީe
+) {}
+
+55 \18\1e
+G\92\94©eAh\97dOfTime
+(
+Isީe
+*
+isީe
+);
+
+57
+ g´iv©e
+:
+
+58
+DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR
+();
+
+59
+DEFINE_PLATFORM_CODE_STUB
+(
+StÜeRegi¡\94sS\8f\8b
+,
+PÏtfÜmCodeStub
+);
+
+63 þas
+ cRe¡ÜeRegi¡\94sS\8f\8bStub
+ :
+public
+
+PÏtfÜmCodeStub
+ {
+
+64
+public
+:
+
+65
+ex¶ic\99
+
+Re¡ÜeRegi¡\94sS\8f\8bStub
+(
+Isީe
+*
+isީe
+)
+
+66 :
+PÏtfÜmCodeStub
+(
+isީe
+) {}
+
+68 \18\1e
+G\92\94©eAh\97dOfTime
+(
+Isީe
+*
+isީe
+);
+
+70
+ g´iv©e
+:
+
+71
+DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR
+();
+
+72
+DEFINE_PLATFORM_CODE_STUB
+(
+Re¡ÜeRegi¡\94sS\8f\8b
+,
+PÏtfÜmCodeStub
+);
+
+76 þas
+ cRecÜdWr\99eStub
+ :
+public
+
+PÏtfÜmCodeStub
+ {
+
+77
+public
+:
+
+78
+RecÜdWr\99eStub
+(
+Isީe
+*
+isީe
+,
+Regi¡\94
+
+objeù
+, Regi¡\94
+v®ue
+,
+
+79
+Regi¡\94
+
+add»ss
+,
+Rememb\94edS\91AùiÚ
+
+»memb\94ed_£t_aùiÚ
+,
+
+80
+SaveFPRegsMode
+
+å_mode
+)
+
+81 :
+PÏtfÜmCodeStub
+(
+isީe
+),
+
+82
+»gs_
+(
+objeù
+,
+
+83
+add»ss
+,
+
+84
+v®ue
+) {
+
+85
+ gm\9aÜ_key_
+ =
+ObjeùB\99s
+::
+\92code
+(
+objeù
+.
+code
+()) |
+
+86
+V®ueB\99s
+::
+\92code
+(
+v®ue
+.
+code
+()) |
+
+87
+Add»ssB\99s
+::
+\92code
+(
+add»ss
+.
+code
+()) |
+
+88
+Rememb\94edS\91AùiÚB\99s
+::
+\92code
+(
+»memb\94ed_£t_aùiÚ
+) |
+
+89
+SaveFPRegsModeB\99s
+::
+\92code
+(
+å_mode
+);
+
+92
+RecÜdWr\99eStub
+(
+u\9at32_t
+
+key
+,
+Isީe
+*
+isީe
+)
+
+93 :
+PÏtfÜmCodeStub
+(
+key
+,
+isީe
+),
+»gs_
+(
+objeù
+(),
+add»ss
+(),
+v®ue
+()) {}
+
+95 \f
+ eMode
+ {
+ gSTORE_BUFFER_ONLY
+,
+ gINCREMENTAL
+,
+ gINCREMENTAL_COMPACTION
+ };
+
+97
+v\9ctu®
+
+boÞ
+
+Som\91imesS\91sUpAF¿me
+(è{ \15
+ gçl£
+; }
+
+99 \18\1e
+P©chB¿nchIÁoNÝ
+(
+MaüoAs£mbËr
+*
+masm
+, \12
+pos
+) {
+
+100
+ gmasm
+->
+\9a¡r_©_put
+(
+pos
+, (
+masm
+->
+\9a¡r_©
+Õosè& ~
+kBOf\9bldMask
+è|
+BT
+);
+
+104 \18\1e
+P©chNÝIÁoB¿nch
+(
+MaüoAs£mbËr
+*
+masm
+, \12
+pos
+) {
+
+105
+ gmasm
+->
+\9a¡r_©_put
+(
+pos
+, (
+masm
+->
+\9a¡r_©
+Õosè& ~
+kBOf\9bldMask
+è|
+BF
+);
+
+109 \18
+Mode
+
+G\91Mode
+(
+Code
+*
+¡ub
+) {
+
+110
+In¡r
+
+ gf\9c¡_\9a¡ruùiÚ
+ =
+
+111
+As£mbËr
+::
+\9a¡r_©
+(
+¡ub
+->
+\9a¡ruùiÚ_¡¬t
+(è+ As£mbËr::
+kIn¡rSize
+);
+
+112
+In¡r
+
+ g£cÚd_\9a¡ruùiÚ
+ =
+As£mbËr
+::
+\9a¡r_©
+(
+¡ub
+->
+\9a¡ruùiÚ_¡¬t
+() +
+
+113 (
+As£mbËr
+::
+kIn¡rSize
+ * 2));
+
+115 ià(
+ gBF
+ =ð(
+f\9c¡_\9a¡ruùiÚ
+ &
+kBOf\9bldMask
+)) {
+
+116 \15
+INCREMENTAL
+;
+
+121 ià(
+ gBF
+ =ð(
+£cÚd_\9a¡ruùiÚ
+ &
+kBOf\9bldMask
+)) {
+
+122 \15
+INCREMENTAL_COMPACTION
+;
+
+127 \15
+ gSTORE_BUFFER_ONLY
+;
+
+130 \18\1e
+P©ch
+(
+Code
+*
+¡ub
+,
+Mode
+
+mode
+) {
+
+131
+MaüoAs£mbËr
+
+masm
+(
+NULL
+,
+¡ub
+->
+\9a¡ruùiÚ_¡¬t
+(),
+
+132
+¡ub
+->
+\9a¡ruùiÚ_size
+());
+
+133 \1a
+ gmode
+) {
+
+134 \ 4
+ gSTORE_BUFFER_ONLY
+:
+
+135
+DCHECK
+(
+G\91Mode
+(
+¡ub
+è=ð
+INCREMENTAL
+ ||
+
+136
+G\91Mode
+(
+¡ub
+è=ð
+INCREMENTAL_COMPACTION
+);
+
+138
+P©chB¿nchIÁoNÝ
+(&
+masm
+,
+As£mbËr
+::
+kIn¡rSize
+);
+
+139
+P©chB¿nchIÁoNÝ
+(&
+masm
+,
+As£mbËr
+::
+kIn¡rSize
+ * 2);
+
+141 \ 4
+ gINCREMENTAL
+:
+
+142
+DCHECK
+(
+G\91Mode
+(
+¡ub
+è=ð
+STORE_BUFFER_ONLY
+);
+
+143
+P©chNÝIÁoB¿nch
+(&
+masm
+,
+As£mbËr
+::
+kIn¡rSize
+);
+
+145 \ 4
+ gINCREMENTAL_COMPACTION
+:
+
+146
+DCHECK
+(
+G\91Mode
+(
+¡ub
+è=ð
+STORE_BUFFER_ONLY
+);
+
+147
+P©chNÝIÁoB¿nch
+(&
+masm
+,
+As£mbËr
+::
+kIn¡rSize
+ * 2);
+
+150
+DCHECK
+(
+G\91Mode
+(
+¡ub
+è=ð
+mode
+);
+
+151
+ gCpuF\97tu»s
+::
+FlushICache
+(
+¡ub
+->
+\9a¡ruùiÚ_¡¬t
+(è+
+As£mbËr
+::
+kIn¡rSize
+,
+
+152 2 *
+As£mbËr
+::
+kIn¡rSize
+);
+
+155
+DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR
+();
+
+157
+ g´iv©e
+:
+
+161 þas
+ cRegi¡\94AÎoÿtiÚ
+ {
+
+162
+public
+:
+
+163
+Regi¡\94AÎoÿtiÚ
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+add»ss
+, Regi¡\94
+sü©ch0
+)
+
+164 :
+objeù_
+(
+objeù
+),
+add»ss_
+(
+add»ss
+),
+sü©ch0_
+(
+sü©ch0
+) {
+
+165
+DCHECK
+(!
+A»Al\9f£d
+(
+sü©ch0
+,
+objeù
+,
+add»ss
+,
+no_»g
+));
+
+166
+ gsü©ch1_
+ =
+G\91Regi¡\94Th©IsNÙOÃOf
+(
+objeù_
+,
+add»ss_
+,
+sü©ch0_
+);
+
+169 \1e
+Save
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+170
+DCHECK
+(!
+A»Al\9f£d
+(
+objeù_
+,
+add»ss_
+,
+sü©ch1_
+,
+sü©ch0_
+));
+
+173
+ gmasm
+->
+push
+(
+sü©ch1_
+);
+
+176 \1e
+Re¡Üe
+(
+MaüoAs£mbËr
+*
+masm
+è{
+ gmasm
+->
+pÝ
+(
+sü©ch1_
+); }
+
+181 \1e
+SaveC®ËrSaveRegi¡\94s
+(
+MaüoAs£mbËr
+*
+masm
+,
+SaveFPRegsMode
+
+mode
+) {
+
+182
+ gmasm
+->
+mær
+(
+r0
+);
+
+183
+ gmasm
+->
+push
+(
+r0
+);
+
+184
+ gmasm
+->
+MuÉiPush
+(
+kJSC®ËrSaved
+ & ~
+sü©ch1_
+.
+b\99
+());
+
+185 ià(
+ gmode
+ =ð
+kSaveFPRegs
+) {
+
+187
+masm
+->
+SaveFPRegs
+(
+¥
+, 1,
+DoubËRegi¡\94
+::
+kNumVÞ©\9eeRegi¡\94s
+ - 1);
+
+191
+\9al\9ae
+ \1e
+Re¡ÜeC®ËrSaveRegi¡\94s
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+192
+SaveFPRegsMode
+
+mode
+) {
+
+193 ià(
+ gmode
+ =ð
+kSaveFPRegs
+) {
+
+195
+masm
+->
+Re¡ÜeFPRegs
+(
+¥
+, 1,
+DoubËRegi¡\94
+::
+kNumVÞ©\9eeRegi¡\94s
+ - 1);
+
+197
+ gmasm
+->
+MuÉiPÝ
+(
+kJSC®ËrSaved
+ & ~
+sü©ch1_
+.
+b\99
+());
+
+198
+ gmasm
+->
+pÝ
+(
+r0
+);
+
+199
+ gmasm
+->
+m\8er
+(
+r0
+);
+
+202
+\9al\9ae
+
+Regi¡\94
+
+objeù
+(è{ \15
+ gobjeù_
+; }
+
+203
+\9al\9ae
+
+Regi¡\94
+
+add»ss
+(è{ \15
+ gadd»ss_
+; }
+
+204
+\9al\9ae
+
+Regi¡\94
+
+sü©ch0
+(è{ \15
+ gsü©ch0_
+; }
+
+205
+\9al\9ae
+
+Regi¡\94
+
+sü©ch1
+(è{ \15
+ gsü©ch1_
+; }
+
+207
+ g´iv©e
+:
+
+208
+Regi¡\94
+
+objeù_
+;
+
+209
+Regi¡\94
+
+ gadd»ss_
+;
+
+210
+Regi¡\94
+
+ gsü©ch0_
+;
+
+211
+Regi¡\94
+
+ gsü©ch1_
+;
+
+213
+ä\9bnd
+
+þass
+
+ gRecÜdWr\99eStub
+;
+
+216 \f
+ eOnNoN\93dToInfÜmInüem\92\8flM¬k\94
+ {
+
+217
+ gkR\91uºOnNoN\93dToInfÜmInüem\92\8flM¬k\94
+,
+
+218
+ gkUpd©eRememb\94edS\91OnNoN\93dToInfÜmInüem\92\8flM¬k\94
+
+
+221
+v\9ctu®
+
+\9al\9ae
+
+MajÜ
+
+MajÜKey
+(ècÚ¡
+FINAL
+
+ gOVERRIDE
+ { \15
+ gRecÜdWr\99e
+; }
+
+223
+v\9ctu®
+ \1e
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+è
+ gOVERRIDE
+;
+
+224 \1e
+G\92\94©eInüem\92\8fl
+(
+MaüoAs£mbËr
+*
+masm
+,
+Mode
+
+mode
+);
+
+225 \1e
+CheckN\93dsToInfÜmInüem\92\8flM¬k\94
+(
+
+226
+MaüoAs£mbËr
+*
+masm
+,
+OnNoN\93dToInfÜmInüem\92\8flM¬k\94
+
+Ú_no_Ãed
+,
+
+227
+Mode
+
+mode
+);
+
+228 \1e
+InfÜmInüem\92\8flM¬k\94
+(
+MaüoAs£mbËr
+*
+masm
+);
+
+230 \1e
+Aùiv©e
+(
+Code
+*
+code
+) {
+
+231
+ gcode
+->
+G\91H\97p
+()->
+\9aüem\92\8fl_m¬k\9ag
+()->
+Aùiv©eG\92\94©edStub
+(
+code
+);
+
+234
+Regi¡\94
+
+objeù
+() const {
+
+235 \15
+ gRegi¡\94
+::
+äom_code
+(
+ObjeùB\99s
+::
+decode
+(
+m\9aÜ_key_
+));
+
+238
+Regi¡\94
+
+v®ue
+() const {
+
+239 \15
+ gRegi¡\94
+::
+äom_code
+(
+V®ueB\99s
+::
+decode
+(
+m\9aÜ_key_
+));
+
+242
+Regi¡\94
+
+add»ss
+() const {
+
+243 \15
+ gRegi¡\94
+::
+äom_code
+(
+Add»ssB\99s
+::
+decode
+(
+m\9aÜ_key_
+));
+
+246
+Rememb\94edS\91AùiÚ
+
+»memb\94ed_£t_aùiÚ
+() const {
+
+247 \15
+ gRememb\94edS\91AùiÚB\99s
+::
+decode
+(
+m\9aÜ_key_
+);
+
+250
+SaveFPRegsMode
+
+§ve_å_»gs_mode
+() const {
+
+251 \15
+ gSaveFPRegsModeB\99s
+::
+decode
+(
+m\9aÜ_key_
+);
+
+254
+þass
+
+ gObjeùB\99s
+ :
+public
+
+B\99F\9bld
+<\12, 0, 5> {};
+
+255
+þass
+
+ gV®ueB\99s
+ :
+public
+
+B\99F\9bld
+<\12, 5, 5> {};
+
+256
+þass
+
+ gAdd»ssB\99s
+ :
+public
+
+B\99F\9bld
+<\12, 10, 5> {};
+
+257
+þass
+
+ gRememb\94edS\91AùiÚB\99s
+ :
+public
+
+B\99F\9bld
+<
+Rememb\94edS\91AùiÚ
+, 15, 1> {
+
+259
+þass
+
+ gSaveFPRegsModeB\99s
+ :
+public
+
+B\99F\9bld
+<
+SaveFPRegsMode
+, 16, 1> {};
+
+261
+Lab\96
+
+ g¦ow_
+;
+
+262
+Regi¡\94AÎoÿtiÚ
+
+ g»gs_
+;
+
+264
+DISALLOW_COPY_AND_ASSIGN
+(
+RecÜdWr\99eStub
+);
+
+273 þas
+ cD\9ceùCEÁryStub
+ :
+public
+
+PÏtfÜmCodeStub
+ {
+
+274
+public
+:
+
+275
+ex¶ic\99
+
+D\9ceùCEÁryStub
+(
+Isީe
+*
+isީe
+è:
+PÏtfÜmCodeStub
+(isolate) {}
+
+276 \1e
+G\92\94©eC®l
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+\8frg\91
+);
+
+278
+ g´iv©e
+:
+
+279
+boÞ
+
+N\93dsImmovabËCode
+(è{ \15
+\8cue
+; }
+
+281
+DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR
+();
+
+282
+DEFINE_PLATFORM_CODE_STUB
+(
+D\9ceùCEÁry
+,
+PÏtfÜmCodeStub
+);
+
+286 þas
+ cNameDiùiÚ¬yLookupStub
+ :
+public
+
+PÏtfÜmCodeStub
+ {
+
+287
+public
+:
+
+288 \f
+ eLookupMode
+ {
+POSITIVE_LOOKUP
+,
+ gNEGATIVE_LOOKUP
+ };
+
+290
+NameDiùiÚ¬yLookupStub
+(
+Isީe
+*
+isީe
+,
+LookupMode
+
+mode
+)
+
+291 :
+PÏtfÜmCodeStub
+(
+isީe
+) {
+
+292
+m\9aÜ_key_
+ =
+LookupModeB\99s
+::
+\92code
+(
+mode
+);
+
+295 \18\1e
+G\92\94©eNeg©iveLookup
+(
+MaüoAs£mbËr
+*
+masm
+,
+Lab\96
+*
+miss
+,
+
+296
+Lab\96
+*
+dÚe
+,
+Regi¡\94
+
+»ûiv\94
+,
+
+297
+Regi¡\94
+
+´Ý\94t\9bs
+,
+HªdË
+<
+Name
+>
+Çme
+,
+
+298
+Regi¡\94
+
+sü©ch0
+);
+
+300 \18\1e
+G\92\94©ePos\99iveLookup
+(
+MaüoAs£mbËr
+*
+masm
+,
+Lab\96
+*
+miss
+,
+
+301
+Lab\96
+*
+dÚe
+,
+Regi¡\94
+
+\96em\92ts
+,
+
+302
+Regi¡\94
+
+Çme
+, Regi¡\94
+r0
+, Regi¡\94
+r1
+);
+
+304
+v\9ctu®
+
+boÞ
+
+Som\91imesS\91sUpAF¿me
+(è{ \15
+ gçl£
+; }
+
+306
+ g´iv©e
+:
+
+307 \18cڡ \12
+kIƚedProbes
+ = 4;
+
+308 \18cڡ \12
+ gkTٮProbes
+ = 20;
+
+310 \18cڡ \12
+ gkCac\99yOff£t
+ =
+
+311
+NameDiùiÚ¬y
+::
+kH\97d\94Size
+ +
+
+312
+NameDiùiÚ¬y
+::
+kCac\99yIndex
+ *
+kPo\9a\8brSize
+;
+
+314 \18cڡ \12
+ gkEËm\92tsS\8f¹Off£t
+ =
+
+315
+NameDiùiÚ¬y
+::
+kH\97d\94Size
+ +
+
+316
+NameDiùiÚ¬y
+::
+kEËm\92tsS\8f¹Index
+ *
+kPo\9a\8brSize
+;
+
+318
+LookupMode
+
+mode
+(ècÚ¡ { \15
+ gLookupModeB\99s
+::
+decode
+(
+m\9aÜ_key_
+); }
+
+320
+þass
+
+ gLookupModeB\99s
+ :
+public
+
+B\99F\9bld
+<
+LookupMode
+, 0, 1> {};
+
+322
+DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR
+();
+
+323
+DEFINE_PLATFORM_CODE_STUB
+(
+NameDiùiÚ¬yLookup
+,
+PÏtfÜmCodeStub
+);
+
+ @codegen-ppc.cc
+
+5 \ 2
+ ~"¤c/v8.h
+"
+
+7 #ià
+V8_TARGET_ARCH_PPC
+
+
+9 \ 2
+ ~"¤c/codeg\92.h
+"
+
+10 \ 2
+ ~"¤c/maüo-as£mbËr.h
+"
+
+11 \ 2
+ ~"¤c/µc/simuÏtÜ-µc.h
+"
+
+13
+Çme¥aû
+
+ gv8
+ {
+
+14
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+17 \ 1
+ #__
+
+masm
+.
+
+ )
+
+20 #ià
+def\9aed
+(
+USE_SIMULATOR
+)
+
+21
+by\8b
+*
+ gç¡_exp_µc_mach\9ae_code
+ =
+NULL
+;
+
+22 \b
+ç¡_exp_simuÏtÜ
+(\b
+x
+) {
+
+23 \15
+ gSimuÏtÜ
+::
+cu¼\92t
+(
+Isީe
+::
+Cu¼\92t
+())
+
+24 ->
+C®lFPR\91uºsDoubË
+(
+ç¡_exp_µc_mach\9ae_code
+,
+x
+, 0);
+
+29
+UÇryM©hFunùiÚ
+
+C»©eExpFunùiÚ
+() {
+
+30 ià(!
+ gFLAG_ç¡_m©h
+è\15 &
+ g¡d
+::
+exp
+;
+
+31
+size_t
+
+ gaùu®_size
+;
+
+32
+by\8b
+*
+ gbufãr
+ =
+
+33
+¡©ic_ÿ¡
+<
+by\8b
+*>(
+ba£
+::
+OS
+::
+AÎoÿ\8b
+(1 *
+KB
+, &
+aùu®_size
+,
+\8cue
+));
+
+34 ià(
+ gbufãr
+ =ð
+NULL
+è\15 &
+¡d
+::
+exp
+;
+
+35
+ gEx\8bº®Reã»nû
+::
+In\99\9flizeM©hExpD©a
+();
+
+37
+MaüoAs£mbËr
+
+masm
+(
+NULL
+,
+bufãr
+,
+¡©ic_ÿ¡
+<\12>(
+aùu®_size
+));
+
+40
+DoubËRegi¡\94
+
+ g\9aput
+ =
+d1
+;
+
+41
+DoubËRegi¡\94
+
+ g»suÉ
+ =
+d2
+;
+
+42
+DoubËRegi¡\94
+
+ gdoubË_sü©ch1
+ =
+d3
+;
+
+43
+DoubËRegi¡\94
+
+ gdoubË_sü©ch2
+ =
+d4
+;
+
+44
+Regi¡\94
+
+ g\8bmp1
+ =
+r7
+;
+
+45
+Regi¡\94
+
+ g\8bmp2
+ =
+r8
+;
+
+46
+Regi¡\94
+
+ g\8bmp3
+ =
+r9
+;
+
+49 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+
+
+50
+__
+
+funùiÚ_desü\9dtÜ
+();
+
+53
+__
+
+Push
+(
+\8bmp3
+,
+\8bmp2
+,
+\8bmp1
+);
+
+54
+ gM©hExpG\92\94©Ü
+::
+Em\99M©hExp
+(&
+masm
+,
+\9aput
+,
+»suÉ
+,
+doubË_sü©ch1
+,
+
+55
+doubË_sü©ch2
+,
+\8bmp1
+,
+\8bmp2
+,
+\8bmp3
+);
+
+56
+__
+
+PÝ
+(
+\8bmp3
+,
+\8bmp2
+,
+\8bmp1
+);
+
+57
+__
+
+fmr
+(
+d1
+,
+»suÉ
+);
+
+58
+__
+
+R\91
+();
+
+61
+CodeDesc
+
+ gdesc
+;
+
+62
+ gmasm
+.
+G\91Code
+(&
+desc
+);
+
+63 #ià!
+ABI_USES_FUNCTION_DESCRIPTORS
+
+
+64
+DCHECK
+(!
+R\96ocInfo
+::
+Requ\9cesR\96oÿtiÚ
+(
+desc
+));
+
+67
+ gCpuF\97tu»s
+::
+FlushICache
+(
+bufãr
+,
+aùu®_size
+);
+
+68
+ gba£
+::
+OS
+::
+PrÙeùCode
+(
+bufãr
+,
+aùu®_size
+);
+
+70 #ià!
+def\9aed
+(
+USE_SIMULATOR
+)
+
+71 \15
+ gFUNCTION_CAST
+<
+ gUÇryM©hFunùiÚ
+>(
+ gbufãr
+);
+
+73
+ gç¡_exp_µc_mach\9ae_code
+ =
+bufãr
+;
+
+74 \15 &
+ gç¡_exp_simuÏtÜ
+;
+
+79
+UÇryM©hFunùiÚ
+
+C»©eSq¹FunùiÚ
+() {
+
+80 #ià
+def\9aed
+(
+USE_SIMULATOR
+)
+
+81 \15 &
+ g¡d
+::
+sq¹
+;
+
+83
+size_t
+
+ gaùu®_size
+;
+
+84
+by\8b
+*
+ gbufãr
+ =
+
+85
+¡©ic_ÿ¡
+<
+by\8b
+*>(
+ba£
+::
+OS
+::
+AÎoÿ\8b
+(1 *
+KB
+, &
+aùu®_size
+,
+\8cue
+));
+
+86 ià(
+ gbufãr
+ =ð
+NULL
+è\15 &
+¡d
+::
+sq¹
+;
+
+88
+MaüoAs£mbËr
+
+masm
+(
+NULL
+,
+bufãr
+,
+¡©ic_ÿ¡
+<\12>(
+aùu®_size
+));
+
+91 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+
+
+92
+__
+
+funùiÚ_desü\9dtÜ
+();
+
+95
+__
+
+MovFromFlßtP¬am\91\94
+(
+d1
+);
+
+96
+__
+
+fsq¹
+(
+d1
+, d1);
+
+97
+__
+
+MovToFlßtResuÉ
+(
+d1
+);
+
+98
+__
+
+R\91
+();
+
+100
+CodeDesc
+
+ gdesc
+;
+
+101
+ gmasm
+.
+G\91Code
+(&
+desc
+);
+
+102 #ià!
+ABI_USES_FUNCTION_DESCRIPTORS
+
+
+103
+DCHECK
+(!
+R\96ocInfo
+::
+Requ\9cesR\96oÿtiÚ
+(
+desc
+));
+
+106
+ gCpuF\97tu»s
+::
+FlushICache
+(
+bufãr
+,
+aùu®_size
+);
+
+107
+ gba£
+::
+OS
+::
+PrÙeùCode
+(
+bufãr
+,
+aùu®_size
+);
+
+108 \15
+ gFUNCTION_CAST
+<
+ gUÇryM©hFunùiÚ
+>(
+ gbufãr
+);
+
+112 #undeà
+__
+
+
+118 \1e
+ gStubRuÁimeC®lH\96³r
+::
+BefÜeC®l
+(
+MaüoAs£mbËr
+*
+masm
+) const {
+
+119
+masm
+->
+EÁ\94F¿me
+(
+S\8fckF¿me
+::
+INTERNAL
+);
+
+120
+DCHECK
+(!
+masm
+->
+has_äame
+());
+
+121
+ gmasm
+->
+£t_has_äame
+(
+\8cue
+);
+
+125 \1e
+ gStubRuÁimeC®lH\96³r
+::
+Aá\94C®l
+(
+MaüoAs£mbËr
+*
+masm
+) const {
+
+126
+masm
+->
+L\97veF¿me
+(
+S\8fckF¿me
+::
+INTERNAL
+);
+
+127
+DCHECK
+(
+masm
+->
+has_äame
+());
+
+128
+ gmasm
+->
+£t_has_äame
+(
+çl£
+);
+
+135 \ 1
+ #__
+
+ `ACCESS_MASM
+(
+masm
+)
+
+ )
+
+137 \1e
+ gEËm\92tsT¿ns\99iÚG\92\94©Ü
+::
+G\92\94©eMChªgeEËm\92tsT¿ns\99iÚ
+(
+
+138
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+»ûiv\94
+, Regi¡\94
+key
+, Regi¡\94
+v®ue
+,
+
+139
+Regi¡\94
+
+\8frg\91_m
+,
+AÎoÿtiÚS\99eMode
+
+mode
+,
+
+140
+Lab\96
+*
+®loÿtiÚ_mem\92to_found
+) {
+
+141
+Regi¡\94
+
+ gsü©ch_\96em\92ts
+ =
+r7
+;
+
+142
+DCHECK
+(!
+A»Al\9f£d
+(
+»ûiv\94
+,
+key
+,
+v®ue
+,
+\8frg\91_m
+,
+sü©ch_\96em\92ts
+));
+
+144 ià(
+ gmode
+ =ð
+TRACK_ALLOCATION_SITE
+) {
+
+145
+DCHECK
+(
+®loÿtiÚ_mem\92to_found
+ !ð
+NULL
+);
+
+146
+__
+
+JumpIfJSA¼ayHasAÎoÿtiÚMem\92to
+(
+»ûiv\94
+,
+sü©ch_\96em\92ts
+,
+
+147
+®loÿtiÚ_mem\92to_found
+);
+
+151
+__
+
+StÜeP
+(
+\8frg\91_m
+,
+F\9bldMemO³¿nd
+(
+»ûiv\94
+,
+H\97pObjeù
+::
+kMOff£t
+),
+r0
+);
+
+152
+__
+
+RecÜdWr\99eF\9bld
+(
+»ûiv\94
+,
+H\97pObjeù
+::
+kMOff£t
+,
+\8frg\91_m
+,
+r11
+,
+
+153
+kLRHasNÙB\93nSaved
+,
+kDÚtSaveFPRegs
+,
+EMIT_REMEMBERED_SET
+,
+
+154
+OMIT_SMI_CHECK
+);
+
+158 \1e
+ gEËm\92tsT¿ns\99iÚG\92\94©Ü
+::
+G\92\94©eSmiToDoubË
+(
+
+159
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+»ûiv\94
+, Regi¡\94
+key
+, Regi¡\94
+v®ue
+,
+
+160
+Regi¡\94
+
+\8frg\91_m
+,
+AÎoÿtiÚS\99eMode
+
+mode
+,
+Lab\96
+*
+ç\9e
+) {
+
+162
+Lab\96
+
+ gloÝ
+,
+ g\92\8cy
+,
+ gcÚv\94t_hÞe
+,
+ ggc_»qu\9ced
+,
+ gÚly_chªge_m
+,
+ gdÚe
+;
+
+163
+Regi¡\94
+
+ g\96em\92ts
+ =
+r7
+;
+
+164
+Regi¡\94
+
+ gËngth
+ =
+r8
+;
+
+165
+Regi¡\94
+
+ g¬¿y
+ =
+r9
+;
+
+166
+Regi¡\94
+
+ g¬¿y_\92d
+ =
+¬¿y
+;
+
+169
+Regi¡\94
+
+ gsü©ch1
+ =
+\8frg\91_m
+;
+
+170
+Regi¡\94
+
+ gsü©ch2
+ =
+r11
+;
+
+173
+DCHECK
+(!
+A»Al\9f£d
+(
+»ûiv\94
+,
+key
+,
+v®ue
+,
+\8frg\91_m
+,
+\96em\92ts
+,
+Ëngth
+,
+¬¿y
+,
+
+174
+sü©ch2
+));
+
+176 ià(
+ gmode
+ =ð
+TRACK_ALLOCATION_SITE
+) {
+
+177
+__
+
+JumpIfJSA¼ayHasAÎoÿtiÚMem\92to
+(
+»ûiv\94
+,
+\96em\92ts
+,
+ç\9e
+);
+
+182
+__
+
+LßdP
+(
+\96em\92ts
+,
+F\9bldMemO³¿nd
+(
+»ûiv\94
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+));
+
+183
+__
+
+Com·»RoÙ
+(
+\96em\92ts
+,
+H\97p
+::
+kEm±yFixedA¼ayRoÙIndex
+);
+
+184
+__
+
+beq
+(&
+Úly_chªge_m
+);
+
+187
+__
+
+mær
+(
+r0
+);
+
+188
+__
+
+Push
+(
+r0
+);
+
+190
+__
+
+LßdP
+(
+Ëngth
+,
+F\9bldMemO³¿nd
+(
+\96em\92ts
+,
+FixedA¼ay
+::
+kL\92gthOff£t
+));
+
+194
+__
+
+SmiToDoubËA¼ayOff£t
+(
+r17
+,
+Ëngth
+);
+
+195
+__
+
+addi
+(
+r17
+,\8417,
+O³¿nd
+(
+FixedDoubËA¼ay
+::
+kH\97d\94Size
+));
+
+196
+__
+
+AÎoÿ\8b
+(
+r17
+,
+¬¿y
+,
+r10
+,
+sü©ch2
+, &
+gc_»qu\9ced
+,
+DOUBLE_ALIGNMENT
+);
+
+199
+__
+
+LßdRoÙ
+(
+sü©ch2
+,
+H\97p
+::
+kFixedDoubËA¼ayMRoÙIndex
+);
+
+200
+__
+
+StÜeP
+(
+Ëngth
+,
+MemO³¿nd
+(
+¬¿y
+,
+FixedDoubËA¼ay
+::
+kL\92gthOff£t
+));
+
+202
+__
+
+StÜeP
+(
+sü©ch2
+,
+MemO³¿nd
+(
+¬¿y
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+204
+__
+
+StÜeP
+(
+\8frg\91_m
+,
+F\9bldMemO³¿nd
+(
+»ûiv\94
+,
+H\97pObjeù
+::
+kMOff£t
+),
+r0
+);
+
+205
+__
+
+RecÜdWr\99eF\9bld
+(
+»ûiv\94
+,
+H\97pObjeù
+::
+kMOff£t
+,
+\8frg\91_m
+,
+sü©ch2
+,
+
+206
+kLRHasB\93nSaved
+,
+kDÚtSaveFPRegs
+,
+OMIT_REMEMBERED_SET
+,
+
+207
+OMIT_SMI_CHECK
+);
+
+209
+__
+
+addi
+(
+sü©ch1
+,
+¬¿y
+,
+O³¿nd
+(
+kH\97pObjeùTag
+));
+
+210
+__
+
+StÜeP
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(
+»ûiv\94
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+),
+r0
+);
+
+211
+__
+
+RecÜdWr\99eF\9bld
+(
+»ûiv\94
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+,
+sü©ch1
+,
+sü©ch2
+,
+
+212
+kLRHasB\93nSaved
+,
+kDÚtSaveFPRegs
+,
+EMIT_REMEMBERED_SET
+,
+
+213
+OMIT_SMI_CHECK
+);
+
+216
+__
+
+addi
+(
+\8frg\91_m
+,
+\96em\92ts
+,
+
+217
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+218
+__
+
+addi
+(
+r10
+,
+¬¿y
+,
+O³¿nd
+(
+FixedDoubËA¼ay
+::
+kH\97d\94Size
+));
+
+219
+__
+
+SmiToDoubËA¼ayOff£t
+(
+¬¿y
+,
+Ëngth
+);
+
+220
+__
+
+add
+(
+¬¿y_\92d
+,
+r10
+,
+¬¿y
+);
+
+222 #ià
+V8_TARGET_ARCH_PPC64
+
+
+223
+Regi¡\94
+
+ ghÞe_\9at64
+ =
+\96em\92ts
+;
+
+225
+Regi¡\94
+
+ ghÞe_low\94
+ =
+\96em\92ts
+;
+
+226
+Regi¡\94
+
+ ghÞe_uµ\94
+ =
+Ëngth
+;
+
+234
+__
+
+b
+(&
+\92\8cy
+);
+
+236
+__
+
+b\9ad
+(&
+Úly_chªge_m
+);
+
+237
+__
+
+StÜeP
+(
+\8frg\91_m
+,
+F\9bldMemO³¿nd
+(
+»ûiv\94
+,
+H\97pObjeù
+::
+kMOff£t
+),
+r0
+);
+
+238
+__
+
+RecÜdWr\99eF\9bld
+(
+»ûiv\94
+,
+H\97pObjeù
+::
+kMOff£t
+,
+\8frg\91_m
+,
+sü©ch2
+,
+
+239
+kLRHasNÙB\93nSaved
+,
+kDÚtSaveFPRegs
+,
+OMIT_REMEMBERED_SET
+,
+
+240
+OMIT_SMI_CHECK
+);
+
+241
+__
+
+b
+(&
+dÚe
+);
+
+244
+__
+
+b\9ad
+(&
+gc_»qu\9ced
+);
+
+245
+__
+
+PÝ
+(
+r0
+);
+
+246
+__
+
+m\8er
+(
+r0
+);
+
+247
+__
+
+b
+(
+ç\9e
+);
+
+250
+__
+
+b\9ad
+(&
+loÝ
+);
+
+251
+__
+
+LßdP
+(
+r11
+,
+MemO³¿nd
+(
+sü©ch1
+));
+
+252
+__
+
+addi
+(
+sü©ch1
+, sü©ch1,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+254
+__
+
+UÁagAndJumpIfNÙSmi
+(
+r11
+,\8411, &
+cÚv\94t_hÞe
+);
+
+257
+__
+
+CÚv\94tIÁToDoubË
+(
+r11
+,
+d0
+);
+
+258
+__
+
+¡fd
+(
+d0
+,
+MemO³¿nd
+(
+sü©ch2
+, 0));
+
+259
+__
+
+addi
+(
+r10
+,\8410,
+O³¿nd
+(8));
+
+261
+__
+
+b
+(&
+\92\8cy
+);
+
+264
+__
+
+b\9ad
+(&
+cÚv\94t_hÞe
+);
+
+265 ià(
+ gFLAG_debug_code
+) {
+
+267
+__
+
+LßdP
+(
+r11
+,
+MemO³¿nd
+(
+r6
+, -
+kPo\9a\8brSize
+));
+
+268
+__
+
+Com·»RoÙ
+(
+r11
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+269
+__
+
+As£¹
+(
+eq
+,
+kObjeùFoundInSmiOÆyA¼ay
+);
+
+271 #ià
+V8_TARGET_ARCH_PPC64
+
+
+272
+__
+
+¡d
+(
+hÞe_\9at64
+,
+MemO³¿nd
+(
+r10
+, 0));
+
+274
+__
+
+¡w
+(
+hÞe_uµ\94
+,
+MemO³¿nd
+(
+r10
+,
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+275
+__
+
+¡w
+(
+hÞe_low\94
+,
+MemO³¿nd
+(
+r10
+,
+Regi¡\94
+::
+kMªtis§Off£t
+));
+
+277
+__
+
+addi
+(
+r10
+,\8410,
+O³¿nd
+(8));
+
+279
+__
+
+b\9ad
+(&
+\92\8cy
+);
+
+280
+__
+
+cmp
+(
+r10
+,
+¬¿y_\92d
+);
+
+281
+__
+
+bÉ
+(&
+loÝ
+);
+
+283
+__
+
+PÝ
+(
+r0
+);
+
+284
+__
+
+m\8er
+(
+r0
+);
+
+285
+__
+
+b\9ad
+(&
+dÚe
+);
+
+289 \1e
+ gEËm\92tsT¿ns\99iÚG\92\94©Ü
+::
+G\92\94©eDoubËToObjeù
+(
+
+290
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+»ûiv\94
+, Regi¡\94
+key
+, Regi¡\94
+v®ue
+,
+
+291
+Regi¡\94
+
+\8frg\91_m
+,
+AÎoÿtiÚS\99eMode
+
+mode
+,
+Lab\96
+*
+ç\9e
+) {
+
+293
+Lab\96
+
+ g\92\8cy
+,
+ gloÝ
+,
+ gcÚv\94t_hÞe
+,
+ ggc_»qu\9ced
+,
+ gÚly_chªge_m
+;
+
+294
+Regi¡\94
+
+ g\96em\92ts
+ =
+r7
+;
+
+295
+Regi¡\94
+
+ g¬¿y
+ =
+r9
+;
+
+296
+Regi¡\94
+
+ gËngth
+ =
+r8
+;
+
+297
+Regi¡\94
+
+ gsü©ch
+ =
+r11
+;
+
+300
+DCHECK
+(!
+A»Al\9f£d
+(
+»ûiv\94
+,
+key
+,
+v®ue
+,
+\8frg\91_m
+,
+\96em\92ts
+,
+¬¿y
+,
+Ëngth
+,
+
+301
+sü©ch
+));
+
+303 ià(
+ gmode
+ =ð
+TRACK_ALLOCATION_SITE
+) {
+
+304
+__
+
+JumpIfJSA¼ayHasAÎoÿtiÚMem\92to
+(
+»ûiv\94
+,
+\96em\92ts
+,
+ç\9e
+);
+
+309
+__
+
+LßdP
+(
+\96em\92ts
+,
+F\9bldMemO³¿nd
+(
+»ûiv\94
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+));
+
+310
+__
+
+Com·»RoÙ
+(
+\96em\92ts
+,
+H\97p
+::
+kEm±yFixedA¼ayRoÙIndex
+);
+
+311
+__
+
+beq
+(&
+Úly_chªge_m
+);
+
+313
+__
+
+Push
+(
+\8frg\91_m
+,
+»ûiv\94
+,
+key
+,
+v®ue
+);
+
+314
+__
+
+LßdP
+(
+Ëngth
+,
+F\9bldMemO³¿nd
+(
+\96em\92ts
+,
+FixedA¼ay
+::
+kL\92gthOff£t
+));
+
+321
+Regi¡\94
+
+ g¬¿y_size
+ =
+v®ue
+;
+
+322
+Regi¡\94
+
+ g®loÿ\8b_sü©ch
+ =
+\8frg\91_m
+;
+
+323
+__
+
+li
+(
+¬¿y_size
+,
+O³¿nd
+(
+FixedDoubËA¼ay
+::
+kH\97d\94Size
+));
+
+324
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r0
+,
+Ëngth
+);
+
+325
+__
+
+add
+(
+¬¿y_size
+,\87¼ay_size,
+r0
+);
+
+326
+__
+
+AÎoÿ\8b
+(
+¬¿y_size
+,
+¬¿y
+,
+®loÿ\8b_sü©ch
+,
+sü©ch
+, &
+gc_»qu\9ced
+,
+
+327
+NO_ALLOCATION_FLAGS
+);
+
+330
+__
+
+LßdRoÙ
+(
+sü©ch
+,
+H\97p
+::
+kFixedA¼ayMRoÙIndex
+);
+
+331
+__
+
+StÜeP
+(
+Ëngth
+,
+MemO³¿nd
+(
+¬¿y
+,
+FixedDoubËA¼ay
+::
+kL\92gthOff£t
+));
+
+332
+__
+
+StÜeP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¬¿y
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+333
+__
+
+addi
+(
+¬¿y
+,\87¼ay,
+O³¿nd
+(
+kH\97pObjeùTag
+));
+
+336
+Regi¡\94
+
+ g¤c_\96em\92ts
+ =
+\96em\92ts
+;
+
+337
+Regi¡\94
+
+ gd¡_\96em\92ts
+ =
+\8frg\91_m
+;
+
+338
+Regi¡\94
+
+ gd¡_\92d
+ =
+Ëngth
+;
+
+339
+Regi¡\94
+
+ gh\97p_numb\94_m
+ =
+sü©ch
+;
+
+340
+__
+
+addi
+(
+¤c_\96em\92ts
+,
+\96em\92ts
+,
+
+341
+O³¿nd
+(
+FixedDoubËA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+342
+__
+
+SmiToP\8cA¼ayOff£t
+(
+Ëngth
+,\86ength);
+
+343
+__
+
+LßdRoÙ
+(
+r10
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+345
+Lab\96
+
+ g\9a\99\9fliz©iÚ_loÝ
+,
+ gloÝ_dÚe
+;
+
+346
+__
+
+ShiáRightImm
+(
+r0
+,
+Ëngth
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+),
+S\91RC
+);
+
+347
+__
+
+beq
+(&
+loÝ_dÚe
+,
+ü0
+);
+
+352
+__
+
+mtùr
+(
+r0
+);
+
+353
+__
+
+addi
+(
+d¡_\96em\92ts
+,
+¬¿y
+,
+
+354
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+ -
+kPo\9a\8brSize
+));
+
+355
+__
+
+b\9ad
+(&
+\9a\99\9fliz©iÚ_loÝ
+);
+
+356
+__
+
+StÜePU
+(
+r10
+,
+MemO³¿nd
+(
+d¡_\96em\92ts
+,
+kPo\9a\8brSize
+));
+
+357
+__
+
+bdnz
+(&
+\9a\99\9fliz©iÚ_loÝ
+);
+
+359
+__
+
+addi
+(
+d¡_\96em\92ts
+,
+¬¿y
+,
+
+360
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+361
+__
+
+add
+(
+d¡_\92d
+,
+d¡_\96em\92ts
+,
+Ëngth
+);
+
+362
+__
+
+LßdRoÙ
+(
+h\97p_numb\94_m
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+372
+__
+
+b
+(&
+loÝ
+);
+
+375
+__
+
+b\9ad
+(&
+gc_»qu\9ced
+);
+
+376
+__
+
+PÝ
+(
+\8frg\91_m
+,
+»ûiv\94
+,
+key
+,
+v®ue
+);
+
+377
+__
+
+b
+(
+ç\9e
+);
+
+380
+__
+
+b\9ad
+(&
+cÚv\94t_hÞe
+);
+
+381
+__
+
+StÜeP
+(
+r10
+,
+MemO³¿nd
+(
+d¡_\96em\92ts
+));
+
+382
+__
+
+addi
+(
+d¡_\96em\92ts
+, d¡_\96em\92ts,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+383
+__
+
+cm¶
+(
+d¡_\96em\92ts
+,
+d¡_\92d
+);
+
+384
+__
+
+bge
+(&
+loÝ_dÚe
+);
+
+386
+__
+
+b\9ad
+(&
+loÝ
+);
+
+387
+Regi¡\94
+
+ guµ\94_b\99s
+ =
+key
+;
+
+388
+__
+
+lwz
+(
+uµ\94_b\99s
+,
+MemO³¿nd
+(
+¤c_\96em\92ts
+,
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+389
+__
+
+addi
+(
+¤c_\96em\92ts
+, src_\96em\92ts,
+O³¿nd
+(
+kDoubËSize
+));
+
+392
+__
+
+Cmpi
+(
+uµ\94_b\99s
+,
+O³¿nd
+(
+kHÞeNªUµ\9432
+),
+r0
+);
+
+393
+__
+
+beq
+(&
+cÚv\94t_hÞe
+);
+
+396
+Regi¡\94
+
+ gh\97p_numb\94
+ =
+»ûiv\94
+;
+
+397
+Regi¡\94
+
+ gsü©ch2
+ =
+v®ue
+;
+
+398
+__
+
+AÎoÿ\8bH\97pNumb\94
+(
+h\97p_numb\94
+,
+sü©ch2
+,
+r11
+,
+h\97p_numb\94_m
+,
+
+399 &
+gc_»qu\9ced
+);
+
+401 #ià
+V8_TARGET_ARCH_PPC64
+
+
+402
+__
+
+ld
+(
+sü©ch2
+,
+MemO³¿nd
+(
+¤c_\96em\92ts
+, -
+kDoubËSize
+));
+
+404
+__
+
+addi
+(
+uµ\94_b\99s
+,
+h\97p_numb\94
+,
+O³¿nd
+(-
+kH\97pObjeùTag
+));
+
+405
+__
+
+¡d
+(
+sü©ch2
+,
+MemO³¿nd
+(
+uµ\94_b\99s
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+407
+__
+
+lwz
+(
+sü©ch2
+,
+
+408
+MemO³¿nd
+(
+¤c_\96em\92ts
+,
+Regi¡\94
+::
+kMªtis§Off£t
+ -
+kDoubËSize
+));
+
+409
+__
+
+lwz
+(
+uµ\94_b\99s
+,
+
+410
+MemO³¿nd
+(
+¤c_\96em\92ts
+,
+Regi¡\94
+::
+kExpÚ\92tOff£t
+ -
+kDoubËSize
+));
+
+411
+__
+
+¡w
+(
+sü©ch2
+,
+F\9bldMemO³¿nd
+(
+h\97p_numb\94
+,
+H\97pNumb\94
+::
+kMªtis§Off£t
+));
+
+412
+__
+
+¡w
+(
+uµ\94_b\99s
+,
+F\9bldMemO³¿nd
+(
+h\97p_numb\94
+,
+H\97pNumb\94
+::
+kExpÚ\92tOff£t
+));
+
+414
+__
+
+mr
+(
+sü©ch2
+,
+d¡_\96em\92ts
+);
+
+415
+__
+
+StÜeP
+(
+h\97p_numb\94
+,
+MemO³¿nd
+(
+d¡_\96em\92ts
+));
+
+416
+__
+
+addi
+(
+d¡_\96em\92ts
+, d¡_\96em\92ts,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+417
+__
+
+RecÜdWr\99e
+(
+¬¿y
+,
+sü©ch2
+,
+h\97p_numb\94
+,
+kLRHasNÙB\93nSaved
+,
+
+418
+kDÚtSaveFPRegs
+,
+EMIT_REMEMBERED_SET
+,
+OMIT_SMI_CHECK
+);
+
+419
+__
+
+b
+(&
+\92\8cy
+);
+
+422
+__
+
+b\9ad
+(&
+cÚv\94t_hÞe
+);
+
+423
+__
+
+StÜeP
+(
+r10
+,
+MemO³¿nd
+(
+d¡_\96em\92ts
+));
+
+424
+__
+
+addi
+(
+d¡_\96em\92ts
+, d¡_\96em\92ts,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+426
+__
+
+b\9ad
+(&
+\92\8cy
+);
+
+427
+__
+
+cm¶
+(
+d¡_\96em\92ts
+,
+d¡_\92d
+);
+
+428
+__
+
+bÉ
+(&
+loÝ
+);
+
+429
+__
+
+b\9ad
+(&
+loÝ_dÚe
+);
+
+431
+__
+
+PÝ
+(
+\8frg\91_m
+,
+»ûiv\94
+,
+key
+,
+v®ue
+);
+
+433
+__
+
+StÜeP
+(
+¬¿y
+,
+F\9bldMemO³¿nd
+(
+»ûiv\94
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+),
+r0
+);
+
+434
+__
+
+RecÜdWr\99eF\9bld
+(
+»ûiv\94
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+,
+¬¿y
+,
+sü©ch
+,
+
+435
+kLRHasNÙB\93nSaved
+,
+kDÚtSaveFPRegs
+,
+EMIT_REMEMBERED_SET
+,
+
+436
+OMIT_SMI_CHECK
+);
+
+438
+__
+
+b\9ad
+(&
+Úly_chªge_m
+);
+
+440
+__
+
+StÜeP
+(
+\8frg\91_m
+,
+F\9bldMemO³¿nd
+(
+»ûiv\94
+,
+H\97pObjeù
+::
+kMOff£t
+),
+r0
+);
+
+441
+__
+
+RecÜdWr\99eF\9bld
+(
+»ûiv\94
+,
+H\97pObjeù
+::
+kMOff£t
+,
+\8frg\91_m
+,
+sü©ch
+,
+
+442
+kLRHasNÙB\93nSaved
+,
+kDÚtSaveFPRegs
+,
+OMIT_REMEMBERED_SET
+,
+
+443
+OMIT_SMI_CHECK
+);
+
+448 \1e
+ gS\8c\9agCh¬LßdG\92\94©Ü
+::
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+¡r\9ag
+,
+
+449
+Regi¡\94
+
+\9adex
+, Regi¡\94
+»suÉ
+,
+
+450
+Lab\96
+*
+ÿÎ_ruÁime
+) {
+
+452
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+453
+__
+
+lbz
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+ÔesuÉ,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+456
+Lab\96
+
+ gcheck_£qu\92t\9fl
+;
+
+457
+__
+
+ªdi
+(
+r0
+,
+»suÉ
+,
+O³¿nd
+(
+kIsInd\9ceùS\8c\9agMask
+));
+
+458
+__
+
+beq
+(&
+check_£qu\92t\9fl
+,
+ü0
+);
+
+461
+Lab\96
+
+ gcÚs_¡r\9ag
+;
+
+462
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+kSliûdNÙCÚsMask
+));
+
+463
+__
+
+ªd_
+(
+r0
+,
+»suÉ
+,
+\9d
+,
+S\91RC
+);
+
+464
+__
+
+beq
+(&
+cÚs_¡r\9ag
+,
+ü0
+);
+
+467
+Lab\96
+
+ g\9ad\9ceù_¡r\9ag_lßded
+;
+
+468
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+SliûdS\8c\9ag
+::
+kOff£tOff£t
+));
+
+469
+__
+
+LßdP
+(
+¡r\9ag
+,
+F\9bldMemO³¿nd
+(¡r\9ag,
+SliûdS\8c\9ag
+::
+kP¬\92tOff£t
+));
+
+470
+__
+
+SmiUÁag
+(
+\9d
+,
+»suÉ
+);
+
+471
+__
+
+add
+(
+\9adex
+, index,
+\9d
+);
+
+472
+__
+
+b
+(&
+\9ad\9ceù_¡r\9ag_lßded
+);
+
+479
+__
+
+b\9ad
+(&
+cÚs_¡r\9ag
+);
+
+480
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+CÚsS\8c\9ag
+::
+kSecÚdOff£t
+));
+
+481
+__
+
+Com·»RoÙ
+(
+»suÉ
+,
+H\97p
+::
+kem±y_¡r\9agRoÙIndex
+);
+
+482
+__
+
+bÃ
+(
+ÿÎ_ruÁime
+);
+
+484
+__
+
+LßdP
+(
+¡r\9ag
+,
+F\9bldMemO³¿nd
+(¡r\9ag,
+CÚsS\8c\9ag
+::
+kF\9c¡Off£t
+));
+
+486
+__
+
+b\9ad
+(&
+\9ad\9ceù_¡r\9ag_lßded
+);
+
+487
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+488
+__
+
+lbz
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+ÔesuÉ,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+493
+Lab\96
+
+ gex\8bº®_¡r\9ag
+,
+ gcheck_\92cod\9ag
+;
+
+494
+__
+
+b\9ad
+(&
+check_£qu\92t\9fl
+);
+
+495
+STATIC_ASSERT
+(
+kSeqS\8c\9agTag
+ == 0);
+
+496
+__
+
+ªdi
+(
+r0
+,
+»suÉ
+,
+O³¿nd
+(
+kS\8c\9agR\95»£Á©iÚMask
+));
+
+497
+__
+
+bÃ
+(&
+ex\8bº®_¡r\9ag
+,
+ü0
+);
+
+500
+STATIC_ASSERT
+(
+SeqTwoBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ =ð
+SeqOÃBy\8bS\8c\9ag
+::kHeaderSize);
+
+501
+__
+
+addi
+(
+¡r\9ag
+, string,
+
+502
+O³¿nd
+(
+SeqTwoBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+503
+__
+
+b
+(&
+check_\92cod\9ag
+);
+
+506
+__
+
+b\9ad
+(&
+ex\8bº®_¡r\9ag
+);
+
+507 ià(
+ gFLAG_debug_code
+) {
+
+510
+__
+
+ªdi
+(
+r0
+,
+»suÉ
+,
+O³¿nd
+(
+kIsInd\9ceùS\8c\9agMask
+));
+
+511
+__
+
+As£¹
+(
+eq
+,
+kEx\8bº®S\8c\9agEx³ùedButNÙFound
+,
+ü0
+);
+
+514
+STATIC_ASSERT
+(
+kShÜtEx\8bº®S\8c\9agTag
+ != 0);
+
+515
+__
+
+ªdi
+(
+r0
+,
+»suÉ
+,
+O³¿nd
+(
+kShÜtEx\8bº®S\8c\9agMask
+));
+
+516
+__
+
+bÃ
+(
+ÿÎ_ruÁime
+,
+ü0
+);
+
+517
+__
+
+LßdP
+(
+¡r\9ag
+,
+
+518
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+Ex\8bº®S\8c\9ag
+::
+kResourûD©aOff£t
+));
+
+520
+Lab\96
+
+ gÚe_by\8b
+,
+ gdÚe
+;
+
+521
+__
+
+b\9ad
+(&
+check_\92cod\9ag
+);
+
+522
+STATIC_ASSERT
+(
+kTwoBy\8bS\8c\9agTag
+ == 0);
+
+523
+__
+
+ªdi
+(
+r0
+,
+»suÉ
+,
+O³¿nd
+(
+kS\8c\9agEncod\9agMask
+));
+
+524
+__
+
+bÃ
+(&
+Úe_by\8b
+,
+ü0
+);
+
+526
+__
+
+ShiáLeáImm
+(
+»suÉ
+,
+\9adex
+,
+O³¿nd
+(1));
+
+527
+__
+
+lhzx
+(
+»suÉ
+,
+MemO³¿nd
+(
+¡r\9ag
+,\84esult));
+
+528
+__
+
+b
+(&
+dÚe
+);
+
+529
+__
+
+b\9ad
+(&
+Úe_by\8b
+);
+
+531
+__
+
+lbzx
+(
+»suÉ
+,
+MemO³¿nd
+(
+¡r\9ag
+,
+\9adex
+));
+
+532
+__
+
+b\9ad
+(&
+dÚe
+);
+
+536 \18
+MemO³¿nd
+
+ExpCÚ¡ªt
+(\12
+\9adex
+,
+Regi¡\94
+
+ba£
+) {
+
+537 \15
+MemO³¿nd
+(
+ba£
+,
+\9adex
+ *
+kDoubËSize
+);
+
+541 \1e
+ gM©hExpG\92\94©Ü
+::
+Em\99M©hExp
+(
+MaüoAs£mbËr
+*
+masm
+,
+DoubËRegi¡\94
+
+\9aput
+,
+
+542
+DoubËRegi¡\94
+
+»suÉ
+,
+
+543
+DoubËRegi¡\94
+
+doubË_sü©ch1
+,
+
+544
+DoubËRegi¡\94
+
+doubË_sü©ch2
+,
+
+545
+Regi¡\94
+
+\8bmp1
+, Regi¡\94
+\8bmp2
+,
+
+546
+Regi¡\94
+
+\8bmp3
+) {
+
+547
+DCHECK
+(!
+\9aput
+.
+is
+(
+»suÉ
+));
+
+548
+DCHECK
+(!
+\9aput
+.
+is
+(
+doubË_sü©ch1
+));
+
+549
+DCHECK
+(!
+\9aput
+.
+is
+(
+doubË_sü©ch2
+));
+
+550
+DCHECK
+(!
+»suÉ
+.
+is
+(
+doubË_sü©ch1
+));
+
+551
+DCHECK
+(!
+»suÉ
+.
+is
+(
+doubË_sü©ch2
+));
+
+552
+DCHECK
+(!
+doubË_sü©ch1
+.
+is
+(
+doubË_sü©ch2
+));
+
+553
+DCHECK
+(!
+\8bmp1
+.
+is
+(
+\8bmp2
+));
+
+554
+DCHECK
+(!
+\8bmp1
+.
+is
+(
+\8bmp3
+));
+
+555
+DCHECK
+(!
+\8bmp2
+.
+is
+(
+\8bmp3
+));
+
+556
+DCHECK
+(
+Ex\8bº®Reã»nû
+::
+m©h_exp_cÚ¡ªts
+(0).
+add»ss
+(è!ð
+NULL
+);
+
+557
+DCHECK
+(!
+masm
+->
+£r\9fliz\94_\92abËd
+());
+
+559
+Lab\96
+
+ gz\94o
+,
+ g\9af\9a\99y
+,
+ gdÚe
+;
+
+561
+__
+
+mov
+(
+\8bmp3
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+m©h_exp_cÚ¡ªts
+(0)));
+
+563
+__
+
+lfd
+(
+doubË_sü©ch1
+,
+ExpCÚ¡ªt
+(0,
+\8bmp3
+));
+
+564
+__
+
+fcmpu
+(
+doubË_sü©ch1
+,
+\9aput
+);
+
+565
+__
+
+fmr
+(
+»suÉ
+,
+\9aput
+);
+
+566
+__
+
+bunÜd\94ed
+(&
+dÚe
+);
+
+567
+__
+
+bge
+(&
+z\94o
+);
+
+569
+__
+
+lfd
+(
+doubË_sü©ch2
+,
+ExpCÚ¡ªt
+(1,
+\8bmp3
+));
+
+570
+__
+
+fcmpu
+(
+\9aput
+,
+doubË_sü©ch2
+);
+
+571
+__
+
+bge
+(&
+\9af\9a\99y
+);
+
+573
+__
+
+lfd
+(
+doubË_sü©ch1
+,
+ExpCÚ¡ªt
+(3,
+\8bmp3
+));
+
+574
+__
+
+lfd
+(
+»suÉ
+,
+ExpCÚ¡ªt
+(4,
+\8bmp3
+));
+
+575
+__
+
+fmul
+(
+doubË_sü©ch1
+, doubË_sü©ch1,
+\9aput
+);
+
+576
+__
+
+çdd
+(
+doubË_sü©ch1
+, doubË_sü©ch1,
+»suÉ
+);
+
+577
+__
+
+MovDoubËLowToIÁ
+(
+\8bmp2
+,
+doubË_sü©ch1
+);
+
+578
+__
+
+fsub
+(
+doubË_sü©ch1
+, doubË_sü©ch1,
+»suÉ
+);
+
+579
+__
+
+lfd
+(
+»suÉ
+,
+ExpCÚ¡ªt
+(6,
+\8bmp3
+));
+
+580
+__
+
+lfd
+(
+doubË_sü©ch2
+,
+ExpCÚ¡ªt
+(5,
+\8bmp3
+));
+
+581
+__
+
+fmul
+(
+doubË_sü©ch1
+, doubË_sü©ch1,
+doubË_sü©ch2
+);
+
+582
+__
+
+fsub
+(
+doubË_sü©ch1
+, doubË_sü©ch1,
+\9aput
+);
+
+583
+__
+
+fsub
+(
+»suÉ
+,\84esuÉ,
+doubË_sü©ch1
+);
+
+584
+__
+
+fmul
+(
+doubË_sü©ch2
+,
+doubË_sü©ch1
+, double_scratch1);
+
+585
+__
+
+fmul
+(
+»suÉ
+,\84esuÉ,
+doubË_sü©ch2
+);
+
+586
+__
+
+lfd
+(
+doubË_sü©ch2
+,
+ExpCÚ¡ªt
+(7,
+\8bmp3
+));
+
+587
+__
+
+fmul
+(
+»suÉ
+,\84esuÉ,
+doubË_sü©ch2
+);
+
+588
+__
+
+fsub
+(
+»suÉ
+,\84esuÉ,
+doubË_sü©ch1
+);
+
+589
+__
+
+lfd
+(
+doubË_sü©ch2
+,
+ExpCÚ¡ªt
+(8,
+\8bmp3
+));
+
+590
+__
+
+çdd
+(
+»suÉ
+,\84esuÉ,
+doubË_sü©ch2
+);
+
+591
+__
+
+¤wi
+(
+\8bmp1
+,
+\8bmp2
+,
+O³¿nd
+(11));
+
+592
+__
+
+ªdi
+(
+\8bmp2
+,\81emp2,
+O³¿nd
+(0x7ff));
+
+593
+__
+
+addi
+(
+\8bmp1
+,\81emp1,
+O³¿nd
+(0x3ff));
+
+596
+__
+
+mov
+(
+\8bmp3
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+m©h_exp_log_\8fbË
+()));
+
+597
+__
+
+¦wi
+(
+\8bmp2
+,\81emp2,
+O³¿nd
+(3));
+
+598 #ià
+V8_TARGET_ARCH_PPC64
+
+
+599
+__
+
+ldx
+(
+\8bmp2
+,
+MemO³¿nd
+(
+\8bmp3
+,\81emp2));
+
+600
+__
+
+¦di
+(
+\8bmp1
+,\81emp1,
+O³¿nd
+(52));
+
+601
+__
+
+Üx
+(
+\8bmp2
+,
+\8bmp1
+,\81emp2);
+
+602
+__
+
+MovIÁ64ToDoubË
+(
+doubË_sü©ch1
+,
+\8bmp2
+);
+
+604
+__
+
+add
+(
+\9d
+,
+\8bmp3
+,
+\8bmp2
+);
+
+605
+__
+
+lwz
+(
+\8bmp3
+,
+MemO³¿nd
+(
+\9d
+,
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+606
+__
+
+lwz
+(
+\8bmp2
+,
+MemO³¿nd
+(
+\9d
+,
+Regi¡\94
+::
+kMªtis§Off£t
+));
+
+607
+__
+
+¦wi
+(
+\8bmp1
+,\81emp1,
+O³¿nd
+(20));
+
+608
+__
+
+Üx
+(
+\8bmp3
+,
+\8bmp1
+,\81emp3);
+
+609
+__
+
+MovIÁ64ToDoubË
+(
+doubË_sü©ch1
+,
+\8bmp3
+,
+\8bmp2
+);
+
+612
+__
+
+fmul
+(
+»suÉ
+,\84esuÉ,
+doubË_sü©ch1
+);
+
+613
+__
+
+b
+(&
+dÚe
+);
+
+615
+__
+
+b\9ad
+(&
+z\94o
+);
+
+616
+__
+
+fmr
+(
+»suÉ
+,
+kDoubËRegZ\94o
+);
+
+617
+__
+
+b
+(&
+dÚe
+);
+
+619
+__
+
+b\9ad
+(&
+\9af\9a\99y
+);
+
+620
+__
+
+lfd
+(
+»suÉ
+,
+ExpCÚ¡ªt
+(2,
+\8bmp3
+));
+
+622
+__
+
+b\9ad
+(&
+dÚe
+);
+
+625 #undeà
+__
+
+
+627
+ gCodeAg\9agH\96³r
+::
+CodeAg\9agH\96³r
+() {
+
+628
+DCHECK
+(
+young_£qu\92û_
+.
+Ëngth
+(è=ð
+kNoCodeAgeSequ\92ûL\92gth
+);
+
+633
+ gSm¬tPo\9a\8br
+<
+ gCodeP©ch\94
+>
+·tch\94
+(
+Ãw
+
+CodeP©ch\94
+(
+
+634
+young_£qu\92û_
+.
+¡¬t
+(), young_£qu\92û_.
+Ëngth
+(è/
+As£mbËr
+::
+kIn¡rSize
+,
+
+635
+CodeP©ch\94
+::
+DONT_FLUSH
+));
+
+636
+P»diùabËCodeSizeScÝe
+
+scÝe
+(
+·tch\94
+->
+masm
+(),
+young_£qu\92û_
+.
+Ëngth
+());
+
+637
+ g·tch\94
+->
+masm
+()->
+PushFixedF¿me
+(
+r4
+);
+
+638
+ g·tch\94
+->
+masm
+()->
+addi
+(
+å
+,
+¥
+,
+
+639
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSizeFromFp
+));
+
+640 \ f\12
+ gi
+ = 0; i <
+ gkNoCodeAgeSequ\92ûNÝs
+; i++) {
+
+641
+ g·tch\94
+->
+masm
+()->
+nÝ
+();
+
+646 #ifdeà
+DEBUG
+
+
+647
+boÞ
+
+ gCodeAg\9agH\96³r
+::
+IsOld
+(
+by\8b
+*
+ÿndid©e
+) const {
+
+648 \15
+As£mbËr
+::
+IsNÝ
+(As£mbËr::
+\9a¡r_©
+(
+ÿndid©e
+));
+
+653
+boÞ
+
+ gCode
+::
+IsYoungSequ\92û
+(
+Isީe
+*
+isީe
+,
+by\8b
+*
+£qu\92û
+) {
+
+654
+boÞ
+
+ g»suÉ
+ =
+isީe
+->
+code_ag\9ag_h\96³r
+()->
+IsYoung
+(
+£qu\92û
+);
+
+655
+DCHECK
+(
+»suÉ
+ ||
+isީe
+->
+code_ag\9ag_h\96³r
+()->
+IsOld
+(
+£qu\92û
+));
+
+656 \15
+ g»suÉ
+;
+
+660 \1e
+ gCode
+::
+G\91CodeAgeAndP¬\99y
+(
+Isީe
+*
+isީe
+,
+by\8b
+*
+£qu\92û
+,
+Age
+*
+age
+,
+
+661
+M¬k\9agP¬\99y
+*
+·r\99y
+) {
+
+662 ià(
+IsYoungSequ\92û
+(
+isީe
+,
+£qu\92û
+)) {
+
+663 *
+ gage
+ =
+kNoAgeCodeAge
+;
+
+664 *
+ g·r\99y
+ =
+NO_MARKING_PARITY
+;
+
+666
+CÚ¡ªtPoÞA¼ay
+*
+ gcÚ¡ªt_poÞ
+ =
+NULL
+;
+
+667
+Add»ss
+
+ g\8frg\91_add»ss
+ =
+As£mbËr
+::
+\8frg\91_add»ss_©
+(
+
+668
+£qu\92û
+ +
+kCodeAg\9agT¬g\91D\96\8f
+,
+cÚ¡ªt_poÞ
+);
+
+669
+Code
+*
+ g¡ub
+ =
+G\91CodeFromT¬g\91Add»ss
+(
+\8frg\91_add»ss
+);
+
+670
+G\91CodeAgeAndP¬\99y
+(
+¡ub
+,
+age
+,
+·r\99y
+);
+
+675 \1e
+ gCode
+::
+P©chPÏtfÜmCodeAge
+(
+Isީe
+*
+isީe
+,
+by\8b
+*
+£qu\92û
+,
+Code
+::
+Age
+
+age
+,
+
+676
+M¬k\9agP¬\99y
+
+·r\99y
+) {
+
+677
+u\9at32_t
+
+ gyoung_Ëngth
+ =
+isީe
+->
+code_ag\9ag_h\96³r
+()->
+young_£qu\92û_Ëngth
+();
+
+678 ià(
+ gage
+ =ð
+kNoAgeCodeAge
+) {
+
+679
+isީe
+->
+code_ag\9ag_h\96³r
+()->
+CÝyYoungSequ\92ûTo
+(
+£qu\92û
+);
+
+680
+ gCpuF\97tu»s
+::
+FlushICache
+(
+£qu\92û
+,
+young_Ëngth
+);
+
+683
+Code
+*
+ g¡ub
+ =
+G\91CodeAgeStub
+(
+isީe
+,
+age
+,
+·r\99y
+);
+
+684
+CodeP©ch\94
+
+·tch\94
+(
+£qu\92û
+,
+young_Ëngth
+ /
+As£mbËr
+::
+kIn¡rSize
+);
+
+685
+ gAs£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+·tch\94
+.
+masm
+());
+
+686
+\9a\8d\8c_t
+
+ g\8frg\91
+ =
+»\9a\8b½»t_ÿ¡
+<\9a\8d\8c_t>(
+¡ub
+->
+\9a¡ruùiÚ_¡¬t
+());
+
+689
+ g·tch\94
+.
+masm
+()->
+nÝ
+();
+
+690
+ g·tch\94
+.
+masm
+()->
+mov
+(
+r3
+,
+O³¿nd
+(
+\8frg\91
+));
+
+691
+ g·tch\94
+.
+masm
+()->
+Jump
+(
+r3
+);
+
+692 \ f\12
+ gi
+ = 0; i <
+ gkCodeAg\9agSequ\92ûNÝs
+; i++) {
+
+693
+ g·tch\94
+.
+masm
+()->
+nÝ
+();
+
+ @codegen-ppc.h
+
+5 #iâdeà
+V8_PPC_CODEGEN_PPC_H_
+
+
+6 \ 1
+ #V8_PPC_CODEGEN_PPC_H_
+
+
+ )
+
+8 \ 2
+ ~"¤c/a¡.h
+"
+
+9 \ 2
+ ~"¤c/maüo-as£mbËr.h
+"
+
+11
+Çme¥aû
+
+ gv8
+ {
+
+12
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+15 \f
+ eTy³ofS\8f\8b
+ {
+ gINSIDE_TYPEOF
+,
+ gNOT_INSIDE_TYPEOF
+ };
+
+18 þas
+ cS\8c\9agCh¬LßdG\92\94©Ü
+ :
+public
+
+AÎS\8ftic
+ {
+
+19
+public
+:
+
+23 \18\1e
+G\92\94©e
+(
+MaüoAs£mbËr
+*
+masm
+,
+Regi¡\94
+
+¡r\9ag
+, Regi¡\94
+\9adex
+,
+
+24
+Regi¡\94
+
+»suÉ
+,
+Lab\96
+*
+ÿÎ_ruÁime
+);
+
+26
+ g´iv©e
+:
+
+27
+DISALLOW_COPY_AND_ASSIGN
+(
+S\8c\9agCh¬LßdG\92\94©Ü
+);
+
+30 þas
+ cM©hExpG\92\94©Ü
+ :
+public
+
+AÎS\8ftic
+ {
+
+31
+public
+:
+
+33 \18\1e
+Em\99M©hExp
+(
+MaüoAs£mbËr
+*
+masm
+,
+DoubËRegi¡\94
+
+\9aput
+,
+
+34
+DoubËRegi¡\94
+
+»suÉ
+, DoubËRegi¡\94
+doubË_sü©ch1
+,
+
+35
+DoubËRegi¡\94
+
+doubË_sü©ch2
+,
+Regi¡\94
+
+\8bmp1
+,
+
+36
+Regi¡\94
+
+\8bmp2
+, Regi¡\94
+\8bmp3
+);
+
+38
+ g´iv©e
+:
+
+39
+DISALLOW_COPY_AND_ASSIGN
+(
+M©hExpG\92\94©Ü
+);
+
+ @constants-ppc.cc
+
+5 \ 2
+ ~"¤c/v8.h
+"
+
+7 #ià
+V8_TARGET_ARCH_PPC
+
+
+9 \ 2
+ ~"¤c/µc/cÚ¡ªts-µc.h
+"
+
+12
+Çme¥aû
+
+ gv8
+ {
+
+13
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+17 cڡ \ 5*
+ gRegi¡\94s
+::
+Çmes_
+[
+kNumRegi¡\94s
+] = {
+
+24 cڡ
+ gRegi¡\94s
+::
+Regi¡\94Al\9fs
+
+Regi¡\94s
+::
+®\9f£s_
+[] = {{10, "sl"},
+
+30 {
+kNoRegi¡\94
+,
+NULL
+}};
+
+33 cڡ \ 5*
+ gRegi¡\94s
+::
+Name
+(\12
+»g
+) {
+
+34 cڡ \ 5*
+»suÉ
+;
+
+35 ià((0 <ð
+»g
+è&& (»g <
+kNumRegi¡\94s
+)) {
+
+36
+»suÉ
+ =
+Çmes_
+[
+»g
+];
+
+38
+ g»suÉ
+ = "noreg";
+
+40 \15
+ g»suÉ
+;
+
+44 cڡ \ 5*
+ gFPRegi¡\94s
+::
+Çmes_
+[
+kNumFPRegi¡\94s
+] = {
+
+50 cڡ \ 5*
+ gFPRegi¡\94s
+::
+Name
+(\12
+»g
+) {
+
+51
+DCHECK
+((0 <ð
+»g
+è&& (»g <
+kNumFPRegi¡\94s
+));
+
+52 \15
+ gÇmes_
+[
+»g
+];
+
+56 \12
+ gFPRegi¡\94s
+::
+Numb\94
+(cڡ \ 5*
+Çme
+) {
+
+57 \ f\12
+i
+ = 0;
+ gi
+ <
+ gkNumFPRegi¡\94s
+; i++) {
+
+58 ià(
+¡rcmp
+(
+Çmes_
+[
+i
+],
+Çme
+) == 0) {
+
+59 \15
+i
+;
+
+64 \15
+ gkNoRegi¡\94
+;
+
+68 \12
+ gRegi¡\94s
+::
+Numb\94
+(cڡ \ 5*
+Çme
+) {
+
+70 \ f\12
+i
+ = 0;
+ gi
+ <
+ gkNumRegi¡\94s
+; i++) {
+
+71 ià(
+¡rcmp
+(
+Çmes_
+[
+i
+],
+Çme
+) == 0) {
+
+72 \15
+i
+;
+
+77 \12
+ gi
+ = 0;
+
+78 \1f
+ g®\9f£s_
+[
+i
+].
+ g»g
+ !ð
+kNoRegi¡\94
+) {
+
+79 ià(
+¡rcmp
+(
+®\9f£s_
+[
+i
+].
+Çme
+,\82ame) == 0) {
+
+80 \15
+®\9f£s_
+[
+i
+].
+»g
+;
+
+82
+ gi
+++;
+
+86 \15
+ gkNoRegi¡\94
+;
+
+ @constants-ppc.h
+
+5 #iâdeà
+V8_PPC_CONSTANTS_PPC_H_
+
+
+6 \ 1
+ #V8_PPC_CONSTANTS_PPC_H_
+
+
+ )
+
+8
+Çme¥aû
+
+ gv8
+ {
+
+9
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+12 cڡ \12
+ gkNumRegi¡\94s
+ = 32;
+
+15 cڡ \12
+ gkNumFPDoubËRegi¡\94s
+ = 32;
+
+16 cڡ \12
+ gkNumFPRegi¡\94s
+ =
+kNumFPDoubËRegi¡\94s
+;
+
+18 cڡ \12
+ gkNoRegi¡\94
+ = -1;
+
+21 \ 1
+ #SIGN_EXT_IMM16
+(
+imm
+è((
+¡©ic_ÿ¡
+<\12>(immè<< 16è>> 16)
+
+ )
+
+24 \ 1
+ #SIGN_EXT_IMM26
+(
+imm
+è((
+¡©ic_ÿ¡
+<\12>(immè<< 6è>> 6)
+
+ )
+
+39 \f
+ eCÚd\99iÚ
+ {
+
+40
+ gkNoCÚd\99iÚ
+ = -1,
+
+41
+ geq
+ = 0,
+
+42
+ gÃ
+ = 1,
+
+43
+ gge
+ = 2,
+
+44
+ gÉ
+ = 3,
+
+45
+ ggt
+ = 4,
+
+46
+ gË
+ = 5,
+
+47
+ gunÜd\94ed
+ = 6,
+
+48
+ gÜd\94ed
+ = 7,
+
+49
+ gov\94æow
+ = 8,
+
+50
+ gnoov\94æow
+ = 9,
+
+51
+ g®
+ = 10
+
+55
+\9al\9ae
+
+CÚd\99iÚ
+
+Neg©eCÚd\99iÚ
+(CÚd\99iÚ
+cÚd
+) {
+
+56
+DCHECK
+(
+cÚd
+ !ð
+®
+);
+
+57 \15
+ g¡©ic_ÿ¡
+<
+ gCÚd\99iÚ
+>(
+ gcÚd
+ ^
+ gÃ
+);
+
+62
+\9al\9ae
+
+CÚd\99iÚ
+
+Commu\8bCÚd\99iÚ
+(CÚd\99iÚ
+cÚd
+) {
+
+63 \1a
+ gcÚd
+) {
+
+64 \ 4
+ gÉ
+:
+
+65 \15
+gt
+;
+
+66 \ 4
+ ggt
+:
+
+67 \15
+É
+;
+
+68 \ 4
+ gge
+:
+
+69 \15
+Ë
+;
+
+70 \ 4
+ gË
+:
+
+71 \15
+ge
+;
+
+73 \15
+cÚd
+;
+
+84 \e
+\9at32_t
+
+ tIn¡r
+;
+
+87 \f
+ eOpcode
+ {
+
+88
+ gTWI
+ = 3 << 26,
+
+89
+ gMULLI
+ = 7 << 26,
+
+90
+ gSUBFIC
+ = 8 << 26,
+
+91
+ gCMPLI
+ = 10 << 26,
+
+92
+ gCMPI
+ = 11 << 26,
+
+93
+ gADDIC
+ = 12 << 26,
+
+94
+ gADDICx
+ = 13 << 26,
+
+95
+ gADDI
+ = 14 << 26,
+
+96
+ gADDIS
+ = 15 << 26,
+
+97
+ gBCX
+ = 16 << 26,
+
+98
+ gSC
+ = 17 << 26,
+
+99
+ gBX
+ = 18 << 26,
+
+100
+ gEXT1
+ = 19 << 26,
+
+101
+ gRLWIMIX
+ = 20 << 26,
+
+102
+ gRLWINMX
+ = 21 << 26,
+
+103
+ gRLWNMX
+ = 23 << 26,
+
+104
+ gORI
+ = 24 << 26,
+
+105
+ gORIS
+ = 25 << 26,
+
+106
+ gXORI
+ = 26 << 26,
+
+107
+ gXORIS
+ = 27 << 26,
+
+108
+ gANDIx
+ = 28 << 26,
+
+109
+ gANDISx
+ = 29 << 26,
+
+110
+ gEXT5
+ = 30 << 26,
+
+111
+ gEXT2
+ = 31 << 26,
+
+112
+ gLWZ
+ = 32 << 26,
+
+113
+ gLWZU
+ = 33 << 26,
+
+114
+ gLBZ
+ = 34 << 26,
+
+115
+ gLBZU
+ = 35 << 26,
+
+116
+ gSTW
+ = 36 << 26,
+
+117
+ gSTWU
+ = 37 << 26,
+
+118
+ gSTB
+ = 38 << 26,
+
+119
+ gSTBU
+ = 39 << 26,
+
+120
+ gLHZ
+ = 40 << 26,
+
+121
+ gLHZU
+ = 41 << 26,
+
+122
+ gLHA
+ = 42 << 26,
+
+123
+ gLHAU
+ = 43 << 26,
+
+124
+ gSTH
+ = 44 << 26,
+
+125
+ gSTHU
+ = 45 << 26,
+
+126
+ gLMW
+ = 46 << 26,
+
+127
+ gSTMW
+ = 47 << 26,
+
+128
+ gLFS
+ = 48 << 26,
+
+129
+ gLFSU
+ = 49 << 26,
+
+130
+ gLFD
+ = 50 << 26,
+
+131
+ gLFDU
+ = 51 << 26,
+
+132
+ gSTFS
+ = 52 << 26,
+
+133
+ gSTFSU
+ = 53 << 26,
+
+134
+ gSTFD
+ = 54 << 26,
+
+135
+ gSTFDU
+ = 55 << 26,
+
+136
+ gLD
+ = 58 << 26,
+
+137
+ gEXT3
+ = 59 << 26,
+
+138
+ gSTD
+ = 62 << 26,
+
+139
+ gEXT4
+ = 63 << 26
+
+143 \f
+ eOpcodeExt1
+ {
+
+144
+ gMCRF
+ = 0 << 1,
+
+145
+ gBCLRX
+ = 16 << 1,
+
+146
+ gCRNOR
+ = 33 << 1,
+
+147
+ gRFI
+ = 50 << 1,
+
+148
+ gCRANDC
+ = 129 << 1,
+
+149
+ gISYNC
+ = 150 << 1,
+
+150
+ gCRXOR
+ = 193 << 1,
+
+151
+ gCRNAND
+ = 225 << 1,
+
+152
+ gCRAND
+ = 257 << 1,
+
+153
+ gCREQV
+ = 289 << 1,
+
+154
+ gCRORC
+ = 417 << 1,
+
+155
+ gCROR
+ = 449 << 1,
+
+156
+ gBCCTRX
+ = 528 << 1
+
+160 \f
+ eOpcodeExt2
+ {
+
+161
+ gCMP
+ = 0 << 1,
+
+162
+ gTW
+ = 4 << 1,
+
+163
+ gSUBFCX
+ = 8 << 1,
+
+164
+ gADDCX
+ = 10 << 1,
+
+165
+ gMULHWUX
+ = 11 << 1,
+
+166
+ gMFCR
+ = 19 << 1,
+
+167
+ gLWARX
+ = 20 << 1,
+
+168
+ gLDX
+ = 21 << 1,
+
+169
+ gLWZX
+ = 23 << 1,
+
+170
+ gSLWX
+ = 24 << 1,
+
+171
+ gCNTLZWX
+ = 26 << 1,
+
+172
+ gSLDX
+ = 27 << 1,
+
+173
+ gANDX
+ = 28 << 1,
+
+174
+ gCMPL
+ = 32 << 1,
+
+175
+ gSUBFX
+ = 40 << 1,
+
+176
+ gMFVSRD
+ = 51 << 1,
+
+177
+ gLDUX
+ = 53 << 1,
+
+178
+ gDCBST
+ = 54 << 1,
+
+179
+ gLWZUX
+ = 55 << 1,
+
+180
+ gCNTLZDX
+ = 58 << 1,
+
+181
+ gANDCX
+ = 60 << 1,
+
+182
+ gMULHWX
+ = 75 << 1,
+
+183
+ gDCBF
+ = 86 << 1,
+
+184
+ gLBZX
+ = 87 << 1,
+
+185
+ gNEGX
+ = 104 << 1,
+
+186
+ gMFVSRWZ
+ = 115 << 1,
+
+187
+ gLBZUX
+ = 119 << 1,
+
+188
+ gNORX
+ = 124 << 1,
+
+189
+ gSUBFEX
+ = 136 << 1,
+
+190
+ gADDEX
+ = 138 << 1,
+
+191
+ gSTDX
+ = 149 << 1,
+
+192
+ gSTWX
+ = 151 << 1,
+
+193
+ gMTVSRD
+ = 179 << 1,
+
+194
+ gSTDUX
+ = 181 << 1,
+
+195
+ gSTWUX
+ = 183 << 1,
+
+202
+ gADDZEX
+ = 202 << 1,
+
+206
+ gMTVSRWA
+ = 211 << 1,
+
+207
+ gSTBX
+ = 215 << 1,
+
+208
+ gMULLD
+ = 233 << 1,
+
+209
+ gMULLW
+ = 235 << 1,
+
+210
+ gMTVSRWZ
+ = 243 << 1,
+
+211
+ gSTBUX
+ = 247 << 1,
+
+212
+ gADDX
+ = 266 << 1,
+
+213
+ gLHZX
+ = 279 << 1,
+
+214
+ gLHZUX
+ = 311 << 1,
+
+215
+ gLHAX
+ = 343 << 1,
+
+216
+ gLHAUX
+ = 375 << 1,
+
+217
+ gXORX
+ = 316 << 1,
+
+218
+ gMFSPR
+ = 339 << 1,
+
+219
+ gSTHX
+ = 407 << 1,
+
+220
+ gSTHUX
+ = 439 << 1,
+
+221
+ gORX
+ = 444 << 1,
+
+222
+ gMTSPR
+ = 467 << 1,
+
+223
+ gDIVD
+ = 489 << 1,
+
+224
+ gDIVW
+ = 491 << 1,
+
+227
+ gLFSX
+ = 535 << 1,
+
+228
+ gSRWX
+ = 536 << 1,
+
+229
+ gSRDX
+ = 539 << 1,
+
+230
+ gLFSUX
+ = 567 << 1,
+
+231
+ gSYNC
+ = 598 << 1,
+
+232
+ gLFDX
+ = 599 << 1,
+
+233
+ gLFDUX
+ = 631 << 1,
+
+234
+ gSTFSX
+ = 663 << 1,
+
+235
+ gSTFSUX
+ = 695 << 1,
+
+236
+ gSTFDX
+ = 727 << 1,
+
+237
+ gSTFDUX
+ = 759 << 1,
+
+238
+ gSRAW
+ = 792 << 1,
+
+239
+ gSRAD
+ = 794 << 1,
+
+240
+ gSRAWIX
+ = 824 << 1,
+
+241
+ gSRADIX
+ = 413 << 2,
+
+242
+ gEXTSH
+ = 922 << 1,
+
+243
+ gEXTSB
+ = 954 << 1,
+
+244
+ gICBI
+ = 982 << 1,
+
+245
+ gEXTSW
+ = 986 << 1
+
+249 \f
+ eOpcodeExt4
+ {
+
+251
+ gFDIV
+ = 18 << 1,
+
+252
+ gFSUB
+ = 20 << 1,
+
+253
+ gFADD
+ = 21 << 1,
+
+254
+ gFSQRT
+ = 22 << 1,
+
+255
+ gFSEL
+ = 23 << 1,
+
+256
+ gFMUL
+ = 25 << 1,
+
+257
+ gFMSUB
+ = 28 << 1,
+
+258
+ gFMADD
+ = 29 << 1,
+
+261
+ gFCMPU
+ = 0 << 1,
+
+262
+ gFRSP
+ = 12 << 1,
+
+263
+ gFCTIW
+ = 14 << 1,
+
+264
+ gFCTIWZ
+ = 15 << 1,
+
+265
+ gFNEG
+ = 40 << 1,
+
+266
+ gMCRFS
+ = 64 << 1,
+
+267
+ gFMR
+ = 72 << 1,
+
+268
+ gMTFSFI
+ = 134 << 1,
+
+269
+ gFABS
+ = 264 << 1,
+
+270
+ gFRIM
+ = 488 << 1,
+
+271
+ gMFFS
+ = 583 << 1,
+
+272
+ gMTFSF
+ = 711 << 1,
+
+273
+ gFCFID
+ = 846 << 1,
+
+274
+ gFCTID
+ = 814 << 1,
+
+275
+ gFCTIDZ
+ = 815 << 1
+
+278 \f
+ eOpcodeExt5
+ {
+
+280
+ gRLDICL
+ = 0 << 1,
+
+281
+ gRLDICR
+ = 2 << 1,
+
+282
+ gRLDIC
+ = 4 << 1,
+
+283
+ gRLDIMI
+ = 6 << 1,
+
+285
+ gRLDCL
+ = 8 << 1,
+
+286
+ gRLDCR
+ = 9 << 1
+
+292
+ gB1
+ = 1 << 1,
+
+293
+ gB4
+ = 1 << 4,
+
+294
+ gB5
+ = 1 << 5,
+
+295
+ gB7
+ = 1 << 7,
+
+296
+ gB8
+ = 1 << 8,
+
+297
+ gB9
+ = 1 << 9,
+
+298
+ gB12
+ = 1 << 12,
+
+299
+ gB18
+ = 1 << 18,
+
+300
+ gB19
+ = 1 << 19,
+
+301
+ gB20
+ = 1 << 20,
+
+302
+ gB22
+ = 1 << 22,
+
+303
+ gB23
+ = 1 << 23,
+
+304
+ gB24
+ = 1 << 24,
+
+305
+ gB25
+ = 1 << 25,
+
+306
+ gB26
+ = 1 << 26,
+
+307
+ gB27
+ = 1 << 27,
+
+308
+ gB28
+ = 1 << 28,
+
+309
+ gB6
+ = 1 << 6,
+
+310
+ gB10
+ = 1 << 10,
+
+311
+ gB11
+ = 1 << 11,
+
+312
+ gB16
+ = 1 << 16,
+
+313
+ gB17
+ = 1 << 17,
+
+314
+ gB21
+ = 1 << 21,
+
+317
+ gkCÚdMask
+ = 0x1F << 21,
+
+318
+ gkOff12Mask
+ = (1 << 12) - 1,
+
+319
+ gkImm24Mask
+ = (1 << 24) - 1,
+
+320
+ gkOff16Mask
+ = (1 << 16) - 1,
+
+321
+ gkImm16Mask
+ = (1 << 16) - 1,
+
+322
+ gkImm26Mask
+ = (1 << 26) - 1,
+
+323
+ gkBOf\9bldMask
+ = 0x1f << 21,
+
+324
+ gkOpcodeMask
+ = 0x3f << 26,
+
+325
+ gkExt1OpcodeMask
+ = 0x3ff << 1,
+
+326
+ gkExt2OpcodeMask
+ = 0x1f << 1,
+
+327
+ gkExt5OpcodeMask
+ = 0x3 << 2,
+
+328
+ gkBOMask
+ = 0x1f << 21,
+
+329
+ gkBIMask
+ = 0x1F << 16,
+
+330
+ gkBDMask
+ = 0x14 << 2,
+
+331
+ gkAAMask
+ = 0x01 << 1,
+
+332
+ gkLKMask
+ = 0x01,
+
+333
+ gkRCMask
+ = 0x01,
+
+334
+ gkTOMask
+ = 0x1f << 21
+
+345 \ 1
+ #FAKE_OPCODE
+ 1 << 26
+
+ )
+
+346 \ 1
+ #MARKER_SUBOPCODE_BIT
+ 25
+
+ )
+
+347 \ 1
+ #MARKER_SUBOPCODE
+ 1 <<
+MARKER_SUBOPCODE_BIT
+
+
+ )
+
+348 \ 1
+ #FAKER_SUBOPCODE
+ 0 <<
+MARKER_SUBOPCODE_BIT
+
+
+ )
+
+350 \f
+ eFAKE_OPCODE_T
+ {
+
+351
+ gfBKPT
+ = 14,
+
+352
+ gfLa¡Fak\94
+
+
+354 \ 1
+ #FAKE_OPCODE_HIGH_BIT
+ 7
+
+355 \ 1
+ #F_NEXT_AVAILABLE_STUB_MARKER
+ 369
+
+356 \ 1
+ #STUB_MARKER_HIGH_BIT
+ 9
+
+359
+
+ )
+
+361 \f
+ eOEB\99
+ {
+
+362
+ gS\91OE
+ = 1 << 10,
+
+363
+ gL\97veOE
+ = 0 << 10
+
+367 \f
+ eRCB\99
+ {
+
+368
+ gS\91RC
+ = 1,
+
+369
+ gL\97veRC
+ = 0
+
+373 \f
+ eLKB\99
+ {
+
+374
+ gS\91LK
+ = 1,
+
+375
+ gL\97veLK
+ = 0
+
+378 \f
+ eBOf\9bld
+ {
+
+379
+ gDCBNZF
+ = 0 << 21,
+
+380
+ gDCBEZF
+ = 2 << 21,
+
+381
+ gBF
+ = 4 << 21,
+
+382
+ gDCBNZT
+ = 8 << 21,
+
+383
+ gDCBEZT
+ = 10 << 21,
+
+384
+ gBT
+ = 12 << 21,
+
+385
+ gDCBNZ
+ = 16 << 21,
+
+386
+ gDCBEZ
+ = 18 << 21,
+
+387
+ gBA
+ = 20 << 21
+
+390 #ià
+V8_OS_AIX
+
+
+391 #undeà
+CR_LT
+
+
+392 #undeà
+CR_GT
+
+
+393 #undeà
+CR_EQ
+
+
+394 #undeà
+CR_SO
+
+
+397 \f
+ eCRB\99
+ {
+ gCR_LT
+ = 0,
+ gCR_GT
+ = 1,
+ gCR_EQ
+ = 2,
+ gCR_SO
+ = 3,
+ gCR_FU
+ = 3 };
+
+399 \ 1
+ #CRWIDTH
+ 4
+
+ )
+
+408 \f
+ eSoáw¬eIÁ\94ru±Codes
+ {
+
+410
+ gkC®lRtRed\9ceùed
+ = 0x10,
+
+412
+ gkB»akpo\9at
+ = 0x821008,
+
+414
+ gkStÝCode
+ = 1 << 23,
+
+416
+ gkInfo
+ = 0x9ff808
+
+418 cڡ
+u\9at32_t
+
+ gkStÝCodeMask
+ =
+kStÝCode
+ - 1;
+
+419 cڡ
+u\9at32_t
+
+ gkMaxStÝCode
+ =
+kStÝCode
+ - 1;
+
+420 cڡ
+\9at32_t
+
+ gkDeçuÉStÝCode
+ = -1;
+
+423 \f
+ eFPRound\9agMode
+ {
+
+424
+ gRN
+ = 0,
+
+425
+ gRZ
+ = 1,
+
+426
+ gRP
+ = 2,
+
+427
+ gRM
+ = 3,
+
+430
+ gkRoundToN\97»¡
+ =
+RN
+,
+
+431
+ gkRoundToZ\94o
+ =
+RZ
+,
+
+432
+ gkRoundToPlusInf
+ =
+RP
+,
+
+433
+ gkRoundToM\9ausInf
+ =
+RM
+
+
+436 cڡ
+u\9at32_t
+
+ gkFPRound\9agModeMask
+ = 3;
+
+438 \f
+ eCheckFÜIÃxaùCÚv\94siÚ
+ {
+
+439
+ gkCheckFÜIÃxaùCÚv\94siÚ
+,
+
+440
+ gkDÚtCheckFÜIÃxaùCÚv\94siÚ
+
+
+450 \rcڡ
+In¡r
+
+kPÝIn¡ruùiÚ
+;
+
+454 \rcڡ
+In¡r
+
+kPushRegP©\8bº
+;
+
+458 \rcڡ
+In¡r
+
+kPÝRegP©\8bº
+;
+
+461 cڡ
+In¡r
+
+ g¹C®lRed\9cIn¡r
+ =
+TWI
+;
+
+479 þas
+ cIn¡ruùiÚ
+ {
+
+480
+ gpublic
+:
+
+481 \92um {
+kIn¡rSize
+ = 4,
+ gkIn¡rSizeLog2
+ = 2,
+ gkPCR\97dOff£t
+ = 8 };
+
+485 \ 1
+ #DECLARE_STATIC_TYPED_ACCESSOR
+(
+»tuº_ty³
+,
+Name
+) \
+
+486 \18
+\9al\9ae
+
+»tuº_ty³
+
+ `Name
+(
+In¡r
+
+\9a¡r
+) { \
+
+487 \ 5*
+\8bmp
+ =
+»\9a\8b½»t_ÿ¡
+<\ 5*>(&
+\9a¡r
+); \
+
+488 \15
+»\9a\8b½»t_ÿ¡
+<
+In¡ruùiÚ
+*>(
+\8bmp
+)->
+ `Name
+(); \
+
+489 }
+
+ )
+
+491 \ 1
+ #DECLARE_STATIC_ACCESSOR
+(
+Name
+è
+ `DECLARE_STATIC_TYPED_ACCESSOR
+(\12, Name)
+
+ )
+
+494
+\9al\9ae
+
+In¡r
+
+In¡ruùiÚB\99s
+() const {
+
+495 \15 *
+ g»\9a\8b½»t_ÿ¡
+<cڡ
+ gIn¡r
+*>(
+ gthis
+);
+
+499
+\9al\9ae
+ \1e
+S\91In¡ruùiÚB\99s
+(
+In¡r
+
+v®ue
+) {
+
+500 *
+ g»\9a\8b½»t_ÿ¡
+<
+ gIn¡r
+*>(
+ gthis
+èð
+v®ue
+;
+
+504
+\9al\9ae
+ \12
+B\99
+(\12
+Ä
+ècÚ¡ { \15 (
+In¡ruùiÚB\99s
+(è>>
+ gÄ
+) & 1; }
+
+507
+\9al\9ae
+ \12
+B\99s
+(\12
+hi
+, \12
+lo
+) const {
+
+508 \15 (
+In¡ruùiÚB\99s
+(è>>
+ glo
+è& ((2 << (
+ ghi
+ -\86o)) - 1);
+
+512
+\9al\9ae
+ \12
+B\99F\9bld
+(\12
+hi
+, \12
+lo
+) const {
+
+513 \15
+In¡ruùiÚB\99s
+(è& (((2 << (
+ ghi
+ -
+ glo
+)) - 1) <<\86o);
+
+519 \18
+\9al\9ae
+ \12
+B\99
+(
+In¡r
+
+\9a¡r
+, \12
+Ä
+è{ \15 (
+ g\9a¡r
+ >>
+ gÄ
+) & 1; }
+
+522 \18
+\9al\9ae
+ \12
+B\99s
+(
+In¡r
+
+\9a¡r
+, \12
+hi
+, \12
+lo
+) {
+
+523 \15 (
+ g\9a¡r
+ >>
+ glo
+è& ((2 << (
+ ghi
+ -\86o)) - 1);
+
+528 \18
+\9al\9ae
+ \12
+B\99F\9bld
+(
+In¡r
+
+\9a¡r
+, \12
+hi
+, \12
+lo
+) {
+
+529 \15
+ g\9a¡r
+ & (((2 << (
+ ghi
+ -
+ glo
+)) - 1) <<\86o);
+
+532
+\9al\9ae
+ \12
+RSV®ue
+(ècÚ¡ { \15
+B\99s
+(25, 21); }
+
+533
+\9al\9ae
+ \12
+RTV®ue
+(ècÚ¡ { \15
+B\99s
+(25, 21); }
+
+534
+\9al\9ae
+ \12
+RAV®ue
+(ècÚ¡ { \15
+B\99s
+(20, 16); }
+
+535
+DECLARE_STATIC_ACCESSOR
+(
+RAV®ue
+);
+
+536
+\9al\9ae
+ \12
+RBV®ue
+(ècÚ¡ { \15
+B\99s
+(15, 11); }
+
+537
+DECLARE_STATIC_ACCESSOR
+(
+RBV®ue
+);
+
+538
+\9al\9ae
+ \12
+RCV®ue
+(ècÚ¡ { \15
+B\99s
+(10, 6); }
+
+539
+DECLARE_STATIC_ACCESSOR
+(
+RCV®ue
+);
+
+541
+\9al\9ae
+ \12
+OpcodeV®ue
+(ècÚ¡ { \15
+ g¡©ic_ÿ¡
+<
+ gOpcode
+>(
+B\99s
+(31, 26)); }
+
+542
+\9al\9ae
+
+Opcode
+
+OpcodeF\9bld
+() const {
+
+543 \15
+ g¡©ic_ÿ¡
+<
+ gOpcode
+>(
+B\99F\9bld
+(24, 21));
+
+547
+\9al\9ae
+
+Soáw¬eIÁ\94ru±Codes
+
+SvcV®ue
+() const {
+
+548 \15
+ g¡©ic_ÿ¡
+<
+ gSoáw¬eIÁ\94ru±Codes
+>(
+B\99s
+(23, 0));
+
+555 \18
+In¡ruùiÚ
+*
+At
+(
+by\8b
+*
+pc
+) {
+
+556 \15
+ g»\9a\8b½»t_ÿ¡
+<
+ gIn¡ruùiÚ
+*>(
+ gpc
+);
+
+560
+ g´iv©e
+:
+
+562
+DISALLOW_IMPLICIT_CONSTRUCTORS
+(
+In¡ruùiÚ
+);
+
+567 þas
+ cRegi¡\94s
+ {
+
+568
+ gpublic
+:
+
+570 \18cڡ \ 5*
+Name
+(\12
+»g
+);
+
+573 \18\12
+Numb\94
+(cڡ \ 5*
+Çme
+);
+
+575 \19
+ sRegi¡\94Al\9fs
+ {
+
+576 \12
+ g»g
+;
+
+577 cڡ \ 5*
+ gÇme
+;
+
+580
+ g´iv©e
+:
+
+581 \18cڡ \ 5*
+Çmes_
+[
+kNumRegi¡\94s
+];
+
+582 \18cڡ
+Regi¡\94Al\9fs
+
+ g®\9f£s_
+[];
+
+586 þas
+ cFPRegi¡\94s
+ {
+
+587
+ gpublic
+:
+
+589 \18cڡ \ 5*
+Name
+(\12
+»g
+);
+
+592 \18\12
+Numb\94
+(cڡ \ 5*
+Çme
+);
+
+594
+ g´iv©e
+:
+
+595 \18cڡ \ 5*
+Çmes_
+[
+kNumFPRegi¡\94s
+];
+
+ @cpu-ppc.cc
+
+6 \ 2
+ ~"¤c/v8.h
+"
+
+8 #ià
+V8_TARGET_ARCH_PPC
+
+
+10 \ 2
+ ~"¤c/as£mbËr.h
+"
+
+11 \ 2
+ ~"¤c/maüo-as£mbËr.h
+"
+
+12 \ 2
+ ~"¤c/simuÏtÜ.h
+"
+
+14
+Çme¥aû
+
+ gv8
+ {
+
+15
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+17 \1e
+ gCpuF\97tu»s
+::
+FlushICache
+(\1e*
+bufãr
+,
+size_t
+
+size
+) {
+
+19 ià(
+ gsize
+ == 0) {
+
+23 #ià
+def\9aed
+(
+USE_SIMULATOR
+)
+
+29
+ gSimuÏtÜ
+::
+FlushICache
+(
+Isީe
+::
+Cu¼\92t
+()->
+simuÏtÜ_i_ÿche
+(),
+bufãr
+,
+size
+);
+
+32 ià(
+ gCpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+INSTR_AND_DATA_CACHE_COHERENCY
+)) {
+
+33
+__asm__
+
+__vÞ©\9ee__
+(
+
+38 : "r"(
+bufãr
+)
+
+43 cڡ \12
+ gkCacheL\9aeSize
+ =
+CpuF\97tu»s
+::
+ÿche_l\9ae_size
+();
+
+44
+\9a\8d\8c_t
+
+ gmask
+ =
+kCacheL\9aeSize
+ - 1;
+
+45
+by\8b
+ *
+ g¡¬t
+ =
+
+46
+»\9a\8b½»t_ÿ¡
+<
+by\8b
+ *>Ôe\9a\8b½»t_ÿ¡<
+\9a\8d\8c_t
+>(
+bufãr
+è& ~
+mask
+);
+
+47
+by\8b
+ *
+ g\92d
+ =
+¡©ic_ÿ¡
+<by\8b *>(
+bufãr
+è+
+size
+;
+
+48 \ f
+by\8b
+ *
+ gpo\9a\8br
+ =
+¡¬t
+;\85o\9a\8b¸<
+ g\92d
+;\85o\9a\8b¸+ð
+kCacheL\9aeSize
+) {
+
+49
+__asm__
+(
+
+55 : "r"(
+po\9a\8br
+));
+
+ @debug-ppc.cc
+
+5 \ 2
+ ~"¤c/v8.h
+"
+
+7 #ià
+V8_TARGET_ARCH_PPC
+
+
+9 \ 2
+ ~"¤c/codeg\92.h
+"
+
+10 \ 2
+ ~"¤c/debug.h
+"
+
+12
+Çme¥aû
+
+ gv8
+ {
+
+13
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+15
+boÞ
+
+ gB»akLoÿtiÚI\8b¿tÜ
+::
+IsDebugB»akAtR\91uº
+() {
+
+16 \15
+Debug
+::
+IsDebugB»akAtR\91uº
+(
+r\9afo
+());
+
+20 \1e
+ gB»akLoÿtiÚI\8b¿tÜ
+::
+S\91DebugB»akAtR\91uº
+() {
+
+34
+CodeP©ch\94
+
+·tch\94
+(
+r\9afo
+()->
+pc
+(),
+As£mbËr
+::
+kJSR\91uºSequ\92ûIn¡ruùiÚs
+);
+
+35
+ gAs£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+·tch\94
+.
+masm
+());
+
+36
+ g·tch\94
+.
+masm
+()->
+mov
+(
+
+37
+v8
+::
+\9a\8bº®
+::
+r0
+,
+
+38
+O³¿nd
+(
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+debug_\9afo_
+->
+G\91IsÞ©e
+()
+
+39 ->
+bu\9et\9as
+()
+
+40 ->
+R\91uº_DebugB»ak
+()
+
+41 ->
+\92\8cy
+())));
+
+42
+ g·tch\94
+.
+masm
+()->
+mtùr
+(
+v8
+::
+\9a\8bº®
+::
+r0
+);
+
+43
+ g·tch\94
+.
+masm
+()->
+bù¾
+();
+
+44
+ g·tch\94
+.
+masm
+()->
+bk±
+(0);
+
+49 \1e
+ gB»akLoÿtiÚI\8b¿tÜ
+::
+CˬDebugB»akAtR\91uº
+() {
+
+50
+r\9afo
+()->
+P©chCode
+(
+Üig\9a®_r\9afo
+()->
+pc
+(),
+
+51
+As£mbËr
+::
+kJSR\91uºSequ\92ûIn¡ruùiÚs
+);
+
+57
+boÞ
+
+ gDebug
+::
+IsDebugB»akAtR\91uº
+(
+R\96ocInfo
+*
+r\9afo
+) {
+
+58
+DCHECK
+(
+R\96ocInfo
+::
+IsJSR\91uº
+(
+r\9afo
+->
+rmode
+()));
+
+59 \15
+ gr\9afo
+->
+IsP©chedR\91uºSequ\92û
+();
+
+63
+boÞ
+
+ gB»akLoÿtiÚI\8b¿tÜ
+::
+IsDebugB»akAtSlÙ
+() {
+
+64
+DCHECK
+(
+IsDebugB»akSlÙ
+());
+
+66 \15
+r\9afo
+()->
+IsP©chedDebugB»akSlÙSequ\92û
+();
+
+70 \1e
+ gB»akLoÿtiÚI\8b¿tÜ
+::
+S\91DebugB»akAtSlÙ
+() {
+
+71
+DCHECK
+(
+IsDebugB»akSlÙ
+());
+
+86
+CodeP©ch\94
+
+·tch\94
+(
+r\9afo
+()->
+pc
+(),
+As£mbËr
+::
+kDebugB»akSlÙIn¡ruùiÚs
+);
+
+87
+ gAs£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+·tch\94
+.
+masm
+());
+
+88
+ g·tch\94
+.
+masm
+()->
+mov
+(
+
+89
+v8
+::
+\9a\8bº®
+::
+r0
+,
+
+90
+O³¿nd
+(
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+
+91
+debug_\9afo_
+->
+G\91IsÞ©e
+()->
+bu\9et\9as
+()->
+SlÙ_DebugB»ak
+()->
+\92\8cy
+())));
+
+92
+ g·tch\94
+.
+masm
+()->
+mtùr
+(
+v8
+::
+\9a\8bº®
+::
+r0
+);
+
+93
+ g·tch\94
+.
+masm
+()->
+bù¾
+();
+
+97 \1e
+ gB»akLoÿtiÚI\8b¿tÜ
+::
+CˬDebugB»akAtSlÙ
+() {
+
+98
+DCHECK
+(
+IsDebugB»akSlÙ
+());
+
+99
+r\9afo
+()->
+P©chCode
+(
+Üig\9a®_r\9afo
+()->
+pc
+(),
+
+100
+As£mbËr
+::
+kDebugB»akSlÙIn¡ruùiÚs
+);
+
+104 \ 1
+ #__
+
+ `ACCESS_MASM
+(
+masm
+)
+
+ )
+
+107 \18\1e
+G\92\94©e_DebugB»akC®lH\96³r
+(
+MaüoAs£mbËr
+*
+masm
+,
+
+108
+RegLi¡
+
+objeù_»gs
+,
+
+109
+RegLi¡
+
+nÚ_objeù_»gs
+) {
+
+111
+F¿meAndCÚ¡ªtPoÞScÝe
+
+scÝe
+(
+masm
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+114
+__
+
+LßdSmiL\99\94®
+(
+\9d
+,
+Smi
+::
+FromIÁ
+(
+LiveEd\99
+::
+kF¿mePadd\9agV®ue
+));
+
+115 \ f\12
+ gi
+ = 0; i <
+ gLiveEd\99
+::
+kF¿mePadd\9agIn\99\9flSize
+; i++) {
+
+116
+__
+
+push
+(
+\9d
+);
+
+118
+__
+
+LßdSmiL\99\94®
+(
+\9d
+,
+Smi
+::
+FromIÁ
+(
+LiveEd\99
+::
+kF¿mePadd\9agIn\99\9flSize
+));
+
+119
+__
+
+push
+(
+\9d
+);
+
+124
+DCHECK
+((
+objeù_»gs
+ & ~
+kJSC®ËrSaved
+) == 0);
+
+125
+DCHECK
+((
+nÚ_objeù_»gs
+ & ~
+kJSC®ËrSaved
+) == 0);
+
+126
+DCHECK
+((
+objeù_»gs
+ &
+nÚ_objeù_»gs
+) == 0);
+
+127 ià((
+ gobjeù_»gs
+ |
+ gnÚ_objeù_»gs
+) != 0) {
+
+128 \ f\12
+i
+ = 0;
+ gi
+ <
+ gkNumJSC®ËrSaved
+; i++) {
+
+129 \12
+ gr
+ =
+JSC®ËrSavedCode
+(
+i
+);
+
+130
+Regi¡\94
+
+ g»g
+ = {
+r
+};
+
+131 ià((
+ gnÚ_objeù_»gs
+ & (1 <<
+ gr
+)) != 0) {
+
+132 ià(
+FLAG_debug_code
+) {
+
+133
+__
+
+Te¡UnsigÃdSmiCªdid©e
+(
+»g
+,
+r0
+);
+
+134
+__
+
+As£¹
+(
+eq
+,
+kUÇbËToEncodeV®ueAsSmi
+,
+ü0
+);
+
+136
+__
+
+SmiTag
+(
+»g
+);
+
+139
+__
+
+MuÉiPush
+(
+objeù_»gs
+ |
+nÚ_objeù_»gs
+);
+
+142 #ifdeà
+DEBUG
+
+
+143
+__
+
+RecÜdComm\92t
+("// Calling from debug break\81o\84untime - come in - over");
+
+145
+__
+
+mov
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+146
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+debug_b»ak
+(
+masm
+->
+isީe
+())));
+
+148
+CEÁryStub
+
+ûb
+(
+masm
+->
+isީe
+(), 1);
+
+149
+__
+
+C®lStub
+(&
+ûb
+);
+
+152 ià((
+ gobjeù_»gs
+ |
+ gnÚ_objeù_»gs
+) != 0) {
+
+153
+__
+
+MuÉiPÝ
+(
+objeù_»gs
+ |
+nÚ_objeù_»gs
+);
+
+154 \ f\12
+ gi
+ = 0; i <
+ gkNumJSC®ËrSaved
+; i++) {
+
+155 \12
+ gr
+ =
+JSC®ËrSavedCode
+(
+i
+);
+
+156
+Regi¡\94
+
+ g»g
+ = {
+r
+};
+
+157 ià((
+ gnÚ_objeù_»gs
+ & (1 <<
+ gr
+)) != 0) {
+
+158
+__
+
+SmiUÁag
+(
+»g
+);
+
+160 ià(
+ gFLAG_debug_code
+ &&
+
+161 (((
+ gobjeù_»gs
+ |
+ gnÚ_objeù_»gs
+è& (1 <<
+ gr
+)) == 0)) {
+
+162
+__
+
+mov
+(
+»g
+,
+O³¿nd
+(
+kDebugZV®ue
+));
+
+176
+Ex\8bº®Reã»nû
+
+ gaá\94_b»ak_\8frg\91
+ =
+
+177
+Ex\8bº®Reã»nû
+::
+debug_aá\94_b»ak_\8frg\91_add»ss
+(
+masm
+->
+isީe
+());
+
+178
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+aá\94_b»ak_\8frg\91
+));
+
+179
+__
+
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(ip));
+
+180
+__
+
+JumpToJSEÁry
+(
+\9d
+);
+
+184 \1e
+ gDebugCodeg\92
+::
+G\92\94©eC®lICStubDebugB»ak
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+190
+G\92\94©e_DebugB»akC®lH\96³r
+(
+masm
+,
+r4
+.
+b\99
+(è|
+r6
+.bit(), 0);
+
+194 \1e
+ gDebugCodeg\92
+::
+G\92\94©eLßdICDebugB»ak
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+196
+Regi¡\94
+
+»ûiv\94
+ =
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+();
+
+197
+Regi¡\94
+
+ gÇme
+ =
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+();
+
+198
+RegLi¡
+
+ g»gs
+ =
+»ûiv\94
+.
+b\99
+(è|
+Çme
+.bit();
+
+199 ià(
+ gFLAG_veùÜ_ics
+) {
+
+200
+ g»gs
+ |ð
+VeùÜLßdICT¿mpÞ\9aeDesü\9dtÜ
+::
+SlÙRegi¡\94
+().
+b\99
+();
+
+202
+G\92\94©e_DebugB»akC®lH\96³r
+(
+masm
+,
+»gs
+, 0);
+
+206 \1e
+ gDebugCodeg\92
+::
+G\92\94©eStÜeICDebugB»ak
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+208
+Regi¡\94
+
+»ûiv\94
+ =
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+();
+
+209
+Regi¡\94
+
+ gÇme
+ =
+StÜeDesü\9dtÜ
+::
+NameRegi¡\94
+();
+
+210
+Regi¡\94
+
+ gv®ue
+ =
+StÜeDesü\9dtÜ
+::
+V®ueRegi¡\94
+();
+
+211
+G\92\94©e_DebugB»akC®lH\96³r
+(
+masm
+,
+»ûiv\94
+.
+b\99
+(è|
+Çme
+.b\99(è|
+v®ue
+.bit(),
+
+216 \1e
+ gDebugCodeg\92
+::
+G\92\94©eKeyedLßdICDebugB»ak
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+218
+G\92\94©eLßdICDebugB»ak
+(
+masm
+);
+
+222 \1e
+ gDebugCodeg\92
+::
+G\92\94©eKeyedStÜeICDebugB»ak
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+224
+Regi¡\94
+
+»ûiv\94
+ =
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+();
+
+225
+Regi¡\94
+
+ gÇme
+ =
+StÜeDesü\9dtÜ
+::
+NameRegi¡\94
+();
+
+226
+Regi¡\94
+
+ gv®ue
+ =
+StÜeDesü\9dtÜ
+::
+V®ueRegi¡\94
+();
+
+227
+G\92\94©e_DebugB»akC®lH\96³r
+(
+masm
+,
+»ûiv\94
+.
+b\99
+(è|
+Çme
+.b\99(è|
+v®ue
+.bit(),
+
+232 \1e
+ gDebugCodeg\92
+::
+G\92\94©eCom·»N\9eICDebugB»ak
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+237
+G\92\94©e_DebugB»akC®lH\96³r
+(
+masm
+,
+r3
+.
+b\99
+(), 0);
+
+241 \1e
+ gDebugCodeg\92
+::
+G\92\94©eR\91uºDebugB»ak
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+245
+G\92\94©e_DebugB»akC®lH\96³r
+(
+masm
+,
+r3
+.
+b\99
+(), 0);
+
+249 \1e
+ gDebugCodeg\92
+::
+G\92\94©eC®lFunùiÚStubDebugB»ak
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+254
+G\92\94©e_DebugB»akC®lH\96³r
+(
+masm
+,
+r4
+.
+b\99
+(), 0);
+
+258 \1e
+ gDebugCodeg\92
+::
+G\92\94©eC®lCÚ¡ruùStubDebugB»ak
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+264
+G\92\94©e_DebugB»akC®lH\96³r
+(
+masm
+,
+r4
+.
+b\99
+(),
+r3
+.bit());
+
+268 \1e
+ gDebugCodeg\92
+::
+G\92\94©eC®lCÚ¡ruùStubRecÜdDebugB»ak
+(
+
+269
+MaüoAs£mbËr
+*
+masm
+) {
+
+277
+G\92\94©e_DebugB»akC®lH\96³r
+(
+masm
+,
+r4
+.
+b\99
+(è|
+r5
+.b\99(è|
+r6
+.b\99(),
+r3
+.bit());
+
+281 \1e
+ gDebugCodeg\92
+::
+G\92\94©eSlÙ
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+284
+As£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+masm
+);
+
+285
+Lab\96
+
+ gcheck_codesize
+;
+
+286
+__
+
+b\9ad
+(&
+check_codesize
+);
+
+287
+__
+
+RecÜdDebugB»akSlÙ
+();
+
+288 \ f\12
+ gi
+ = 0; i <
+ gAs£mbËr
+::
+kDebugB»akSlÙIn¡ruùiÚs
+; i++) {
+
+289
+__
+
+nÝ
+(
+MaüoAs£mbËr
+::
+DEBUG_BREAK_NOP
+);
+
+291
+DCHECK_EQ
+(
+As£mbËr
+::
+kDebugB»akSlÙIn¡ruùiÚs
+,
+
+292
+masm
+->
+In¡ruùiÚsG\92\94©edS\9aû
+(&
+check_codesize
+));
+
+296 \1e
+ gDebugCodeg\92
+::
+G\92\94©eSlÙDebugB»ak
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+299
+G\92\94©e_DebugB»akC®lH\96³r
+(
+masm
+, 0, 0);
+
+303 \1e
+ gDebugCodeg\92
+::
+G\92\94©ePÏ\9aR\91uºLiveEd\99
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+304
+__
+
+R\91
+();
+
+308 \1e
+ gDebugCodeg\92
+::
+G\92\94©eF¿meDrݳrLiveEd\99
+(
+MaüoAs£mbËr
+*
+masm
+) {
+
+309
+Ex\8bº®Reã»nû
+
+»¡¬\8br_äame_funùiÚ_¦Ù
+ =
+
+310
+Ex\8bº®Reã»nû
+::
+debug_»¡¬\8br_äame_funùiÚ_po\9a\8br_add»ss
+(
+
+311
+masm
+->
+isީe
+());
+
+312
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+»¡¬\8br_äame_funùiÚ_¦Ù
+));
+
+313
+__
+
+li
+(
+r4
+,
+O³¿nd
+::
+Z\94o
+());
+
+314
+__
+
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+\9d
+, 0));
+
+317
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ¡ªtPoÞOff£t
+ -
+
+318
+kPo\9a\8brSize
+));
+
+322
+__
+
+L\97veF¿me
+(
+S\8fckF¿me
+::
+INTERNAL
+);
+
+325
+__
+
+LßdP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCÚ\8bxtOff£t
+));
+
+328
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+329
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(\9d,
+Sh¬edFunùiÚInfo
+::
+kCodeOff£t
+));
+
+330
+__
+
+addi
+(
+\9d
+, ip,
+O³¿nd
+(
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+333
+__
+
+Jump
+(
+\9d
+);
+
+337 cڡ
+boÞ
+
+ gLiveEd\99
+::
+kF¿meDrݳrSuµÜ\8bd
+ =
+\8cue
+;
+
+339 #undeà
+__
+
+
+ @deoptimizer-ppc.cc
+
+5 \ 2
+ ~"¤c/v8.h
+"
+
+7 \ 2
+ ~"¤c/codeg\92.h
+"
+
+8 \ 2
+ ~"¤c/deÝtimiz\94.h
+"
+
+9 \ 2
+ ~"¤c/fuÎ-codeg\92.h
+"
+
+10 \ 2
+ ~"¤c/§ãpo\9at-\8fbË.h
+"
+
+12
+Çme¥aû
+
+ gv8
+ {
+
+13
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+15 cڡ \12
+ gDeÝtimiz\94
+::
+\8fbË_\92\8cy_size_
+ = 8;
+
+18 \12
+ gDeÝtimiz\94
+::
+·tch_size
+() {
+
+19 #ià
+V8_TARGET_ARCH_PPC64
+
+
+20 cڡ \12
+kC®lIn¡ruùiÚSizeInWÜds
+ = 7;
+
+22 cڡ \12
+ gkC®lIn¡ruùiÚSizeInWÜds
+ = 4;
+
+24 \15
+kC®lIn¡ruùiÚSizeInWÜds
+ *
+ gAs£mbËr
+::
+kIn¡rSize
+;
+
+28 \1e
+ gDeÝtimiz\94
+::
+P©chCodeFÜDeÝtimiz©iÚ
+(
+Isީe
+*
+isީe
+,
+Code
+*
+code
+) {
+
+29
+Add»ss
+
+ gcode_¡¬t_add»ss
+ =
+code
+->
+\9a¡ruùiÚ_¡¬t
+();
+
+33
+ gcode
+->
+Inv®id©eR\96oÿtiÚ
+();
+
+35 ià(
+ gFLAG_z_code_¥aû
+) {
+
+37
+by\8b
+*
+ gpo\9a\8br
+ =
+code
+->
+F\9adCodeAgeSequ\92û
+();
+
+38 ià(
+ gpo\9a\8br
+ !ð
+NULL
+) {
+
+39
+po\9a\8br
+ +ð
+kNoCodeAgeSequ\92ûL\92gth
+;
+
+41
+ gpo\9a\8br
+ =
+code
+->
+\9a¡ruùiÚ_¡¬t
+();
+
+43
+CodeP©ch\94
+
+·tch\94
+(
+po\9a\8br
+, 1);
+
+44
+ g·tch\94
+.
+masm
+()->
+bk±
+(0);
+
+46
+DeÝtimiz©iÚIÅutD©a
+*
+ gd©a
+ =
+
+47
+DeÝtimiz©iÚIÅutD©a
+::
+ÿ¡
+(
+code
+->
+deÝtimiz©iÚ_d©a
+());
+
+48 \12
+ go¤_off£t
+ =
+d©a
+->
+O¤PcOff£t
+()->
+v®ue
+();
+
+49 ià(
+ go¤_off£t
+ > 0) {
+
+50
+CodeP©ch\94
+
+o¤_·tch\94
+(
+code
+->
+\9a¡ruùiÚ_¡¬t
+(è+
+o¤_off£t
+, 1);
+
+51
+ go¤_·tch\94
+.
+masm
+()->
+bk±
+(0);
+
+55
+DeÝtimiz©iÚIÅutD©a
+*
+ gdeÝt_d©a
+ =
+
+56
+DeÝtimiz©iÚIÅutD©a
+::
+ÿ¡
+(
+code
+->
+deÝtimiz©iÚ_d©a
+());
+
+57 #ifdeà
+DEBUG
+
+
+58
+Add»ss
+
+ g´ev_ÿÎ_add»ss
+ =
+NULL
+;
+
+62 \ f\12
+ gi
+ = 0; i <
+ gdeÝt_d©a
+->
+DeÝtCouÁ
+(); i++) {
+
+63 ià(
+ gdeÝt_d©a
+->
+Pc
+(
+i
+)->
+v®ue
+() == -1) \ 6;
+
+64
+Add»ss
+
+ gÿÎ_add»ss
+ =
+code_¡¬t_add»ss
+ +
+deÝt_d©a
+->
+Pc
+(
+i
+)->
+v®ue
+();
+
+65
+Add»ss
+
+ gdeÝt_\92\8cy
+ =
+G\91DeÝtimiz©iÚEÁry
+(
+isީe
+,
+i
+,
+LAZY
+);
+
+68 \12
+ gÿÎ_size_\9a_by\8bs
+ =
+MaüoAs£mbËr
+::
+C®lSizeNÙP»diùabËCodeSize
+(
+
+69
+deÝt_\92\8cy
+,
+kR\96ocInfo_NONEPTR
+);
+
+70 \12
+ gÿÎ_size_\9a_wÜds
+ =
+ÿÎ_size_\9a_by\8bs
+ /
+As£mbËr
+::
+kIn¡rSize
+;
+
+71
+DCHECK
+(
+ÿÎ_size_\9a_by\8bs
+ %
+As£mbËr
+::
+kIn¡rSize
+ == 0);
+
+72
+DCHECK
+(
+ÿÎ_size_\9a_by\8bs
+ <ð
+·tch_size
+());
+
+73
+CodeP©ch\94
+
+·tch\94
+(
+ÿÎ_add»ss
+,
+ÿÎ_size_\9a_wÜds
+);
+
+74
+ g·tch\94
+.
+masm
+()->
+C®l
+(
+deÝt_\92\8cy
+,
+kR\96ocInfo_NONEPTR
+);
+
+75
+DCHECK
+(
+´ev_ÿÎ_add»ss
+ =ð
+NULL
+ ||
+
+76
+ÿÎ_add»ss
+ >ð
+´ev_ÿÎ_add»ss
+ +
+·tch_size
+());
+
+77
+DCHECK
+(
+ÿÎ_add»ss
+ +
+·tch_size
+(è<ð
+code
+->
+\9a¡ruùiÚ_\92d
+());
+
+78 #ifdeà
+DEBUG
+
+
+79
+ g´ev_ÿÎ_add»ss
+ =
+ÿÎ_add»ss
+;
+
+85 \1e
+ gDeÝtimiz\94
+::
+F\9elIÅutF¿me
+(
+Add»ss
+
+tos
+,
+JavaSü\9dtF¿me
+*
+äame
+) {
+
+90 \ f\12
+ gi
+ = 0; i <
+ gRegi¡\94
+::
+kNumRegi¡\94s
+; i++) {
+
+91
+ g\9aput_
+->
+S\91Regi¡\94
+(
+i
+, i * 4);
+
+93
+ g\9aput_
+->
+S\91Regi¡\94
+(
+¥
+.
+code
+(),
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+äame
+->sp()));
+
+94
+ g\9aput_
+->
+S\91Regi¡\94
+(
+å
+.
+code
+(),
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+äame
+->fp()));
+
+95 \ f\12
+ gi
+ = 0; i <
+ gDoubËRegi¡\94
+::
+NumAÎoÿ\8fbËRegi¡\94s
+(); i++) {
+
+96
+ g\9aput_
+->
+S\91DoubËRegi¡\94
+(
+i
+, 0.0);
+
+100 \ f\1d
+ gi
+ = 0; i <
+ g\9aput_
+->
+G\91F¿meSize
+(); i +ð
+kPo\9a\8brSize
+) {
+
+101
+\9aput_
+->
+S\91F¿meSlÙ
+(
+
+102
+i
+,
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+MemÜy
+::
+Add»ss_©
+(
+tos
+ + i)));
+
+107 \1e
+ gDeÝtimiz\94
+::
+S\91PÏtfÜmComp\9eedStubRegi¡\94s
+(
+
+108
+F¿meDesü\9dtiÚ
+*
+ou\8dut_äame
+,
+CodeStubDesü\9dtÜ
+*
+desü\9dtÜ
+) {
+
+109
+ApiFunùiÚ
+
+funùiÚ
+(
+desü\9dtÜ
+->
+deÝtimiz©iÚ_hªdËr
+());
+
+110
+Ex\8bº®Reã»nû
+
+x»f
+(&
+funùiÚ
+, Ex\8bº®Reã»nû::
+BUILTIN_CALL
+,
+isީe_
+);
+
+111
+\9a\8d\8c_t
+
+ ghªdËr
+ =
+»\9a\8b½»t_ÿ¡
+<\9a\8d\8c_t>(
+x»f
+.
+add»ss
+());
+
+112 \12
+ g·¿ms
+ =
+desü\9dtÜ
+->
+G\91HªdËrP¬am\91\94CouÁ
+();
+
+113
+ gou\8dut_äame
+->
+S\91Regi¡\94
+(
+r3
+.
+code
+(),
+·¿ms
+);
+
+114
+ gou\8dut_äame
+->
+S\91Regi¡\94
+(
+r4
+.
+code
+(),
+hªdËr
+);
+
+118 \1e
+ gDeÝtimiz\94
+::
+CÝyDoubËRegi¡\94s
+(
+F¿meDesü\9dtiÚ
+*
+ou\8dut_äame
+) {
+
+119 \ f\12
+i
+ = 0;
+ gi
+ <
+ gDoubËRegi¡\94
+::
+kMaxNumRegi¡\94s
+; ++i) {
+
+120 \b
+ gdoubË_v®ue
+ =
+\9aput_
+->
+G\91DoubËRegi¡\94
+(
+i
+);
+
+121
+ gou\8dut_äame
+->
+S\91DoubËRegi¡\94
+(
+i
+,
+doubË_v®ue
+);
+
+126
+boÞ
+
+ gDeÝtimiz\94
+::
+HasAlignm\92tPadd\9ag
+(
+JSFunùiÚ
+*
+funùiÚ
+) {
+
+128 \15
+çl£
+;
+
+132 \ 1
+ #__
+
+ `masm
+()->
+
+ )
+
+136 \1e
+ gDeÝtimiz\94
+::
+EÁryG\92\94©Ü
+::
+G\92\94©e
+() {
+
+137
+G\92\94©ePrÞogue
+();
+
+141 cڡ \12
+ gkNumb\94OfRegi¡\94s
+ =
+Regi¡\94
+::
+kNumRegi¡\94s
+;
+
+143
+RegLi¡
+
+ g»¡Üed_»gs
+ =
+kJSC®ËrSaved
+ |
+kC®ËeSaved
+;
+
+144
+RegLi¡
+
+ g§ved_»gs
+ =
+»¡Üed_»gs
+ |
+¥
+.
+b\99
+();
+
+146 cڡ \12
+ gkDoubËRegsSize
+ =
+
+147
+kDoubËSize
+ *
+DoubËRegi¡\94
+::
+kMaxNumAÎoÿ\8fbËRegi¡\94s
+;
+
+150
+__
+
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËRegsSize
+));
+
+151 \ f\12
+ gi
+ = 0; i <
+ gDoubËRegi¡\94
+::
+kMaxNumAÎoÿ\8fbËRegi¡\94s
+; ++i) {
+
+152
+DoubËRegi¡\94
+
+ gåu_»g
+ = DoubËRegi¡\94::
+FromAÎoÿtiÚIndex
+(
+i
+);
+
+153 \12
+ goff£t
+ =
+i
+ *
+kDoubËSize
+;
+
+154
+__
+
+¡fd
+(
+åu_»g
+,
+MemO³¿nd
+(
+¥
+,
+off£t
+));
+
+159
+__
+
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+kNumb\94OfRegi¡\94s
+ *
+kPo\9a\8brSize
+));
+
+160 \ f
+\9at16_t
+
+ gi
+ =
+kNumb\94OfRegi¡\94s
+ - 1; i >= 0; i--) {
+
+161 ià((
+ g§ved_»gs
+ & (1 <<
+ gi
+)) != 0) {
+
+162
+__
+
+StÜeP
+(
+ToRegi¡\94
+(
+i
+),
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+ * i));
+
+166 cڡ \12
+ gkSavedRegi¡\94sA»aSize
+ =
+
+167 (
+kNumb\94OfRegi¡\94s
+ *
+kPo\9a\8brSize
+è+
+kDoubËRegsSize
+;
+
+170
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+,
+kSavedRegi¡\94sA»aSize
+));
+
+175
+__
+
+mær
+(
+r6
+);
+
+177
+__
+
+addi
+(
+r7
+,
+¥
+,
+O³¿nd
+(
+kSavedRegi¡\94sA»aSize
+ + (1 *
+kPo\9a\8brSize
+)));
+
+178
+__
+
+sub
+(
+r7
+,
+å
+,\847);
+
+182
+__
+
+P»·»C®lCFunùiÚ
+(6,
+r8
+);
+
+183
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+184
+__
+
+li
+(
+r4
+,
+O³¿nd
+(
+ty³
+()));
+
+188
+__
+
+mov
+(
+r8
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+isީe
+())));
+
+191
+AÎowEx\8bº®C®lTh©CªtCau£GC
+
+scÝe
+(
+masm
+());
+
+192
+__
+
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+::
+Ãw_deÝtimiz\94_funùiÚ
+(
+isީe
+()), 6);
+
+197
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+r3
+,
+DeÝtimiz\94
+::
+\9aput_off£t
+()));
+
+200
+DCHECK
+(
+Regi¡\94
+::
+kNumRegi¡\94s
+ =ð
+kNumb\94OfRegi¡\94s
+);
+
+201 \ f\12
+ gi
+ = 0; i <
+ gkNumb\94OfRegi¡\94s
+; i++) {
+
+202 \12
+ goff£t
+ = (
+i
+ *
+kPo\9a\8brSize
+è+
+F¿meDesü\9dtiÚ
+::
+»gi¡\94s_off£t
+();
+
+203
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+,
+i
+ *
+kPo\9a\8brSize
+));
+
+204
+__
+
+StÜeP
+(
+r5
+,
+MemO³¿nd
+(
+r4
+,
+off£t
+));
+
+207 \12
+ gdoubË_»gs_off£t
+ =
+F¿meDesü\9dtiÚ
+::
+doubË_»gi¡\94s_off£t
+();
+
+210 \ f\12
+ gi
+ = 0; i <
+ gDoubËRegi¡\94
+::
+NumAÎoÿ\8fbËRegi¡\94s
+(); ++i) {
+
+211 \12
+ gd¡_off£t
+ =
+i
+ *
+kDoubËSize
+ +
+doubË_»gs_off£t
+;
+
+212 \12
+ g¤c_off£t
+ =
+i
+ *
+kDoubËSize
+ +
+kNumb\94OfRegi¡\94s
+ *
+kPo\9a\8brSize
+;
+
+213
+__
+
+lfd
+(
+d0
+,
+MemO³¿nd
+(
+¥
+,
+¤c_off£t
+));
+
+214
+__
+
+¡fd
+(
+d0
+,
+MemO³¿nd
+(
+r4
+,
+d¡_off£t
+));
+
+218
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kSavedRegi¡\94sA»aSize
+ + (1 *
+kPo\9a\8brSize
+)));
+
+222
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+r4
+,
+F¿meDesü\9dtiÚ
+::
+äame_size_off£t
+()));
+
+223
+__
+
+add
+(
+r5
+,\845,
+¥
+);
+
+228
+__
+
+addi
+(
+r6
+,
+r4
+,
+O³¿nd
+(
+F¿meDesü\9dtiÚ
+::
+äame_cÚ\8bÁ_off£t
+()));
+
+229
+Lab\96
+
+ gpÝ_loÝ
+;
+
+230
+Lab\96
+
+ gpÝ_loÝ_h\97d\94
+;
+
+231
+__
+
+b
+(&
+pÝ_loÝ_h\97d\94
+);
+
+232
+__
+
+b\9ad
+(&
+pÝ_loÝ
+);
+
+233
+__
+
+pÝ
+(
+r7
+);
+
+234
+__
+
+StÜeP
+(
+r7
+,
+MemO³¿nd
+(
+r6
+, 0));
+
+235
+__
+
+addi
+(
+r6
+,\846,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+236
+__
+
+b\9ad
+(&
+pÝ_loÝ_h\97d\94
+);
+
+237
+__
+
+cmp
+(
+r5
+,
+¥
+);
+
+238
+__
+
+bÃ
+(&
+pÝ_loÝ
+);
+
+241
+__
+
+push
+(
+r3
+);
+
+243
+__
+
+P»·»C®lCFunùiÚ
+(1,
+r4
+);
+
+246
+AÎowEx\8bº®C®lTh©CªtCau£GC
+
+scÝe
+(
+masm
+());
+
+247
+__
+
+C®lCFunùiÚ
+(
+
+248
+Ex\8bº®Reã»nû
+::
+compu\8b_ou\8dut_äames_funùiÚ
+(
+isީe
+()), 1);
+
+250
+__
+
+pÝ
+(
+r3
+);
+
+253
+Lab\96
+
+ gou\8br_push_loÝ
+,
+ g\9aÃr_push_loÝ
+,
+ gou\8br_loÝ_h\97d\94
+,
+ g\9aÃr_loÝ_h\97d\94
+;
+
+256
+__
+
+lwz
+(
+r4
+,
+MemO³¿nd
+(
+r3
+,
+DeÝtimiz\94
+::
+ou\8dut_couÁ_off£t
+()));
+
+257
+__
+
+LßdP
+(
+r7
+,
+MemO³¿nd
+(
+r3
+,
+DeÝtimiz\94
+::
+ou\8dut_off£t
+()));
+
+258
+__
+
+ShiáLeáImm
+(
+r4
+,\844,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+259
+__
+
+add
+(
+r4
+,
+r7
+,\844);
+
+260
+__
+
+b
+(&
+ou\8br_loÝ_h\97d\94
+);
+
+262
+__
+
+b\9ad
+(&
+ou\8br_push_loÝ
+);
+
+264
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+r7
+, 0));
+
+265
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+r5
+,
+F¿meDesü\9dtiÚ
+::
+äame_size_off£t
+()));
+
+266
+__
+
+b
+(&
+\9aÃr_loÝ_h\97d\94
+);
+
+268
+__
+
+b\9ad
+(&
+\9aÃr_push_loÝ
+);
+
+269
+__
+
+addi
+(
+r6
+,\846,
+O³¿nd
+(-\17(
+\9a\8d\8c_t
+)));
+
+270
+__
+
+add
+(
+r9
+,
+r5
+,
+r6
+);
+
+271
+__
+
+LßdP
+(
+r9
+,
+MemO³¿nd
+Ô9,
+F¿meDesü\9dtiÚ
+::
+äame_cÚ\8bÁ_off£t
+()));
+
+272
+__
+
+push
+(
+r9
+);
+
+274
+__
+
+b\9ad
+(&
+\9aÃr_loÝ_h\97d\94
+);
+
+275
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+::
+Z\94o
+());
+
+276
+__
+
+bÃ
+(&
+\9aÃr_push_loÝ
+);
+
+278
+__
+
+addi
+(
+r7
+,\847,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+279
+__
+
+b\9ad
+(&
+ou\8br_loÝ_h\97d\94
+);
+
+280
+__
+
+cmp
+(
+r7
+,
+r4
+);
+
+281
+__
+
+bÉ
+(&
+ou\8br_push_loÝ
+);
+
+283
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+r3
+,
+DeÝtimiz\94
+::
+\9aput_off£t
+()));
+
+284 \ f\12
+ gi
+ = 0; i <
+ gDoubËRegi¡\94
+::
+kMaxNumAÎoÿ\8fbËRegi¡\94s
+; ++i) {
+
+285 cڡ
+DoubËRegi¡\94
+
+ gd»g
+ = DoubËRegi¡\94::
+FromAÎoÿtiÚIndex
+(
+i
+);
+
+286 \12
+ g¤c_off£t
+ =
+i
+ *
+kDoubËSize
+ +
+doubË_»gs_off£t
+;
+
+287
+__
+
+lfd
+(
+d»g
+,
+MemO³¿nd
+(
+r4
+,
+¤c_off£t
+));
+
+291
+__
+
+LßdP
+(
+r9
+,
+MemO³¿nd
+(
+r5
+,
+F¿meDesü\9dtiÚ
+::
+¡©e_off£t
+()));
+
+292
+__
+
+push
+(
+r9
+);
+
+293
+__
+
+LßdP
+(
+r9
+,
+MemO³¿nd
+(
+r5
+,
+F¿meDesü\9dtiÚ
+::
+pc_off£t
+()));
+
+294
+__
+
+push
+(
+r9
+);
+
+295
+__
+
+LßdP
+(
+r9
+,
+MemO³¿nd
+(
+r5
+,
+F¿meDesü\9dtiÚ
+::
+cÚt\9au©iÚ_off£t
+()));
+
+296
+__
+
+push
+(
+r9
+);
+
+299
+DCHECK
+(!(
+\9d
+.
+b\99
+(è&
+»¡Üed_»gs
+));
+
+300
+__
+
+mr
+(
+\9d
+,
+r5
+);
+
+301 \ f\12
+ gi
+ =
+kNumb\94OfRegi¡\94s
+ - 1; i >= 0; i--) {
+
+302 \12
+ goff£t
+ = (
+i
+ *
+kPo\9a\8brSize
+è+
+F¿meDesü\9dtiÚ
+::
+»gi¡\94s_off£t
+();
+
+303 ià((
+ g»¡Üed_»gs
+ & (1 <<
+ gi
+)) != 0) {
+
+304
+__
+
+LßdP
+(
+ToRegi¡\94
+(
+i
+),
+MemO³¿nd
+(
+\9d
+,
+off£t
+));
+
+308
+__
+
+In\99\9flizeRoÙRegi¡\94
+();
+
+310
+__
+
+pÝ
+(
+\9d
+);
+
+311
+__
+
+pÝ
+(
+r0
+);
+
+312
+__
+
+m\8er
+(
+r0
+);
+
+313
+__
+
+Jump
+(
+\9d
+);
+
+314
+__
+
+¡Ý
+("Unreachable.");
+
+318 \1e
+ gDeÝtimiz\94
+::
+TabËEÁryG\92\94©Ü
+::
+G\92\94©ePrÞogue
+() {
+
+319
+As£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+masm
+());
+
+323
+Lab\96
+
+ gdÚe
+;
+
+324 \ f\12
+ gi
+ = 0; i <
+couÁ
+(); i++) {
+
+325 \12
+ g¡¬t
+ =
+masm
+()->
+pc_off£t
+();
+
+326
+USE
+(
+¡¬t
+);
+
+327
+__
+
+li
+(
+\9d
+,
+O³¿nd
+(
+i
+));
+
+328
+__
+
+b
+(&
+dÚe
+);
+
+329
+DCHECK
+(
+masm
+()->
+pc_off£t
+(è-
+¡¬t
+ =ð
+\8fbË_\92\8cy_size_
+);
+
+331
+__
+
+b\9ad
+(&
+dÚe
+);
+
+332
+__
+
+push
+(
+\9d
+);
+
+336 \1e
+ gF¿meDesü\9dtiÚ
+::
+S\91C®ËrPc
+(\1d
+off£t
+,
+\9a\8d\8c_t
+
+v®ue
+) {
+
+337
+S\91F¿meSlÙ
+(
+off£t
+,
+v®ue
+);
+
+341 \1e
+ gF¿meDesü\9dtiÚ
+::
+S\91C®ËrFp
+(\1d
+off£t
+,
+\9a\8d\8c_t
+
+v®ue
+) {
+
+342
+S\91F¿meSlÙ
+(
+off£t
+,
+v®ue
+);
+
+346 \1e
+ gF¿meDesü\9dtiÚ
+::
+S\91C®ËrCÚ¡ªtPoÞ
+(\1d
+off£t
+,
+\9a\8d\8c_t
+
+v®ue
+) {
+
+347 #ià
+V8_OOL_CONSTANT_POOL
+
+
+348
+DCHECK
+(
+FLAG_\92abË_oÞ_cÚ¡ªt_poÞ
+);
+
+349
+S\91F¿meSlÙ
+(
+off£t
+,
+v®ue
+);
+
+352
+UNREACHABLE
+();
+
+357 #undeà
+__
+
+
+ @disasm-ppc.cc
+
+26 \ 2
+ ~<as£¹.h
+>
+
+27 \ 2
+ ~<¡d¬g.h
+>
+
+28 \ 2
+ ~<¡dio.h
+>
+
+29 \ 2
+ ~<¡r\9ag.h
+>
+
+31 \ 2
+ ~"¤c/v8.h
+"
+
+33 #ià
+V8_TARGET_ARCH_PPC
+
+
+35 \ 2
+ ~"¤c/ba£/¶©fÜm/¶©fÜm.h
+"
+
+36 \ 2
+ ~"¤c/di§sm.h
+"
+
+37 \ 2
+ ~"¤c/maüo-as£mbËr.h
+"
+
+38 \ 2
+ ~"¤c/µc/cÚ¡ªts-µc.h
+"
+
+41
+Çme¥aû
+
+ gv8
+ {
+
+42
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+50 þas
+ cDecod\94
+ {
+
+51
+ gpublic
+:
+
+52
+Decod\94
+(cڡ
+di§sm
+::
+NameCÚv\94\8br
+&
+cÚv\94\8br
+,
+VeùÜ
+<\ 5>
+out_bufãr
+)
+
+53 :
+cÚv\94\8br_
+(
+cÚv\94\8br
+),
+out_bufãr_
+(
+out_bufãr
+),
+out_bufãr_pos_
+(0) {
+
+54
+ gout_bufãr_
+[
+out_bufãr_pos_
+] = '\0';
+
+57 ~
+Decod\94
+() {}
+
+61 \12
+In¡ruùiÚDecode
+(
+by\8b
+*
+\9a¡ruùiÚ
+);
+
+63
+ g´iv©e
+:
+
+65 \1e
+Pr\9atCh¬
+(cڡ \ 5
+ch
+);
+
+66 \1e
+Pr\9at
+(cڡ \ 5*
+¡r
+);
+
+69 \1e
+Pr\9atRegi¡\94
+(\12
+»g
+);
+
+70 \1e
+Pr\9atDRegi¡\94
+(\12
+»g
+);
+
+71 \12
+FÜm©FPRegi¡\94
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+fÜm©
+);
+
+72 \1e
+Pr\9atSoáw¬eIÁ\94ru±
+(
+Soáw¬eIÁ\94ru±Codes
+
+svc
+);
+
+75 \12
+FÜm©Regi¡\94
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+ÝtiÚ
+);
+
+76 \12
+FÜm©O±iÚ
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+ÝtiÚ
+);
+
+77 \1e
+FÜm©
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+fÜm©
+);
+
+78 \1e
+Unknown
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+79 \1e
+UnknownFÜm©
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+Ýúame
+);
+
+80 \1e
+M¬k\94FÜm©
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+Ýúame
+, \12
+id
+);
+
+82 \1e
+DecodeExt1
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+83 \1e
+DecodeExt2
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+84 \1e
+DecodeExt4
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+85 \1e
+DecodeExt5
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+87 cڡ
+ gdi§sm
+::
+NameCÚv\94\8br
+&
+cÚv\94\8br_
+;
+
+88
+ gVeùÜ
+<\ 5>
+ gout_bufãr_
+;
+
+89 \12
+ gout_bufãr_pos_
+;
+
+91
+DISALLOW_COPY_AND_ASSIGN
+(
+Decod\94
+);
+
+96 \ 1
+ #STRING_STARTS_WITH
+(
+¡r\9ag
+,
+com·»_¡r\9ag
+) \
+
+97 (
+ `¡ºcmp
+(
+¡r\9ag
+,
+com·»_¡r\9ag
+,
+ `¡¾\92
+(com·»_¡r\9ag)è=ð0)
+
+ )
+
+101 \1e
+ gDecod\94
+::
+Pr\9atCh¬
+(cڡ \ 5
+ch
+è{
+out_bufãr_
+[
+out_bufãr_pos_
+++] = ch; }
+
+105 \1e
+ gDecod\94
+::
+Pr\9at
+(cڡ \ 5*
+¡r
+) {
+
+106 \ 5
+cur
+ = *
+¡r
+++;
+
+107 \1f
+ gcur
+ !ð'\0' && (
+out_bufãr_pos_
+ < (
+out_bufãr_
+.
+Ëngth
+() - 1))) {
+
+108
+Pr\9atCh¬
+(
+cur
+);
+
+109
+ gcur
+ = *
+¡r
+++;
+
+111
+ gout_bufãr_
+[
+out_bufãr_pos_
+] = 0;
+
+116 \1e
+ gDecod\94
+::
+Pr\9atRegi¡\94
+(\12
+»g
+) {
+
+117
+Pr\9at
+(
+cÚv\94\8br_
+.
+NameOfCPURegi¡\94
+(
+»g
+));
+
+122 \1e
+ gDecod\94
+::
+Pr\9atDRegi¡\94
+(\12
+»g
+è{
+Pr\9at
+(
+FPRegi¡\94s
+::
+Name
+(reg)); }
+
+127 \1e
+ gDecod\94
+::
+Pr\9atSoáw¬eIÁ\94ru±
+(
+Soáw¬eIÁ\94ru±Codes
+
+svc
+) {
+
+128 \1a
+svc
+) {
+
+129 \ 4
+kC®lRtRed\9ceùed
+:
+
+130
+Pr\9at
+("call\84t\84edirected");
+
+132 \ 4
+ gkB»akpo\9at
+:
+
+133
+Pr\9at
+("breakpoint");
+
+136 ià(
+svc
+ >ð
+kStÝCode
+) {
+
+137
+out_bufãr_pos_
+ +ð
+SNPr\9atF
+(
+out_bufãr_
+ + out_buffer_pos_, "%d - 0x%x",
+
+138
+svc
+ &
+kStÝCodeMask
+, svc & kStopCodeMask);
+
+140
+ gout_bufãr_pos_
+ +ð
+SNPr\9atF
+(
+out_bufãr_
+ +
+out_bufãr_pos_
+, "%d",
+svc
+);
+
+149 \12
+ gDecod\94
+::
+FÜm©Regi¡\94
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+fÜm©
+) {
+
+150
+DCHECK
+(
+fÜm©
+[0] == 'r');
+
+152 ià((
+ gfÜm©
+[1] =ð't'è|| (
+fÜm©
+[1] == 's')) {
+
+153 \12
+»g
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+154
+Pr\9atRegi¡\94
+(
+»g
+);
+
+156 } \vià(
+ gfÜm©
+[1] == 'a') {
+
+157 \12
+»g
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+158
+Pr\9atRegi¡\94
+(
+»g
+);
+
+160 } \vià(
+ gfÜm©
+[1] == 'b') {
+
+161 \12
+»g
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+162
+Pr\9atRegi¡\94
+(
+»g
+);
+
+166
+UNREACHABLE
+();
+
+173 \12
+ gDecod\94
+::
+FÜm©FPRegi¡\94
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+fÜm©
+) {
+
+174
+DCHECK
+(
+fÜm©
+[0] == 'D');
+
+176 \12
+ g»tv®
+ = 2;
+
+177 \12
+ g»g
+ = -1;
+
+178 ià(
+ gfÜm©
+[1] == 't') {
+
+179
+»g
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+180 } \vià(
+ gfÜm©
+[1] == 'a') {
+
+181
+»g
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+182 } \vià(
+ gfÜm©
+[1] == 'b') {
+
+183
+»g
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+184 } \vià(
+ gfÜm©
+[1] == 'c') {
+
+185
+»g
+ =
+\9a¡r
+->
+RCV®ue
+();
+
+187
+UNREACHABLE
+();
+
+190
+Pr\9atDRegi¡\94
+(
+»g
+);
+
+192 \15
+ g»tv®
+;
+
+201 \12
+ gDecod\94
+::
+FÜm©O±iÚ
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+fÜm©
+) {
+
+202 \1a
+ gfÜm©
+[0]) {
+
+204 ià(
+\9a¡r
+->
+B\99
+(10) == 1) {
+
+205
+Pr\9at
+("o");
+
+210 ià(
+\9a¡r
+->
+B\99
+(0) == 1) {
+
+211
+Pr\9at
+(".");
+
+213
+Pr\9at
+(" ");
+
+218 \15
+FÜm©Regi¡\94
+(
+\9a¡r
+,
+fÜm©
+);
+
+221 \15
+FÜm©FPRegi¡\94
+(
+\9a¡r
+,
+fÜm©
+);
+
+224
+\9at32_t
+
+v®ue
+ = (
+\9a¡r
+->
+B\99s
+(15, 0) << 16) >> 16;
+
+225
+ gout_bufãr_pos_
+ +ð
+SNPr\9atF
+(
+out_bufãr_
+ +
+out_bufãr_pos_
+, "%d",
+v®ue
+);
+
+229
+\9at32_t
+
+v®ue
+ =
+\9a¡r
+->
+B\99s
+(15, 0);
+
+230
+ gout_bufãr_pos_
+ +ð
+SNPr\9atF
+(
+out_bufãr_
+ +
+out_bufãr_pos_
+, "%d",
+v®ue
+);
+
+235 ià(
+\9a¡r
+->
+B\99
+(0) == 1) {
+
+236
+Pr\9at
+("l");
+
+242 ià(
+\9a¡r
+->
+B\99
+(1) == 1) {
+
+243
+Pr\9at
+("a");
+
+249
+DCHECK
+(
+STRING_STARTS_WITH
+(
+fÜm©
+, "target"));
+
+250 ià((
+ gfÜm©
+[6] =ð'2'è&& (
+fÜm©
+[7] == '6')) {
+
+251 \12
+off
+ = ((
+\9a¡r
+->
+B\99s
+(25, 2)) << 8) >> 6;
+
+252
+ gout_bufãr_pos_
+ +ð
+SNPr\9atF
+(
+
+253
+out_bufãr_
+ +
+out_bufãr_pos_
+, "%+d -> %s",
+off
+,
+
+254
+cÚv\94\8br_
+.
+NameOfAdd»ss
+(
+»\9a\8b½»t_ÿ¡
+<
+by\8b
+*>(
+\9a¡r
+è+
+off
+));
+
+256 } \vià((
+ gfÜm©
+[6] =ð'1'è&& (
+fÜm©
+[7] == '6')) {
+
+257 \12
+off
+ = ((
+\9a¡r
+->
+B\99s
+(15, 2)) << 18) >> 16;
+
+258
+ gout_bufãr_pos_
+ +ð
+SNPr\9atF
+(
+
+259
+out_bufãr_
+ +
+out_bufãr_pos_
+, "%+d -> %s",
+off
+,
+
+260
+cÚv\94\8br_
+.
+NameOfAdd»ss
+(
+»\9a\8b½»t_ÿ¡
+<
+by\8b
+*>(
+\9a¡r
+è+
+off
+));
+
+264
+DCHECK
+(
+fÜm©
+[1] == 'h');
+
+265
+\9at32_t
+
+ gv®ue
+ = 0;
+
+266
+\9at32_t
+
+ gÝcode
+ =
+\9a¡r
+->
+OpcodeV®ue
+() << 26;
+
+267
+\9at32_t
+
+ gsh
+ =
+\9a¡r
+->
+B\99s
+(15, 11);
+
+268 ià(
+ gÝcode
+ =ð
+EXT5
+ ||
+
+269 (
+Ýcode
+ =ð
+EXT2
+ &&
+\9a¡r
+->
+B\99s
+(10, 2è<< 2 =ð
+SRADIX
+)) {
+
+271
+v®ue
+ = (
+sh
+ | (
+\9a¡r
+->
+B\99
+(1) << 5));
+
+274
+ gv®ue
+ = (
+sh
+ << 26) >> 26;
+
+276
+ gout_bufãr_pos_
+ +ð
+SNPr\9atF
+(
+out_bufãr_
+ +
+out_bufãr_pos_
+, "%d",
+v®ue
+);
+
+280
+\9at32_t
+
+v®ue
+ = 0;
+
+281 ià(
+ gfÜm©
+[1] == 'e') {
+
+282 ià(
+\9a¡r
+->
+OpcodeV®ue
+(è<< 26 !ð
+EXT5
+) {
+
+284
+v®ue
+ = (
+\9a¡r
+->
+B\99s
+(10, 6) << 26) >> 26;
+
+287
+ gv®ue
+ = (
+\9a¡r
+->
+B\99s
+(10, 6è| (
+ g\9a¡r
+->
+B\99
+(5) << 5));
+
+289 } \vià(
+ gfÜm©
+[1] == 'b') {
+
+290 ià(
+\9a¡r
+->
+OpcodeV®ue
+(è<< 26 !ð
+EXT5
+) {
+
+292
+v®ue
+ = (
+\9a¡r
+->
+B\99s
+(5, 1) << 26) >> 26;
+
+295
+ gv®ue
+ = (
+\9a¡r
+->
+B\99s
+(10, 6è| (
+ g\9a¡r
+->
+B\99
+(5) << 5));
+
+298
+UNREACHABLE
+();
+
+300
+ gout_bufãr_pos_
+ +ð
+SNPr\9atF
+(
+out_bufãr_
+ +
+out_bufãr_pos_
+, "%d",
+v®ue
+);
+
+304 #ià
+V8_TARGET_ARCH_PPC64
+
+
+306
+\9at32_t
+
+v®ue
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0) & ~3);
+
+307
+ gout_bufãr_pos_
+ +ð
+SNPr\9atF
+(
+out_bufãr_
+ +
+out_bufãr_pos_
+, "%d",
+v®ue
+);
+
+312
+UNREACHABLE
+();
+
+317
+UNREACHABLE
+();
+
+325 \1e
+ gDecod\94
+::
+FÜm©
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+fÜm©
+) {
+
+326 \ 5
+ gcur
+ = *
+fÜm©
+++;
+
+327 \1f(
+ gcur
+ !ð0è&& (
+out_bufãr_pos_
+ < (
+out_bufãr_
+.
+Ëngth
+() - 1))) {
+
+328 ià(
+cur
+ == '\'') {
+
+329
+fÜm©
+ +ð
+FÜm©O±iÚ
+(
+\9a¡r
+, format);
+
+331
+ gout_bufãr_
+[
+out_bufãr_pos_
+++] =
+cur
+;
+
+333
+ gcur
+ = *
+fÜm©
+++;
+
+335
+ gout_bufãr_
+[
+out_bufãr_pos_
+] = '\0';
+
+341 \ 1
+ #VERIFY
+(
+cÚd\99iÚ
+) \
+
+342 ià(!(
+cÚd\99iÚ
+)) { \
+
+343
+ `Unknown
+(
+\9a¡r
+); \
+
+345 }
+
+ )
+
+350 \1e
+ gDecod\94
+::
+Unknown
+(
+In¡ruùiÚ
+*
+\9a¡r
+è{
+FÜm©
+(instr, "unknown"); }
+
+356 \1e
+ gDecod\94
+::
+UnknownFÜm©
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+Çme
+) {
+
+357 \ 5
+ gbufãr
+[100];
+
+358
+¢´\9atf
+(
+bufãr
+, \17(bufãr), "% (unknown-fÜm©)",
+Çme
+);
+
+359
+FÜm©
+(
+\9a¡r
+,
+bufãr
+);
+
+363 \1e
+ gDecod\94
+::
+M¬k\94FÜm©
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+Çme
+, \12
+id
+) {
+
+364 \ 5
+ gbufãr
+[100];
+
+365
+¢´\9atf
+(
+bufãr
+, \17(bufãr), "% %d",
+Çme
+,
+id
+);
+
+366
+FÜm©
+(
+\9a¡r
+,
+bufãr
+);
+
+370 \1e
+ gDecod\94
+::
+DecodeExt1
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+371 \1a
+\9a¡r
+->
+B\99s
+(10, 1) << 1) {
+
+372 \ 4
+ gMCRF
+: {
+
+373
+UnknownFÜm©
+(
+\9a¡r
+, "mcrf");
+
+376 \ 4
+ gBCLRX
+: {
+
+377 \1a
+\9a¡r
+->
+B\99s
+(25, 21) << 21) {
+
+378 \ 4
+ gDCBNZF
+: {
+
+379
+UnknownFÜm©
+(
+\9a¡r
+, "bclrx-dcbnzf");
+
+382 \ 4
+ gDCBEZF
+: {
+
+383
+UnknownFÜm©
+(
+\9a¡r
+, "bclrx-dcbezf");
+
+386 \ 4
+ gBF
+: {
+
+387
+UnknownFÜm©
+(
+\9a¡r
+, "bclrx-bf");
+
+390 \ 4
+ gDCBNZT
+: {
+
+391
+UnknownFÜm©
+(
+\9a¡r
+, "bclrx-dcbbzt");
+
+394 \ 4
+ gDCBEZT
+: {
+
+395
+UnknownFÜm©
+(
+\9a¡r
+, "bclrx-dcbnezt");
+
+398 \ 4
+ gBT
+: {
+
+399
+UnknownFÜm©
+(
+\9a¡r
+, "bclrx-bt");
+
+402 \ 4
+ gDCBNZ
+: {
+
+403
+UnknownFÜm©
+(
+\9a¡r
+, "bclrx-dcbnz");
+
+406 \ 4
+ gDCBEZ
+: {
+
+407
+UnknownFÜm©
+(
+\9a¡r
+, "bclrx-dcbez");
+
+410 \ 4
+ gBA
+: {
+
+411 ià(
+\9a¡r
+->
+B\99
+(0) == 1) {
+
+412
+FÜm©
+(
+\9a¡r
+, "blrl");
+
+414
+FÜm©
+(
+\9a¡r
+, "blr");
+
+421 \ 4
+ gBCCTRX
+: {
+
+422 \1a
+\9a¡r
+->
+B\99s
+(25, 21) << 21) {
+
+423 \ 4
+ gDCBNZF
+: {
+
+424
+UnknownFÜm©
+(
+\9a¡r
+, "bcctrx-dcbnzf");
+
+427 \ 4
+ gDCBEZF
+: {
+
+428
+UnknownFÜm©
+(
+\9a¡r
+, "bcctrx-dcbezf");
+
+431 \ 4
+ gBF
+: {
+
+432
+UnknownFÜm©
+(
+\9a¡r
+, "bcctrx-bf");
+
+435 \ 4
+ gDCBNZT
+: {
+
+436
+UnknownFÜm©
+(
+\9a¡r
+, "bcctrx-dcbnzt");
+
+439 \ 4
+ gDCBEZT
+: {
+
+440
+UnknownFÜm©
+(
+\9a¡r
+, "bcctrx-dcbezf");
+
+443 \ 4
+ gBT
+: {
+
+444
+UnknownFÜm©
+(
+\9a¡r
+, "bcctrx-bt");
+
+447 \ 4
+ gDCBNZ
+: {
+
+448
+UnknownFÜm©
+(
+\9a¡r
+, "bcctrx-dcbnz");
+
+451 \ 4
+ gDCBEZ
+: {
+
+452
+UnknownFÜm©
+(
+\9a¡r
+, "bcctrx-dcbez");
+
+455 \ 4
+ gBA
+: {
+
+456 ià(
+\9a¡r
+->
+B\99
+(0) == 1) {
+
+457
+FÜm©
+(
+\9a¡r
+, "bctrl");
+
+459
+FÜm©
+(
+\9a¡r
+, "bctr");
+
+463 \a: {
+UNREACHABLE
+(); }
+
+467 \ 4
+ gCRNOR
+: {
+
+468
+FÜm©
+(
+\9a¡r
+, "crnor (stuff)");
+
+471 \ 4
+ gRFI
+: {
+
+472
+FÜm©
+(
+\9a¡r
+, "rfi (stuff)");
+
+475 \ 4
+ gCRANDC
+: {
+
+476
+FÜm©
+(
+\9a¡r
+, "crandc (stuff)");
+
+479 \ 4
+ gISYNC
+: {
+
+480
+FÜm©
+(
+\9a¡r
+, "isync (stuff)");
+
+483 \ 4
+ gCRXOR
+: {
+
+484
+FÜm©
+(
+\9a¡r
+, "crxor (stuff)");
+
+487 \ 4
+ gCRNAND
+: {
+
+488
+UnknownFÜm©
+(
+\9a¡r
+, "crnand");
+
+491 \ 4
+ gCRAND
+: {
+
+492
+UnknownFÜm©
+(
+\9a¡r
+, "crand");
+
+495 \ 4
+ gCREQV
+: {
+
+496
+UnknownFÜm©
+(
+\9a¡r
+, "creqv");
+
+499 \ 4
+ gCRORC
+: {
+
+500
+UnknownFÜm©
+(
+\9a¡r
+, "crorc");
+
+503 \ 4
+ gCROR
+: {
+
+504
+UnknownFÜm©
+(
+\9a¡r
+, "cror");
+
+508
+Unknown
+(
+\9a¡r
+);
+
+514 \1e
+ gDecod\94
+::
+DecodeExt2
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+516 \1a
+\9a¡r
+->
+B\99s
+(10, 1) << 1) {
+
+517 \ 4
+ gSRWX
+: {
+
+518
+FÜm©
+(
+\9a¡r
+, "srw'. 'ra, 'rs, 'rb");
+
+521 #ià
+V8_TARGET_ARCH_PPC64
+
+
+522 \ 4
+ gSRDX
+: {
+
+523
+FÜm©
+(
+\9a¡r
+, "srd'. 'ra, 'rs, 'rb");
+
+527 \ 4
+ gSRAW
+: {
+
+528
+FÜm©
+(
+\9a¡r
+, "sraw'. 'ra, 'rs, 'rb");
+
+531 #ià
+V8_TARGET_ARCH_PPC64
+
+
+532 \ 4
+ gSRAD
+: {
+
+533
+FÜm©
+(
+\9a¡r
+, "srad'. 'ra, 'rs, 'rb");
+
+537 \ 4
+ gSRAWIX
+: {
+
+538
+FÜm©
+(
+\9a¡r
+, "srawi'. 'ra,'rs,'sh");
+
+541 \ 4
+ gEXTSH
+: {
+
+542
+FÜm©
+(
+\9a¡r
+, "extsh'. 'ra, 'rs");
+
+545 #ià
+V8_TARGET_ARCH_PPC64
+
+
+546 \ 4
+ gEXTSW
+: {
+
+547
+FÜm©
+(
+\9a¡r
+, "extsw'. 'ra, 'rs");
+
+551 \ 4
+ gEXTSB
+: {
+
+552
+FÜm©
+(
+\9a¡r
+, "extsb'. 'ra, 'rs");
+
+555 \ 4
+ gLFSX
+: {
+
+556
+FÜm©
+(
+\9a¡r
+, "lfsx 'rt, 'ra, 'rb");
+
+559 \ 4
+ gLFSUX
+: {
+
+560
+FÜm©
+(
+\9a¡r
+, "lfsux 'rt, 'ra, 'rb");
+
+563 \ 4
+ gLFDX
+: {
+
+564
+FÜm©
+(
+\9a¡r
+, "lfdx 'rt, 'ra, 'rb");
+
+567 \ 4
+ gLFDUX
+: {
+
+568
+FÜm©
+(
+\9a¡r
+, "lfdux 'rt, 'ra, 'rb");
+
+571 \ 4
+ gSTFSX
+: {
+
+572
+FÜm©
+(
+\9a¡r
+, "stfsx 'rs, 'ra, 'rb");
+
+575 \ 4
+ gSTFSUX
+: {
+
+576
+FÜm©
+(
+\9a¡r
+, "stfsux 'rs, 'ra, 'rb");
+
+579 \ 4
+ gSTFDX
+: {
+
+580
+FÜm©
+(
+\9a¡r
+, "stfdx 'rs, 'ra, 'rb");
+
+583 \ 4
+ gSTFDUX
+: {
+
+584
+FÜm©
+(
+\9a¡r
+, "stfdux 'rs, 'ra, 'rb");
+
+589 \1a
+ g\9a¡r
+->
+B\99s
+(10, 2) << 2) {
+
+590 \ 4
+ gSRADIX
+: {
+
+591
+FÜm©
+(
+\9a¡r
+, "sradi'. 'ra,'rs,'sh");
+
+597 \1a
+ g\9a¡r
+->
+B\99s
+(9, 1) << 1) {
+
+598 \ 4
+ gCMP
+: {
+
+599 #ià
+V8_TARGET_ARCH_PPC64
+
+
+600 ià(
+\9a¡r
+->
+B\99
+(21)) {
+
+602
+FÜm©
+(
+\9a¡r
+, "cmp 'ra, 'rb");
+
+603 #ià
+V8_TARGET_ARCH_PPC64
+
+
+605
+FÜm©
+(
+\9a¡r
+, "cmpw 'ra, 'rb");
+
+610 \ 4
+ gSLWX
+: {
+
+611
+FÜm©
+(
+\9a¡r
+, "slw'. 'ra, 'rs, 'rb");
+
+614 #ià
+V8_TARGET_ARCH_PPC64
+
+
+615 \ 4
+ gSLDX
+: {
+
+616
+FÜm©
+(
+\9a¡r
+, "sld'. 'ra, 'rs, 'rb");
+
+620 \ 4
+ gSUBFCX
+: {
+
+621
+FÜm©
+(
+\9a¡r
+, "subfc'. 'rt, 'ra, 'rb");
+
+624 \ 4
+ gADDCX
+: {
+
+625
+FÜm©
+(
+\9a¡r
+, "addc'. 'rt, 'ra, 'rb");
+
+628 \ 4
+ gCNTLZWX
+: {
+
+629
+FÜm©
+(
+\9a¡r
+, "cntlzw'. 'ra, 'rs");
+
+632 #ià
+V8_TARGET_ARCH_PPC64
+
+
+633 \ 4
+ gCNTLZDX
+: {
+
+634
+FÜm©
+(
+\9a¡r
+, "cntlzd'. 'ra, 'rs");
+
+638 \ 4
+ gANDX
+: {
+
+639
+FÜm©
+(
+\9a¡r
+, "and'. 'ra, 'rs, 'rb");
+
+642 \ 4
+ gANDCX
+: {
+
+643
+FÜm©
+(
+\9a¡r
+, "andc'. 'ra, 'rs, 'rb");
+
+646 \ 4
+ gCMPL
+: {
+
+647 #ià
+V8_TARGET_ARCH_PPC64
+
+
+648 ià(
+\9a¡r
+->
+B\99
+(21)) {
+
+650
+FÜm©
+(
+\9a¡r
+, "cmpl 'ra, 'rb");
+
+651 #ià
+V8_TARGET_ARCH_PPC64
+
+
+653
+FÜm©
+(
+\9a¡r
+, "cmplw 'ra, 'rb");
+
+658 \ 4
+ gNEGX
+: {
+
+659
+FÜm©
+(
+\9a¡r
+, "neg'. 'rt, 'ra");
+
+662 \ 4
+ gNORX
+: {
+
+663
+FÜm©
+(
+\9a¡r
+, "nor'. 'rt, 'ra, 'rb");
+
+666 \ 4
+ gSUBFX
+: {
+
+667
+FÜm©
+(
+\9a¡r
+, "subf'. 'rt, 'ra, 'rb");
+
+670 \ 4
+ gMULHWX
+: {
+
+671
+FÜm©
+(
+\9a¡r
+, "mulhw'o'. 'rt, 'ra, 'rb");
+
+674 \ 4
+ gADDZEX
+: {
+
+675
+FÜm©
+(
+\9a¡r
+, "addze'. 'rt, 'ra");
+
+678 \ 4
+ gMULLW
+: {
+
+679
+FÜm©
+(
+\9a¡r
+, "mullw'o'. 'rt, 'ra, 'rb");
+
+682 #ià
+V8_TARGET_ARCH_PPC64
+
+
+683 \ 4
+ gMULLD
+: {
+
+684
+FÜm©
+(
+\9a¡r
+, "mulld'o'. 'rt, 'ra, 'rb");
+
+688 \ 4
+ gDIVW
+: {
+
+689
+FÜm©
+(
+\9a¡r
+, "divw'o'. 'rt, 'ra, 'rb");
+
+692 #ià
+V8_TARGET_ARCH_PPC64
+
+
+693 \ 4
+ gDIVD
+: {
+
+694
+FÜm©
+(
+\9a¡r
+, "divd'o'. 'rt, 'ra, 'rb");
+
+698 \ 4
+ gADDX
+: {
+
+699
+FÜm©
+(
+\9a¡r
+, "add'o 'rt, 'ra, 'rb");
+
+702 \ 4
+ gXORX
+: {
+
+703
+FÜm©
+(
+\9a¡r
+, "xor'. 'ra, 'rs, 'rb");
+
+706 \ 4
+ gORX
+: {
+
+707 ià(
+\9a¡r
+->
+RTV®ue
+(è=ð\9a¡r->
+RBV®ue
+()) {
+
+708
+FÜm©
+(
+\9a¡r
+, "mr 'ra, 'rb");
+
+710
+FÜm©
+(
+\9a¡r
+, "or 'ra, 'rs, 'rb");
+
+714 \ 4
+ gMFSPR
+: {
+
+715 \12
+¥r
+ =
+\9a¡r
+->
+B\99s
+(20, 11);
+
+716 ià(256 =ð
+¥r
+) {
+
+717
+FÜm©
+(
+\9a¡r
+, "mflr 'rt");
+
+719
+FÜm©
+(
+\9a¡r
+, "mfspr 'rt ??");
+
+723 \ 4
+ gMTSPR
+: {
+
+724 \12
+¥r
+ =
+\9a¡r
+->
+B\99s
+(20, 11);
+
+725 ià(256 =ð
+¥r
+) {
+
+726
+FÜm©
+(
+\9a¡r
+, "mtlr 'rt");
+
+727 } \vià(288 =ð
+¥r
+) {
+
+728
+FÜm©
+(
+\9a¡r
+, "mtctr 'rt");
+
+730
+FÜm©
+(
+\9a¡r
+, "mtspr 'rt ??");
+
+734 \ 4
+ gMFCR
+: {
+
+735
+FÜm©
+(
+\9a¡r
+, "mfcr 'rt");
+
+738 \ 4
+ gSTWX
+: {
+
+739
+FÜm©
+(
+\9a¡r
+, "stwx 'rs, 'ra, 'rb");
+
+742 \ 4
+ gSTWUX
+: {
+
+743
+FÜm©
+(
+\9a¡r
+, "stwux 'rs, 'ra, 'rb");
+
+746 \ 4
+ gSTBX
+: {
+
+747
+FÜm©
+(
+\9a¡r
+, "stbx 'rs, 'ra, 'rb");
+
+750 \ 4
+ gSTBUX
+: {
+
+751
+FÜm©
+(
+\9a¡r
+, "stbux 'rs, 'ra, 'rb");
+
+754 \ 4
+ gSTHX
+: {
+
+755
+FÜm©
+(
+\9a¡r
+, "sthx 'rs, 'ra, 'rb");
+
+758 \ 4
+ gSTHUX
+: {
+
+759
+FÜm©
+(
+\9a¡r
+, "sthux 'rs, 'ra, 'rb");
+
+762 \ 4
+ gLWZX
+: {
+
+763
+FÜm©
+(
+\9a¡r
+, "lwzx 'rt, 'ra, 'rb");
+
+766 \ 4
+ gLWZUX
+: {
+
+767
+FÜm©
+(
+\9a¡r
+, "lwzux 'rt, 'ra, 'rb");
+
+770 \ 4
+ gLBZX
+: {
+
+771
+FÜm©
+(
+\9a¡r
+, "lbzx 'rt, 'ra, 'rb");
+
+774 \ 4
+ gLBZUX
+: {
+
+775
+FÜm©
+(
+\9a¡r
+, "lbzux 'rt, 'ra, 'rb");
+
+778 \ 4
+ gLHZX
+: {
+
+779
+FÜm©
+(
+\9a¡r
+, "lhzx 'rt, 'ra, 'rb");
+
+782 \ 4
+ gLHZUX
+: {
+
+783
+FÜm©
+(
+\9a¡r
+, "lhzux 'rt, 'ra, 'rb");
+
+786 #ià
+V8_TARGET_ARCH_PPC64
+
+
+787 \ 4
+ gLDX
+: {
+
+788
+FÜm©
+(
+\9a¡r
+, "ldx 'rt, 'ra, 'rb");
+
+791 \ 4
+ gLDUX
+: {
+
+792
+FÜm©
+(
+\9a¡r
+, "ldux 'rt, 'ra, 'rb");
+
+795 \ 4
+ gSTDX
+: {
+
+796
+FÜm©
+(
+\9a¡r
+, "stdx 'rt, 'ra, 'rb");
+
+799 \ 4
+ gSTDUX
+: {
+
+800
+FÜm©
+(
+\9a¡r
+, "stdux 'rt, 'ra, 'rb");
+
+803 \ 4
+ gMFVSRD
+: {
+
+804
+FÜm©
+(
+\9a¡r
+, "mffprd 'ra, 'Dt");
+
+807 \ 4
+ gMFVSRWZ
+: {
+
+808
+FÜm©
+(
+\9a¡r
+, "mffprwz 'ra, 'Dt");
+
+811 \ 4
+ gMTVSRD
+: {
+
+812
+FÜm©
+(
+\9a¡r
+, "mtfprd 'Dt, 'ra");
+
+815 \ 4
+ gMTVSRWA
+: {
+
+816
+FÜm©
+(
+\9a¡r
+, "mtfprwa 'Dt, 'ra");
+
+819 \ 4
+ gMTVSRWZ
+: {
+
+820
+FÜm©
+(
+\9a¡r
+, "mtfprwz 'Dt, 'ra");
+
+825
+Unknown
+(
+\9a¡r
+);
+
+831 \1e
+ gDecod\94
+::
+DecodeExt4
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+832 \1a
+\9a¡r
+->
+B\99s
+(5, 1) << 1) {
+
+833 \ 4
+ gFDIV
+: {
+
+834
+FÜm©
+(
+\9a¡r
+, "fdiv'. 'Dt, 'Da, 'Db");
+
+837 \ 4
+ gFSUB
+: {
+
+838
+FÜm©
+(
+\9a¡r
+, "fsub'. 'Dt, 'Da, 'Db");
+
+841 \ 4
+ gFADD
+: {
+
+842
+FÜm©
+(
+\9a¡r
+, "fadd'. 'Dt, 'Da, 'Db");
+
+845 \ 4
+ gFSQRT
+: {
+
+846
+FÜm©
+(
+\9a¡r
+, "fsqrt'. 'Dt, 'Db");
+
+849 \ 4
+ gFSEL
+: {
+
+850
+FÜm©
+(
+\9a¡r
+, "fsel'. 'Dt, 'Da, 'Dc, 'Db");
+
+853 \ 4
+ gFMUL
+: {
+
+854
+FÜm©
+(
+\9a¡r
+, "fmul'. 'Dt, 'Da, 'Dc");
+
+857 \ 4
+ gFMSUB
+: {
+
+858
+FÜm©
+(
+\9a¡r
+, "fmsub'. 'Dt, 'Da, 'Dc, 'Db");
+
+861 \ 4
+ gFMADD
+: {
+
+862
+FÜm©
+(
+\9a¡r
+, "fmadd'. 'Dt, 'Da, 'Dc, 'Db");
+
+867 \1a
+ g\9a¡r
+->
+B\99s
+(10, 1) << 1) {
+
+868 \ 4
+ gFCMPU
+: {
+
+869
+FÜm©
+(
+\9a¡r
+, "fcmpu 'Da, 'Db");
+
+872 \ 4
+ gFRSP
+: {
+
+873
+FÜm©
+(
+\9a¡r
+, "frsp'. 'Dt, 'Db");
+
+876 \ 4
+ gFCFID
+: {
+
+877
+FÜm©
+(
+\9a¡r
+, "fcfid'. 'Dt, 'Db");
+
+880 \ 4
+ gFCTID
+: {
+
+881
+FÜm©
+(
+\9a¡r
+, "fctid 'Dt, 'Db");
+
+884 \ 4
+ gFCTIDZ
+: {
+
+885
+FÜm©
+(
+\9a¡r
+, "fctidz 'Dt, 'Db");
+
+888 \ 4
+ gFCTIW
+: {
+
+889
+FÜm©
+(
+\9a¡r
+, "fctiw'. 'Dt, 'Db");
+
+892 \ 4
+ gFCTIWZ
+: {
+
+893
+FÜm©
+(
+\9a¡r
+, "fctiwz'. 'Dt, 'Db");
+
+896 \ 4
+ gFMR
+: {
+
+897
+FÜm©
+(
+\9a¡r
+, "fmr'. 'Dt, 'Db");
+
+900 \ 4
+ gMTFSFI
+: {
+
+901
+FÜm©
+(
+\9a¡r
+, "mtfsfi'. ?,?");
+
+904 \ 4
+ gMFFS
+: {
+
+905
+FÜm©
+(
+\9a¡r
+, "mffs'. 'Dt");
+
+908 \ 4
+ gMTFSF
+: {
+
+909
+FÜm©
+(
+\9a¡r
+, "mtfsf'. 'Db ?,?,?");
+
+912 \ 4
+ gFABS
+: {
+
+913
+FÜm©
+(
+\9a¡r
+, "fabs'. 'Dt, 'Db");
+
+916 \ 4
+ gFRIM
+: {
+
+917
+FÜm©
+(
+\9a¡r
+, "frim 'Dt, 'Db");
+
+920 \ 4
+ gFNEG
+: {
+
+921
+FÜm©
+(
+\9a¡r
+, "fneg'. 'Dt, 'Db");
+
+925
+Unknown
+(
+\9a¡r
+);
+
+931 \1e
+ gDecod\94
+::
+DecodeExt5
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+932 \1a
+\9a¡r
+->
+B\99s
+(4, 2) << 2) {
+
+933 \ 4
+ gRLDICL
+: {
+
+934
+FÜm©
+(
+\9a¡r
+, "rldicl'. 'ra, 'rs, 'sh, 'mb");
+
+937 \ 4
+ gRLDICR
+: {
+
+938
+FÜm©
+(
+\9a¡r
+, "rldicr'. 'ra, 'rs, 'sh, 'me");
+
+941 \ 4
+ gRLDIC
+: {
+
+942
+FÜm©
+(
+\9a¡r
+, "rldic'. 'ra, 'rs, 'sh, 'mb");
+
+945 \ 4
+ gRLDIMI
+: {
+
+946
+FÜm©
+(
+\9a¡r
+, "rldimi'. 'ra, 'rs, 'sh, 'mb");
+
+950 \1a
+ g\9a¡r
+->
+B\99s
+(4, 1) << 1) {
+
+951 \ 4
+ gRLDCL
+: {
+
+952
+FÜm©
+(
+\9a¡r
+, "rldcl'. 'ra, 'rs, 'sb, 'mb");
+
+956
+Unknown
+(
+\9a¡r
+);
+
+959 #undeà
+VERIFIY
+
+
+962 \12
+ gDecod\94
+::
+In¡ruùiÚDecode
+(
+by\8b
+*
+\9a¡r_±r
+) {
+
+963
+In¡ruùiÚ
+*
+\9a¡r
+ = In¡ruùiÚ::
+At
+(
+\9a¡r_±r
+);
+
+965
+ gout_bufãr_pos_
+ +ð
+SNPr\9atF
+(
+out_bufãr_
+ +
+out_bufãr_pos_
+, "%08x ",
+
+966
+\9a¡r
+->
+In¡ruùiÚB\99s
+());
+
+968 \1a
+ g\9a¡r
+->
+OpcodeV®ue
+() << 26) {
+
+969 \ 4
+ gTWI
+: {
+
+970
+Pr\9atSoáw¬eIÁ\94ru±
+(
+\9a¡r
+->
+SvcV®ue
+());
+
+973 \ 4
+ gMULLI
+: {
+
+974
+UnknownFÜm©
+(
+\9a¡r
+, "mulli");
+
+977 \ 4
+ gSUBFIC
+: {
+
+978
+FÜm©
+(
+\9a¡r
+, "subfic 'rt, 'ra, 'int16");
+
+981 \ 4
+ gCMPLI
+: {
+
+982 #ià
+V8_TARGET_ARCH_PPC64
+
+
+983 ià(
+\9a¡r
+->
+B\99
+(21)) {
+
+985
+FÜm©
+(
+\9a¡r
+, "cmpli 'ra, 'uint16");
+
+986 #ià
+V8_TARGET_ARCH_PPC64
+
+
+988
+FÜm©
+(
+\9a¡r
+, "cmplwi 'ra, 'uint16");
+
+993 \ 4
+ gCMPI
+: {
+
+994 #ià
+V8_TARGET_ARCH_PPC64
+
+
+995 ià(
+\9a¡r
+->
+B\99
+(21)) {
+
+997
+FÜm©
+(
+\9a¡r
+, "cmpi 'ra, 'int16");
+
+998 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1000
+FÜm©
+(
+\9a¡r
+, "cmpwi 'ra, 'int16");
+
+1005 \ 4
+ gADDIC
+: {
+
+1006
+FÜm©
+(
+\9a¡r
+, "addic 'rt, 'ra, 'int16");
+
+1009 \ 4
+ gADDICx
+: {
+
+1010
+UnknownFÜm©
+(
+\9a¡r
+, "addicx");
+
+1013 \ 4
+ gADDI
+: {
+
+1014 ià(
+\9a¡r
+->
+RAV®ue
+() == 0) {
+
+1016
+FÜm©
+(
+\9a¡r
+, "li 'rt, 'int16");
+
+1018
+FÜm©
+(
+\9a¡r
+, "addi 'rt, 'ra, 'int16");
+
+1022 \ 4
+ gADDIS
+: {
+
+1023 ià(
+\9a¡r
+->
+RAV®ue
+() == 0) {
+
+1024
+FÜm©
+(
+\9a¡r
+, "lis 'rt, 'int16");
+
+1026
+FÜm©
+(
+\9a¡r
+, "addis 'rt, 'ra, 'int16");
+
+1030 \ 4
+ gBCX
+: {
+
+1031 \12
+bo
+ =
+\9a¡r
+->
+B\99s
+(25, 21) << 21;
+
+1032 \12
+ gbi
+ =
+\9a¡r
+->
+B\99s
+(20, 16);
+
+1033 \1a
+ gbi
+) {
+
+1036 ià(
+BT
+ =ð
+bo
+) {
+
+1037
+FÜm©
+(
+\9a¡r
+, "beq'l'a 'target16");
+
+1040 ià(
+ gBF
+ =ð
+bo
+) {
+
+1041
+FÜm©
+(
+\9a¡r
+, "bne'l'a 'target16");
+
+1044
+FÜm©
+(
+\9a¡r
+, "bc'l'a 'target16");
+
+1047 ià(
+BT
+ =ð
+bo
+) {
+
+1048
+FÜm©
+(
+\9a¡r
+, "bgt'l'a 'target16");
+
+1051 ià(
+ gBF
+ =ð
+bo
+) {
+
+1052
+FÜm©
+(
+\9a¡r
+, "ble'l'a 'target16");
+
+1055
+FÜm©
+(
+\9a¡r
+, "bc'l'a 'target16");
+
+1058 ià(
+BT
+ =ð
+bo
+) {
+
+1059
+FÜm©
+(
+\9a¡r
+, "blt'l'a 'target16");
+
+1062 ià(
+ gBF
+ =ð
+bo
+) {
+
+1063
+FÜm©
+(
+\9a¡r
+, "bge'l'a 'target16");
+
+1066
+FÜm©
+(
+\9a¡r
+, "bc'l'a 'target16");
+
+1069
+FÜm©
+(
+\9a¡r
+, "bc'l'a 'target16");
+
+1074 \ 4
+ gSC
+: {
+
+1075
+UnknownFÜm©
+(
+\9a¡r
+, "sc");
+
+1078 \ 4
+ gBX
+: {
+
+1079
+FÜm©
+(
+\9a¡r
+, "b'l'a 'target26");
+
+1082 \ 4
+ gEXT1
+: {
+
+1083
+DecodeExt1
+(
+\9a¡r
+);
+
+1086 \ 4
+ gRLWIMIX
+: {
+
+1087
+FÜm©
+(
+\9a¡r
+, "rlwimi'. 'ra, 'rs, 'sh, 'me, 'mb");
+
+1090 \ 4
+ gRLWINMX
+: {
+
+1091
+FÜm©
+(
+\9a¡r
+, "rlwinm'. 'ra, 'rs, 'sh, 'me, 'mb");
+
+1094 \ 4
+ gRLWNMX
+: {
+
+1095
+FÜm©
+(
+\9a¡r
+, "rlwnm'. 'ra, 'rs, 'rb, 'me, 'mb");
+
+1098 \ 4
+ gORI
+: {
+
+1099
+FÜm©
+(
+\9a¡r
+, "ori 'ra, 'rs, 'uint16");
+
+1102 \ 4
+ gORIS
+: {
+
+1103
+FÜm©
+(
+\9a¡r
+, "oris 'ra, 'rs, 'uint16");
+
+1106 \ 4
+ gXORI
+: {
+
+1107
+FÜm©
+(
+\9a¡r
+, "xori 'ra, 'rs, 'uint16");
+
+1110 \ 4
+ gXORIS
+: {
+
+1111
+FÜm©
+(
+\9a¡r
+, "xoris 'ra, 'rs, 'uint16");
+
+1114 \ 4
+ gANDIx
+: {
+
+1115
+FÜm©
+(
+\9a¡r
+, "andi. 'ra, 'rs, 'uint16");
+
+1118 \ 4
+ gANDISx
+: {
+
+1119
+FÜm©
+(
+\9a¡r
+, "andis. 'ra, 'rs, 'uint16");
+
+1122 \ 4
+ gEXT2
+: {
+
+1123
+DecodeExt2
+(
+\9a¡r
+);
+
+1126 \ 4
+ gLWZ
+: {
+
+1127
+FÜm©
+(
+\9a¡r
+, "lwz 'rt, 'int16('ra)");
+
+1130 \ 4
+ gLWZU
+: {
+
+1131
+FÜm©
+(
+\9a¡r
+, "lwzu 'rt, 'int16('ra)");
+
+1134 \ 4
+ gLBZ
+: {
+
+1135
+FÜm©
+(
+\9a¡r
+, "lbz 'rt, 'int16('ra)");
+
+1138 \ 4
+ gLBZU
+: {
+
+1139
+FÜm©
+(
+\9a¡r
+, "lbzu 'rt, 'int16('ra)");
+
+1142 \ 4
+ gSTW
+: {
+
+1143
+FÜm©
+(
+\9a¡r
+, "stw 'rs, 'int16('ra)");
+
+1146 \ 4
+ gSTWU
+: {
+
+1147
+FÜm©
+(
+\9a¡r
+, "stwu 'rs, 'int16('ra)");
+
+1150 \ 4
+ gSTB
+: {
+
+1151
+FÜm©
+(
+\9a¡r
+, "stb 'rs, 'int16('ra)");
+
+1154 \ 4
+ gSTBU
+: {
+
+1155
+FÜm©
+(
+\9a¡r
+, "stbu 'rs, 'int16('ra)");
+
+1158 \ 4
+ gLHZ
+: {
+
+1159
+FÜm©
+(
+\9a¡r
+, "lhz 'rt, 'int16('ra)");
+
+1162 \ 4
+ gLHZU
+: {
+
+1163
+FÜm©
+(
+\9a¡r
+, "lhzu 'rt, 'int16('ra)");
+
+1166 \ 4
+ gLHA
+: {
+
+1167
+FÜm©
+(
+\9a¡r
+, "lha 'rt, 'int16('ra)");
+
+1170 \ 4
+ gLHAU
+: {
+
+1171
+FÜm©
+(
+\9a¡r
+, "lhau 'rt, 'int16('ra)");
+
+1174 \ 4
+ gSTH
+: {
+
+1175
+FÜm©
+(
+\9a¡r
+, "sth 'rs, 'int16('ra)");
+
+1178 \ 4
+ gSTHU
+: {
+
+1179
+FÜm©
+(
+\9a¡r
+, "sthu 'rs, 'int16('ra)");
+
+1182 \ 4
+ gLMW
+: {
+
+1183
+UnknownFÜm©
+(
+\9a¡r
+, "lmw");
+
+1186 \ 4
+ gSTMW
+: {
+
+1187
+UnknownFÜm©
+(
+\9a¡r
+, "stmw");
+
+1190 \ 4
+ gLFS
+: {
+
+1191
+FÜm©
+(
+\9a¡r
+, "lfs 'Dt, 'int16('ra)");
+
+1194 \ 4
+ gLFSU
+: {
+
+1195
+FÜm©
+(
+\9a¡r
+, "lfsu 'Dt, 'int16('ra)");
+
+1198 \ 4
+ gLFD
+: {
+
+1199
+FÜm©
+(
+\9a¡r
+, "lfd 'Dt, 'int16('ra)");
+
+1202 \ 4
+ gLFDU
+: {
+
+1203
+FÜm©
+(
+\9a¡r
+, "lfdu 'Dt, 'int16('ra)");
+
+1206 \ 4
+ gSTFS
+: {
+
+1207
+FÜm©
+(
+\9a¡r
+, "stfs 'Dt, 'int16('ra)");
+
+1210 \ 4
+ gSTFSU
+: {
+
+1211
+FÜm©
+(
+\9a¡r
+, "stfsu 'Dt, 'int16('ra)");
+
+1214 \ 4
+ gSTFD
+: {
+
+1215
+FÜm©
+(
+\9a¡r
+, "stfd 'Dt, 'int16('ra)");
+
+1218 \ 4
+ gSTFDU
+: {
+
+1219
+FÜm©
+(
+\9a¡r
+, "stfdu 'Dt, 'int16('ra)");
+
+1222 \ 4
+ gEXT3
+:
+
+1223 \ 4
+EXT4
+: {
+
+1224
+DecodeExt4
+(
+\9a¡r
+);
+
+1227 \ 4
+ gEXT5
+: {
+
+1228
+DecodeExt5
+(
+\9a¡r
+);
+
+1231 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1232 \ 4
+ gLD
+: {
+
+1233 \1a
+\9a¡r
+->
+B\99s
+(1, 0)) {
+
+1235
+FÜm©
+(
+\9a¡r
+, "ld 'rt, 'd('ra)");
+
+1238
+FÜm©
+(
+\9a¡r
+, "ldu 'rt, 'd('ra)");
+
+1241
+FÜm©
+(
+\9a¡r
+, "lwa 'rt, 'd('ra)");
+
+1246 \ 4
+ gSTD
+: {
+
+1247 ià(
+\9a¡r
+->
+B\99
+(0) == 0) {
+
+1248
+FÜm©
+(
+\9a¡r
+, "std 'rs, 'd('ra)");
+
+1250
+FÜm©
+(
+\9a¡r
+, "stdu 'rs, 'd('ra)");
+
+1256 \ 4
+ gFAKE_OPCODE
+: {
+
+1257 ià(
+\9a¡r
+->
+B\99s
+(
+MARKER_SUBOPCODE_BIT
+, MARKER_SUBOPCODE_BIT) == 1) {
+
+1258 \12
+m¬k\94_code
+ =
+\9a¡r
+->
+B\99s
+(
+STUB_MARKER_HIGH_BIT
+, 0);
+
+1259
+DCHECK
+(
+m¬k\94_code
+ <
+F_NEXT_AVAILABLE_STUB_MARKER
+);
+
+1260
+M¬k\94FÜm©
+(
+\9a¡r
+, "¡ub-m¬k\94 ",
+m¬k\94_code
+);
+
+1262 \12
+ gçke_Ýcode
+ =
+\9a¡r
+->
+B\99s
+(
+FAKE_OPCODE_HIGH_BIT
+, 0);
+
+1263
+M¬k\94FÜm©
+(
+\9a¡r
+, "çk\94-Ýcod\90",
+çke_Ýcode
+);
+
+1268
+Unknown
+(
+\9a¡r
+);
+
+1273 \15
+ gIn¡ruùiÚ
+::
+kIn¡rSize
+;
+
+1281
+Çme¥aû
+
+ gdi§sm
+ {
+
+1284 cڡ \ 5*
+ gNameCÚv\94\8br
+::
+NameOfAdd»ss
+(
+by\8b
+*
+addr
+) const {
+
+1285
+v8
+::
+\9a\8bº®
+::
+SNPr\9atF
+(
+tmp_bufãr_
+, "%p",
+addr
+);
+
+1286 \15
+ gtmp_bufãr_
+.
+¡¬t
+();
+
+1290 cڡ \ 5*
+ gNameCÚv\94\8br
+::
+NameOfCÚ¡ªt
+(
+by\8b
+*
+addr
+) const {
+
+1291 \15
+NameOfAdd»ss
+(
+addr
+);
+
+1295 cڡ \ 5*
+ gNameCÚv\94\8br
+::
+NameOfCPURegi¡\94
+(\12
+»g
+) const {
+
+1296 \15
+v8
+::
+\9a\8bº®
+::
+Regi¡\94s
+::
+Name
+(
+»g
+);
+
+1299 cڡ \ 5*
+ gNameCÚv\94\8br
+::
+NameOfBy\8bCPURegi¡\94
+(\12
+»g
+) const {
+
+1300
+UNREACHABLE
+();
+
+1305 cڡ \ 5*
+ gNameCÚv\94\8br
+::
+NameOfXMMRegi¡\94
+(\12
+»g
+) const {
+
+1306
+UNREACHABLE
+();
+
+1310 cڡ \ 5*
+ gNameCÚv\94\8br
+::
+NameInCode
+(
+by\8b
+*
+addr
+) const {
+
+1319
+ gDi§s£mbËr
+::
+Di§s£mbËr
+(cڡ
+NameCÚv\94\8br
+&
+cÚv\94\8br
+)
+
+1320 :
+cÚv\94\8br_
+(
+cÚv\94\8br
+) {}
+
+1323
+Di§s£mbËr
+::~Disassembler() {}
+
+1326 \12
+Di§s£mbËr
+::
+In¡ruùiÚDecode
+(
+v8
+::
+\9a\8bº®
+::
+VeùÜ
+<\ 5>
+bufãr
+,
+
+1327
+by\8b
+*
+\9a¡ruùiÚ
+) {
+
+1328
+ gv8
+::
+\9a\8bº®
+::
+Decod\94
+
+d
+(
+cÚv\94\8br_
+,
+bufãr
+);
+
+1329 \15
+ gd
+.
+In¡ruùiÚDecode
+(
+\9a¡ruùiÚ
+);
+
+1334 \12
+ gDi§s£mbËr
+::
+CÚ¡ªtPoÞSizeAt
+(
+by\8b
+*
+\9a¡ruùiÚ
+) { \15 -1; }
+
+1337 \1e
+ gDi§s£mbËr
+::
+Di§s£mbË
+(
+FILE
+*
+f
+,
+by\8b
+*
+beg\9a
+, by\8b*
+\92d
+) {
+
+1338
+NameCÚv\94\8br
+
+ gcÚv\94\8br
+;
+
+1339
+Di§s£mbËr
+
+d
+(
+cÚv\94\8br
+);
+
+1340 \ f
+by\8b
+*
+ gpc
+ =
+beg\9a
+;\85ø<
+ g\92d
+;) {
+
+1341
+ gv8
+::
+\9a\8bº®
+::
+EmbeddedVeùÜ
+<\ 5, 128>
+ gbufãr
+;
+
+1342
+ gbufãr
+[0] = '\0';
+
+1343
+by\8b
+*
+ g´ev_pc
+ =
+pc
+;
+
+1344
+ gpc
+ +ð
+d
+.
+In¡ruùiÚDecode
+(
+bufãr
+,
+pc
+);
+
+1345
+ gv8
+::
+\9a\8bº®
+::
+Pr\9atF
+(
+f
+, "%° %08x %s\n",
+´ev_pc
+,
+
+1346 *
+»\9a\8b½»t_ÿ¡
+<
+\9at32_t
+*>(
+´ev_pc
+),
+bufãr
+.
+¡¬t
+());
+
+ @frames-ppc.cc
+
+5 \ 2
+ ~"¤c/v8.h
+"
+
+7 #ià
+V8_TARGET_ARCH_PPC
+
+
+9 \ 2
+ ~"¤c/as£mbËr.h
+"
+
+10 \ 2
+ ~"¤c/äames.h
+"
+
+11 \ 2
+ ~"¤c/maüo-as£mbËr.h
+"
+
+13 \ 2
+ ~"¤c/µc/as£mbËr-µc.h
+"
+
+14 \ 2
+ ~"¤c/µc/as£mbËr-µc-\9al.h
+"
+
+15 \ 2
+ ~"¤c/µc/maüo-as£mbËr-µc.h
+"
+
+17
+Çme¥aû
+
+ gv8
+ {
+
+18
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+21
+Regi¡\94
+
+ gJavaSü\9dtF¿me
+::
+å_»gi¡\94
+(è{ \15
+v8
+::
+\9a\8bº®
+::
+å
+; }
+
+22
+Regi¡\94
+
+ gJavaSü\9dtF¿me
+::
+cÚ\8bxt_»gi¡\94
+(è{ \15
+ý
+; }
+
+23
+Regi¡\94
+
+ gJavaSü\9dtF¿me
+::
+cÚ¡ªt_poÞ_po\9a\8br_»gi¡\94
+() {
+
+24 #ià
+V8_OOL_CONSTANT_POOL
+
+
+25
+DCHECK
+(
+FLAG_\92abË_oÞ_cÚ¡ªt_poÞ
+);
+
+26 \15
+ gkCÚ¡ªtPoÞRegi¡\94
+;
+
+28
+UNREACHABLE
+();
+
+29 \15
+ gno_»g
+;
+
+34
+Regi¡\94
+
+ gStubFa\9eu»T¿mpÞ\9aeF¿me
+::
+å_»gi¡\94
+(è{ \15
+v8
+::
+\9a\8bº®
+::
+å
+; }
+
+35
+Regi¡\94
+
+ gStubFa\9eu»T¿mpÞ\9aeF¿me
+::
+cÚ\8bxt_»gi¡\94
+(è{ \15
+ý
+; }
+
+36
+Regi¡\94
+
+ gStubFa\9eu»T¿mpÞ\9aeF¿me
+::
+cÚ¡ªt_poÞ_po\9a\8br_»gi¡\94
+() {
+
+37 #ià
+V8_OOL_CONSTANT_POOL
+
+
+38
+DCHECK
+(
+FLAG_\92abË_oÞ_cÚ¡ªt_poÞ
+);
+
+39 \15
+ gkCÚ¡ªtPoÞRegi¡\94
+;
+
+41
+UNREACHABLE
+();
+
+42 \15
+ gno_»g
+;
+
+47
+ gObjeù
+*&
+ gEx\99F¿me
+::
+cÚ¡ªt_poÞ_¦Ù
+() const {
+
+48 #ià
+V8_OOL_CONSTANT_POOL
+
+
+49
+DCHECK
+(
+FLAG_\92abË_oÞ_cÚ¡ªt_poÞ
+);
+
+50 cڡ \12
+ goff£t
+ =
+Ex\99F¿meCÚ¡ªts
+::
+kCÚ¡ªtPoÞOff£t
+;
+
+51 \15
+ gMemÜy
+::
+Objeù_©
+(
+å
+(è+
+off£t
+);
+
+53
+UNREACHABLE
+();
+
+54 \15
+ gMemÜy
+::
+Objeù_©
+(
+NULL
+);
+
+ @frames-ppc.h
+
+5 #iâdeà
+V8_PPC_FRAMES_PPC_H_
+
+
+6 \ 1
+ #V8_PPC_FRAMES_PPC_H_
+
+
+ )
+
+8
+Çme¥aû
+
+ gv8
+ {
+
+9
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+14 cڡ \12
+ gkNumRegs
+ = 32;
+
+18 cڡ
+RegLi¡
+
+ gkJSC®ËrSaved
+ = 1 << 3 |
+
+28 cڡ \12
+ gkNumJSC®ËrSaved
+ = 9;
+
+32 \12
+JSC®ËrSavedCode
+(\12
+n
+);
+
+36 cڡ
+RegLi¡
+
+ gkC®ËeSaved
+ = 1 << 14 |
+
+56 cڡ \12
+ gkNumC®ËeSaved
+ = 18;
+
+61 cڡ \12
+ gkNumSaãpo\9atRegi¡\94s
+ = 32;
+
+66 cڡ
+RegLi¡
+
+ gkSaãpo\9atSavedRegi¡\94s
+ =
+kJSC®ËrSaved
+ |
+kC®ËeSaved
+;
+
+67 cڡ \12
+ gkNumSaãpo\9atSavedRegi¡\94s
+ =
+kNumJSC®ËrSaved
+ +
+kNumC®ËeSaved
+;
+
+72 #ià
+V8_TARGET_ARCH_PPC64
+ &&
+V8_TARGET_LITTLE_ENDIAN
+
+
+82 cڡ \12
+ gkNumRequ\9cedS\8fckF¿meSlÙs
+ = 12;
+
+83 cڡ \12
+ gkS\8fckF¿meLRSlÙ
+ = 2;
+
+84 cڡ \12
+ gkS\8fckF¿meEx\8caP¬amSlÙ
+ = 12;
+
+85 #\96ià
+V8_OS_AIX
+ ||
+V8_TARGET_ARCH_PPC64
+
+
+97 #ià
+V8_TARGET_ARCH_PPC64
+
+
+98 cڡ \12
+ gkNumRequ\9cedS\8fckF¿meSlÙs
+ = 14;
+
+100 cڡ \12
+ gkNumRequ\9cedS\8fckF¿meSlÙs
+ = 16;
+
+102 cڡ \12
+ gkS\8fckF¿meLRSlÙ
+ = 2;
+
+103 cڡ \12
+ gkS\8fckF¿meEx\8caP¬amSlÙ
+ = 14;
+
+109 cڡ \12
+ gkNumRequ\9cedS\8fckF¿meSlÙs
+ = 4;
+
+110 cڡ \12
+ gkS\8fckF¿meLRSlÙ
+ = 1;
+
+111 cڡ \12
+ gkS\8fckF¿meEx\8caP¬amSlÙ
+ = 2;
+
+117 þas
+ cEÁryF¿meCÚ¡ªts
+ :
+public
+
+AÎS\8ftic
+ {
+
+118
+public
+:
+
+119 \18cڡ \12
+kC®ËrFPOff£t
+ =
+
+120 -(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSizeFromFp
+ +
+kPo\9a\8brSize
+);
+
+124 þas
+ cEx\99F¿meCÚ¡ªts
+ :
+public
+
+AÎS\8ftic
+ {
+
+125
+public
+:
+
+126 #ià
+V8_OOL_CONSTANT_POOL
+
+
+127 \18cڡ \12
+kF¿meSize
+ = 3 *
+kPo\9a\8brSize
+;
+
+128 \18cڡ \12
+ gkCÚ¡ªtPoÞOff£t
+ = -3 *
+kPo\9a\8brSize
+;
+
+130 \18cڡ \12
+ gkF¿meSize
+ = 2 *
+kPo\9a\8brSize
+;
+
+131 \18cڡ \12
+ gkCÚ¡ªtPoÞOff£t
+ = 0;
+
+133 \18cڡ \12
+ gkCodeOff£t
+ = -2 *
+kPo\9a\8brSize
+;
+
+134 \18cڡ \12
+ gkSPOff£t
+ = -1 *
+kPo\9a\8brSize
+;
+
+137 \18cڡ \12
+ gkC®ËrFPOff£t
+ = 0 *
+kPo\9a\8brSize
+;
+
+139 \18cڡ \12
+ gkC®ËrPCOff£t
+ = 1 *
+kPo\9a\8brSize
+;
+
+143 \18cڡ \12
+ gkC®ËrSPDi¥Ïûm\92t
+ = 2 *
+kPo\9a\8brSize
+;
+
+147 þas
+ cJavaSü\9dtF¿meCÚ¡ªts
+ :
+public
+
+AÎS\8ftic
+ {
+
+148
+public
+:
+
+150 \18cڡ \12
+kLoÿl0Off£t
+ =
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kEx´essiÚsOff£t
+;
+
+151 \18cڡ \12
+ gkLa¡P¬am\91\94Off£t
+ = +2 *
+kPo\9a\8brSize
+;
+
+152 \18cڡ \12
+ gkFunùiÚOff£t
+ =
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kM¬k\94Off£t
+;
+
+155 \18cڡ \12
+ gkP¬am0Off£t
+ = -2 *
+kPo\9a\8brSize
+;
+
+156 \18cڡ \12
+ gkReûiv\94Off£t
+ = -1 *
+kPo\9a\8brSize
+;
+
+160 þas
+ cArgum\92tsAdtÜF¿meCÚ¡ªts
+ :
+public
+
+AÎS\8ftic
+ {
+
+161
+public
+:
+
+163 \18cڡ \12
+kL\92gthOff£t
+ =
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kEx´essiÚsOff£t
+;
+
+165 \18cڡ \12
+ gkF¿meSize
+ =
+
+166
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSize
+ +
+kPo\9a\8brSize
+;
+
+170 þas
+ cCÚ¡ruùF¿meCÚ¡ªts
+ :
+public
+
+AÎS\8ftic
+ {
+
+171
+public
+:
+
+173 \18cڡ \12
+kIm¶ic\99Reûiv\94Off£t
+ = -6 *
+kPo\9a\8brSize
+;
+
+174 \18cڡ \12
+ gkCÚ¡ruùÜOff£t
+ = -5 *
+kPo\9a\8brSize
+;
+
+175 \18cڡ \12
+ gkL\92gthOff£t
+ = -4 *
+kPo\9a\8brSize
+;
+
+176 \18cڡ \12
+ gkCodeOff£t
+ =
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kEx´essiÚsOff£t
+;
+
+178 \18cڡ \12
+ gkF¿meSize
+ =
+
+179
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSize
+ + 4 *
+kPo\9a\8brSize
+;
+
+183 þas
+ cIÁ\94ÇlF¿meCÚ¡ªts
+ :
+public
+
+AÎS\8ftic
+ {
+
+184
+public
+:
+
+186 \18cڡ \12
+kCodeOff£t
+ =
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kEx´essiÚsOff£t
+;
+
+190
+\9al\9ae
+
+Objeù
+*
+ gJavaSü\9dtF¿me
+::
+funùiÚ_¦Ù_objeù
+() const {
+
+191 cڡ \12
+off£t
+ =
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+;
+
+192 \15
+ gMemÜy
+::
+Objeù_©
+(
+å
+(è+
+off£t
+);
+
+196
+\9al\9ae
+ \1e
+ gS\8fckHªdËr
+::
+S\91Fp
+(
+Add»ss
+
+¦Ù
+, Add»s
+å
+) {
+
+197
+ gMemÜy
+::
+Add»ss_©
+(
+¦Ù
+èð
+å
+;
+
+ @full-codegen-ppc.cc
+
+5 \ 2
+ ~"¤c/v8.h
+"
+
+7 #ià
+V8_TARGET_ARCH_PPC
+
+
+9 \ 2
+ ~"¤c/code-çùÜy.h
+"
+
+10 \ 2
+ ~"¤c/code-¡ubs.h
+"
+
+11 \ 2
+ ~"¤c/codeg\92.h
+"
+
+12 \ 2
+ ~"¤c/comp\9e\94.h
+"
+
+13 \ 2
+ ~"¤c/debug.h
+"
+
+14 \ 2
+ ~"¤c/fuÎ-codeg\92.h
+"
+
+15 \ 2
+ ~"¤c/ic/ic.h
+"
+
+16 \ 2
+ ~"¤c/isÞ©e-\9al.h
+"
+
+17 \ 2
+ ~"¤c/·r£r.h
+"
+
+18 \ 2
+ ~"¤c/scÝes.h
+"
+
+20 \ 2
+ ~"¤c/µc/code-¡ubs-µc.h
+"
+
+21 \ 2
+ ~"¤c/µc/maüo-as£mbËr-µc.h
+"
+
+23
+Çme¥aû
+
+ gv8
+ {
+
+24
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+26 \ 1
+ #__
+
+ `ACCESS_MASM
+(
+masm_
+)
+
+ )
+
+35 þas
+ cJumpP©chS\99e
+
+ gBASE_EMBEDDED
+ {
+
+36
+ gpublic
+:
+
+37
+ex¶ic\99
+
+JumpP©chS\99e
+(
+MaüoAs£mbËr
+*
+masm
+è:
+masm_
+(masm) {
+
+38 #ifdeà
+DEBUG
+
+
+39
+\9afo_em\99\8bd_
+ =
+çl£
+;
+
+43 ~
+JumpP©chS\99e
+(è{
+DCHECK
+(
+·tch_s\99e_
+.
+is_bound
+(è=ð
+\9afo_em\99\8bd_
+); }
+
+47 \1e
+Em\99JumpIfNÙSmi
+(
+Regi¡\94
+
+»g
+,
+Lab\96
+*
+\8frg\91
+) {
+
+48
+DCHECK
+(!
+·tch_s\99e_
+.
+is_bound
+(è&& !
+\9afo_em\99\8bd_
+);
+
+49
+ gAs£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+masm_
+);
+
+50
+__
+
+b\9ad
+(&
+·tch_s\99e_
+);
+
+51
+__
+
+cmp
+(
+»g
+,\84eg,
+ü0
+);
+
+52
+__
+
+beq
+(
+\8frg\91
+,
+ü0
+);
+
+57 \1e
+Em\99JumpIfSmi
+(
+Regi¡\94
+
+»g
+,
+Lab\96
+*
+\8frg\91
+) {
+
+58
+ gAs£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+masm_
+);
+
+59
+DCHECK
+(!
+·tch_s\99e_
+.
+is_bound
+(è&& !
+\9afo_em\99\8bd_
+);
+
+60
+__
+
+b\9ad
+(&
+·tch_s\99e_
+);
+
+61
+__
+
+cmp
+(
+»g
+,\84eg,
+ü0
+);
+
+62
+__
+
+bÃ
+(
+\8frg\91
+,
+ü0
+);
+
+65 \1e
+Em\99P©chInfo
+() {
+
+66 ià(
+ g·tch_s\99e_
+.
+is_bound
+()) {
+
+67 \12
+ gd\96\8f_to_·tch_s\99e
+ =
+masm_
+->
+In¡ruùiÚsG\92\94©edS\9aû
+(&
+·tch_s\99e_
+);
+
+68
+Regi¡\94
+
+ g»g
+;
+
+70
+ g»g
+.
+£t_code
+(
+d\96\8f_to_·tch_s\99e
+ /
+kOff16Mask
+);
+
+71
+__
+
+cmpi
+(
+»g
+,
+O³¿nd
+(
+d\96\8f_to_·tch_s\99e
+ %
+kOff16Mask
+));
+
+72 #ifdeà
+DEBUG
+
+
+73
+ g\9afo_em\99\8bd_
+ =
+\8cue
+;
+
+76
+__
+
+nÝ
+();
+
+80
+ g´iv©e
+:
+
+81
+MaüoAs£mbËr
+*
+masm_
+;
+
+82
+Lab\96
+
+ g·tch_s\99e_
+;
+
+83 #ifdeà
+DEBUG
+
+
+84
+boÞ
+
+ g\9afo_em\99\8bd_
+;
+
+104 \1e
+ gFuÎCodeG\92\94©Ü
+::
+G\92\94©e
+() {
+
+105
+Comp\9e©iÚInfo
+*
+\9afo
+ =
+\9afo_
+;
+
+106
+ ghªdËr_\8fbË_
+ =
+
+107
+isީe
+()->
+çùÜy
+()->
+NewFixedA¼ay
+(
+funùiÚ
+()->
+hªdËr_couÁ
+(),
+TENURED
+);
+
+109
+ g´of\9e\9ag_couÁ\94_
+ =
+isީe
+()->
+çùÜy
+()->
+NewC\96l
+(
+
+110
+HªdË
+<
+Smi
+>(Smi::
+FromIÁ
+(
+FLAG_\9a\8b¼u±_budg\91
+),
+isީe
+()));
+
+111
+S\91FunùiÚPos\99iÚ
+(
+funùiÚ
+());
+
+112
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ function compiled by full code generator");
+
+114
+ gProf\9eeEÁryHookStub
+::
+MaybeC®lEÁryHook
+(
+masm_
+);
+
+116 #ifdeà
+DEBUG
+
+
+117 ià(
+¡¾\92
+(
+FLAG_¡Ý_©
+) > 0 &&
+
+118
+ g\9afo
+->
+funùiÚ
+()->
+Çme
+()->
+IsUtf8Equ®To
+(
+CS\8cVeùÜ
+(
+FLAG_¡Ý_©
+))) {
+
+119
+__
+
+¡Ý
+("stop-at");
+
+126 ià(
+ g\9afo
+->
+¡riù_mode
+(è=ð
+SLOPPY
+ && !
+\9afo
+->
+is_Çtive
+()) {
+
+127
+Lab\96
+
+ok
+;
+
+128 \12
+ g»ûiv\94_off£t
+ =
+\9afo
+->
+scÝe
+()->
+num_·¿m\91\94s
+(è*
+kPo\9a\8brSize
+;
+
+129
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+,
+»ûiv\94_off£t
+),
+r0
+);
+
+130
+__
+
+Com·»RoÙ
+(
+r5
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+131
+__
+
+bÃ
+(&
+ok
+);
+
+133
+__
+
+LßdP
+(
+r5
+,
+Glob®ObjeùO³¿nd
+());
+
+134
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+Ô5,
+Glob®Objeù
+::
+kGlob®ProxyOff£t
+));
+
+136
+__
+
+StÜeP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+,
+»ûiv\94_off£t
+),
+r0
+);
+
+138
+__
+
+b\9ad
+(&
+ok
+);
+
+144
+F¿meScÝe
+
+äame_scÝe
+(
+masm_
+,
+S\8fckF¿me
+::
+MANUAL
+);
+
+145 \12
+ g´Þogue_off£t
+ =
+masm_
+->
+pc_off£t
+();
+
+147 ià(
+ g´Þogue_off£t
+) {
+
+150
+ g´Þogue_off£t
+ +ð
+In¡ruùiÚ
+::
+kIn¡rSize
+;
+
+151
+__
+
+addi
+(
+\9d
+, ip,
+O³¿nd
+(
+´Þogue_off£t
+));
+
+153
+ g\9afo
+->
+£t_´Þogue_off£t
+(
+´Þogue_off£t
+);
+
+154
+__
+
+PrÞogue
+(
+\9afo
+->
+IsCodeP»Ag\9agAùive
+(),
+´Þogue_off£t
+);
+
+155
+ g\9afo
+->
+AddNoF¿meRªge
+(0,
+masm_
+->
+pc_off£t
+());
+
+158
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Allocate\86ocals");
+
+159 \12
+ gloÿls_couÁ
+ =
+\9afo
+->
+scÝe
+()->
+num_¡ack_¦Ùs
+();
+
+161
+DCHECK
+(!
+\9afo
+->
+funùiÚ
+()->
+is_g\92\94©Ü
+(è||
+loÿls_couÁ
+ == 0);
+
+162 ià(
+ gloÿls_couÁ
+ > 0) {
+
+163 ià(
+ gloÿls_couÁ
+ >= 128) {
+
+164
+Lab\96
+
+ok
+;
+
+165
+__
+
+Add
+(
+\9d
+,
+¥
+, -(
+loÿls_couÁ
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+166
+__
+
+LßdRoÙ
+(
+r5
+,
+H\97p
+::
+kR\97lS\8fckLim\99RoÙIndex
+);
+
+167
+__
+
+cm¶
+(
+\9d
+,
+r5
+);
+
+168
+__
+
+bc_shÜt
+(
+ge
+, &
+ok
+);
+
+169
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+STACK_OVERFLOW
+,
+CALL_FUNCTION
+);
+
+170
+__
+
+b\9ad
+(&
+ok
+);
+
+172
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+173 \12
+ gkMaxPushes
+ =
+FLAG_Ýtimize_fÜ_size
+ ? 4 : 32;
+
+174 ià(
+ gloÿls_couÁ
+ >ð
+kMaxPushes
+) {
+
+175 \12
+loÝ_\99\94©iÚs
+ =
+loÿls_couÁ
+ /
+kMaxPushes
+;
+
+176
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+loÝ_\99\94©iÚs
+));
+
+177
+__
+
+mtùr
+(
+r5
+);
+
+178
+Lab\96
+
+ gloÝ_h\97d\94
+;
+
+179
+__
+
+b\9ad
+(&
+loÝ_h\97d\94
+);
+
+181 \ f\12
+ gi
+ = 0; i <
+ gkMaxPushes
+; i++) {
+
+182
+__
+
+push
+(
+\9d
+);
+
+185
+__
+
+bdnz
+(&
+loÝ_h\97d\94
+);
+
+187 \12
+ g»ma\9a\9ag
+ =
+loÿls_couÁ
+ %
+kMaxPushes
+;
+
+189 \ f\12
+ gi
+ = 0; i <
+ g»ma\9a\9ag
+; i++) {
+
+190
+__
+
+push
+(
+\9d
+);
+
+195
+boÞ
+
+ gfunùiÚ_\9a_»gi¡\94
+ =
+\8cue
+;
+
+198 \12
+ gh\97p_¦Ùs
+ =
+\9afo
+->
+scÝe
+()->
+num_h\97p_¦Ùs
+(è-
+Cڋxt
+::
+MIN_CONTEXT_SLOTS
+;
+
+199 ià(
+ gh\97p_¦Ùs
+ > 0) {
+
+201
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Allocate context");
+
+202
+boÞ
+
+ gÃed_wr\99e_b¬r\9br
+ =
+\8cue
+;
+
+203 ià(
+ gFLAG_h¬mÚy_scÝ\9ag
+ &&
+ g\9afo
+->
+scÝe
+()->
+is_glob®_scÝe
+()) {
+
+204
+__
+
+push
+(
+r4
+);
+
+205
+__
+
+Push
+(
+\9afo
+->
+scÝe
+()->
+G\91ScÝeInfo
+());
+
+206
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kNewGlob®CÚ\8bxt
+, 2);
+
+207 } \vià(
+ gh\97p_¦Ùs
+ <ð
+Fa¡NewCÚ\8bxtStub
+::
+kMaximumSlÙs
+) {
+
+208
+Fa¡NewCÚ\8bxtStub
+
+¡ub
+(
+isީe
+(),
+h\97p_¦Ùs
+);
+
+209
+__
+
+C®lStub
+(&
+¡ub
+);
+
+211
+ gÃed_wr\99e_b¬r\9br
+ =
+çl£
+;
+
+213
+__
+
+push
+(
+r4
+);
+
+214
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kNewFunùiÚCÚ\8bxt
+, 1);
+
+216
+ gfunùiÚ_\9a_»gi¡\94
+ =
+çl£
+;
+
+219
+__
+
+mr
+(
+ý
+,
+r3
+);
+
+220
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+222 \12
+ gnum_·¿m\91\94s
+ =
+\9afo
+->
+scÝe
+()->
+num_·¿m\91\94s
+();
+
+223 \ f\12
+ gi
+ = 0; i <
+ gnum_·¿m\91\94s
+; i++) {
+
+224
+V¬\9fbË
+*
+ gv¬
+ =
+scÝe
+()->
+·¿m\91\94
+(
+i
+);
+
+225 ià(
+ gv¬
+->
+IsCÚ\8bxtSlÙ
+()) {
+
+226 \12
+ g·¿m\91\94_off£t
+ =
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrSPOff£t
+ +
+
+227 (
+num_·¿m\91\94s
+ - 1 -
+i
+è*
+kPo\9a\8brSize
+;
+
+229
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+·¿m\91\94_off£t
+),
+r0
+);
+
+231
+MemO³¿nd
+
+ g\8frg\91
+ =
+CÚ\8bxtO³¿nd
+(
+ý
+,
+v¬
+->
+\9adex
+());
+
+232
+__
+
+StÜeP
+(
+r3
+,
+\8frg\91
+,
+r0
+);
+
+235 ià(
+ gÃed_wr\99e_b¬r\9br
+) {
+
+236
+__
+
+RecÜdWr\99eCÚ\8bxtSlÙ
+(
+ý
+,
+\8frg\91
+.
+off£t
+(),
+r3
+,
+r6
+,
+
+237
+kLRHasB\93nSaved
+,
+kDÚtSaveFPRegs
+);
+
+238 } \vià(
+ gFLAG_debug_code
+) {
+
+239
+Lab\96
+
+ gdÚe
+;
+
+240
+__
+
+JumpIfInNewS·û
+(
+ý
+,
+r3
+, &
+dÚe
+);
+
+241
+__
+
+AbÜt
+(
+kEx³ùedNewS·ûObjeù
+);
+
+242
+__
+
+b\9ad
+(&
+dÚe
+);
+
+248
+V¬\9fbË
+*
+ g¬gum\92ts
+ =
+scÝe
+()->
+¬gum\92ts
+();
+
+249 ià(
+ g¬gum\92ts
+ !ð
+NULL
+) {
+
+251
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Allocate\87rguments object");
+
+252 ià(!
+ gfunùiÚ_\9a_»gi¡\94
+) {
+
+254
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+256
+__
+
+mr
+(
+r6
+,
+r4
+);
+
+259 \12
+ gnum_·¿m\91\94s
+ =
+\9afo
+->
+scÝe
+()->
+num_·¿m\91\94s
+();
+
+260 \12
+ goff£t
+ =
+num_·¿m\91\94s
+ *
+kPo\9a\8brSize
+;
+
+261
+__
+
+addi
+(
+r5
+,
+å
+,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrSPOff£t
+ +
+off£t
+));
+
+262
+__
+
+LßdSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(
+num_·¿m\91\94s
+));
+
+263
+__
+
+Push
+(
+r6
+,
+r5
+,
+r4
+);
+
+269
+ gArgum\92tsAcûssStub
+::
+Ty³
+
+ty³
+;
+
+270 ià(
+¡riù_mode
+(è=ð
+STRICT
+) {
+
+271
+ty³
+ =
+Argum\92tsAcûssStub
+::
+NEW_STRICT
+;
+
+272 } \vià(
+funùiÚ
+()->
+has_du¶iÿ\8b_·¿m\91\94s
+()) {
+
+273
+ gty³
+ =
+Argum\92tsAcûssStub
+::
+NEW_SLOPPY_SLOW
+;
+
+275
+ gty³
+ =
+Argum\92tsAcûssStub
+::
+NEW_SLOPPY_FAST
+;
+
+277
+Argum\92tsAcûssStub
+
+¡ub
+(
+isީe
+(),
+ty³
+);
+
+278
+__
+
+C®lStub
+(&
+¡ub
+);
+
+280
+S\91V¬
+(
+¬gum\92ts
+,
+r3
+,
+r4
+,
+r5
+);
+
+283 ià(
+ gFLAG_\8caû
+) {
+
+284
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kT¿ûEÁ\94
+, 0);
+
+289 ià(
+scÝe
+()->
+HasIÎeg®Redeþ¬©iÚ
+()) {
+
+290
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Declarations");
+
+291
+scÝe
+()->
+Vis\99IÎeg®Redeþ¬©iÚ
+(
+this
+);
+
+294
+P»·»FÜBa\9eoutFÜId
+(
+Ba\9eoutId
+::
+FunùiÚEÁry
+(),
+NO_REGISTERS
+);
+
+296
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Declarations");
+
+299 ià(
+scÝe
+()->
+is_funùiÚ_scÝe
+(è&& scÝe()->
+funùiÚ
+(è!ð
+NULL
+) {
+
+300
+V¬\9fbËDeþ¬©iÚ
+*
+funùiÚ
+ =
+scÝe
+()->function();
+
+301
+DCHECK
+(
+funùiÚ
+->
+´oxy
+()->
+v¬
+()->
+mode
+(è=ð
+CONST
+ ||
+
+302
+funùiÚ
+->
+´oxy
+()->
+v¬
+()->
+mode
+(è=ð
+CONST_LEGACY
+);
+
+303
+DCHECK
+(
+funùiÚ
+->
+´oxy
+()->
+v¬
+()->
+loÿtiÚ
+(è!ð
+V¬\9fbË
+::
+UNALLOCATED
+);
+
+304
+Vis\99V¬\9fbËDeþ¬©iÚ
+(
+funùiÚ
+);
+
+306
+Vis\99Deþ¬©iÚs
+(
+scÝe
+()->
+deþ¬©iÚs
+());
+
+310
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Stack check");
+
+311
+P»·»FÜBa\9eoutFÜId
+(
+Ba\9eoutId
+::
+Deþ¬©iÚs
+(),
+NO_REGISTERS
+);
+
+312
+Lab\96
+
+ gok
+;
+
+313
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kS\8fckLim\99RoÙIndex
+);
+
+314
+__
+
+cm¶
+(
+¥
+,
+\9d
+);
+
+315
+__
+
+bc_shÜt
+(
+ge
+, &
+ok
+);
+
+316
+__
+
+C®l
+(
+isީe
+()->
+bu\9et\9as
+()->
+S\8fckCheck
+(),
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+317
+__
+
+b\9ad
+(&
+ok
+);
+
+321
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Body");
+
+322
+DCHECK
+(
+loÝ_d\95th
+() == 0);
+
+323
+Vis\99S\8f\8bm\92ts
+(
+funùiÚ
+()->
+body
+());
+
+324
+DCHECK
+(
+loÝ_d\95th
+() == 0);
+
+331
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[\84eturn <undefined>;");
+
+332
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+334
+Em\99R\91uºSequ\92û
+();
+
+338 \1e
+ gFuÎCodeG\92\94©Ü
+::
+CˬAccumuÏtÜ
+() {
+
+339
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(0));
+
+343 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99Prof\9e\9agCouÁ\94Deüem\92t
+(\12
+d\96\8f
+) {
+
+344
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+´of\9e\9ag_couÁ\94_
+));
+
+345
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+C\96l
+::
+kV®ueOff£t
+));
+
+346
+__
+
+SubSmiL\99\94®
+(
+r6
+,\846,
+Smi
+::
+FromIÁ
+(
+d\96\8f
+),
+r0
+);
+
+347
+__
+
+StÜeP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+C\96l
+::
+kV®ueOff£t
+),
+r0
+);
+
+351 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99Prof\9e\9agCouÁ\94Re£t
+() {
+
+352 \12
+»£t_v®ue
+ =
+FLAG_\9a\8b¼u±_budg\91
+;
+
+353 ià(
+ g\9afo_
+->
+is_debug
+()) {
+
+355
+ g»£t_v®ue
+ =
+FLAG_\9a\8b¼u±_budg\91
+ >> 4;
+
+357
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+´of\9e\9ag_couÁ\94_
+));
+
+358
+__
+
+LßdSmiL\99\94®
+(
+r6
+,
+Smi
+::
+FromIÁ
+(
+»£t_v®ue
+));
+
+359
+__
+
+StÜeP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+C\96l
+::
+kV®ueOff£t
+),
+r0
+);
+
+363 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99BackEdgeBookk\93p\9ag
+(
+I\8b¿tiÚS\8f\8bm\92t
+*
+¡mt
+,
+
+364
+Lab\96
+*
+back_edge_\8frg\91
+) {
+
+365
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Back\83dge bookkeeping");
+
+366
+Lab\96
+
+ gok
+;
+
+368
+DCHECK
+(
+back_edge_\8frg\91
+->
+is_bound
+());
+
+369 \12
+ gdi¡ªû
+ =
+masm_
+->
+SizeOfCodeG\92\94©edS\9aû
+(
+back_edge_\8frg\91
+) +
+
+370
+kCodeSizeMuÉ\9dl\9br
+ / 2;
+
+371 \12
+ gweight
+ =
+M\9a
+(
+kMaxBackEdgeWeight
+,
+Max
+(1,
+di¡ªû
+ /
+kCodeSizeMuÉ\9dl\9br
+));
+
+372
+Em\99Prof\9e\9agCouÁ\94Deüem\92t
+(
+weight
+);
+
+374
+ gAs£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+masm_
+);
+
+376
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+::
+Z\94o
+());
+
+377
+__
+
+bc_shÜt
+(
+ge
+, &
+ok
+);
+
+378
+__
+
+C®l
+(
+isީe
+()->
+bu\9et\9as
+()->
+IÁ\94ru±Check
+(),
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+383
+RecÜdBackEdge
+(
+¡mt
+->
+O¤EÁryId
+());
+
+385
+Em\99Prof\9e\9agCouÁ\94Re£t
+();
+
+387
+__
+
+b\9ad
+(&
+ok
+);
+
+388
+P»·»FÜBa\9eoutFÜId
+(
+¡mt
+->
+EÁryId
+(),
+NO_REGISTERS
+);
+
+392
+P»·»FÜBa\9eoutFÜId
+(
+¡mt
+->
+O¤EÁryId
+(),
+NO_REGISTERS
+);
+
+396 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99R\91uºSequ\92û
+() {
+
+397
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Return sequence");
+
+398 ià(
+ g»tuº_Ïb\96_
+.
+is_bound
+()) {
+
+399
+__
+
+b
+(&
+»tuº_Ïb\96_
+);
+
+401
+__
+
+b\9ad
+(&
+»tuº_Ïb\96_
+);
+
+402 ià(
+ gFLAG_\8caû
+) {
+
+405
+__
+
+push
+(
+r3
+);
+
+406
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kT¿ûEx\99
+, 1);
+
+409 \12
+ gweight
+ = 1;
+
+410 ià(
+ g\9afo_
+->
+ShouldS\96fO±imize
+()) {
+
+411
+ gweight
+ =
+FLAG_\9a\8b¼u±_budg\91
+ /
+FLAG_£lf_Ýt_couÁ
+;
+
+413 \12
+ gdi¡ªû
+ =
+masm_
+->
+pc_off£t
+(è+
+kCodeSizeMuÉ\9dl\9br
+ / 2;
+
+414
+ gweight
+ =
+M\9a
+(
+kMaxBackEdgeWeight
+,
+Max
+(1,
+di¡ªû
+ /
+kCodeSizeMuÉ\9dl\9br
+));
+
+416
+Em\99Prof\9e\9agCouÁ\94Deüem\92t
+(
+weight
+);
+
+417
+Lab\96
+
+ gok
+;
+
+418
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+::
+Z\94o
+());
+
+419
+__
+
+bge
+(&
+ok
+);
+
+420
+__
+
+push
+(
+r3
+);
+
+421
+__
+
+C®l
+(
+isީe
+()->
+bu\9et\9as
+()->
+IÁ\94ru±Check
+(),
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+422
+__
+
+pÝ
+(
+r3
+);
+
+423
+Em\99Prof\9e\9agCouÁ\94Re£t
+();
+
+424
+__
+
+b\9ad
+(&
+ok
+);
+
+426 #ifdeà
+DEBUG
+
+
+428
+Lab\96
+
+ gcheck_ex\99_codesize
+;
+
+429
+__
+
+b\9ad
+(&
+check_ex\99_codesize
+);
+
+434
+ gAs£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+masm_
+);
+
+435
+\9at32_t
+
+ g¥_d\96\8f
+ = (
+\9afo_
+->
+scÝe
+()->
+num_·¿m\91\94s
+(è+ 1è*
+kPo\9a\8brSize
+;
+
+436
+ gCodeG\92\94©Ü
+::
+RecÜdPos\99iÚs
+(
+masm_
+,
+funùiÚ
+()->
+\92d_pos\99iÚ
+() - 1);
+
+437
+__
+
+RecÜdJSR\91uº
+();
+
+438 \12
+ gno_äame_¡¬t
+ =
+__
+
+L\97veF¿me
+(
+S\8fckF¿me
+::
+JAVA_SCRIPT
+,
+¥_d\96\8f
+);
+
+439 #ià
+V8_TARGET_ARCH_PPC64
+
+
+442 ià(
+is_\9at16
+(
+¥_d\96\8f
+)) {
+
+443 #ià!
+V8_OOL_CONSTANT_POOL
+
+
+444
+ gmasm_
+->
+nÝ
+();
+
+446
+ gmasm_
+->
+nÝ
+();
+
+449
+__
+
+bÌ
+();
+
+450
+ g\9afo_
+->
+AddNoF¿meRªge
+(
+no_äame_¡¬t
+,
+masm_
+->
+pc_off£t
+());
+
+453 #ifdeà
+DEBUG
+
+
+456
+DCHECK
+(
+As£mbËr
+::
+kJSR\91uºSequ\92ûIn¡ruùiÚs
+ <=
+
+457
+masm_
+->
+In¡ruùiÚsG\92\94©edS\9aû
+(&
+check_ex\99_codesize
+));
+
+463 \1e
+ gFuÎCodeG\92\94©Ü
+::
+EfãùCÚ\8bxt
+::
+Plug
+(
+V¬\9fbË
+*
+v¬
+) const {
+
+464
+DCHECK
+(
+v¬
+->
+IsS\8fckAÎoÿ\8bd
+(è|| v¬->
+IsCÚ\8bxtSlÙ
+());
+
+468 \1e
+ gFuÎCodeG\92\94©Ü
+::
+AccumuÏtÜV®ueCÚ\8bxt
+::
+Plug
+(
+V¬\9fbË
+*
+v¬
+) const {
+
+469
+DCHECK
+(
+v¬
+->
+IsS\8fckAÎoÿ\8bd
+(è|| v¬->
+IsCÚ\8bxtSlÙ
+());
+
+470
+codeg\92
+()->
+G\91V¬
+(
+»suÉ_»gi¡\94
+(),
+v¬
+);
+
+474 \1e
+ gFuÎCodeG\92\94©Ü
+::
+S\8fckV®ueCÚ\8bxt
+::
+Plug
+(
+V¬\9fbË
+*
+v¬
+) const {
+
+475
+DCHECK
+(
+v¬
+->
+IsS\8fckAÎoÿ\8bd
+(è|| v¬->
+IsCÚ\8bxtSlÙ
+());
+
+476
+codeg\92
+()->
+G\91V¬
+(
+»suÉ_»gi¡\94
+(),
+v¬
+);
+
+477
+__
+
+push
+(
+»suÉ_»gi¡\94
+());
+
+481 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Te¡CÚ\8bxt
+::
+Plug
+(
+V¬\9fbË
+*
+v¬
+) const {
+
+482
+DCHECK
+(
+v¬
+->
+IsS\8fckAÎoÿ\8bd
+(è|| v¬->
+IsCÚ\8bxtSlÙ
+());
+
+484
+codeg\92
+()->
+G\91V¬
+(
+»suÉ_»gi¡\94
+(),
+v¬
+);
+
+485
+codeg\92
+()->
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+cÚd\99iÚ
+(),
+çl£
+,
+NULL
+, NULL);
+
+486
+codeg\92
+()->
+DoTe¡
+(
+this
+);
+
+490 \1e
+ gFuÎCodeG\92\94©Ü
+::
+EfãùCÚ\8bxt
+::
+Plug
+(
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+) const {}
+
+493 \1e
+FuÎCodeG\92\94©Ü
+::
+AccumuÏtÜV®ueCÚ\8bxt
+::
+Plug
+(
+
+494
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+) const {
+
+495
+__
+
+LßdRoÙ
+(
+»suÉ_»gi¡\94
+(),
+\9adex
+);
+
+499 \1e
+ gFuÎCodeG\92\94©Ü
+::
+S\8fckV®ueCÚ\8bxt
+::
+Plug
+(
+
+500
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+) const {
+
+501
+__
+
+LßdRoÙ
+(
+»suÉ_»gi¡\94
+(),
+\9adex
+);
+
+502
+__
+
+push
+(
+»suÉ_»gi¡\94
+());
+
+506 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Te¡CÚ\8bxt
+::
+Plug
+(
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+) const {
+
+507
+codeg\92
+()->
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+cÚd\99iÚ
+(),
+\8cue
+,
+\8cue_Ïb\96_
+,
+
+508
+çl£_Ïb\96_
+);
+
+509 ià(
+ g\9adex
+ =ð
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+ ||
+
+510
+\9adex
+ =ð
+H\97p
+::
+kNuÎV®ueRoÙIndex
+ ||
+
+511
+\9adex
+ =ð
+H\97p
+::
+kF®£V®ueRoÙIndex
+) {
+
+512 ià(
+çl£_Ïb\96_
+ !ð
+çÎ_through_
+è
+__
+
+b
+(false_label_);
+
+513 } \vià(
+ g\9adex
+ =ð
+H\97p
+::
+kTrueV®ueRoÙIndex
+) {
+
+514 ià(
+\8cue_Ïb\96_
+ !ð
+çÎ_through_
+è
+__
+
+b
+(true_label_);
+
+516
+__
+
+LßdRoÙ
+(
+»suÉ_»gi¡\94
+(),
+\9adex
+);
+
+517
+codeg\92
+()->
+DoTe¡
+(
+this
+);
+
+522 \1e
+ gFuÎCodeG\92\94©Ü
+::
+EfãùCÚ\8bxt
+::
+Plug
+(
+HªdË
+<
+Objeù
+>
+l\99
+) const {}
+
+525 \1e
+FuÎCodeG\92\94©Ü
+::
+AccumuÏtÜV®ueCÚ\8bxt
+::
+Plug
+(
+
+526
+HªdË
+<
+Objeù
+>
+l\99
+) const {
+
+527
+__
+
+mov
+(
+»suÉ_»gi¡\94
+(),
+O³¿nd
+(
+l\99
+));
+
+531 \1e
+ gFuÎCodeG\92\94©Ü
+::
+S\8fckV®ueCÚ\8bxt
+::
+Plug
+(
+HªdË
+<
+Objeù
+>
+l\99
+) const {
+
+533
+__
+
+mov
+(
+»suÉ_»gi¡\94
+(),
+O³¿nd
+(
+l\99
+));
+
+534
+__
+
+push
+(
+»suÉ_»gi¡\94
+());
+
+538 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Te¡CÚ\8bxt
+::
+Plug
+(
+HªdË
+<
+Objeù
+>
+l\99
+) const {
+
+539
+codeg\92
+()->
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+cÚd\99iÚ
+(),
+\8cue
+,
+\8cue_Ïb\96_
+,
+
+540
+çl£_Ïb\96_
+);
+
+541
+DCHECK
+(!
+l\99
+->
+IsUnd\91eùabËObjeù
+());
+
+542 ià(
+ gl\99
+->
+IsUndef\9aed
+(è||\86\99->
+IsNuÎ
+(è||\86\99->
+IsF®£
+()) {
+
+543 ià(
+ gçl£_Ïb\96_
+ !ð
+çÎ_through_
+è
+__
+
+b
+(
+çl£_Ïb\96_
+);
+
+544 } \vià(
+ gl\99
+->
+IsTrue
+(è||\86\99->
+IsJSObjeù
+()) {
+
+545 ià(
+ g\8cue_Ïb\96_
+ !ð
+çÎ_through_
+è
+__
+
+b
+(
+\8cue_Ïb\96_
+);
+
+546 } \vià(
+ gl\99
+->
+IsS\8c\9ag
+()) {
+
+547 ià(
+ gS\8c\9ag
+::
+ÿ¡
+(*
+l\99
+)->
+Ëngth
+() == 0) {
+
+548 ià(
+çl£_Ïb\96_
+ !ð
+çÎ_through_
+è
+__
+
+b
+(false_label_);
+
+550 ià(
+ g\8cue_Ïb\96_
+ !ð
+çÎ_through_
+è
+__
+
+b
+(
+\8cue_Ïb\96_
+);
+
+552 } \vià(
+ gl\99
+->
+IsSmi
+()) {
+
+553 ià(
+ gSmi
+::
+ÿ¡
+(*
+l\99
+)->
+v®ue
+() == 0) {
+
+554 ià(
+çl£_Ïb\96_
+ !ð
+çÎ_through_
+è
+__
+
+b
+(false_label_);
+
+556 ià(
+ g\8cue_Ïb\96_
+ !ð
+çÎ_through_
+è
+__
+
+b
+(
+\8cue_Ïb\96_
+);
+
+560
+__
+
+mov
+(
+»suÉ_»gi¡\94
+(),
+O³¿nd
+(
+l\99
+));
+
+561
+codeg\92
+()->
+DoTe¡
+(
+this
+);
+
+566 \1e
+ gFuÎCodeG\92\94©Ü
+::
+EfãùCÚ\8bxt
+::
+DrÝAndPlug
+(\12
+couÁ
+,
+
+567
+Regi¡\94
+
+»g
+) const {
+
+568
+DCHECK
+(
+couÁ
+ > 0);
+
+569
+__
+
+DrÝ
+(
+couÁ
+);
+
+573 \1e
+ gFuÎCodeG\92\94©Ü
+::
+AccumuÏtÜV®ueCÚ\8bxt
+::
+DrÝAndPlug
+(
+
+574 \12
+couÁ
+,
+Regi¡\94
+
+»g
+) const {
+
+575
+DCHECK
+(
+couÁ
+ > 0);
+
+576
+__
+
+DrÝ
+(
+couÁ
+);
+
+577
+__
+
+Move
+(
+»suÉ_»gi¡\94
+(),
+»g
+);
+
+581 \1e
+ gFuÎCodeG\92\94©Ü
+::
+S\8fckV®ueCÚ\8bxt
+::
+DrÝAndPlug
+(\12
+couÁ
+,
+
+582
+Regi¡\94
+
+»g
+) const {
+
+583
+DCHECK
+(
+couÁ
+ > 0);
+
+584 ià(
+ gcouÁ
+ > 1è
+__
+
+DrÝ
+(
+couÁ
+ - 1);
+
+585
+__
+
+StÜeP
+(
+»g
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+589 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Te¡CÚ\8bxt
+::
+DrÝAndPlug
+(\12
+couÁ
+,
+
+590
+Regi¡\94
+
+»g
+) const {
+
+591
+DCHECK
+(
+couÁ
+ > 0);
+
+593
+__
+
+DrÝ
+(
+couÁ
+);
+
+594
+__
+
+Move
+(
+»suÉ_»gi¡\94
+(),
+»g
+);
+
+595
+codeg\92
+()->
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+cÚd\99iÚ
+(),
+çl£
+,
+NULL
+, NULL);
+
+596
+codeg\92
+()->
+DoTe¡
+(
+this
+);
+
+600 \1e
+ gFuÎCodeG\92\94©Ü
+::
+EfãùCÚ\8bxt
+::
+Plug
+(
+Lab\96
+*
+m©\94\9flize_\8cue
+,
+
+601
+Lab\96
+*
+m©\94\9flize_çl£
+) const {
+
+602
+DCHECK
+(
+m©\94\9flize_\8cue
+ =ð
+m©\94\9flize_çl£
+);
+
+603
+__
+
+b\9ad
+(
+m©\94\9flize_\8cue
+);
+
+607 \1e
+ gFuÎCodeG\92\94©Ü
+::
+AccumuÏtÜV®ueCÚ\8bxt
+::
+Plug
+(
+
+608
+Lab\96
+*
+m©\94\9flize_\8cue
+, Lab\96*
+m©\94\9flize_çl£
+) const {
+
+609
+Lab\96
+
+ gdÚe
+;
+
+610
+__
+
+b\9ad
+(
+m©\94\9flize_\8cue
+);
+
+611
+__
+
+LßdRoÙ
+(
+»suÉ_»gi¡\94
+(),
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+612
+__
+
+b
+(&
+dÚe
+);
+
+613
+__
+
+b\9ad
+(
+m©\94\9flize_çl£
+);
+
+614
+__
+
+LßdRoÙ
+(
+»suÉ_»gi¡\94
+(),
+H\97p
+::
+kF®£V®ueRoÙIndex
+);
+
+615
+__
+
+b\9ad
+(&
+dÚe
+);
+
+619 \1e
+ gFuÎCodeG\92\94©Ü
+::
+S\8fckV®ueCÚ\8bxt
+::
+Plug
+(
+
+620
+Lab\96
+*
+m©\94\9flize_\8cue
+, Lab\96*
+m©\94\9flize_çl£
+) const {
+
+621
+Lab\96
+
+ gdÚe
+;
+
+622
+__
+
+b\9ad
+(
+m©\94\9flize_\8cue
+);
+
+623
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+624
+__
+
+b
+(&
+dÚe
+);
+
+625
+__
+
+b\9ad
+(
+m©\94\9flize_çl£
+);
+
+626
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kF®£V®ueRoÙIndex
+);
+
+627
+__
+
+b\9ad
+(&
+dÚe
+);
+
+628
+__
+
+push
+(
+\9d
+);
+
+632 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Te¡CÚ\8bxt
+::
+Plug
+(
+Lab\96
+*
+m©\94\9flize_\8cue
+,
+
+633
+Lab\96
+*
+m©\94\9flize_çl£
+) const {
+
+634
+DCHECK
+(
+m©\94\9flize_\8cue
+ =ð
+\8cue_Ïb\96_
+);
+
+635
+DCHECK
+(
+m©\94\9flize_çl£
+ =ð
+çl£_Ïb\96_
+);
+
+639 \1e
+ gFuÎCodeG\92\94©Ü
+::
+EfãùCÚ\8bxt
+::
+Plug
+(
+boÞ
+
+æag
+) const {}
+
+642 \1e
+FuÎCodeG\92\94©Ü
+::
+AccumuÏtÜV®ueCÚ\8bxt
+::
+Plug
+(
+boÞ
+
+æag
+) const {
+
+643
+H\97p
+::
+RoÙLi¡Index
+
+v®ue_roÙ_\9adex
+ =
+
+644
+æag
+ ?
+H\97p
+::
+kTrueV®ueRoÙIndex
+ : H\97p::
+kF®£V®ueRoÙIndex
+;
+
+645
+__
+
+LßdRoÙ
+(
+»suÉ_»gi¡\94
+(),
+v®ue_roÙ_\9adex
+);
+
+649 \1e
+ gFuÎCodeG\92\94©Ü
+::
+S\8fckV®ueCÚ\8bxt
+::
+Plug
+(
+boÞ
+
+æag
+) const {
+
+650
+H\97p
+::
+RoÙLi¡Index
+
+v®ue_roÙ_\9adex
+ =
+
+651
+æag
+ ?
+H\97p
+::
+kTrueV®ueRoÙIndex
+ : H\97p::
+kF®£V®ueRoÙIndex
+;
+
+652
+__
+
+LßdRoÙ
+(
+\9d
+,
+v®ue_roÙ_\9adex
+);
+
+653
+__
+
+push
+(
+\9d
+);
+
+657 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Te¡CÚ\8bxt
+::
+Plug
+(
+boÞ
+
+æag
+) const {
+
+658
+codeg\92
+()->
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+cÚd\99iÚ
+(),
+\8cue
+,
+\8cue_Ïb\96_
+,
+
+659
+çl£_Ïb\96_
+);
+
+660 ià(
+ gæag
+) {
+
+661 ià(
+ g\8cue_Ïb\96_
+ !ð
+çÎ_through_
+è
+__
+
+b
+(
+\8cue_Ïb\96_
+);
+
+663 ià(
+ gçl£_Ïb\96_
+ !ð
+çÎ_through_
+è
+__
+
+b
+(
+çl£_Ïb\96_
+);
+
+668 \1e
+ gFuÎCodeG\92\94©Ü
+::
+DoTe¡
+(
+Ex´essiÚ
+*
+cÚd\99iÚ
+,
+Lab\96
+*
+if_\8cue
+,
+
+669
+Lab\96
+*
+if_çl£
+, Lab\96*
+çÎ_through
+) {
+
+670
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+ToBoޗnStub
+::
+G\91Un\9a\99\9flized
+(
+isީe
+());
+
+671
+C®lIC
+(
+ic
+,
+cÚd\99iÚ
+->
+\8b¡_id
+());
+
+672
+__
+
+cmpi
+(
+»suÉ_»gi¡\94
+(),
+O³¿nd
+::
+Z\94o
+());
+
+673
+S¶\99
+(
+Ã
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+677 \1e
+ gFuÎCodeG\92\94©Ü
+::
+S¶\99
+(
+CÚd\99iÚ
+
+cÚd
+,
+Lab\96
+*
+if_\8cue
+, Lab\96*
+if_çl£
+,
+
+678
+Lab\96
+*
+çÎ_through
+,
+CRegi¡\94
+
+ü
+) {
+
+679 ià(
+ gif_çl£
+ =ð
+çÎ_through
+) {
+
+680
+__
+
+b
+(
+cÚd
+,
+if_\8cue
+,
+ü
+);
+
+681 } \vià(
+ gif_\8cue
+ =ð
+çÎ_through
+) {
+
+682
+__
+
+b
+(
+Neg©eCÚd\99iÚ
+(
+cÚd
+),
+if_çl£
+,
+ü
+);
+
+684
+__
+
+b
+(
+cÚd
+,
+if_\8cue
+,
+ü
+);
+
+685
+__
+
+b
+(
+if_çl£
+);
+
+690
+MemO³¿nd
+
+ gFuÎCodeG\92\94©Ü
+::
+S\8fckO³¿nd
+(
+V¬\9fbË
+*
+v¬
+) {
+
+691
+DCHECK
+(
+v¬
+->
+IsS\8fckAÎoÿ\8bd
+());
+
+693 \12
+ goff£t
+ = -
+v¬
+->
+\9adex
+(è*
+kPo\9a\8brSize
+;
+
+695 ià(
+ gv¬
+->
+IsP¬am\91\94
+()) {
+
+696
+ goff£t
+ +ð(
+\9afo_
+->
+scÝe
+()->
+num_·¿m\91\94s
+(è+ 1è*
+kPo\9a\8brSize
+;
+
+698
+ goff£t
+ +ð
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kLoÿl0Off£t
+;
+
+700 \15
+MemO³¿nd
+(
+å
+,
+off£t
+);
+
+704
+MemO³¿nd
+
+ gFuÎCodeG\92\94©Ü
+::
+V¬O³¿nd
+(
+V¬\9fbË
+*
+v¬
+,
+Regi¡\94
+
+sü©ch
+) {
+
+705
+DCHECK
+(
+v¬
+->
+IsCÚ\8bxtSlÙ
+(è|| v¬->
+IsS\8fckAÎoÿ\8bd
+());
+
+706 ià(
+ gv¬
+->
+IsCÚ\8bxtSlÙ
+()) {
+
+707 \12
+ gcÚ\8bxt_cha\9a_Ëngth
+ =
+scÝe
+()->
+CÚ\8bxtCha\9aL\92gth
+(
+v¬
+->scope());
+
+708
+__
+
+LßdCÚ\8bxt
+(
+sü©ch
+,
+cÚ\8bxt_cha\9a_Ëngth
+);
+
+709 \15
+CÚ\8bxtO³¿nd
+(
+sü©ch
+,
+v¬
+->
+\9adex
+());
+
+711 \15
+S\8fckO³¿nd
+(
+v¬
+);
+
+716 \1e
+ gFuÎCodeG\92\94©Ü
+::
+G\91V¬
+(
+Regi¡\94
+
+de¡
+,
+V¬\9fbË
+*
+v¬
+) {
+
+718
+MemO³¿nd
+
+ gloÿtiÚ
+ =
+V¬O³¿nd
+(
+v¬
+,
+de¡
+);
+
+719
+__
+
+LßdP
+(
+de¡
+,
+loÿtiÚ
+,
+r0
+);
+
+723 \1e
+ gFuÎCodeG\92\94©Ü
+::
+S\91V¬
+(
+V¬\9fbË
+*
+v¬
+,
+Regi¡\94
+
+¤c
+, Regi¡\94
+sü©ch0
+,
+
+724
+Regi¡\94
+
+sü©ch1
+) {
+
+725
+DCHECK
+(
+v¬
+->
+IsCÚ\8bxtSlÙ
+(è|| v¬->
+IsS\8fckAÎoÿ\8bd
+());
+
+726
+DCHECK
+(!
+sü©ch0
+.
+is
+(
+¤c
+));
+
+727
+DCHECK
+(!
+sü©ch0
+.
+is
+(
+sü©ch1
+));
+
+728
+DCHECK
+(!
+sü©ch1
+.
+is
+(
+¤c
+));
+
+729
+MemO³¿nd
+
+ gloÿtiÚ
+ =
+V¬O³¿nd
+(
+v¬
+,
+sü©ch0
+);
+
+730
+__
+
+StÜeP
+(
+¤c
+,
+loÿtiÚ
+,
+r0
+);
+
+733 ià(
+ gv¬
+->
+IsCÚ\8bxtSlÙ
+()) {
+
+734
+__
+
+RecÜdWr\99eCÚ\8bxtSlÙ
+(
+sü©ch0
+,
+loÿtiÚ
+.
+off£t
+(),
+¤c
+,
+sü©ch1
+,
+
+735
+kLRHasB\93nSaved
+,
+kDÚtSaveFPRegs
+);
+
+740 \1e
+ gFuÎCodeG\92\94©Ü
+::
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+Ex´essiÚ
+*
+ex´
+,
+
+741
+boÞ
+
+should_nÜm®ize
+,
+
+742
+Lab\96
+*
+if_\8cue
+,
+
+743
+Lab\96
+*
+if_çl£
+) {
+
+747 ià(!
+cڋxt
+()->
+IsTe¡
+(è|| !
+ g\9afo_
+->
+IsO±imizabË
+()) \15;
+
+749
+Lab\96
+
+ gsk\9d
+;
+
+750 ià(
+ gshould_nÜm®ize
+è
+__
+
+b
+(&
+sk\9d
+);
+
+751
+P»·»FÜBa\9eout
+(
+ex´
+,
+TOS_REG
+);
+
+752 ià(
+ gshould_nÜm®ize
+) {
+
+753
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+754
+__
+
+cmp
+(
+r3
+,
+\9d
+);
+
+755
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+NULL
+);
+
+756
+__
+
+b\9ad
+(&
+sk\9d
+);
+
+761 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99DebugCheckDeþ¬©iÚCÚ\8bxt
+(
+V¬\9fbË
+*
+v¬\9fbË
+) {
+
+764
+DCHECK_EQ
+(0,
+scÝe
+()->
+CÚ\8bxtCha\9aL\92gth
+(
+v¬\9fbË
+->scope()));
+
+765 ià(
+ gg\92\94©e_debug_code_
+) {
+
+767
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+ý
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+768
+__
+
+Com·»RoÙ
+(
+r4
+,
+H\97p
+::
+kW\99hCÚ\8bxtMRoÙIndex
+);
+
+769
+__
+
+Check
+(
+Ã
+,
+kDeþ¬©iÚInW\99hCÚ\8bxt
+);
+
+770
+__
+
+Com·»RoÙ
+(
+r4
+,
+H\97p
+::
+kC©chCÚ\8bxtMRoÙIndex
+);
+
+771
+__
+
+Check
+(
+Ã
+,
+kDeþ¬©iÚInC©chCÚ\8bxt
+);
+
+776 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99V¬\9fbËDeþ¬©iÚ
+(
+
+777
+V¬\9fbËDeþ¬©iÚ
+*
+deþ¬©iÚ
+) {
+
+781
+V¬\9fbËProxy
+*
+´oxy
+ =
+deþ¬©iÚ
+->proxy();
+
+782
+V¬\9fbËMode
+
+ gmode
+ =
+deþ¬©iÚ
+->
+mode
+();
+
+783
+V¬\9fbË
+*
+ gv¬\9fbË
+ =
+´oxy
+->
+v¬
+();
+
+784
+boÞ
+
+ ghÞe_\9a\99
+ =
+mode
+ =ð
+LET
+ || mod\90=ð
+CONST
+ || mod\90=ð
+CONST_LEGACY
+;
+
+785 \1a
+ gv¬\9fbË
+->
+loÿtiÚ
+()) {
+
+786 \ 4
+ gV¬\9fbË
+::
+UNALLOCATED
+:
+
+787
+glob®s_
+->
+Add
+(
+v¬\9fbË
+->
+Çme
+(),
+zÚe
+());
+
+788
+ gglob®s_
+->
+Add
+(
+v¬\9fbË
+->
+b\9ad\9ag_Ãeds_\9a\99
+()
+
+789 ?
+isީe
+()->
+çùÜy
+()->
+the_hÞe_v®ue
+()
+
+790 :
+isީe
+()->
+çùÜy
+()->
+undef\9aed_v®ue
+(),
+
+791
+zÚe
+());
+
+794 \ 4
+ gV¬\9fbË
+::
+PARAMETER
+:
+
+795 \ 4
+V¬\9fbË
+::
+LOCAL
+:
+
+796 ià(
+hÞe_\9a\99
+) {
+
+797
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ VariableDeclaration");
+
+798
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+799
+__
+
+StÜeP
+(
+\9d
+,
+S\8fckO³¿nd
+(
+v¬\9fbË
+));
+
+803 \ 4
+ gV¬\9fbË
+::
+CONTEXT
+:
+
+804 ià(
+hÞe_\9a\99
+) {
+
+805
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ VariableDeclaration");
+
+806
+Em\99DebugCheckDeþ¬©iÚCÚ\8bxt
+(
+v¬\9fbË
+);
+
+807
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+808
+__
+
+StÜeP
+(
+\9d
+,
+CÚ\8bxtO³¿nd
+(
+ý
+,
+v¬\9fbË
+->
+\9adex
+()),
+r0
+);
+
+810
+P»·»FÜBa\9eoutFÜId
+(
+´oxy
+->
+id
+(),
+NO_REGISTERS
+);
+
+814 \ 4
+ gV¬\9fbË
+::
+LOOKUP
+: {
+
+815
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ VariableDeclaration");
+
+816
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+v¬\9fbË
+->
+Çme
+()));
+
+818
+DCHECK
+(
+IsDeþ¬edV¬\9fbËMode
+(
+mode
+));
+
+819
+PrÝ\94tyA\89ribu\8bs
+
+ g©\8c
+ =
+
+820
+IsImmu\8fbËV¬\9fbËMode
+(
+mode
+è?
+READ_ONLY
+ :
+NONE
+;
+
+821
+__
+
+LßdSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(
+©\8c
+));
+
+826 ià(
+ ghÞe_\9a\99
+) {
+
+827
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+828
+__
+
+Push
+(
+ý
+,
+r5
+,
+r4
+,
+r3
+);
+
+830
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(0));
+
+831
+__
+
+Push
+(
+ý
+,
+r5
+,
+r4
+,
+r3
+);
+
+833
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kDeþ¬eLookupSlÙ
+, 4);
+
+840 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99FunùiÚDeþ¬©iÚ
+(
+
+841
+FunùiÚDeþ¬©iÚ
+*
+deþ¬©iÚ
+) {
+
+842
+V¬\9fbËProxy
+*
+´oxy
+ =
+deþ¬©iÚ
+->proxy();
+
+843
+V¬\9fbË
+*
+ gv¬\9fbË
+ =
+´oxy
+->
+v¬
+();
+
+844 \1a
+ gv¬\9fbË
+->
+loÿtiÚ
+()) {
+
+845 \ 4
+ gV¬\9fbË
+::
+UNALLOCATED
+: {
+
+846
+glob®s_
+->
+Add
+(
+v¬\9fbË
+->
+Çme
+(),
+zÚe
+());
+
+847
+ gHªdË
+<
+ gSh¬edFunùiÚInfo
+>
+ gfunùiÚ
+ =
+
+848
+Comp\9e\94
+::
+Bu\9edFunùiÚInfo
+(
+deþ¬©iÚ
+->
+fun
+(),
+sü\9dt
+(),
+\9afo_
+);
+
+850 ià(
+ gfunùiÚ
+.
+is_nuÎ
+()è\15
+S\91S\8fckOv\94æow
+();
+
+851
+ gglob®s_
+->
+Add
+(
+funùiÚ
+,
+zÚe
+());
+
+855 \ 4
+ gV¬\9fbË
+::
+PARAMETER
+:
+
+856 \ 4
+V¬\9fbË
+::
+LOCAL
+: {
+
+857
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ FunctionDeclaration");
+
+858
+Vis\99FÜAccumuÏtÜV®ue
+(
+deþ¬©iÚ
+->
+fun
+());
+
+859
+__
+
+StÜeP
+(
+»suÉ_»gi¡\94
+(),
+S\8fckO³¿nd
+(
+v¬\9fbË
+));
+
+863 \ 4
+ gV¬\9fbË
+::
+CONTEXT
+: {
+
+864
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ FunctionDeclaration");
+
+865
+Em\99DebugCheckDeþ¬©iÚCÚ\8bxt
+(
+v¬\9fbË
+);
+
+866
+Vis\99FÜAccumuÏtÜV®ue
+(
+deþ¬©iÚ
+->
+fun
+());
+
+867
+__
+
+StÜeP
+(
+»suÉ_»gi¡\94
+(),
+CÚ\8bxtO³¿nd
+(
+ý
+,
+v¬\9fbË
+->
+\9adex
+()),
+r0
+);
+
+868 \12
+ goff£t
+ =
+Cڋxt
+::
+SlÙOff£t
+(
+v¬\9fbË
+->
+\9adex
+());
+
+870
+__
+
+RecÜdWr\99eCÚ\8bxtSlÙ
+(
+ý
+,
+off£t
+,
+»suÉ_»gi¡\94
+(),
+r5
+,
+
+871
+kLRHasB\93nSaved
+,
+kDÚtSaveFPRegs
+,
+
+872
+EMIT_REMEMBERED_SET
+,
+OMIT_SMI_CHECK
+);
+
+873
+P»·»FÜBa\9eoutFÜId
+(
+´oxy
+->
+id
+(),
+NO_REGISTERS
+);
+
+877 \ 4
+ gV¬\9fbË
+::
+LOOKUP
+: {
+
+878
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ FunctionDeclaration");
+
+879
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+v¬\9fbË
+->
+Çme
+()));
+
+880
+__
+
+LßdSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(
+NONE
+));
+
+881
+__
+
+Push
+(
+ý
+,
+r5
+,
+r4
+);
+
+883
+Vis\99FÜS\8fckV®ue
+(
+deþ¬©iÚ
+->
+fun
+());
+
+884
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kDeþ¬eLookupSlÙ
+, 4);
+
+891 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99ModuËDeþ¬©iÚ
+(
+ModuËDeþ¬©iÚ
+*
+deþ¬©iÚ
+) {
+
+892
+V¬\9fbË
+*
+v¬\9fbË
+ =
+deþ¬©iÚ
+->
+´oxy
+()->
+v¬
+();
+
+893
+DCHECK
+(
+v¬\9fbË
+->
+loÿtiÚ
+(è=ð
+V¬\9fbË
+::
+CONTEXT
+);
+
+894
+DCHECK
+(
+v¬\9fbË
+->
+\9a\8brçû
+()->
+IsFroz\92
+());
+
+896
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ ModuleDeclaration");
+
+897
+Em\99DebugCheckDeþ¬©iÚCÚ\8bxt
+(
+v¬\9fbË
+);
+
+900
+__
+
+LßdCÚ\8bxt
+(
+r4
+,
+scÝe_
+->
+CÚ\8bxtCha\9aL\92gth
+(scÝe_->
+Glob®ScÝe
+()));
+
+901
+__
+
+LßdP
+(
+r4
+,
+CÚ\8bxtO³¿nd
+Ô4,
+v¬\9fbË
+->
+\9a\8brçû
+()->
+Index
+()));
+
+902
+__
+
+LßdP
+(
+r4
+,
+CÚ\8bxtO³¿nd
+Ô4,
+Cڋxt
+::
+EXTENSION_INDEX
+));
+
+905
+__
+
+StÜeP
+(
+r4
+,
+CÚ\8bxtO³¿nd
+(
+ý
+,
+v¬\9fbË
+->
+\9adex
+()),
+r0
+);
+
+907
+__
+
+RecÜdWr\99eCÚ\8bxtSlÙ
+(
+ý
+,
+Cڋxt
+::
+SlÙOff£t
+(
+v¬\9fbË
+->
+\9adex
+()),
+r4
+,
+r6
+,
+
+908
+kLRHasB\93nSaved
+,
+kDÚtSaveFPRegs
+,
+
+909
+EMIT_REMEMBERED_SET
+,
+OMIT_SMI_CHECK
+);
+
+910
+P»·»FÜBa\9eoutFÜId
+(
+deþ¬©iÚ
+->
+´oxy
+()->
+id
+(),
+NO_REGISTERS
+);
+
+913
+Vis\99
+(
+deþ¬©iÚ
+->
+moduË
+());
+
+917 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99ImpÜtDeþ¬©iÚ
+(
+ImpÜtDeþ¬©iÚ
+*
+deþ¬©iÚ
+) {
+
+918
+V¬\9fbËProxy
+*
+´oxy
+ =
+deþ¬©iÚ
+->proxy();
+
+919
+V¬\9fbË
+*
+ gv¬\9fbË
+ =
+´oxy
+->
+v¬
+();
+
+920 \1a
+ gv¬\9fbË
+->
+loÿtiÚ
+()) {
+
+921 \ 4
+ gV¬\9fbË
+::
+UNALLOCATED
+:
+
+925 \ 4
+ gV¬\9fbË
+::
+CONTEXT
+: {
+
+926
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ ImportDeclaration");
+
+927
+Em\99DebugCheckDeþ¬©iÚCÚ\8bxt
+(
+v¬\9fbË
+);
+
+932 \ 4
+ gV¬\9fbË
+::
+PARAMETER
+:
+
+933 \ 4
+V¬\9fbË
+::
+LOCAL
+:
+
+934 \ 4
+V¬\9fbË
+::
+LOOKUP
+:
+
+935
+UNREACHABLE
+();
+
+940 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99ExpÜtDeþ¬©iÚ
+(
+ExpÜtDeþ¬©iÚ
+*
+deþ¬©iÚ
+) {
+
+945 \1e
+FuÎCodeG\92\94©Ü
+::
+Deþ¬eGlob®s
+(
+HªdË
+<
+FixedA¼ay
+>
+·\9cs
+) {
+
+948
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+·\9cs
+));
+
+949
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+Deþ¬eGlob®sFÏgs
+()));
+
+950
+__
+
+Push
+(
+ý
+,
+r4
+,
+r3
+);
+
+951
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kDeþ¬eGlob®s
+, 3);
+
+956 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Deþ¬eModuËs
+(
+HªdË
+<
+FixedA¼ay
+>
+desü\9dtiÚs
+) {
+
+958
+__
+
+Push
+(
+desü\9dtiÚs
+);
+
+959
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kDeþ¬eModuËs
+, 1);
+
+964 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99Sw\99chS\8f\8bm\92t
+(
+Sw\99chS\8f\8bm\92t
+*
+¡mt
+) {
+
+965
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ SwitchStatement");
+
+966
+B»akabË
+
+áed_¡©em\92t
+(
+this
+,
+¡mt
+);
+
+967
+S\91S\8f\8bm\92tPos\99iÚ
+(
+¡mt
+);
+
+970
+Vis\99FÜS\8fckV®ue
+(
+¡mt
+->
+\8fg
+());
+
+971
+P»·»FÜBa\9eoutFÜId
+(
+¡mt
+->
+EÁryId
+(),
+NO_REGISTERS
+);
+
+973
+ gZÚeLi¡
+<
+ gCa£CÏu£
+*>*
+ gþau£s
+ =
+¡mt
+->
+ÿ£s
+();
+
+974
+Ca£CÏu£
+*
+ gdeçuÉ_þau£
+ =
+NULL
+;
+
+976
+Lab\96
+
+ gÃxt_\8b¡
+;
+
+978 \ f\12
+ gi
+ = 0; i <
+ gþau£s
+->
+Ëngth
+(); i++) {
+
+979
+Ca£CÏu£
+*
+ gþau£
+ =
+þau£s
+->
+©
+(
+i
+);
+
+980
+ gþau£
+->
+body_\8frg\91
+()->
+Unu£
+();
+
+983 ià(
+ gþau£
+->
+is_deçuÉ
+()) {
+
+984
+ gdeçuÉ_þau£
+ =
+þau£
+;
+
+988
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Case comparison");
+
+989
+__
+
+b\9ad
+(&
+Ãxt_\8b¡
+);
+
+990
+ gÃxt_\8b¡
+.
+Unu£
+();
+
+993
+Vis\99FÜAccumuÏtÜV®ue
+(
+þau£
+->
+Ïb\96
+());
+
+996
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+997
+boÞ
+
+ g\9al\9ae_smi_code
+ =
+ShouldIÆ\9aeSmiCa£
+(
+Tok\92
+::
+EQ_STRICT
+);
+
+998
+JumpP©chS\99e
+
+·tch_s\99e
+(
+masm_
+);
+
+999 ià(
+ g\9al\9ae_smi_code
+) {
+
+1000
+Lab\96
+
+ g¦ow_ÿ£
+;
+
+1001
+__
+
+Üx
+(
+r5
+,
+r4
+,
+r3
+);
+
+1002
+ g·tch_s\99e
+.
+Em\99JumpIfNÙSmi
+(
+r5
+, &
+¦ow_ÿ£
+);
+
+1004
+__
+
+cmp
+(
+r4
+,
+r3
+);
+
+1005
+__
+
+bÃ
+(&
+Ãxt_\8b¡
+);
+
+1006
+__
+
+DrÝ
+(1);
+
+1007
+__
+
+b
+(
+þau£
+->
+body_\8frg\91
+());
+
+1008
+__
+
+b\9ad
+(&
+¦ow_ÿ£
+);
+
+1012
+S\91SourûPos\99iÚ
+(
+þau£
+->
+pos\99iÚ
+());
+
+1013
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+
+1014
+CodeFaùÜy
+::
+Com·»IC
+(
+isީe
+(),
+Tok\92
+::
+EQ_STRICT
+).
+code
+();
+
+1015
+C®lIC
+(
+ic
+,
+þau£
+->
+Com·»Id
+());
+
+1016
+ g·tch_s\99e
+.
+Em\99P©chInfo
+();
+
+1018
+Lab\96
+
+ gsk\9d
+;
+
+1019
+__
+
+b
+(&
+sk\9d
+);
+
+1020
+P»·»FÜBa\9eout
+(
+þau£
+,
+TOS_REG
+);
+
+1021
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+1022
+__
+
+cmp
+(
+r3
+,
+\9d
+);
+
+1023
+__
+
+bÃ
+(&
+Ãxt_\8b¡
+);
+
+1024
+__
+
+DrÝ
+(1);
+
+1025
+__
+
+b
+(
+þau£
+->
+body_\8frg\91
+());
+
+1026
+__
+
+b\9ad
+(&
+sk\9d
+);
+
+1028
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+1029
+__
+
+bÃ
+(&
+Ãxt_\8b¡
+);
+
+1030
+__
+
+DrÝ
+(1);
+
+1031
+__
+
+b
+(
+þau£
+->
+body_\8frg\91
+());
+
+1036
+__
+
+b\9ad
+(&
+Ãxt_\8b¡
+);
+
+1037
+__
+
+DrÝ
+(1);
+
+1038 ià(
+ gdeçuÉ_þau£
+ =ð
+NULL
+) {
+
+1039
+__
+
+b
+(
+áed_¡©em\92t
+.
+b»ak_Ïb\96
+());
+
+1041
+__
+
+b
+(
+deçuÉ_þau£
+->
+body_\8frg\91
+());
+
+1045 \ f\12
+ gi
+ = 0; i <
+ gþau£s
+->
+Ëngth
+(); i++) {
+
+1046
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Case body");
+
+1047
+Ca£CÏu£
+*
+ gþau£
+ =
+þau£s
+->
+©
+(
+i
+);
+
+1048
+__
+
+b\9ad
+(
+þau£
+->
+body_\8frg\91
+());
+
+1049
+P»·»FÜBa\9eoutFÜId
+(
+þau£
+->
+EÁryId
+(),
+NO_REGISTERS
+);
+
+1050
+Vis\99S\8f\8bm\92ts
+(
+þau£
+->
+¡©em\92ts
+());
+
+1053
+__
+
+b\9ad
+(
+áed_¡©em\92t
+.
+b»ak_Ïb\96
+());
+
+1054
+P»·»FÜBa\9eoutFÜId
+(
+¡mt
+->
+Ex\99Id
+(),
+NO_REGISTERS
+);
+
+1058 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99FÜInS\8f\8bm\92t
+(
+FÜInS\8f\8bm\92t
+*
+¡mt
+) {
+
+1059
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ ForInStatement");
+
+1060
+F\93dbackVeùÜSlÙ
+
+ g¦Ù
+ =
+¡mt
+->
+FÜInF\93dbackSlÙ
+();
+
+1061
+S\91S\8f\8bm\92tPos\99iÚ
+(
+¡mt
+);
+
+1063
+Lab\96
+
+ gloÝ
+,
+ gex\99
+;
+
+1064
+FÜIn
+
+loÝ_¡©em\92t
+(
+this
+,
+¡mt
+);
+
+1065
+\9aüem\92t_loÝ_d\95th
+();
+
+1069
+Vis\99FÜAccumuÏtÜV®ue
+(
+¡mt
+->
+\92um\94abË
+());
+
+1070
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+1071
+__
+
+cmp
+(
+r3
+,
+\9d
+);
+
+1072
+__
+
+beq
+(&
+ex\99
+);
+
+1073
+Regi¡\94
+
+ gnuÎ_v®ue
+ =
+r7
+;
+
+1074
+__
+
+LßdRoÙ
+(
+nuÎ_v®ue
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+1075
+__
+
+cmp
+(
+r3
+,
+nuÎ_v®ue
+);
+
+1076
+__
+
+beq
+(&
+ex\99
+);
+
+1078
+P»·»FÜBa\9eoutFÜId
+(
+¡mt
+->
+P»·»Id
+(),
+TOS_REG
+);
+
+1081
+Lab\96
+
+ gcÚv\94t
+,
+ gdÚe_cÚv\94t
+;
+
+1082
+__
+
+JumpIfSmi
+(
+r3
+, &
+cÚv\94t
+);
+
+1083
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,\844,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+1084
+__
+
+bge
+(&
+dÚe_cÚv\94t
+);
+
+1085
+__
+
+b\9ad
+(&
+cÚv\94t
+);
+
+1086
+__
+
+push
+(
+r3
+);
+
+1087
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+TO_OBJECT
+,
+CALL_FUNCTION
+);
+
+1088
+__
+
+b\9ad
+(&
+dÚe_cÚv\94t
+);
+
+1089
+P»·»FÜBa\9eoutFÜId
+(
+¡mt
+->
+ToObjeùId
+(),
+TOS_REG
+);
+
+1090
+__
+
+push
+(
+r3
+);
+
+1093
+Lab\96
+
+ gÿÎ_ruÁime
+;
+
+1094
+STATIC_ASSERT
+(
+FIRST_JS_PROXY_TYPE
+ =ð
+FIRST_SPEC_OBJECT_TYPE
+);
+
+1095
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,\844,
+LAST_JS_PROXY_TYPE
+);
+
+1096
+__
+
+bË
+(&
+ÿÎ_ruÁime
+);
+
+1102
+__
+
+CheckEnumCache
+(
+nuÎ_v®ue
+, &
+ÿÎ_ruÁime
+);
+
+1106
+Lab\96
+
+ gu£_ÿche
+;
+
+1107
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1108
+__
+
+b
+(&
+u£_ÿche
+);
+
+1111
+__
+
+b\9ad
+(&
+ÿÎ_ruÁime
+);
+
+1112
+__
+
+push
+(
+r3
+);
+
+1113
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kG\91PrÝ\94tyNamesFa¡
+, 1);
+
+1114
+P»·»FÜBa\9eoutFÜId
+(
+¡mt
+->
+EnumId
+(),
+TOS_REG
+);
+
+1119
+Lab\96
+
+ gfixed_¬¿y
+;
+
+1120
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1121
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kM\91aMRoÙIndex
+);
+
+1122
+__
+
+cmp
+(
+r5
+,
+\9d
+);
+
+1123
+__
+
+bÃ
+(&
+fixed_¬¿y
+);
+
+1126
+Lab\96
+
+ gno_desü\9dtÜs
+;
+
+1127
+__
+
+b\9ad
+(&
+u£_ÿche
+);
+
+1129
+__
+
+EnumL\92gth
+(
+r4
+,
+r3
+);
+
+1130
+__
+
+CmpSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(0),
+r0
+);
+
+1131
+__
+
+beq
+(&
+no_desü\9dtÜs
+);
+
+1133
+__
+
+LßdIn¡ªûDesü\9dtÜs
+(
+r3
+,
+r5
+);
+
+1134
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+Ô5,
+Desü\9dtÜA¼ay
+::
+kEnumCacheOff£t
+));
+
+1135
+__
+
+LßdP
+(
+r5
+,
+
+1136
+F\9bldMemO³¿nd
+(
+r5
+,
+Desü\9dtÜA¼ay
+::
+kEnumCacheBridgeCacheOff£t
+));
+
+1139
+__
+
+push
+(
+r3
+);
+
+1140
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(0));
+
+1142
+__
+
+Push
+(
+r5
+,
+r4
+,
+r3
+);
+
+1143
+__
+
+b
+(&
+loÝ
+);
+
+1145
+__
+
+b\9ad
+(&
+no_desü\9dtÜs
+);
+
+1146
+__
+
+DrÝ
+(1);
+
+1147
+__
+
+b
+(&
+ex\99
+);
+
+1150
+Lab\96
+
+ gnÚ_´oxy
+;
+
+1151
+__
+
+b\9ad
+(&
+fixed_¬¿y
+);
+
+1153
+__
+
+Move
+(
+r4
+,
+F\93dbackVeùÜ
+());
+
+1154
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+Ty³F\93dbackVeùÜ
+::
+MegamÜphicS\92t\9a\96
+(
+isީe
+())));
+
+1155 \12
+ gveùÜ_\9adex
+ =
+F\93dbackVeùÜ
+()->
+G\91Index
+(
+¦Ù
+);
+
+1156
+__
+
+StÜeP
+(
+
+1157
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+FixedA¼ay
+::
+Off£tOfEËm\92tAt
+(
+veùÜ_\9adex
+)),
+r0
+);
+
+1159
+__
+
+LßdSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(1));
+
+1160
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+, 0 *
+kPo\9a\8brSize
+));
+
+1161
+STATIC_ASSERT
+(
+FIRST_JS_PROXY_TYPE
+ =ð
+FIRST_SPEC_OBJECT_TYPE
+);
+
+1162
+__
+
+Com·»ObjeùTy³
+(
+r5
+,
+r6
+,\846,
+LAST_JS_PROXY_TYPE
+);
+
+1163
+__
+
+bgt
+(&
+nÚ_´oxy
+);
+
+1164
+__
+
+LßdSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(0));
+
+1165
+__
+
+b\9ad
+(&
+nÚ_´oxy
+);
+
+1166
+__
+
+Push
+(
+r4
+,
+r3
+);
+
+1167
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+FixedA¼ay
+::
+kL\92gthOff£t
+));
+
+1168
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(0));
+
+1169
+__
+
+Push
+(
+r4
+,
+r3
+);
+
+1172
+P»·»FÜBa\9eoutFÜId
+(
+¡mt
+->
+BodyId
+(),
+NO_REGISTERS
+);
+
+1173
+__
+
+b\9ad
+(&
+loÝ
+);
+
+1175
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+, 0 *
+kPo\9a\8brSize
+));
+
+1176
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+1177
+__
+
+cm¶
+(
+r3
+,
+r4
+);
+
+1178
+__
+
+bge
+(
+loÝ_¡©em\92t
+.
+b»ak_Ïb\96
+());
+
+1181
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+1182
+__
+
+addi
+(
+r5
+,\845,
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+1183
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r6
+,
+r3
+);
+
+1184
+__
+
+LßdPX
+(
+r6
+,
+MemO³¿nd
+Ô6,
+r5
+));
+
+1188
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+, 3 *
+kPo\9a\8brSize
+));
+
+1192
+Lab\96
+
+ gupd©e_\97ch
+;
+
+1193
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, 4 *
+kPo\9a\8brSize
+));
+
+1194
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1195
+__
+
+cmp
+(
+r7
+,
+r5
+);
+
+1196
+__
+
+beq
+(&
+upd©e_\97ch
+);
+
+1200
+__
+
+CmpSmiL\99\94®
+(
+r5
+,
+Smi
+::
+FromIÁ
+(0),
+r0
+);
+
+1201
+__
+
+beq
+(&
+upd©e_\97ch
+);
+
+1206
+__
+
+Push
+(
+r4
+,
+r6
+);
+
+1207
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+FILTER_KEY
+,
+CALL_FUNCTION
+);
+
+1208
+__
+
+mr
+(
+r6
+,
+r3
+);
+
+1209
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+::
+Z\94o
+());
+
+1210
+__
+
+beq
+(
+loÝ_¡©em\92t
+.
+cÚt\9aue_Ïb\96
+());
+
+1214
+__
+
+b\9ad
+(&
+upd©e_\97ch
+);
+
+1215
+__
+
+mr
+(
+»suÉ_»gi¡\94
+(),
+r6
+);
+
+1218
+EfãùCÚ\8bxt
+
+cڋxt
+(
+this
+);
+
+1219
+Em\99Assignm\92t
+(
+¡mt
+->
+\97ch
+());
+
+1223
+Vis\99
+(
+¡mt
+->
+body
+());
+
+1227
+__
+
+b\9ad
+(
+loÝ_¡©em\92t
+.
+cÚt\9aue_Ïb\96
+());
+
+1228
+__
+
+pÝ
+(
+r3
+);
+
+1229
+__
+
+AddSmiL\99\94®
+(
+r3
+,\843,
+Smi
+::
+FromIÁ
+(1),
+r0
+);
+
+1230
+__
+
+push
+(
+r3
+);
+
+1232
+Em\99BackEdgeBookk\93p\9ag
+(
+¡mt
+, &
+loÝ
+);
+
+1233
+__
+
+b
+(&
+loÝ
+);
+
+1236
+__
+
+b\9ad
+(
+loÝ_¡©em\92t
+.
+b»ak_Ïb\96
+());
+
+1237
+__
+
+DrÝ
+(5);
+
+1240
+P»·»FÜBa\9eoutFÜId
+(
+¡mt
+->
+Ex\99Id
+(),
+NO_REGISTERS
+);
+
+1241
+__
+
+b\9ad
+(&
+ex\99
+);
+
+1242
+deüem\92t_loÝ_d\95th
+();
+
+1246 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99FÜOfS\8f\8bm\92t
+(
+FÜOfS\8f\8bm\92t
+*
+¡mt
+) {
+
+1247
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ ForOfStatement");
+
+1248
+S\91S\8f\8bm\92tPos\99iÚ
+(
+¡mt
+);
+
+1250
+I\8b¿tiÚ
+
+loÝ_¡©em\92t
+(
+this
+,
+¡mt
+);
+
+1251
+\9aüem\92t_loÝ_d\95th
+();
+
+1254
+Vis\99FÜEfãù
+(
+¡mt
+->
+assign_\99\94©Ü
+());
+
+1257
+__
+
+b\9ad
+(
+loÝ_¡©em\92t
+.
+cÚt\9aue_Ïb\96
+());
+
+1260
+Vis\99FÜEfãù
+(
+¡mt
+->
+Ãxt_»suÉ
+());
+
+1263
+Lab\96
+
+ g»suÉ_nÙ_dÚe
+;
+
+1264
+Vis\99FÜCÚ\8cÞ
+(
+¡mt
+->
+»suÉ_dÚe
+(),
+loÝ_¡©em\92t
+.
+b»ak_Ïb\96
+(),
+
+1265 &
+»suÉ_nÙ_dÚe
+, &result_not_done);
+
+1266
+__
+
+b\9ad
+(&
+»suÉ_nÙ_dÚe
+);
+
+1269
+Vis\99FÜEfãù
+(
+¡mt
+->
+assign_\97ch
+());
+
+1272
+Vis\99
+(
+¡mt
+->
+body
+());
+
+1275
+P»·»FÜBa\9eoutFÜId
+(
+¡mt
+->
+BackEdgeId
+(),
+NO_REGISTERS
+);
+
+1276
+Em\99BackEdgeBookk\93p\9ag
+(
+¡mt
+,
+loÝ_¡©em\92t
+.
+cÚt\9aue_Ïb\96
+());
+
+1277
+__
+
+b
+(
+loÝ_¡©em\92t
+.
+cÚt\9aue_Ïb\96
+());
+
+1280
+P»·»FÜBa\9eoutFÜId
+(
+¡mt
+->
+Ex\99Id
+(),
+NO_REGISTERS
+);
+
+1281
+__
+
+b\9ad
+(
+loÝ_¡©em\92t
+.
+b»ak_Ïb\96
+());
+
+1282
+deüem\92t_loÝ_d\95th
+();
+
+1286 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99NewClosu»
+(
+HªdË
+<
+Sh¬edFunùiÚInfo
+>
+\9afo
+,
+
+1287
+boÞ
+
+´\91\92u»
+) {
+
+1294 ià(!
+ gFLAG_®ways_Ýt
+ && !
+ gFLAG_´\95¬e_®ways_Ýt
+ && !
+ g´\91\92u»
+ &&
+
+1295
+scÝe
+()->
+is_funùiÚ_scÝe
+(è&&
+ g\9afo
+->
+num_l\99\94®s
+() == 0) {
+
+1296
+Fa¡NewClosu»Stub
+
+¡ub
+(
+isީe
+(),
+\9afo
+->
+¡riù_mode
+(), info->
+k\9ad
+());
+
+1297
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+\9afo
+));
+
+1298
+__
+
+C®lStub
+(&
+¡ub
+);
+
+1300
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+\9afo
+));
+
+1301
+__
+
+LßdRoÙ
+(
+
+1302
+r4
+,
+´\91\92u»
+ ?
+H\97p
+::
+kTrueV®ueRoÙIndex
+ : H\97p::
+kF®£V®ueRoÙIndex
+);
+
+1303
+__
+
+Push
+(
+ý
+,
+r3
+,
+r4
+);
+
+1304
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kNewClosu»
+, 3);
+
+1306
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+1310 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99V¬\9fbËProxy
+(
+V¬\9fbËProxy
+*
+ex´
+) {
+
+1311
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ VariableProxy");
+
+1312
+Em\99V¬\9fbËLßd
+(
+ex´
+);
+
+1316 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99LßdHomeObjeù
+(
+Su³rReã»nû
+*
+ex´
+) {
+
+1317
+Comm\92t
+
+úmt
+(
+masm_
+, "[ SuperReference ");
+
+1319
+__
+
+LßdP
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+
+1320
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+1322
+ gHªdË
+<
+ gSymbÞ
+>
+home_objeù_symbÞ
+(
+isީe
+()->
+h\97p
+()->home_object_symbol());
+
+1323
+__
+
+Move
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+home_objeù_symbÞ
+);
+
+1325 ià(
+ gFLAG_veùÜ_ics
+) {
+
+1326
+__
+
+mov
+(
+VeùÜLßdICDesü\9dtÜ
+::
+SlÙRegi¡\94
+(),
+
+1327
+O³¿nd
+(
+SmiFromSlÙ
+(
+ex´
+->
+HomeObjeùF\93dbackSlÙ
+())));
+
+1328
+C®lLßdIC
+(
+NOT_CONTEXTUAL
+);
+
+1330
+C®lLßdIC
+(
+NOT_CONTEXTUAL
+,
+ex´
+->
+HomeObjeùF\93dbackId
+());
+
+1333
+__
+
+Cmpi
+(
+r3
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+undef\9aed_v®ue
+()),
+r0
+);
+
+1334
+Lab\96
+
+ gdÚe
+;
+
+1335
+__
+
+bÃ
+(&
+dÚe
+);
+
+1336
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kThrowNÚM\91hodE¼Ü
+, 0);
+
+1337
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1341 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99LßdGlob®CheckEx\8bnsiÚs
+(
+V¬\9fbËProxy
+*
+´oxy
+,
+
+1342
+Ty³ofS\8f\8b
+
+ty³of_¡©e
+,
+
+1343
+Lab\96
+*
+¦ow
+) {
+
+1344
+Regi¡\94
+
+ gcu¼\92t
+ =
+ý
+;
+
+1345
+Regi¡\94
+
+ gÃxt
+ =
+r4
+;
+
+1346
+Regi¡\94
+
+ g\8bmp
+ =
+r5
+;
+
+1348
+ScÝe
+*
+ gs
+ =
+scÝe
+();
+
+1349 \1f
+ gs
+ !ð
+NULL
+) {
+
+1350 ià(
+s
+->
+num_h\97p_¦Ùs
+() > 0) {
+
+1351 ià(
+s
+->
+ÿÎs_¦Ýpy_ev®
+()) {
+
+1353
+__
+
+LßdP
+(
+\8bmp
+,
+CÚ\8bxtO³¿nd
+(
+cu¼\92t
+,
+Cڋxt
+::
+EXTENSION_INDEX
+));
+
+1354
+__
+
+cmpi
+(
+\8bmp
+,
+O³¿nd
+::
+Z\94o
+());
+
+1355
+__
+
+bÃ
+(
+¦ow
+);
+
+1358
+__
+
+LßdP
+(
+Ãxt
+,
+CÚ\8bxtO³¿nd
+(
+cu¼\92t
+,
+Cڋxt
+::
+PREVIOUS_INDEX
+));
+
+1360
+ gcu¼\92t
+ =
+Ãxt
+;
+
+1364 ià(!
+ gs
+->
+ou\8br_scÝe_ÿÎs_¦Ýpy_ev®
+(è|| s->
+is_ev®_scÝe
+()) \ 3;
+
+1365
+ gs
+ =
+s
+->
+ou\8br_scÝe
+();
+
+1368 ià(
+ gs
+->
+is_ev®_scÝe
+()) {
+
+1369
+Lab\96
+
+ gloÝ
+,
+ gç¡
+;
+
+1370 ià(!
+ gcu¼\92t
+.
+is
+(
+Ãxt
+)) {
+
+1371
+__
+
+Move
+(
+Ãxt
+,
+cu¼\92t
+);
+
+1373
+__
+
+b\9ad
+(&
+loÝ
+);
+
+1375
+__
+
+LßdP
+(
+\8bmp
+,
+F\9bldMemO³¿nd
+(
+Ãxt
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1376
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kN©iveCÚ\8bxtMRoÙIndex
+);
+
+1377
+__
+
+cmp
+(
+\8bmp
+,
+\9d
+);
+
+1378
+__
+
+beq
+(&
+ç¡
+);
+
+1380
+__
+
+LßdP
+(
+\8bmp
+,
+CÚ\8bxtO³¿nd
+(
+Ãxt
+,
+Cڋxt
+::
+EXTENSION_INDEX
+));
+
+1381
+__
+
+cmpi
+(
+\8bmp
+,
+O³¿nd
+::
+Z\94o
+());
+
+1382
+__
+
+bÃ
+(
+¦ow
+);
+
+1384
+__
+
+LßdP
+(
+Ãxt
+,
+CÚ\8bxtO³¿nd
+Òext,
+Cڋxt
+::
+PREVIOUS_INDEX
+));
+
+1385
+__
+
+b
+(&
+loÝ
+);
+
+1386
+__
+
+b\9ad
+(&
+ç¡
+);
+
+1389
+__
+
+LßdP
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+Glob®ObjeùO³¿nd
+());
+
+1390
+__
+
+mov
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+O³¿nd
+(
+´oxy
+->
+v¬
+()->
+Çme
+()));
+
+1391 ià(
+ gFLAG_veùÜ_ics
+) {
+
+1392
+__
+
+mov
+(
+VeùÜLßdICDesü\9dtÜ
+::
+SlÙRegi¡\94
+(),
+
+1393
+O³¿nd
+(
+SmiFromSlÙ
+(
+´oxy
+->
+V¬\9fbËF\93dbackSlÙ
+())));
+
+1396
+CÚ\8bxtu®Mode
+
+ gmode
+ =
+
+1397 (
+ty³of_¡©e
+ =ð
+INSIDE_TYPEOF
+è?
+NOT_CONTEXTUAL
+ :
+CONTEXTUAL
+;
+
+1398
+C®lLßdIC
+(
+mode
+);
+
+1402
+MemO³¿nd
+
+ gFuÎCodeG\92\94©Ü
+::
+CÚ\8bxtSlÙO³¿ndCheckEx\8bnsiÚs
+(
+V¬\9fbË
+*
+v¬
+,
+
+1403
+Lab\96
+*
+¦ow
+) {
+
+1404
+DCHECK
+(
+v¬
+->
+IsCÚ\8bxtSlÙ
+());
+
+1405
+Regi¡\94
+
+ gcڋxt
+ =
+ý
+;
+
+1406
+Regi¡\94
+
+ gÃxt
+ =
+r6
+;
+
+1407
+Regi¡\94
+
+ g\8bmp
+ =
+r7
+;
+
+1409 \ f
+ScÝe
+*
+ gs
+ =
+scÝe
+(); s !ð
+v¬
+->scÝe(); s =
+s
+->
+ou\8br_scÝe
+()) {
+
+1410 ià(
+s
+->
+num_h\97p_¦Ùs
+() > 0) {
+
+1411 ià(
+s
+->
+ÿÎs_¦Ýpy_ev®
+()) {
+
+1413
+__
+
+LßdP
+(
+\8bmp
+,
+CÚ\8bxtO³¿nd
+(
+cڋxt
+,
+Cڋxt
+::
+EXTENSION_INDEX
+));
+
+1414
+__
+
+cmpi
+(
+\8bmp
+,
+O³¿nd
+::
+Z\94o
+());
+
+1415
+__
+
+bÃ
+(
+¦ow
+);
+
+1417
+__
+
+LßdP
+(
+Ãxt
+,
+CÚ\8bxtO³¿nd
+(
+cڋxt
+,
+Cڋxt
+::
+PREVIOUS_INDEX
+));
+
+1419
+ gcڋxt
+ =
+Ãxt
+;
+
+1423
+__
+
+LßdP
+(
+\8bmp
+,
+CÚ\8bxtO³¿nd
+(
+cڋxt
+,
+Cڋxt
+::
+EXTENSION_INDEX
+));
+
+1424
+__
+
+cmpi
+(
+\8bmp
+,
+O³¿nd
+::
+Z\94o
+());
+
+1425
+__
+
+bÃ
+(
+¦ow
+);
+
+1430 \15
+CÚ\8bxtO³¿nd
+(
+cڋxt
+,
+v¬
+->
+\9adex
+());
+
+1434 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99DyÇmicLookupFa¡Ca£
+(
+V¬\9fbËProxy
+*
+´oxy
+,
+
+1435
+Ty³ofS\8f\8b
+
+ty³of_¡©e
+,
+
+1436
+Lab\96
+*
+¦ow
+, Lab\96*
+dÚe
+) {
+
+1442
+V¬\9fbË
+*
+ gv¬
+ =
+´oxy
+->
+v¬
+();
+
+1443 ià(
+ gv¬
+->
+mode
+(è=ð
+DYNAMIC_GLOBAL
+) {
+
+1444
+Em\99LßdGlob®CheckEx\8bnsiÚs
+(
+´oxy
+,
+ty³of_¡©e
+,
+¦ow
+);
+
+1445
+__
+
+b
+(
+dÚe
+);
+
+1446 } \vià(
+ gv¬
+->
+mode
+(è=ð
+DYNAMIC_LOCAL
+) {
+
+1447
+V¬\9fbË
+*
+loÿl
+ =
+v¬
+->
+loÿl_if_nÙ_shadowed
+();
+
+1448
+__
+
+LßdP
+(
+r3
+,
+CÚ\8bxtSlÙO³¿ndCheckEx\8bnsiÚs
+(
+loÿl
+,
+¦ow
+));
+
+1449 ià(
+ gloÿl
+->
+mode
+(è=ð
+LET
+ ||
+loÿl
+->mode(è=ð
+CONST
+ ||
+
+1450
+loÿl
+->
+mode
+(è=ð
+CONST_LEGACY
+) {
+
+1451
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+1452
+__
+
+bÃ
+(
+dÚe
+);
+
+1453 ià(
+ gloÿl
+->
+mode
+(è=ð
+CONST_LEGACY
+) {
+
+1454
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+1456
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+v¬
+->
+Çme
+()));
+
+1457
+__
+
+push
+(
+r3
+);
+
+1458
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kThrowReã»nûE¼Ü
+, 1);
+
+1461
+__
+
+b
+(
+dÚe
+);
+
+1466 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99V¬\9fbËLßd
+(
+V¬\9fbËProxy
+*
+´oxy
+) {
+
+1468
+S\91SourûPos\99iÚ
+(
+´oxy
+->
+pos\99iÚ
+());
+
+1469
+V¬\9fbË
+*
+ gv¬
+ =
+´oxy
+->
+v¬
+();
+
+1473 \1a
+ gv¬
+->
+loÿtiÚ
+()) {
+
+1474 \ 4
+ gV¬\9fbË
+::
+UNALLOCATED
+: {
+
+1475
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Global variable");
+
+1476
+__
+
+LßdP
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+Glob®ObjeùO³¿nd
+());
+
+1477
+__
+
+mov
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+O³¿nd
+(
+v¬
+->
+Çme
+()));
+
+1478 ià(
+ gFLAG_veùÜ_ics
+) {
+
+1479
+__
+
+mov
+(
+VeùÜLßdICDesü\9dtÜ
+::
+SlÙRegi¡\94
+(),
+
+1480
+O³¿nd
+(
+SmiFromSlÙ
+(
+´oxy
+->
+V¬\9fbËF\93dbackSlÙ
+())));
+
+1482
+C®lLßdIC
+(
+CONTEXTUAL
+);
+
+1483
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+1487 \ 4
+ gV¬\9fbË
+::
+PARAMETER
+:
+
+1488 \ 4
+V¬\9fbË
+::
+LOCAL
+:
+
+1489 \ 4
+V¬\9fbË
+::
+CONTEXT
+: {
+
+1490
+Comm\92t
+
+cmÁ
+(
+masm_
+,
+v¬
+->
+IsCÚ\8bxtSlÙ
+() ? "[ Context variable"
+
+1492 ià(
+ gv¬
+->
+b\9ad\9ag_Ãeds_\9a\99
+()) {
+
+1498
+DCHECK
+(
+v¬
+->
+scÝe
+(è!ð
+NULL
+);
+
+1516
+boÞ
+
+ gsk\9d_\9a\99_check
+;
+
+1517 ià(
+ gv¬
+->
+scÝe
+()->
+Deþ¬©iÚScÝe
+() != scope()->DeclarationScope()) {
+
+1518
+sk\9d_\9a\99_check
+ =
+çl£
+;
+
+1521
+DCHECK
+(
+v¬
+->
+\9a\99\9fliz\94_pos\99iÚ
+(è!ð
+R\96ocInfo
+::
+kNoPos\99iÚ
+);
+
+1522
+DCHECK
+(
+´oxy
+->
+pos\99iÚ
+(è!ð
+R\96ocInfo
+::
+kNoPos\99iÚ
+);
+
+1523
+ gsk\9d_\9a\99_check
+ =
+v¬
+->
+mode
+(è!ð
+CONST_LEGACY
+ &&
+
+1524
+v¬
+->
+\9a\99\9fliz\94_pos\99iÚ
+(è<
+´oxy
+->
+pos\99iÚ
+();
+
+1527 ià(!
+ gsk\9d_\9a\99_check
+) {
+
+1528
+Lab\96
+
+ gdÚe
+;
+
+1530
+G\91V¬
+(
+r3
+,
+v¬
+);
+
+1531
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+1532
+__
+
+bÃ
+(&
+dÚe
+);
+
+1533 ià(
+ gv¬
+->
+mode
+(è=ð
+LET
+ ||
+v¬
+->mode(è=ð
+CONST
+) {
+
+1536
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+v¬
+->
+Çme
+()));
+
+1537
+__
+
+push
+(
+r3
+);
+
+1538
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kThrowReã»nûE¼Ü
+, 1);
+
+1541
+DCHECK
+(
+v¬
+->
+mode
+(è=ð
+CONST_LEGACY
+);
+
+1542
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+1544
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1545
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+1549
+cڋxt
+()->
+Plug
+(
+v¬
+);
+
+1553 \ 4
+ gV¬\9fbË
+::
+LOOKUP
+: {
+
+1554
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Lookup variable");
+
+1555
+Lab\96
+
+ gdÚe
+,
+ g¦ow
+;
+
+1558
+Em\99DyÇmicLookupFa¡Ca£
+(
+´oxy
+,
+NOT_INSIDE_TYPEOF
+, &
+¦ow
+, &
+dÚe
+);
+
+1559
+__
+
+b\9ad
+(&
+¦ow
+);
+
+1560
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+v¬
+->
+Çme
+()));
+
+1561
+__
+
+Push
+(
+ý
+,
+r4
+);
+
+1562
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kLßdLookupSlÙ
+, 2);
+
+1563
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1564
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+1570 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99RegExpL\99\94®
+(
+RegExpL\99\94®
+*
+ex´
+) {
+
+1571
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ RegExpLiteral");
+
+1572
+Lab\96
+
+ gm©\94\9flized
+;
+
+1580
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+1581
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSFunùiÚ
+::
+kL\99\94®sOff£t
+));
+
+1582 \12
+ gl\99\94®_off£t
+ =
+
+1583
+FixedA¼ay
+::
+kH\97d\94Size
+ +
+ex´
+->
+l\99\94®_\9adex
+(è*
+kPo\9a\8brSize
+;
+
+1584
+__
+
+LßdP
+(
+r8
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+l\99\94®_off£t
+),
+r0
+);
+
+1585
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+1586
+__
+
+cmp
+(
+r8
+,
+\9d
+);
+
+1587
+__
+
+bÃ
+(&
+m©\94\9flized
+);
+
+1591
+__
+
+LßdSmiL\99\94®
+(
+r6
+,
+Smi
+::
+FromIÁ
+(
+ex´
+->
+l\99\94®_\9adex
+()));
+
+1592
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+ex´
+->
+·\89\94n
+()));
+
+1593
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+ex´
+->
+æags
+()));
+
+1594
+__
+
+Push
+(
+r7
+,
+r6
+,
+r5
+,
+r4
+);
+
+1595
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kM©\94\9flizeRegExpL\99\94®
+, 4);
+
+1596
+__
+
+mr
+(
+r8
+,
+r3
+);
+
+1598
+__
+
+b\9ad
+(&
+m©\94\9flized
+);
+
+1599 \12
+ gsize
+ =
+JSRegExp
+::
+kSize
+ + JSRegExp::
+kInObjeùF\9bldCouÁ
+ *
+kPo\9a\8brSize
+;
+
+1600
+Lab\96
+
+ g®loÿ\8bd
+,
+ gruÁime_®loÿ\8b
+;
+
+1601
+__
+
+AÎoÿ\8b
+(
+size
+,
+r3
+,
+r5
+,
+r6
+, &
+ruÁime_®loÿ\8b
+,
+TAG_OBJECT
+);
+
+1602
+__
+
+b
+(&
+®loÿ\8bd
+);
+
+1604
+__
+
+b\9ad
+(&
+ruÁime_®loÿ\8b
+);
+
+1605
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+size
+));
+
+1606
+__
+
+Push
+(
+r8
+,
+r3
+);
+
+1607
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kAÎoÿ\8bInNewS·û
+, 1);
+
+1608
+__
+
+pÝ
+(
+r8
+);
+
+1610
+__
+
+b\9ad
+(&
+®loÿ\8bd
+);
+
+1615
+__
+
+CÝyF\9blds
+(
+r3
+,
+r8
+,
+r5
+.
+b\99
+(),
+size
+ /
+kPo\9a\8brSize
+);
+
+1616
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+1620 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99AcûssÜ
+(
+Ex´essiÚ
+*
+ex´essiÚ
+) {
+
+1621 ià(
+ex´essiÚ
+ =ð
+NULL
+) {
+
+1622
+__
+
+LßdRoÙ
+(
+r4
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+1623
+__
+
+push
+(
+r4
+);
+
+1625
+Vis\99FÜS\8fckV®ue
+(
+ex´essiÚ
+);
+
+1630 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99ObjeùL\99\94®
+(
+ObjeùL\99\94®
+*
+ex´
+) {
+
+1631
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ ObjectLiteral");
+
+1633
+ gex´
+->
+Bu\9edCÚ¡ªtPrÝ\94t\9bs
+(
+isީe
+());
+
+1634
+ gHªdË
+<
+ gFixedA¼ay
+>
+ gcÚ¡ªt_´Ý\94t\9bs
+ =
+ex´
+->
+cÚ¡ªt_´Ý\94t\9bs
+();
+
+1635
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+1636
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+Ô6,
+JSFunùiÚ
+::
+kL\99\94®sOff£t
+));
+
+1637
+__
+
+LßdSmiL\99\94®
+(
+r5
+,
+Smi
+::
+FromIÁ
+(
+ex´
+->
+l\99\94®_\9adex
+()));
+
+1638
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+cÚ¡ªt_´Ý\94t\9bs
+));
+
+1639 \12
+ gæags
+ =
+ex´
+->
+ç¡_\96em\92ts
+(è?
+ObjeùL\99\94®
+::
+kFa¡EËm\92ts
+
+
+1640 :
+ObjeùL\99\94®
+::
+kNoFÏgs
+;
+
+1641
+ gæags
+ |ð
+ex´
+->
+has_funùiÚ
+(è?
+ObjeùL\99\94®
+::
+kHasFunùiÚ
+
+
+1642 :
+ObjeùL\99\94®
+::
+kNoFÏgs
+;
+
+1643
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+æags
+));
+
+1644 \12
+ g´Ý\94t\9bs_couÁ
+ =
+cÚ¡ªt_´Ý\94t\9bs
+->
+Ëngth
+() / 2;
+
+1645 ià(
+ gex´
+->
+may_¡Üe_doubËs
+(è||\83x´->
+d\95th
+() > 1 ||
+
+1646
+masm
+()->
+£r\9fliz\94_\92abËd
+(è||
+ gæags
+ !ð
+ObjeùL\99\94®
+::
+kFa¡EËm\92ts
+ ||
+
+1647
+´Ý\94t\9bs_couÁ
+ >
+Fa¡ClÚeSh®lowObjeùStub
+::
+kMaximumClÚedPrÝ\94t\9bs
+) {
+
+1648
+__
+
+Push
+(
+r6
+,
+r5
+,
+r4
+,
+r3
+);
+
+1649
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kC»©eObjeùL\99\94®
+, 4);
+
+1651
+Fa¡ClÚeSh®lowObjeùStub
+
+¡ub
+(
+isީe
+(),
+´Ý\94t\9bs_couÁ
+);
+
+1652
+__
+
+C®lStub
+(&
+¡ub
+);
+
+1654
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+C»©eL\99\94®Id
+(),
+TOS_REG
+);
+
+1658
+boÞ
+
+ g»suÉ_§ved
+ =
+çl£
+;
+
+1663
+ gex´
+->
+C®cuÏ\8bEm\99StÜe
+(
+zÚe
+());
+
+1665
+AcûssÜTabË
+
+acûssÜ_\8fbË
+(
+zÚe
+());
+
+1666 \ f\12
+ gi
+ = 0; i <
+ gex´
+->
+´Ý\94t\9bs
+()->
+Ëngth
+(); i++) {
+
+1667
+ gObjeùL\99\94®
+::
+Prݔty
+*
+´Ý\94ty
+ =
+ex´
+->
+´Ý\94t\9bs
+()->
+©
+(
+i
+);
+
+1668 ià(
+ g´Ý\94ty
+->
+IsComp\9eeTimeV®ue
+()) \ 6;
+
+1670
+L\99\94®
+*
+ gkey
+ =
+´Ý\94ty
+->
+key
+();
+
+1671
+Ex´essiÚ
+*
+ gv®ue
+ =
+´Ý\94ty
+->
+v®ue
+();
+
+1672 ià(!
+ g»suÉ_§ved
+) {
+
+1673
+__
+
+push
+(
+r3
+);
+
+1674
+ g»suÉ_§ved
+ =
+\8cue
+;
+
+1676 \1a
+ g´Ý\94ty
+->
+k\9ad
+()) {
+
+1677 \ 4
+ gObjeùL\99\94®
+::
+Prݔty
+::
+CONSTANT
+:
+
+1678
+UNREACHABLE
+();
+
+1679 \ 4
+ gObjeùL\99\94®
+::
+Prݔty
+::
+MATERIALIZED_LITERAL
+:
+
+1680
+DCHECK
+(!
+Comp\9eeTimeV®ue
+::
+IsComp\9eeTimeV®ue
+(
+´Ý\94ty
+->
+v®ue
+()));
+
+1682 \ 4
+ gObjeùL\99\94®
+::
+Prݔty
+::
+COMPUTED
+:
+
+1685 ià(
+key
+->
+v®ue
+()->
+IsIÁ\94ÇlizedS\8c\9ag
+()) {
+
+1686 ià(
+´Ý\94ty
+->
+em\99_¡Üe
+()) {
+
+1687
+Vis\99FÜAccumuÏtÜV®ue
+(
+v®ue
+);
+
+1688
+DCHECK
+(
+StÜeDesü\9dtÜ
+::
+V®ueRegi¡\94
+().
+is
+(
+r3
+));
+
+1689
+__
+
+mov
+(
+StÜeDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+O³¿nd
+(
+key
+->
+v®ue
+()));
+
+1690
+__
+
+LßdP
+(
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+MemO³¿nd
+(
+¥
+));
+
+1691
+C®lStÜeIC
+(
+key
+->
+L\99\94®F\93dbackId
+());
+
+1692
+P»·»FÜBa\9eoutFÜId
+(
+key
+->
+id
+(),
+NO_REGISTERS
+);
+
+1694
+Vis\99FÜEfãù
+(
+v®ue
+);
+
+1699
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+));
+
+1700
+__
+
+push
+(
+r3
+);
+
+1701
+Vis\99FÜS\8fckV®ue
+(
+key
+);
+
+1702
+Vis\99FÜS\8fckV®ue
+(
+v®ue
+);
+
+1703 ià(
+ g´Ý\94ty
+->
+em\99_¡Üe
+()) {
+
+1704
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+SLOPPY
+));
+
+1705
+__
+
+push
+(
+r3
+);
+
+1706
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kS\91PrÝ\94ty
+, 4);
+
+1708
+__
+
+DrÝ
+(3);
+
+1711 \ 4
+ gObjeùL\99\94®
+::
+Prݔty
+::
+PROTOTYPE
+:
+
+1713
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+));
+
+1714
+__
+
+push
+(
+r3
+);
+
+1715
+Vis\99FÜS\8fckV®ue
+(
+v®ue
+);
+
+1716 ià(
+ g´Ý\94ty
+->
+em\99_¡Üe
+()) {
+
+1717
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kIÁ\94ÇlS\91PrÙÙy³
+, 2);
+
+1719
+__
+
+DrÝ
+(2);
+
+1722 \ 4
+ gObjeùL\99\94®
+::
+Prݔty
+::
+GETTER
+:
+
+1723
+acûssÜ_\8fbË
+.
+lookup
+(
+key
+)->
+£cÚd
+->
+g\91\8br
+ =
+v®ue
+;
+
+1725 \ 4
+ gObjeùL\99\94®
+::
+Prݔty
+::
+SETTER
+:
+
+1726
+acûssÜ_\8fbË
+.
+lookup
+(
+key
+)->
+£cÚd
+->
+£\89\94
+ =
+v®ue
+;
+
+1733 \ f
+ gAcûssÜTabË
+::
+I\8b¿tÜ
+
+\99
+ =
+acûssÜ_\8fbË
+.
+beg\9a
+();
+
+1734
+ g\99
+ !ð
+acûssÜ_\8fbË
+.
+\92d
+(); ++it) {
+
+1735
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+));
+
+1736
+__
+
+push
+(
+r3
+);
+
+1737
+Vis\99FÜS\8fckV®ue
+(
+\99
+->
+f\9c¡
+);
+
+1738
+Em\99AcûssÜ
+(
+\99
+->
+£cÚd
+->
+g\91\8br
+);
+
+1739
+Em\99AcûssÜ
+(
+\99
+->
+£cÚd
+->
+£\89\94
+);
+
+1740
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+NONE
+));
+
+1741
+__
+
+push
+(
+r3
+);
+
+1742
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kDef\9aeAcûssÜPrÝ\94tyUnchecked
+, 5);
+
+1745 ià(
+ gex´
+->
+has_funùiÚ
+()) {
+
+1746
+DCHECK
+(
+»suÉ_§ved
+);
+
+1747
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+));
+
+1748
+__
+
+push
+(
+r3
+);
+
+1749
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kToFa¡PrÝ\94t\9bs
+, 1);
+
+1752 ià(
+ g»suÉ_§ved
+) {
+
+1753
+cڋxt
+()->
+PlugTOS
+();
+
+1755
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+1760 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99A¼ayL\99\94®
+(
+A¼ayL\99\94®
+*
+ex´
+) {
+
+1761
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ ArrayLiteral");
+
+1763
+ gex´
+->
+Bu\9edCÚ¡ªtEËm\92ts
+(
+isީe
+());
+
+1764 \12
+ gæags
+ =
+ex´
+->
+d\95th
+(è=ð1 ?
+A¼ayL\99\94®
+::
+kSh®lowEËm\92ts
+
+
+1765 :
+A¼ayL\99\94®
+::
+kNoFÏgs
+;
+
+1767
+ gZÚeLi¡
+<
+ gEx´essiÚ
+*>*
+ gsubex´s
+ =
+ex´
+->
+v®ues
+();
+
+1768 \12
+ gËngth
+ =
+subex´s
+->
+Ëngth
+();
+
+1769
+ gHªdË
+<
+ gFixedA¼ay
+>
+ gcÚ¡ªt_\96em\92ts
+ =
+ex´
+->
+cÚ¡ªt_\96em\92ts
+();
+
+1770
+DCHECK_EQ
+(2,
+cÚ¡ªt_\96em\92ts
+->
+Ëngth
+());
+
+1771
+EËm\92tsK\9ad
+
+ gcÚ¡ªt_\96em\92ts_k\9ad
+ =
+
+1772
+¡©ic_ÿ¡
+<
+EËm\92tsK\9ad
+>(
+Smi
+::
+ÿ¡
+(
+cÚ¡ªt_\96em\92ts
+->
+g\91
+(0))->
+v®ue
+());
+
+1773
+boÞ
+
+ ghas_ç¡_\96em\92ts
+ =
+IsFa¡ObjeùEËm\92tsK\9ad
+(
+cÚ¡ªt_\96em\92ts_k\9ad
+);
+
+1774
+ gHªdË
+<
+ gFixedA¼ayBa£
+>
+cÚ¡ªt_\96em\92ts_v®ues
+(
+
+1775
+FixedA¼ayBa£
+::
+ÿ¡
+(
+cÚ¡ªt_\96em\92ts
+->
+g\91
+(1)));
+
+1777
+AÎoÿtiÚS\99eMode
+
+ g®loÿtiÚ_s\99e_mode
+ =
+TRACK_ALLOCATION_SITE
+;
+
+1778 ià(
+ ghas_ç¡_\96em\92ts
+ && !
+ gFLAG_®loÿtiÚ_s\99e_´\91\92ur\9ag
+) {
+
+1781
+ g®loÿtiÚ_s\99e_mode
+ =
+DONT_TRACK_ALLOCATION_SITE
+;
+
+1784
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+1785
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+Ô6,
+JSFunùiÚ
+::
+kL\99\94®sOff£t
+));
+
+1786
+__
+
+LßdSmiL\99\94®
+(
+r5
+,
+Smi
+::
+FromIÁ
+(
+ex´
+->
+l\99\94®_\9adex
+()));
+
+1787
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+cÚ¡ªt_\96em\92ts
+));
+
+1788 ià(
+ gex´
+->
+d\95th
+(è> 1 ||
+ gËngth
+ >
+ gJSObjeù
+::
+kIn\99\9flMaxFa¡EËm\92tA¼ay
+) {
+
+1789
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+æags
+));
+
+1790
+__
+
+Push
+(
+r6
+,
+r5
+,
+r4
+,
+r3
+);
+
+1791
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kC»©eA¼ayL\99\94®
+, 4);
+
+1793
+Fa¡ClÚeSh®lowA¼ayStub
+
+¡ub
+(
+isީe
+(),
+®loÿtiÚ_s\99e_mode
+);
+
+1794
+__
+
+C®lStub
+(&
+¡ub
+);
+
+1797
+boÞ
+
+ g»suÉ_§ved
+ =
+çl£
+;
+
+1801 \ f\12
+ gi
+ = 0; i <
+ gËngth
+; i++) {
+
+1802
+Ex´essiÚ
+*
+ gsubex´
+ =
+subex´s
+->
+©
+(
+i
+);
+
+1805 ià(
+ gComp\9eeTimeV®ue
+::
+IsComp\9eeTimeV®ue
+(
+subex´
+)) \ 6;
+
+1807 ià(!
+ g»suÉ_§ved
+) {
+
+1808
+__
+
+push
+(
+r3
+);
+
+1809
+__
+
+Push
+(
+Smi
+::
+FromIÁ
+(
+ex´
+->
+l\99\94®_\9adex
+()));
+
+1810
+ g»suÉ_§ved
+ =
+\8cue
+;
+
+1812
+Vis\99FÜAccumuÏtÜV®ue
+(
+subex´
+);
+
+1814 ià(
+IsFa¡ObjeùEËm\92tsK\9ad
+(
+cÚ¡ªt_\96em\92ts_k\9ad
+)) {
+
+1815 \12
+ goff£t
+ =
+FixedA¼ay
+::
+kH\97d\94Size
+ + (
+i
+ *
+kPo\9a\8brSize
+);
+
+1816
+__
+
+LßdP
+(
+r8
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+1817
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r8
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+));
+
+1818
+__
+
+StÜeP
+(
+»suÉ_»gi¡\94
+(),
+F\9bldMemO³¿nd
+(
+r4
+,
+off£t
+),
+r0
+);
+
+1820
+__
+
+RecÜdWr\99eF\9bld
+(
+r4
+,
+off£t
+,
+»suÉ_»gi¡\94
+(),
+r5
+,
+kLRHasB\93nSaved
+,
+
+1821
+kDÚtSaveFPRegs
+,
+EMIT_REMEMBERED_SET
+,
+
+1822
+INLINE_SMI_CHECK
+);
+
+1824
+__
+
+LßdSmiL\99\94®
+(
+r6
+,
+Smi
+::
+FromIÁ
+(
+i
+));
+
+1825
+StÜeA¼ayL\99\94®EËm\92tStub
+
+¡ub
+(
+isީe
+());
+
+1826
+__
+
+C®lStub
+(&
+¡ub
+);
+
+1829
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+G\91IdFÜEËm\92t
+(
+i
+),
+NO_REGISTERS
+);
+
+1832 ià(
+ g»suÉ_§ved
+) {
+
+1833
+__
+
+pÝ
+();
+
+1834
+cڋxt
+()->
+PlugTOS
+();
+
+1836
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+1841 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99Assignm\92t
+(
+Assignm\92t
+*
+ex´
+) {
+
+1842
+DCHECK
+(
+ex´
+->
+\8frg\91
+()->
+IsV®idReã»nûEx´essiÚ
+());
+
+1844
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Assignment");
+
+1846
+Prݔty
+*
+ g´Ý\94ty
+ =
+ex´
+->
+\8frg\91
+()->
+AsPrݔty
+();
+
+1847
+LhsK\9ad
+
+ gassign_ty³
+ =
+G\91AssignTy³
+(
+´Ý\94ty
+);
+
+1850 \1a
+ gassign_ty³
+) {
+
+1851 \ 4
+ gVARIABLE
+:
+
+1854 \ 4
+ gNAMED_PROPERTY
+:
+
+1855 ià(
+ex´
+->
+is_compound
+()) {
+
+1857
+Vis\99FÜS\8fckV®ue
+(
+´Ý\94ty
+->
+obj
+());
+
+1858
+__
+
+LßdP
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+MemO³¿nd
+(
+¥
+, 0));
+
+1860
+Vis\99FÜS\8fckV®ue
+(
+´Ý\94ty
+->
+obj
+());
+
+1863 \ 4
+ gNAMED_SUPER_PROPERTY
+:
+
+1864
+Vis\99FÜS\8fckV®ue
+(
+´Ý\94ty
+->
+obj
+()->
+AsSu³rReã»nû
+()->
+this_v¬
+());
+
+1865
+Em\99LßdHomeObjeù
+(
+´Ý\94ty
+->
+obj
+()->
+AsSu³rReã»nû
+());
+
+1866
+__
+
+Push
+(
+»suÉ_»gi¡\94
+());
+
+1867 ià(
+ gex´
+->
+is_compound
+()) {
+
+1868 cڡ
+Regi¡\94
+
+ gsü©ch
+ =
+r4
+;
+
+1869
+__
+
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+1870
+__
+
+Push
+(
+sü©ch
+,
+»suÉ_»gi¡\94
+());
+
+1873 \ 4
+ gKEYED_SUPER_PROPERTY
+: {
+
+1874 cڡ
+Regi¡\94
+
+sü©ch
+ =
+r4
+;
+
+1875
+Vis\99FÜS\8fckV®ue
+(
+´Ý\94ty
+->
+obj
+()->
+AsSu³rReã»nû
+()->
+this_v¬
+());
+
+1876
+Em\99LßdHomeObjeù
+(
+´Ý\94ty
+->
+obj
+()->
+AsSu³rReã»nû
+());
+
+1877
+__
+
+Move
+(
+sü©ch
+,
+»suÉ_»gi¡\94
+());
+
+1878
+Vis\99FÜAccumuÏtÜV®ue
+(
+´Ý\94ty
+->
+key
+());
+
+1879
+__
+
+Push
+(
+sü©ch
+,
+»suÉ_»gi¡\94
+());
+
+1880 ià(
+ gex´
+->
+is_compound
+()) {
+
+1881 cڡ
+Regi¡\94
+
+ gsü©ch1
+ =
+r5
+;
+
+1882
+__
+
+LßdP
+(
+sü©ch1
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+1883
+__
+
+Push
+(
+sü©ch1
+,
+sü©ch
+,
+»suÉ_»gi¡\94
+());
+
+1887 \ 4
+ gKEYED_PROPERTY
+:
+
+1888 ià(
+ex´
+->
+is_compound
+()) {
+
+1889
+Vis\99FÜS\8fckV®ue
+(
+´Ý\94ty
+->
+obj
+());
+
+1890
+Vis\99FÜS\8fckV®ue
+(
+´Ý\94ty
+->
+key
+());
+
+1891
+__
+
+LßdP
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+
+1892
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+1893
+__
+
+LßdP
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+MemO³¿nd
+(
+¥
+, 0));
+
+1895
+Vis\99FÜS\8fckV®ue
+(
+´Ý\94ty
+->
+obj
+());
+
+1896
+Vis\99FÜS\8fckV®ue
+(
+´Ý\94ty
+->
+key
+());
+
+1903 ià(
+ gex´
+->
+is_compound
+()) {
+
+1905
+AccumuÏtÜV®ueCÚ\8bxt
+
+cڋxt
+(
+this
+);
+
+1906 \1a
+ gassign_ty³
+) {
+
+1907 \ 4
+ gVARIABLE
+:
+
+1908
+Em\99V¬\9fbËLßd
+(
+ex´
+->
+\8frg\91
+()->
+AsV¬\9fbËProxy
+());
+
+1909
+P»·»FÜBa\9eout
+(
+ex´
+->
+\8frg\91
+(),
+TOS_REG
+);
+
+1911 \ 4
+ gNAMED_PROPERTY
+:
+
+1912
+Em\99NamedPrÝ\94tyLßd
+(
+´Ý\94ty
+);
+
+1913
+P»·»FÜBa\9eoutFÜId
+(
+´Ý\94ty
+->
+LßdId
+(),
+TOS_REG
+);
+
+1915 \ 4
+ gNAMED_SUPER_PROPERTY
+:
+
+1916
+Em\99NamedSu³rPrÝ\94tyLßd
+(
+´Ý\94ty
+);
+
+1917
+P»·»FÜBa\9eoutFÜId
+(
+´Ý\94ty
+->
+LßdId
+(),
+TOS_REG
+);
+
+1919 \ 4
+ gKEYED_SUPER_PROPERTY
+:
+
+1920
+Em\99KeyedSu³rPrÝ\94tyLßd
+(
+´Ý\94ty
+);
+
+1921
+P»·»FÜBa\9eoutFÜId
+(
+´Ý\94ty
+->
+LßdId
+(),
+TOS_REG
+);
+
+1923 \ 4
+ gKEYED_PROPERTY
+:
+
+1924
+Em\99KeyedPrÝ\94tyLßd
+(
+´Ý\94ty
+);
+
+1925
+P»·»FÜBa\9eoutFÜId
+(
+´Ý\94ty
+->
+LßdId
+(),
+TOS_REG
+);
+
+1930
+ gTok\92
+::
+V®ue
+
+Ý
+ =
+ex´
+->
+b\9a¬y_Ý
+();
+
+1931
+__
+
+push
+(
+r3
+);
+
+1932
+Vis\99FÜAccumuÏtÜV®ue
+(
+ex´
+->
+v®ue
+());
+
+1934
+Ov\94wr\99eMode
+
+ gmode
+ =
+ex´
+->
+v®ue
+()->
+ResuÉOv\94wr\99eAÎowed
+()
+
+1935 ?
+OVERWRITE_RIGHT
+
+
+1936 :
+NO_OVERWRITE
+;
+
+1937
+S\91SourûPos\99iÚ
+(
+ex´
+->
+pos\99iÚ
+() + 1);
+
+1938
+AccumuÏtÜV®ueCÚ\8bxt
+
+cڋxt
+(
+this
+);
+
+1939 ià(
+ShouldIÆ\9aeSmiCa£
+(
+Ý
+)) {
+
+1940
+Em\99IÆ\9aeSmiB\9a¬yOp
+(
+ex´
+->
+b\9a¬y_Ý\94©iÚ
+(),
+Ý
+,
+mode
+,\83x´->
+\8frg\91
+(),
+
+1941
+ex´
+->
+v®ue
+());
+
+1943
+Em\99B\9a¬yOp
+(
+ex´
+->
+b\9a¬y_Ý\94©iÚ
+(),
+Ý
+,
+mode
+);
+
+1947
+P»·»FÜBa\9eout
+(
+ex´
+->
+b\9a¬y_Ý\94©iÚ
+(),
+TOS_REG
+);
+
+1949
+Vis\99FÜAccumuÏtÜV®ue
+(
+ex´
+->
+v®ue
+());
+
+1953
+S\91SourûPos\99iÚ
+(
+ex´
+->
+pos\99iÚ
+());
+
+1956 \1a
+ gassign_ty³
+) {
+
+1957 \ 4
+ gVARIABLE
+:
+
+1958
+Em\99V¬\9fbËAssignm\92t
+(
+ex´
+->
+\8frg\91
+()->
+AsV¬\9fbËProxy
+()->
+v¬
+(),
+
+1959
+ex´
+->
+Ý
+());
+
+1960
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+Assignm\92tId
+(),
+TOS_REG
+);
+
+1961
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+1963 \ 4
+ gNAMED_PROPERTY
+:
+
+1964
+Em\99NamedPrÝ\94tyAssignm\92t
+(
+ex´
+);
+
+1966 \ 4
+ gNAMED_SUPER_PROPERTY
+:
+
+1967
+Em\99NamedSu³rPrÝ\94tyStÜe
+(
+´Ý\94ty
+);
+
+1968
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+1970 \ 4
+ gKEYED_SUPER_PROPERTY
+:
+
+1971
+Em\99KeyedSu³rPrÝ\94tyStÜe
+(
+´Ý\94ty
+);
+
+1972
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+1974 \ 4
+ gKEYED_PROPERTY
+:
+
+1975
+Em\99KeyedPrÝ\94tyAssignm\92t
+(
+ex´
+);
+
+1981 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99Y\9bld
+(
+Y\9bld
+*
+ex´
+) {
+
+1982
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Yield");
+
+1985
+Vis\99FÜS\8fckV®ue
+(
+ex´
+->
+ex´essiÚ
+());
+
+1987 \1a
+ gex´
+->
+y\9bld_k\9ad
+()) {
+
+1988 \ 4
+ gY\9bld
+::
+kSu¥\92d
+:
+
+1990
+Em\99C»©eI\8b¿tÜResuÉ
+(
+çl£
+);
+
+1991
+__
+
+push
+(
+»suÉ_»gi¡\94
+());
+
+1993 \ 4
+ gY\9bld
+::
+kIn\99\9fl
+: {
+
+1994
+Lab\96
+
+su¥\92d
+,
+ gcÚt\9au©iÚ
+,
+ gpo¡_ruÁime
+,
+ g»sume
+;
+
+1996
+__
+
+b
+(&
+su¥\92d
+);
+
+1998
+__
+
+b\9ad
+(&
+cÚt\9au©iÚ
+);
+
+1999
+__
+
+b
+(&
+»sume
+);
+
+2001
+__
+
+b\9ad
+(&
+su¥\92d
+);
+
+2002
+Vis\99FÜAccumuÏtÜV®ue
+(
+ex´
+->
+g\92\94©Ü_objeù
+());
+
+2003
+DCHECK
+(
+cÚt\9au©iÚ
+.
+pos
+(è> 0 &&
+Smi
+::
+IsV®id
+(continuation.pos()));
+
+2004
+__
+
+LßdSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(
+cÚt\9au©iÚ
+.
+pos
+()));
+
+2005
+__
+
+StÜeP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSG\92\94©ÜObjeù
+::
+kCÚt\9au©iÚOff£t
+),
+
+2006
+r0
+);
+
+2007
+__
+
+StÜeP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSG\92\94©ÜObjeù
+::
+kCÚ\8bxtOff£t
+),
+r0
+);
+
+2008
+__
+
+mr
+(
+r4
+,
+ý
+);
+
+2009
+__
+
+RecÜdWr\99eF\9bld
+(
+r3
+,
+JSG\92\94©ÜObjeù
+::
+kCÚ\8bxtOff£t
+,
+r4
+,
+r5
+,
+
+2010
+kLRHasB\93nSaved
+,
+kDÚtSaveFPRegs
+);
+
+2011
+__
+
+addi
+(
+r4
+,
+å
+,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kEx´essiÚsOff£t
+));
+
+2012
+__
+
+cmp
+(
+¥
+,
+r4
+);
+
+2013
+__
+
+beq
+(&
+po¡_ruÁime
+);
+
+2014
+__
+
+push
+(
+r3
+);
+
+2015
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kSu¥\92dJSG\92\94©ÜObjeù
+, 1);
+
+2016
+__
+
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+2017
+__
+
+b\9ad
+(&
+po¡_ruÁime
+);
+
+2018
+__
+
+pÝ
+(
+»suÉ_»gi¡\94
+());
+
+2019
+Em\99R\91uºSequ\92û
+();
+
+2021
+__
+
+b\9ad
+(&
+»sume
+);
+
+2022
+cڋxt
+()->
+Plug
+(
+»suÉ_»gi¡\94
+());
+
+2026 \ 4
+ gY\9bld
+::
+kF\9a®
+: {
+
+2027
+Vis\99FÜAccumuÏtÜV®ue
+(
+ex´
+->
+g\92\94©Ü_objeù
+());
+
+2028
+__
+
+LßdSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(
+JSG\92\94©ÜObjeù
+::
+kG\92\94©ÜClo£d
+));
+
+2029
+__
+
+StÜeP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+»suÉ_»gi¡\94
+(),
+
+2030
+JSG\92\94©ÜObjeù
+::
+kCÚt\9au©iÚOff£t
+),
+
+2031
+r0
+);
+
+2033
+Em\99C»©eI\8b¿tÜResuÉ
+(
+\8cue
+);
+
+2034
+Em\99Unw\9adBefÜeR\91uº
+();
+
+2035
+Em\99R\91uºSequ\92û
+();
+
+2039 \ 4
+ gY\9bld
+::
+kD\96eg©\9ag
+: {
+
+2040
+Vis\99FÜS\8fckV®ue
+(
+ex´
+->
+g\92\94©Ü_objeù
+());
+
+2046
+Lab\96
+
+ gl_ÿtch
+,
+ gl_\8cy
+,
+ gl_su¥\92d
+,
+ gl_cÚt\9au©iÚ
+,
+ gl_»sume
+;
+
+2047
+Lab\96
+
+ gl_Ãxt
+,
+ gl_ÿÎ
+;
+
+2048
+Regi¡\94
+
+ glßd_»ûiv\94
+ =
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+();
+
+2049
+Regi¡\94
+
+ glßd_Çme
+ =
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+();
+
+2052
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+2053
+__
+
+b
+(&
+l_Ãxt
+);
+
+2056
+__
+
+b\9ad
+(&
+l_ÿtch
+);
+
+2057
+hªdËr_\8fbË
+()->
+£t
+(
+ex´
+->
+\9adex
+(),
+Smi
+::
+FromIÁ
+(
+l_ÿtch
+.
+pos
+()));
+
+2058
+__
+
+LßdRoÙ
+(
+lßd_Çme
+,
+H\97p
+::
+kthrow_¡r\9agRoÙIndex
+);
+
+2059
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+2060
+__
+
+Push
+(
+lßd_Çme
+,
+r6
+,
+r3
+);
+
+2061
+__
+
+b
+(&
+l_ÿÎ
+);
+
+2066
+__
+
+b\9ad
+(&
+l_\8cy
+);
+
+2067
+__
+
+pÝ
+(
+r3
+);
+
+2068
+__
+
+PushTryHªdËr
+(
+S\8fckHªdËr
+::
+CATCH
+,
+ex´
+->
+\9adex
+());
+
+2069 cڡ \12
+ ghªdËr_size
+ =
+S\8fckHªdËrCÚ¡ªts
+::
+kSize
+;
+
+2070
+__
+
+push
+(
+r3
+);
+
+2071
+__
+
+b
+(&
+l_su¥\92d
+);
+
+2072
+__
+
+b\9ad
+(&
+l_cÚt\9au©iÚ
+);
+
+2073
+__
+
+b
+(&
+l_»sume
+);
+
+2074
+__
+
+b\9ad
+(&
+l_su¥\92d
+);
+
+2075 cڡ \12
+ gg\92\94©Ü_objeù_d\95th
+ =
+kPo\9a\8brSize
+ +
+hªdËr_size
+;
+
+2076
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+g\92\94©Ü_objeù_d\95th
+));
+
+2077
+__
+
+push
+(
+r3
+);
+
+2078
+DCHECK
+(
+l_cÚt\9au©iÚ
+.
+pos
+(è> 0 &&
+Smi
+::
+IsV®id
+(l_continuation.pos()));
+
+2079
+__
+
+LßdSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(
+l_cÚt\9au©iÚ
+.
+pos
+()));
+
+2080
+__
+
+StÜeP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSG\92\94©ÜObjeù
+::
+kCÚt\9au©iÚOff£t
+),
+
+2081
+r0
+);
+
+2082
+__
+
+StÜeP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSG\92\94©ÜObjeù
+::
+kCÚ\8bxtOff£t
+),
+r0
+);
+
+2083
+__
+
+mr
+(
+r4
+,
+ý
+);
+
+2084
+__
+
+RecÜdWr\99eF\9bld
+(
+r3
+,
+JSG\92\94©ÜObjeù
+::
+kCÚ\8bxtOff£t
+,
+r4
+,
+r5
+,
+
+2085
+kLRHasB\93nSaved
+,
+kDÚtSaveFPRegs
+);
+
+2086
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kSu¥\92dJSG\92\94©ÜObjeù
+, 1);
+
+2087
+__
+
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+2088
+__
+
+pÝ
+(
+r3
+);
+
+2089
+Em\99R\91uºSequ\92û
+();
+
+2090
+__
+
+b\9ad
+(&
+l_»sume
+);
+
+2091
+__
+
+PÝTryHªdËr
+();
+
+2094
+__
+
+b\9ad
+(&
+l_Ãxt
+);
+
+2096
+__
+
+LßdRoÙ
+(
+lßd_Çme
+,
+H\97p
+::
+kÃxt_¡r\9agRoÙIndex
+);
+
+2097
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+2098
+__
+
+Push
+(
+lßd_Çme
+,
+r6
+,
+r3
+);
+
+2101
+__
+
+b\9ad
+(&
+l_ÿÎ
+);
+
+2102
+__
+
+LßdP
+(
+lßd_»ûiv\94
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+2103
+__
+
+LßdP
+(
+lßd_Çme
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+2104 ià(
+ gFLAG_veùÜ_ics
+) {
+
+2105
+__
+
+mov
+(
+VeùÜLßdICDesü\9dtÜ
+::
+SlÙRegi¡\94
+(),
+
+2106
+O³¿nd
+(
+SmiFromSlÙ
+(
+ex´
+->
+KeyedLßdF\93dbackSlÙ
+())));
+
+2108
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+CodeFaùÜy
+::
+KeyedLßdIC
+(
+isީe
+()).
+code
+();
+
+2109
+C®lIC
+(
+ic
+,
+Ty³F\93dbackId
+::
+NÚe
+());
+
+2110
+__
+
+mr
+(
+r4
+,
+r3
+);
+
+2111
+__
+
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+2112
+C®lFunùiÚStub
+
+¡ub
+(
+isީe
+(), 1,
+CALL_AS_METHOD
+);
+
+2113
+__
+
+C®lStub
+(&
+¡ub
+);
+
+2115
+__
+
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+2116
+__
+
+DrÝ
+(1);
+
+2119
+__
+
+Move
+(
+lßd_»ûiv\94
+,
+r3
+);
+
+2121
+__
+
+push
+(
+lßd_»ûiv\94
+);
+
+2122
+__
+
+LßdRoÙ
+(
+lßd_Çme
+,
+H\97p
+::
+kdÚe_¡r\9agRoÙIndex
+);
+
+2123 ià(
+ gFLAG_veùÜ_ics
+) {
+
+2124
+__
+
+mov
+(
+VeùÜLßdICDesü\9dtÜ
+::
+SlÙRegi¡\94
+(),
+
+2125
+O³¿nd
+(
+SmiFromSlÙ
+(
+ex´
+->
+DÚeF\93dbackSlÙ
+())));
+
+2127
+C®lLßdIC
+(
+NOT_CONTEXTUAL
+);
+
+2128
+ gHªdË
+<
+ gCode
+>
+ gboÞ_ic
+ =
+ToBoޗnStub
+::
+G\91Un\9a\99\9flized
+(
+isީe
+());
+
+2129
+C®lIC
+(
+boÞ_ic
+);
+
+2130
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+2131
+__
+
+beq
+(&
+l_\8cy
+);
+
+2134
+__
+
+pÝ
+(
+lßd_»ûiv\94
+);
+
+2135
+__
+
+LßdRoÙ
+(
+lßd_Çme
+,
+H\97p
+::
+kv®ue_¡r\9agRoÙIndex
+);
+
+2136 ià(
+ gFLAG_veùÜ_ics
+) {
+
+2137
+__
+
+mov
+(
+VeùÜLßdICDesü\9dtÜ
+::
+SlÙRegi¡\94
+(),
+
+2138
+O³¿nd
+(
+SmiFromSlÙ
+(
+ex´
+->
+V®ueF\93dbackSlÙ
+())));
+
+2140
+C®lLßdIC
+(
+NOT_CONTEXTUAL
+);
+
+2141
+cڋxt
+()->
+DrÝAndPlug
+(2,
+r3
+);
+
+2148 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99G\92\94©ÜResume
+(
+
+2149
+Ex´essiÚ
+*
+g\92\94©Ü
+, Ex´essiÚ*
+v®ue
+,
+
+2150
+JSG\92\94©ÜObjeù
+::
+ResumeMode
+
+»sume_mode
+) {
+
+2155
+Vis\99FÜS\8fckV®ue
+(
+g\92\94©Ü
+);
+
+2156
+Vis\99FÜAccumuÏtÜV®ue
+(
+v®ue
+);
+
+2157
+__
+
+pÝ
+(
+r4
+);
+
+2160
+Lab\96
+
+ gwrÚg_¡©e
+,
+ gþo£d_¡©e
+,
+ gdÚe
+;
+
+2161
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSG\92\94©ÜObjeù
+::
+kCÚt\9au©iÚOff£t
+));
+
+2162
+STATIC_ASSERT
+(
+JSG\92\94©ÜObjeù
+::
+kG\92\94©ÜExecut\9ag
+ < 0);
+
+2163
+STATIC_ASSERT
+(
+JSG\92\94©ÜObjeù
+::
+kG\92\94©ÜClo£d
+ == 0);
+
+2164
+__
+
+CmpSmiL\99\94®
+(
+r6
+,
+Smi
+::
+FromIÁ
+(0),
+r0
+);
+
+2165
+__
+
+beq
+(&
+þo£d_¡©e
+);
+
+2166
+__
+
+bÉ
+(&
+wrÚg_¡©e
+);
+
+2169
+__
+
+LßdP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSG\92\94©ÜObjeù
+::
+kCÚ\8bxtOff£t
+));
+
+2170
+__
+
+LßdP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSG\92\94©ÜObjeù
+::
+kFunùiÚOff£t
+));
+
+2173
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSG\92\94©ÜObjeù
+::
+kReûiv\94Off£t
+));
+
+2174
+__
+
+push
+(
+r5
+);
+
+2177
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+2178
+__
+
+LßdWÜdAr\99h
+(
+
+2179
+r6
+,
+F\9bldMemO³¿nd
+Ô6,
+Sh¬edFunùiÚInfo
+::
+kFÜm®P¬am\91\94CouÁOff£t
+));
+
+2180
+__
+
+LßdRoÙ
+(
+r5
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+2181
+Lab\96
+
+ g¬gum\92t_loÝ
+,
+ gpush_äame
+;
+
+2182 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2183
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+::
+Z\94o
+());
+
+2184
+__
+
+beq
+(&
+push_äame
+);
+
+2186
+__
+
+SmiUÁag
+(
+r6
+,
+S\91RC
+);
+
+2187
+__
+
+beq
+(&
+push_äame
+,
+ü0
+);
+
+2189
+__
+
+mtùr
+(
+r6
+);
+
+2190
+__
+
+b\9ad
+(&
+¬gum\92t_loÝ
+);
+
+2191
+__
+
+push
+(
+r5
+);
+
+2192
+__
+
+bdnz
+(&
+¬gum\92t_loÝ
+);
+
+2196
+Lab\96
+
+ g»sume_äame
+;
+
+2197
+__
+
+b\9ad
+(&
+push_äame
+);
+
+2198
+__
+
+b
+(&
+»sume_äame
+,
+S\91LK
+);
+
+2199
+__
+
+b
+(&
+dÚe
+);
+
+2200
+__
+
+b\9ad
+(&
+»sume_äame
+);
+
+2205
+__
+
+PushFixedF¿me
+(
+r7
+);
+
+2207
+__
+
+addi
+(
+å
+,
+¥
+,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSizeFromFp
+));
+
+2210
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSG\92\94©ÜObjeù
+::
+kO³¿ndS\8fckOff£t
+));
+
+2211
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+Ô6,
+FixedA¼ay
+::
+kL\92gthOff£t
+));
+
+2212
+__
+
+SmiUÁag
+(
+r6
+,
+S\91RC
+);
+
+2216
+Lab\96
+
+ gÿÎ_»sume
+;
+
+2217 ià(
+ g»sume_mode
+ =ð
+JSG\92\94©ÜObjeù
+::
+NEXT
+) {
+
+2218
+Lab\96
+
+¦ow_»sume
+;
+
+2219
+__
+
+bÃ
+(&
+¦ow_»sume
+,
+ü0
+);
+
+2220
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+r7
+,
+JSFunùiÚ
+::
+kCodeEÁryOff£t
+));
+
+2221 #ià
+V8_OOL_CONSTANT_POOL
+
+
+2223
+CÚ¡ªtPoÞUÇva\9eabËScÝe
+
+cÚ¡ªt_poÞ_uÇva\9eabË
+(
+masm_
+);
+
+2225
+__
+
+LßdP
+(
+kCÚ¡ªtPoÞRegi¡\94
+,
+
+2226
+MemO³¿nd
+(
+\9d
+,
+Code
+::
+kCÚ¡ªtPoÞOff£t
+ - Code::
+kH\97d\94Size
+));
+
+2228
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSG\92\94©ÜObjeù
+::
+kCÚt\9au©iÚOff£t
+));
+
+2229
+__
+
+SmiUÁag
+(
+r5
+);
+
+2230
+__
+
+add
+(
+\9d
+, ip,
+r5
+);
+
+2231
+__
+
+LßdSmiL\99\94®
+(
+r5
+,
+
+2232
+Smi
+::
+FromIÁ
+(
+JSG\92\94©ÜObjeù
+::
+kG\92\94©ÜExecut\9ag
+));
+
+2233
+__
+
+StÜeP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSG\92\94©ÜObjeù
+::
+kCÚt\9au©iÚOff£t
+),
+
+2234
+r0
+);
+
+2235
+__
+
+Jump
+(
+\9d
+);
+
+2236
+__
+
+b\9ad
+(&
+¦ow_»sume
+);
+
+2237 #ià
+V8_OOL_CONSTANT_POOL
+
+
+2241
+__
+
+beq
+(&
+ÿÎ_»sume
+,
+ü0
+);
+
+2246
+Lab\96
+
+ gÝ\94ªd_loÝ
+;
+
+2247
+__
+
+mtùr
+(
+r6
+);
+
+2248
+__
+
+b\9ad
+(&
+Ý\94ªd_loÝ
+);
+
+2249
+__
+
+push
+(
+r5
+);
+
+2250
+__
+
+bdnz
+(&
+Ý\94ªd_loÝ
+);
+
+2252
+__
+
+b\9ad
+(&
+ÿÎ_»sume
+);
+
+2253
+DCHECK
+(!
+»suÉ_»gi¡\94
+().
+is
+(
+r4
+));
+
+2254
+__
+
+Push
+(
+r4
+,
+»suÉ_»gi¡\94
+());
+
+2255
+__
+
+Push
+(
+Smi
+::
+FromIÁ
+(
+»sume_mode
+));
+
+2256
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kResumeJSG\92\94©ÜObjeù
+, 3);
+
+2258
+__
+
+¡Ý
+("not-reached");
+
+2261
+__
+
+b\9ad
+(&
+þo£d_¡©e
+);
+
+2262 ià(
+ g»sume_mode
+ =ð
+JSG\92\94©ÜObjeù
+::
+NEXT
+) {
+
+2264
+__
+
+LßdRoÙ
+(
+r5
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+2265
+__
+
+push
+(
+r5
+);
+
+2267
+Em\99C»©eI\8b¿tÜResuÉ
+(
+\8cue
+);
+
+2270
+__
+
+push
+(
+r3
+);
+
+2271
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kThrow
+, 1);
+
+2273
+__
+
+b
+(&
+dÚe
+);
+
+2276
+__
+
+b\9ad
+(&
+wrÚg_¡©e
+);
+
+2277
+__
+
+push
+(
+r4
+);
+
+2278
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kThrowG\92\94©ÜS\8f\8bE¼Ü
+, 1);
+
+2280
+__
+
+b\9ad
+(&
+dÚe
+);
+
+2281
+cڋxt
+()->
+Plug
+(
+»suÉ_»gi¡\94
+());
+
+2285 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99C»©eI\8b¿tÜResuÉ
+(
+boÞ
+
+dÚe
+) {
+
+2286
+Lab\96
+
+gc_»qu\9ced
+;
+
+2287
+Lab\96
+
+ g®loÿ\8bd
+;
+
+2289 cڡ \12
+ g\9a¡ªû_size
+ = 5 *
+kPo\9a\8brSize
+;
+
+2290
+DCHECK_EQ
+(
+isީe
+()->
+Çtive_cÚ\8bxt
+()->
+\99\94©Ü_»suÉ_m
+()->
+\9a¡ªû_size
+(),
+
+2291
+\9a¡ªû_size
+);
+
+2293
+__
+
+AÎoÿ\8b
+(
+\9a¡ªû_size
+,
+r3
+,
+r5
+,
+r6
+, &
+gc_»qu\9ced
+,
+TAG_OBJECT
+);
+
+2294
+__
+
+b
+(&
+®loÿ\8bd
+);
+
+2296
+__
+
+b\9ad
+(&
+gc_»qu\9ced
+);
+
+2297
+__
+
+Push
+(
+Smi
+::
+FromIÁ
+(
+\9a¡ªû_size
+));
+
+2298
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kAÎoÿ\8bInNewS·û
+, 1);
+
+2299
+__
+
+LßdP
+(
+cÚ\8bxt_»gi¡\94
+(),
+
+2300
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+2302
+__
+
+b\9ad
+(&
+®loÿ\8bd
+);
+
+2303
+__
+
+LßdP
+(
+r4
+,
+CÚ\8bxtO³¿nd
+(
+ý
+,
+Cڋxt
+::
+GLOBAL_OBJECT_INDEX
+));
+
+2304
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+Ô4,
+Glob®Objeù
+::
+kN©iveCÚ\8bxtOff£t
+));
+
+2305
+__
+
+LßdP
+(
+r4
+,
+CÚ\8bxtO³¿nd
+Ô4,
+Cڋxt
+::
+ITERATOR_RESULT_MAP_INDEX
+));
+
+2306
+__
+
+pÝ
+(
+r5
+);
+
+2307
+__
+
+mov
+(
+r6
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+ToBoޗn
+(
+dÚe
+)));
+
+2308
+__
+
+mov
+(
+r7
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+em±y_fixed_¬¿y
+()));
+
+2309
+__
+
+StÜeP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pObjeù
+::
+kMOff£t
+),
+r0
+);
+
+2310
+__
+
+StÜeP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kPrÝ\94t\9bsOff£t
+),
+r0
+);
+
+2311
+__
+
+StÜeP
+(
+r7
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kEËm\92tsOff£t
+),
+r0
+);
+
+2312
+__
+
+StÜeP
+(
+r5
+,
+
+2313
+F\9bldMemO³¿nd
+(
+r3
+,
+JSG\92\94©ÜObjeù
+::
+kResuÉV®uePrÝ\94tyOff£t
+),
+
+2314
+r0
+);
+
+2315
+__
+
+StÜeP
+(
+r6
+,
+
+2316
+F\9bldMemO³¿nd
+(
+r3
+,
+JSG\92\94©ÜObjeù
+::
+kResuÉDÚePrÝ\94tyOff£t
+),
+
+2317
+r0
+);
+
+2321
+__
+
+RecÜdWr\99eF\9bld
+(
+r3
+,
+JSG\92\94©ÜObjeù
+::
+kResuÉV®uePrÝ\94tyOff£t
+,
+r5
+,
+r6
+,
+
+2322
+kLRHasB\93nSaved
+,
+kDÚtSaveFPRegs
+);
+
+2326 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99NamedPrÝ\94tyLßd
+(
+Prݔty
+*
+´Ý
+) {
+
+2327
+S\91SourûPos\99iÚ
+(
+´Ý
+->
+pos\99iÚ
+());
+
+2328
+L\99\94®
+*
+ gkey
+ =
+´Ý
+->
+key
+()->
+AsL\99\94®
+();
+
+2329
+DCHECK
+(!
+´Ý
+->
+IsSu³rAcûss
+());
+
+2331
+__
+
+mov
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+O³¿nd
+(
+key
+->
+v®ue
+()));
+
+2332 ià(
+ gFLAG_veùÜ_ics
+) {
+
+2333
+__
+
+mov
+(
+VeùÜLßdICDesü\9dtÜ
+::
+SlÙRegi¡\94
+(),
+
+2334
+O³¿nd
+(
+SmiFromSlÙ
+(
+´Ý
+->
+PrÝ\94tyF\93dbackSlÙ
+())));
+
+2335
+C®lLßdIC
+(
+NOT_CONTEXTUAL
+);
+
+2337
+C®lLßdIC
+(
+NOT_CONTEXTUAL
+,
+´Ý
+->
+PrÝ\94tyF\93dbackId
+());
+
+2342 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99NamedSu³rPrÝ\94tyLßd
+(
+Prݔty
+*
+´Ý
+) {
+
+2344
+S\91SourûPos\99iÚ
+(
+´Ý
+->
+pos\99iÚ
+());
+
+2345
+L\99\94®
+*
+ gkey
+ =
+´Ý
+->
+key
+()->
+AsL\99\94®
+();
+
+2346
+DCHECK
+(!
+key
+->
+v®ue
+()->
+IsSmi
+());
+
+2347
+DCHECK
+(
+´Ý
+->
+IsSu³rAcûss
+());
+
+2349
+__
+
+Push
+(
+key
+->
+v®ue
+());
+
+2350
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kLßdFromSu³r
+, 3);
+
+2354 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99KeyedPrÝ\94tyLßd
+(
+Prݔty
+*
+´Ý
+) {
+
+2355
+S\91SourûPos\99iÚ
+(
+´Ý
+->
+pos\99iÚ
+());
+
+2356
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+CodeFaùÜy
+::
+KeyedLßdIC
+(
+isީe
+()).
+code
+();
+
+2357 ià(
+ gFLAG_veùÜ_ics
+) {
+
+2358
+__
+
+mov
+(
+VeùÜLßdICDesü\9dtÜ
+::
+SlÙRegi¡\94
+(),
+
+2359
+O³¿nd
+(
+SmiFromSlÙ
+(
+´Ý
+->
+PrÝ\94tyF\93dbackSlÙ
+())));
+
+2360
+C®lIC
+(
+ic
+);
+
+2362
+C®lIC
+(
+ic
+,
+´Ý
+->
+PrÝ\94tyF\93dbackId
+());
+
+2367 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99KeyedSu³rPrÝ\94tyLßd
+(
+Prݔty
+*
+´Ý
+) {
+
+2369
+S\91SourûPos\99iÚ
+(
+´Ý
+->
+pos\99iÚ
+());
+
+2371
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kLßdKeyedFromSu³r
+, 3);
+
+2375 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IÆ\9aeSmiB\9a¬yOp
+(
+B\9a¬yO³¿tiÚ
+*
+ex´
+,
+
+2376
+Tok\92
+::
+V®ue
+
+Ý
+,
+
+2377
+Ov\94wr\99eMode
+
+mode
+,
+
+2378
+Ex´essiÚ
+*
+Ëá_ex´
+,
+
+2379
+Ex´essiÚ
+*
+right_ex´
+) {
+
+2380
+Lab\96
+
+ gdÚe
+,
+ gsmi_ÿ£
+,
+ g¡ub_ÿÎ
+;
+
+2382
+Regi¡\94
+
+ gsü©ch1
+ =
+r5
+;
+
+2383
+Regi¡\94
+
+ gsü©ch2
+ =
+r6
+;
+
+2386
+Regi¡\94
+
+ gËá
+ =
+r4
+;
+
+2387
+Regi¡\94
+
+ gright
+ =
+r3
+;
+
+2388
+__
+
+pÝ
+(
+Ëá
+);
+
+2391
+__
+
+Üx
+(
+sü©ch1
+,
+Ëá
+,
+right
+);
+
+2392
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+2393
+JumpP©chS\99e
+
+·tch_s\99e
+(
+masm_
+);
+
+2394
+ g·tch_s\99e
+.
+Em\99JumpIfSmi
+(
+sü©ch1
+, &
+smi_ÿ£
+);
+
+2396
+__
+
+b\9ad
+(&
+¡ub_ÿÎ
+);
+
+2397
+ gHªdË
+<
+ gCode
+>
+ gcode
+ =
+CodeFaùÜy
+::
+B\9a¬yOpIC
+(
+isީe
+(),
+Ý
+,
+mode
+).
+code
+();
+
+2398
+C®lIC
+(
+code
+,
+ex´
+->
+B\9a¬yO³¿tiÚF\93dbackId
+());
+
+2399
+ g·tch_s\99e
+.
+Em\99P©chInfo
+();
+
+2400
+__
+
+b
+(&
+dÚe
+);
+
+2402
+__
+
+b\9ad
+(&
+smi_ÿ£
+);
+
+2405 \1a
+ gÝ
+) {
+
+2406 \ 4
+ gTok\92
+::
+SAR
+:
+
+2407
+__
+
+G\91L\97¡B\99sFromSmi
+(
+sü©ch1
+,
+right
+, 5);
+
+2408
+__
+
+ShiáRightAr\99h
+(
+right
+,
+Ëá
+,
+sü©ch1
+);
+
+2409
+__
+
+CˬRightImm
+(
+right
+,\84ight,
+O³¿nd
+(
+kSmiTagSize
+ +
+kSmiShiáSize
+));
+
+2411 \ 4
+ gTok\92
+::
+SHL
+: {
+
+2412
+__
+
+G\91L\97¡B\99sFromSmi
+(
+sü©ch2
+,
+right
+, 5);
+
+2413 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2414
+__
+
+ShiáLeá_
+(
+right
+,
+Ëá
+,
+sü©ch2
+);
+
+2416
+__
+
+SmiUÁag
+(
+sü©ch1
+,
+Ëá
+);
+
+2417
+__
+
+ShiáLeá_
+(
+sü©ch1
+, sü©ch1,
+sü©ch2
+);
+
+2419
+__
+
+JumpIfNÙSmiCªdid©e
+(
+sü©ch1
+,
+sü©ch2
+, &
+¡ub_ÿÎ
+);
+
+2420
+__
+
+SmiTag
+(
+right
+,
+sü©ch1
+);
+
+2424 \ 4
+ gTok\92
+::
+SHR
+: {
+
+2425
+__
+
+SmiUÁag
+(
+sü©ch1
+,
+Ëá
+);
+
+2426
+__
+
+G\91L\97¡B\99sFromSmi
+(
+sü©ch2
+,
+right
+, 5);
+
+2427
+__
+
+¤w
+(
+sü©ch1
+, sü©ch1,
+sü©ch2
+);
+
+2429
+__
+
+JumpIfNÙUnsigÃdSmiCªdid©e
+(
+sü©ch1
+,
+r0
+, &
+¡ub_ÿÎ
+);
+
+2430
+__
+
+SmiTag
+(
+right
+,
+sü©ch1
+);
+
+2433 \ 4
+ gTok\92
+::
+ADD
+: {
+
+2434
+__
+
+AddAndCheckFÜOv\94æow
+(
+sü©ch1
+,
+Ëá
+,
+right
+,
+sü©ch2
+,
+r0
+);
+
+2435
+__
+
+bÃ
+(&
+¡ub_ÿÎ
+,
+ü0
+);
+
+2436
+__
+
+mr
+(
+right
+,
+sü©ch1
+);
+
+2439 \ 4
+ gTok\92
+::
+SUB
+: {
+
+2440
+__
+
+SubAndCheckFÜOv\94æow
+(
+sü©ch1
+,
+Ëá
+,
+right
+,
+sü©ch2
+,
+r0
+);
+
+2441
+__
+
+bÃ
+(&
+¡ub_ÿÎ
+,
+ü0
+);
+
+2442
+__
+
+mr
+(
+right
+,
+sü©ch1
+);
+
+2445 \ 4
+ gTok\92
+::
+MUL
+: {
+
+2446
+Lab\96
+
+mul_z\94o
+;
+
+2447 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2449
+__
+
+SmiUÁag
+(
+\9d
+,
+right
+);
+
+2450
+__
+
+SmiUÁag
+(
+r0
+,
+Ëá
+);
+
+2451
+__
+
+Mul
+(
+sü©ch1
+,
+r0
+,
+\9d
+);
+
+2454
+__
+
+Te¡IfIÁ32
+(
+sü©ch1
+,
+sü©ch2
+,
+\9d
+);
+
+2455
+__
+
+bÃ
+(&
+¡ub_ÿÎ
+);
+
+2457
+__
+
+SmiUÁag
+(
+\9d
+,
+right
+);
+
+2458
+__
+
+muÎw
+(
+sü©ch1
+,
+Ëá
+,
+\9d
+);
+
+2459
+__
+
+mulhw
+(
+sü©ch2
+,
+Ëá
+,
+\9d
+);
+
+2462
+__
+
+Te¡IfIÁ32
+(
+sü©ch2
+,
+sü©ch1
+,
+\9d
+);
+
+2463
+__
+
+bÃ
+(&
+¡ub_ÿÎ
+);
+
+2466
+__
+
+cmpi
+(
+sü©ch1
+,
+O³¿nd
+::
+Z\94o
+());
+
+2467
+__
+
+beq
+(&
+mul_z\94o
+);
+
+2468 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2469
+__
+
+SmiTag
+(
+right
+,
+sü©ch1
+);
+
+2471
+__
+
+mr
+(
+right
+,
+sü©ch1
+);
+
+2473
+__
+
+b
+(&
+dÚe
+);
+
+2476
+__
+
+b\9ad
+(&
+mul_z\94o
+);
+
+2477
+__
+
+add
+(
+sü©ch2
+,
+right
+,
+Ëá
+);
+
+2478
+__
+
+cmpi
+(
+sü©ch2
+,
+O³¿nd
+::
+Z\94o
+());
+
+2479
+__
+
+bÉ
+(&
+¡ub_ÿÎ
+);
+
+2480
+__
+
+LßdSmiL\99\94®
+(
+right
+,
+Smi
+::
+FromIÁ
+(0));
+
+2483 \ 4
+ gTok\92
+::
+BIT_OR
+:
+
+2484
+__
+
+Üx
+(
+right
+,
+Ëá
+,\84ight);
+
+2486 \ 4
+ gTok\92
+::
+BIT_AND
+:
+
+2487
+__
+
+ªd_
+(
+right
+,
+Ëá
+,\84ight);
+
+2489 \ 4
+ gTok\92
+::
+BIT_XOR
+:
+
+2490
+__
+
+xÜ_
+(
+right
+,
+Ëá
+,\84ight);
+
+2493
+UNREACHABLE
+();
+
+2496
+__
+
+b\9ad
+(&
+dÚe
+);
+
+2497
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+2501 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99CÏssDef\9aePrÝ\94t\9bs
+(
+CÏssL\99\94®
+*
+l\99
+) {
+
+2503
+DCHECK
+(
+l\99
+ !ð
+NULL
+);
+
+2504
+__
+
+push
+(
+r3
+);
+
+2508
+Regi¡\94
+
+ gsü©ch
+ =
+r4
+;
+
+2509
+__
+
+LßdP
+(
+sü©ch
+,
+
+2510
+F\9bldMemO³¿nd
+(
+r3
+,
+JSFunùiÚ
+::
+kPrÙÙy³OrIn\99\9flMOff£t
+));
+
+2511
+__
+
+push
+(
+sü©ch
+);
+
+2513 \ f\12
+ gi
+ = 0; i <
+ gl\99
+->
+´Ý\94t\9bs
+()->
+Ëngth
+(); i++) {
+
+2514
+ gObjeùL\99\94®
+::
+Prݔty
+*
+´Ý\94ty
+ =
+l\99
+->
+´Ý\94t\9bs
+()->
+©
+(
+i
+);
+
+2515
+L\99\94®
+*
+ gkey
+ =
+´Ý\94ty
+->
+key
+()->
+AsL\99\94®
+();
+
+2516
+Ex´essiÚ
+*
+ gv®ue
+ =
+´Ý\94ty
+->
+v®ue
+();
+
+2517
+DCHECK
+(
+key
+ !ð
+NULL
+);
+
+2519 ià(
+ g´Ý\94ty
+->
+is_¡©ic
+()) {
+
+2520
+__
+
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+2522
+__
+
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+2524
+__
+
+push
+(
+sü©ch
+);
+
+2525
+Vis\99FÜS\8fckV®ue
+(
+key
+);
+
+2526
+Vis\99FÜS\8fckV®ue
+(
+v®ue
+);
+
+2528 \1a
+ g´Ý\94ty
+->
+k\9ad
+()) {
+
+2529 \ 4
+ gObjeùL\99\94®
+::
+Prݔty
+::
+CONSTANT
+:
+
+2530 \ 4
+ObjeùL\99\94®
+::
+Prݔty
+::
+MATERIALIZED_LITERAL
+:
+
+2531 \ 4
+ObjeùL\99\94®
+::
+Prݔty
+::
+COMPUTED
+:
+
+2532 \ 4
+ObjeùL\99\94®
+::
+Prݔty
+::
+PROTOTYPE
+:
+
+2533
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kDef\9aeCÏssM\91hod
+, 3);
+
+2536 \ 4
+ gObjeùL\99\94®
+::
+Prݔty
+::
+GETTER
+:
+
+2537
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kDef\9aeCÏssG\91\8br
+, 3);
+
+2540 \ 4
+ gObjeùL\99\94®
+::
+Prݔty
+::
+SETTER
+:
+
+2541
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kDef\9aeCÏssS\91\8br
+, 3);
+
+2545
+UNREACHABLE
+();
+
+2550
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kToFa¡PrÝ\94t\9bs
+, 1);
+
+2553
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kToFa¡PrÝ\94t\9bs
+, 1);
+
+2557 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99B\9a¬yOp
+(
+B\9a¬yO³¿tiÚ
+*
+ex´
+,
+Tok\92
+::
+V®ue
+
+Ý
+,
+
+2558
+Ov\94wr\99eMode
+
+mode
+) {
+
+2559
+__
+
+pÝ
+(
+r4
+);
+
+2560
+ gHªdË
+<
+ gCode
+>
+ gcode
+ =
+CodeFaùÜy
+::
+B\9a¬yOpIC
+(
+isީe
+(),
+Ý
+,
+mode
+).
+code
+();
+
+2561
+JumpP©chS\99e
+
+·tch_s\99e
+(
+masm_
+);
+
+2562
+C®lIC
+(
+code
+,
+ex´
+->
+B\9a¬yO³¿tiÚF\93dbackId
+());
+
+2563
+ g·tch_s\99e
+.
+Em\99P©chInfo
+();
+
+2564
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+2568 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99Assignm\92t
+(
+Ex´essiÚ
+*
+ex´
+) {
+
+2569
+DCHECK
+(
+ex´
+->
+IsV®idReã»nûEx´essiÚ
+());
+
+2571
+Prݔty
+*
+ g´Ý
+ =
+ex´
+->
+AsPrݔty
+();
+
+2572
+LhsK\9ad
+
+ gassign_ty³
+ =
+G\91AssignTy³
+(
+´Ý
+);
+
+2574 \1a
+ gassign_ty³
+) {
+
+2575 \ 4
+ gVARIABLE
+: {
+
+2576
+V¬\9fbË
+*
+v¬
+ =
+ex´
+->
+AsV¬\9fbËProxy
+()->var();
+
+2577
+EfãùCÚ\8bxt
+
+cڋxt
+(
+this
+);
+
+2578
+Em\99V¬\9fbËAssignm\92t
+(
+v¬
+,
+Tok\92
+::
+ASSIGN
+);
+
+2581 \ 4
+ gNAMED_PROPERTY
+: {
+
+2582
+__
+
+push
+(
+r3
+);
+
+2583
+Vis\99FÜAccumuÏtÜV®ue
+(
+´Ý
+->
+obj
+());
+
+2584
+__
+
+Move
+(
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+r3
+);
+
+2585
+__
+
+pÝ
+(
+StÜeDesü\9dtÜ
+::
+V®ueRegi¡\94
+());
+
+2586
+__
+
+mov
+(
+StÜeDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+
+2587
+O³¿nd
+(
+´Ý
+->
+key
+()->
+AsL\99\94®
+()->
+v®ue
+()));
+
+2588
+C®lStÜeIC
+();
+
+2591 \ 4
+ gNAMED_SUPER_PROPERTY
+: {
+
+2592
+__
+
+Push
+(
+r3
+);
+
+2593
+Vis\99FÜS\8fckV®ue
+(
+´Ý
+->
+obj
+()->
+AsSu³rReã»nû
+()->
+this_v¬
+());
+
+2594
+Em\99LßdHomeObjeù
+(
+´Ý
+->
+obj
+()->
+AsSu³rReã»nû
+());
+
+2596
+Regi¡\94
+
+ gsü©ch
+ =
+r5
+;
+
+2597
+Regi¡\94
+
+ gsü©ch2
+ =
+r6
+;
+
+2598
+__
+
+mr
+(
+sü©ch
+,
+»suÉ_»gi¡\94
+());
+
+2599
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+2600
+__
+
+LßdP
+(
+sü©ch2
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+2601
+__
+
+StÜeP
+(
+sü©ch2
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+2602
+__
+
+StÜeP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+2604
+Em\99NamedSu³rPrÝ\94tyStÜe
+(
+´Ý
+);
+
+2607 \ 4
+ gKEYED_SUPER_PROPERTY
+: {
+
+2608
+__
+
+Push
+(
+r3
+);
+
+2609
+Vis\99FÜS\8fckV®ue
+(
+´Ý
+->
+obj
+()->
+AsSu³rReã»nû
+()->
+this_v¬
+());
+
+2610
+Em\99LßdHomeObjeù
+(
+´Ý
+->
+obj
+()->
+AsSu³rReã»nû
+());
+
+2611
+__
+
+Push
+(
+»suÉ_»gi¡\94
+());
+
+2612
+Vis\99FÜAccumuÏtÜV®ue
+(
+´Ý
+->
+key
+());
+
+2613
+Regi¡\94
+
+ gsü©ch
+ =
+r5
+;
+
+2614
+Regi¡\94
+
+ gsü©ch2
+ =
+r6
+;
+
+2615
+__
+
+LßdP
+(
+sü©ch2
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+2617
+__
+
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+2618
+__
+
+StÜeP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+2619
+__
+
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+2620
+__
+
+StÜeP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+2621
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+2622
+__
+
+Move
+(
+r3
+,
+sü©ch2
+);
+
+2624
+Em\99KeyedSu³rPrÝ\94tyStÜe
+(
+´Ý
+);
+
+2627 \ 4
+ gKEYED_PROPERTY
+: {
+
+2628
+__
+
+push
+(
+r3
+);
+
+2629
+Vis\99FÜS\8fckV®ue
+(
+´Ý
+->
+obj
+());
+
+2630
+Vis\99FÜAccumuÏtÜV®ue
+(
+´Ý
+->
+key
+());
+
+2631
+__
+
+Move
+(
+StÜeDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+r3
+);
+
+2632
+__
+
+PÝ
+(
+StÜeDesü\9dtÜ
+::
+V®ueRegi¡\94
+(),
+
+2633
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+());
+
+2634
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+
+2635
+CodeFaùÜy
+::
+KeyedStÜeIC
+(
+isީe
+(),
+¡riù_mode
+()).
+code
+();
+
+2636
+C®lIC
+(
+ic
+);
+
+2640
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+2644 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99StÜeToS\8fckLoÿlOrCÚ\8bxtSlÙ
+(
+
+2645
+V¬\9fbË
+*
+v¬
+,
+MemO³¿nd
+
+loÿtiÚ
+) {
+
+2646
+__
+
+StÜeP
+(
+»suÉ_»gi¡\94
+(),
+loÿtiÚ
+,
+r0
+);
+
+2647 ià(
+ gv¬
+->
+IsCÚ\8bxtSlÙ
+()) {
+
+2649
+__
+
+mr
+(
+r6
+,
+»suÉ_»gi¡\94
+());
+
+2650 \12
+ goff£t
+ =
+Cڋxt
+::
+SlÙOff£t
+(
+v¬
+->
+\9adex
+());
+
+2651
+__
+
+RecÜdWr\99eCÚ\8bxtSlÙ
+(
+r4
+,
+off£t
+,
+r6
+,
+r5
+,
+kLRHasB\93nSaved
+,
+
+2652
+kDÚtSaveFPRegs
+);
+
+2657 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99V¬\9fbËAssignm\92t
+(
+V¬\9fbË
+*
+v¬
+,
+Tok\92
+::
+V®ue
+
+Ý
+) {
+
+2658 ià(
+v¬
+->
+IsUÇÎoÿ\8bd
+()) {
+
+2660
+__
+
+mov
+(
+StÜeDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+O³¿nd
+(
+v¬
+->
+Çme
+()));
+
+2661
+__
+
+LßdP
+(
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+Glob®ObjeùO³¿nd
+());
+
+2662
+C®lStÜeIC
+();
+
+2664 } \vià(
+ gÝ
+ =ð
+Tok\92
+::
+INIT_CONST_LEGACY
+) {
+
+2666
+DCHECK
+(!
+v¬
+->
+IsP¬am\91\94
+());
+
+2667 ià(
+ gv¬
+->
+IsLookupSlÙ
+()) {
+
+2668
+__
+
+push
+(
+r3
+);
+
+2669
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+v¬
+->
+Çme
+()));
+
+2670
+__
+
+Push
+(
+ý
+,
+r3
+);
+
+2671
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kIn\99\9flizeLegacyCÚ¡LookupSlÙ
+, 3);
+
+2673
+DCHECK
+(
+v¬
+->
+IsS\8fckAÎoÿ\8bd
+(è|| v¬->
+IsCÚ\8bxtSlÙ
+());
+
+2674
+Lab\96
+
+ gsk\9d
+;
+
+2675
+MemO³¿nd
+
+ gloÿtiÚ
+ =
+V¬O³¿nd
+(
+v¬
+,
+r4
+);
+
+2676
+__
+
+LßdP
+(
+r5
+,
+loÿtiÚ
+);
+
+2677
+__
+
+Com·»RoÙ
+(
+r5
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+2678
+__
+
+bÃ
+(&
+sk\9d
+);
+
+2679
+Em\99StÜeToS\8fckLoÿlOrCÚ\8bxtSlÙ
+(
+v¬
+,
+loÿtiÚ
+);
+
+2680
+__
+
+b\9ad
+(&
+sk\9d
+);
+
+2683 } \vià(
+ gv¬
+->
+mode
+(è=ð
+LET
+ &&
+Ý
+ !ð
+Tok\92
+::
+INIT_LET
+) {
+
+2685
+DCHECK
+(!
+v¬
+->
+IsLookupSlÙ
+());
+
+2686
+DCHECK
+(
+v¬
+->
+IsS\8fckAÎoÿ\8bd
+(è|| v¬->
+IsCÚ\8bxtSlÙ
+());
+
+2687
+Lab\96
+
+ gassign
+;
+
+2688
+MemO³¿nd
+
+ gloÿtiÚ
+ =
+V¬O³¿nd
+(
+v¬
+,
+r4
+);
+
+2689
+__
+
+LßdP
+(
+r6
+,
+loÿtiÚ
+);
+
+2690
+__
+
+Com·»RoÙ
+(
+r6
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+2691
+__
+
+bÃ
+(&
+assign
+);
+
+2692
+__
+
+mov
+(
+r6
+,
+O³¿nd
+(
+v¬
+->
+Çme
+()));
+
+2693
+__
+
+push
+(
+r6
+);
+
+2694
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kThrowReã»nûE¼Ü
+, 1);
+
+2696
+__
+
+b\9ad
+(&
+assign
+);
+
+2697
+Em\99StÜeToS\8fckLoÿlOrCÚ\8bxtSlÙ
+(
+v¬
+,
+loÿtiÚ
+);
+
+2699 } \vià(!
+ gv¬
+->
+is_cڡ_mode
+(è||
+ gÝ
+ =ð
+Tok\92
+::
+INIT_CONST
+) {
+
+2700 ià(
+v¬
+->
+IsLookupSlÙ
+()) {
+
+2702
+__
+
+push
+(
+r3
+);
+
+2703
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+v¬
+->
+Çme
+()));
+
+2704
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+Smi
+::
+FromIÁ
+(
+¡riù_mode
+())));
+
+2705
+__
+
+Push
+(
+ý
+,
+r4
+,
+r3
+);
+
+2706
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kStÜeLookupSlÙ
+, 4);
+
+2710
+DCHECK
+((
+v¬
+->
+IsS\8fckAÎoÿ\8bd
+(è|| v¬->
+IsCÚ\8bxtSlÙ
+()));
+
+2711
+MemO³¿nd
+
+ gloÿtiÚ
+ =
+V¬O³¿nd
+(
+v¬
+,
+r4
+);
+
+2712 ià(
+ gg\92\94©e_debug_code_
+ &&
+ gÝ
+ =ð
+Tok\92
+::
+INIT_LET
+) {
+
+2714
+__
+
+LßdP
+(
+r5
+,
+loÿtiÚ
+);
+
+2715
+__
+
+Com·»RoÙ
+(
+r5
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+2716
+__
+
+Check
+(
+eq
+,
+kL\91B\9ad\9agReIn\99\9fliz©iÚ
+);
+
+2718
+Em\99StÜeToS\8fckLoÿlOrCÚ\8bxtSlÙ
+(
+v¬
+,
+loÿtiÚ
+);
+
+2725 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99NamedPrÝ\94tyAssignm\92t
+(
+Assignm\92t
+*
+ex´
+) {
+
+2727
+Prݔty
+*
+´Ý
+ =
+ex´
+->
+\8frg\91
+()->
+AsPrݔty
+();
+
+2728
+DCHECK
+(
+´Ý
+ !ð
+NULL
+);
+
+2729
+DCHECK
+(
+´Ý
+->
+key
+()->
+IsL\99\94®
+());
+
+2732
+S\91SourûPos\99iÚ
+(
+ex´
+->
+pos\99iÚ
+());
+
+2733
+__
+
+mov
+(
+StÜeDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+
+2734
+O³¿nd
+(
+´Ý
+->
+key
+()->
+AsL\99\94®
+()->
+v®ue
+()));
+
+2735
+__
+
+pÝ
+(
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+());
+
+2736
+C®lStÜeIC
+(
+ex´
+->
+Assignm\92tF\93dbackId
+());
+
+2738
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+Assignm\92tId
+(),
+TOS_REG
+);
+
+2739
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+2743 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99NamedSu³rPrÝ\94tyStÜe
+(
+Prݔty
+*
+´Ý
+) {
+
+2747
+DCHECK
+(
+´Ý
+ !ð
+NULL
+);
+
+2748
+L\99\94®
+*
+ gkey
+ =
+´Ý
+->
+key
+()->
+AsL\99\94®
+();
+
+2749
+DCHECK
+(
+key
+ !ð
+NULL
+);
+
+2751
+__
+
+Push
+(
+key
+->
+v®ue
+());
+
+2752
+__
+
+Push
+(
+r3
+);
+
+2753
+__
+
+C®lRuÁime
+((
+¡riù_mode
+(è=ð
+STRICT
+ ?
+RuÁime
+::
+kStÜeToSu³r_S\8ciù
+
+
+2754 :
+RuÁime
+::
+kStÜeToSu³r_SlÝpy
+),
+
+2759 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99KeyedSu³rPrÝ\94tyStÜe
+(
+Prݔty
+*
+´Ý
+) {
+
+2763
+DCHECK
+(
+´Ý
+ !ð
+NULL
+);
+
+2765
+__
+
+Push
+(
+r3
+);
+
+2766
+__
+
+C®lRuÁime
+((
+¡riù_mode
+(è=ð
+STRICT
+ ?
+RuÁime
+::
+kStÜeKeyedToSu³r_S\8ciù
+
+
+2767 :
+RuÁime
+::
+kStÜeKeyedToSu³r_SlÝpy
+),
+
+2772 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99KeyedPrÝ\94tyAssignm\92t
+(
+Assignm\92t
+*
+ex´
+) {
+
+2776
+S\91SourûPos\99iÚ
+(
+ex´
+->
+pos\99iÚ
+());
+
+2777
+__
+
+PÝ
+(
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(), StÜeDesü\9dtÜ::
+NameRegi¡\94
+());
+
+2778
+DCHECK
+(
+StÜeDesü\9dtÜ
+::
+V®ueRegi¡\94
+().
+is
+(
+r3
+));
+
+2780
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+CodeFaùÜy
+::
+KeyedStÜeIC
+(
+isީe
+(),
+¡riù_mode
+()).
+code
+();
+
+2781
+C®lIC
+(
+ic
+,
+ex´
+->
+Assignm\92tF\93dbackId
+());
+
+2783
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+Assignm\92tId
+(),
+TOS_REG
+);
+
+2784
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+2788 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99PrÝ\94ty
+(
+Prݔty
+*
+ex´
+) {
+
+2789
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Property");
+
+2790
+Ex´essiÚ
+*
+ gkey
+ =
+ex´
+->
+key
+();
+
+2792 ià(
+ gkey
+->
+IsPrݔtyName
+()) {
+
+2793 ià(!
+ gex´
+->
+IsSu³rAcûss
+()) {
+
+2794
+Vis\99FÜAccumuÏtÜV®ue
+(
+ex´
+->
+obj
+());
+
+2795
+__
+
+Move
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+r3
+);
+
+2796
+Em\99NamedPrÝ\94tyLßd
+(
+ex´
+);
+
+2798
+Vis\99FÜS\8fckV®ue
+(
+ex´
+->
+obj
+()->
+AsSu³rReã»nû
+()->
+this_v¬
+());
+
+2799
+Em\99LßdHomeObjeù
+(
+ex´
+->
+obj
+()->
+AsSu³rReã»nû
+());
+
+2800
+__
+
+Push
+(
+»suÉ_»gi¡\94
+());
+
+2801
+Em\99NamedSu³rPrÝ\94tyLßd
+(
+ex´
+);
+
+2803
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+LßdId
+(),
+TOS_REG
+);
+
+2804
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+2806 ià(!
+ gex´
+->
+IsSu³rAcûss
+()) {
+
+2807
+Vis\99FÜS\8fckV®ue
+(
+ex´
+->
+obj
+());
+
+2808
+Vis\99FÜAccumuÏtÜV®ue
+(
+ex´
+->
+key
+());
+
+2809
+__
+
+Move
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+r3
+);
+
+2810
+__
+
+pÝ
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+());
+
+2811
+Em\99KeyedPrÝ\94tyLßd
+(
+ex´
+);
+
+2813
+Vis\99FÜS\8fckV®ue
+(
+ex´
+->
+obj
+()->
+AsSu³rReã»nû
+()->
+this_v¬
+());
+
+2814
+Em\99LßdHomeObjeù
+(
+ex´
+->
+obj
+()->
+AsSu³rReã»nû
+());
+
+2815
+__
+
+Push
+(
+»suÉ_»gi¡\94
+());
+
+2816
+Vis\99FÜS\8fckV®ue
+(
+ex´
+->
+key
+());
+
+2817
+Em\99KeyedSu³rPrÝ\94tyLßd
+(
+ex´
+);
+
+2819
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+2824 \1e
+ gFuÎCodeG\92\94©Ü
+::
+C®lIC
+(
+HªdË
+<
+Code
+>
+code
+,
+Ty³F\93dbackId
+
+a¡_id
+) {
+
+2825
+ gic_tÙ®_couÁ_
+++;
+
+2826
+__
+
+C®l
+(
+code
+,
+R\96ocInfo
+::
+CODE_TARGET
+,
+a¡_id
+);
+
+2831 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99C®lW\99hLßdIC
+(
+C®l
+*
+ex´
+) {
+
+2832
+Ex´essiÚ
+*
+ÿÎ\93
+ =
+ex´
+->
+ex´essiÚ
+();
+
+2834
+ gC®lICS\8f\8b
+::
+C®lTy³
+
+ÿÎ_ty³
+ =
+
+2835
+ÿÎ\93
+->
+IsV¬\9fbËProxy
+(è?
+C®lICS\8f\8b
+::
+FUNCTION
+ : C®lICS\8f\8b::
+METHOD
+;
+
+2838 ià(
+ gÿÎ_ty³
+ =ð
+C®lICS\8f\8b
+::
+FUNCTION
+) {
+
+2840
+S\8fckV®ueCÚ\8bxt
+
+cڋxt
+(
+this
+);
+
+2841
+Em\99V¬\9fbËLßd
+(
+ÿÎ\93
+->
+AsV¬\9fbËProxy
+());
+
+2842
+P»·»FÜBa\9eout
+(
+ÿÎ\93
+,
+NO_REGISTERS
+);
+
+2846
+__
+
+Push
+(
+isީe
+()->
+çùÜy
+()->
+undef\9aed_v®ue
+());
+
+2849
+DCHECK
+(
+ÿÎ\93
+->
+IsPrݔty
+());
+
+2850
+DCHECK
+(!
+ÿÎ\93
+->
+AsPrݔty
+()->
+IsSu³rAcûss
+());
+
+2851
+__
+
+LßdP
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+MemO³¿nd
+(
+¥
+, 0));
+
+2852
+Em\99NamedPrÝ\94tyLßd
+(
+ÿÎ\93
+->
+AsPrݔty
+());
+
+2853
+P»·»FÜBa\9eoutFÜId
+(
+ÿÎ\93
+->
+AsPrݔty
+()->
+LßdId
+(),
+TOS_REG
+);
+
+2855
+__
+
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+2856
+__
+
+push
+(
+\9d
+);
+
+2857
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+2860
+Em\99C®l
+(
+ex´
+,
+ÿÎ_ty³
+);
+
+2864 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99Su³rC®lW\99hLßdIC
+(
+C®l
+*
+ex´
+) {
+
+2865
+Ex´essiÚ
+*
+ÿÎ\93
+ =
+ex´
+->
+ex´essiÚ
+();
+
+2866
+DCHECK
+(
+ÿÎ\93
+->
+IsPrݔty
+());
+
+2867
+Prݔty
+*
+ g´Ý
+ =
+ÿÎ\93
+->
+AsPrݔty
+();
+
+2868
+DCHECK
+(
+´Ý
+->
+IsSu³rAcûss
+());
+
+2870
+S\91SourûPos\99iÚ
+(
+´Ý
+->
+pos\99iÚ
+());
+
+2871
+L\99\94®
+*
+ gkey
+ =
+´Ý
+->
+key
+()->
+AsL\99\94®
+();
+
+2872
+DCHECK
+(!
+key
+->
+v®ue
+()->
+IsSmi
+());
+
+2874 cڡ
+Regi¡\94
+
+ gsü©ch
+ =
+r4
+;
+
+2875
+Su³rReã»nû
+*
+ gsu³r_»f
+ =
+´Ý
+->
+obj
+()->
+AsSu³rReã»nû
+();
+
+2876
+Em\99LßdHomeObjeù
+(
+su³r_»f
+);
+
+2877
+__
+
+mr
+(
+sü©ch
+,
+r3
+);
+
+2878
+Vis\99FÜAccumuÏtÜV®ue
+(
+su³r_»f
+->
+this_v¬
+());
+
+2879
+__
+
+Push
+(
+sü©ch
+,
+r3
+,\843, scratch);
+
+2880
+__
+
+Push
+(
+key
+->
+v®ue
+());
+
+2888
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kLßdFromSu³r
+, 3);
+
+2891
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+2896
+Em\99C®l
+(
+ex´
+,
+C®lICS\8f\8b
+::
+METHOD
+);
+
+2901 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99KeyedC®lW\99hLßdIC
+(
+C®l
+*
+ex´
+,
+Ex´essiÚ
+*
+key
+) {
+
+2903
+Vis\99FÜAccumuÏtÜV®ue
+(
+key
+);
+
+2905
+Ex´essiÚ
+*
+ gÿÎ\93
+ =
+ex´
+->
+ex´essiÚ
+();
+
+2908
+DCHECK
+(
+ÿÎ\93
+->
+IsPrݔty
+());
+
+2909
+__
+
+LßdP
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+MemO³¿nd
+(
+¥
+, 0));
+
+2910
+__
+
+Move
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+r3
+);
+
+2911
+Em\99KeyedPrÝ\94tyLßd
+(
+ÿÎ\93
+->
+AsPrݔty
+());
+
+2912
+P»·»FÜBa\9eoutFÜId
+(
+ÿÎ\93
+->
+AsPrݔty
+()->
+LßdId
+(),
+TOS_REG
+);
+
+2915
+__
+
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+2916
+__
+
+push
+(
+\9d
+);
+
+2917
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+2919
+Em\99C®l
+(
+ex´
+,
+C®lICS\8f\8b
+::
+METHOD
+);
+
+2923 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99KeyedSu³rC®lW\99hLßdIC
+(
+C®l
+*
+ex´
+) {
+
+2924
+Ex´essiÚ
+*
+ÿÎ\93
+ =
+ex´
+->
+ex´essiÚ
+();
+
+2925
+DCHECK
+(
+ÿÎ\93
+->
+IsPrݔty
+());
+
+2926
+Prݔty
+*
+ g´Ý
+ =
+ÿÎ\93
+->
+AsPrݔty
+();
+
+2927
+DCHECK
+(
+´Ý
+->
+IsSu³rAcûss
+());
+
+2929
+S\91SourûPos\99iÚ
+(
+´Ý
+->
+pos\99iÚ
+());
+
+2931 cڡ
+Regi¡\94
+
+ gsü©ch
+ =
+r4
+;
+
+2932
+Su³rReã»nû
+*
+ gsu³r_»f
+ =
+´Ý
+->
+obj
+()->
+AsSu³rReã»nû
+();
+
+2933
+Em\99LßdHomeObjeù
+(
+su³r_»f
+);
+
+2934
+__
+
+Push
+(
+r3
+);
+
+2935
+Vis\99FÜAccumuÏtÜV®ue
+(
+su³r_»f
+->
+this_v¬
+());
+
+2936
+__
+
+Push
+(
+r3
+);
+
+2937
+__
+
+Push
+(
+r3
+);
+
+2938
+__
+
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+ * 2));
+
+2939
+__
+
+Push
+(
+sü©ch
+);
+
+2940
+Vis\99FÜS\8fckV®ue
+(
+´Ý
+->
+key
+());
+
+2948
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kLßdKeyedFromSu³r
+, 3);
+
+2951
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+2956
+Em\99C®l
+(
+ex´
+,
+C®lICS\8f\8b
+::
+METHOD
+);
+
+2960 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99C®l
+(
+C®l
+*
+ex´
+,
+C®lICS\8f\8b
+::
+C®lTy³
+
+ÿÎ_ty³
+) {
+
+2962
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+2963 \12
+ g¬g_couÁ
+ =
+¬gs
+->
+Ëngth
+();
+
+2965
+P»£rvePos\99iÚScÝe
+
+scÝe
+(
+masm
+()->
+pos\99iÚs_»cÜd\94
+());
+
+2966 \ f\12
+ gi
+ = 0; i <
+ g¬g_couÁ
+; i++) {
+
+2967
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(
+i
+));
+
+2972
+S\91SourûPos\99iÚ
+(
+ex´
+->
+pos\99iÚ
+());
+
+2973
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+C®lIC
+::
+\9a\99\9flize_¡ub
+(
+isީe
+(),
+¬g_couÁ
+,
+ÿÎ_ty³
+);
+
+2974
+__
+
+LßdSmiL\99\94®
+(
+r6
+,
+SmiFromSlÙ
+(
+ex´
+->
+C®lF\93dbackSlÙ
+()));
+
+2975
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, (
+¬g_couÁ
+ + 1è*
+kPo\9a\8brSize
+),
+r0
+);
+
+2978
+C®lIC
+(
+ic
+);
+
+2980
+RecÜdJSR\91uºS\99e
+(
+ex´
+);
+
+2982
+__
+
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+2983
+cڋxt
+()->
+DrÝAndPlug
+(1,
+r3
+);
+
+2987 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99ResÞvePossiblyD\9ceùEv®
+(\12
+¬g_couÁ
+) {
+
+2989 ià(
+¬g_couÁ
+ > 0) {
+
+2990
+__
+
+LßdP
+(
+r8
+,
+MemO³¿nd
+(
+¥
+,
+¬g_couÁ
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+2992
+__
+
+LßdRoÙ
+(
+r8
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+2996
+__
+
+LßdP
+(
+r7
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+2999 \12
+ g»ûiv\94_off£t
+ = 2 +
+\9afo_
+->
+scÝe
+()->
+num_·¿m\91\94s
+();
+
+3000
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+å
+,
+»ûiv\94_off£t
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+3003
+__
+
+LßdSmiL\99\94®
+(
+r5
+,
+Smi
+::
+FromIÁ
+(
+¡riù_mode
+()));
+
+3006
+__
+
+LßdSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(
+scÝe
+()->
+¡¬t_pos\99iÚ
+()));
+
+3009
+__
+
+Push
+(
+r8
+,
+r7
+,
+r6
+,
+r5
+,
+r4
+);
+
+3010
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kResÞvePossiblyD\9ceùEv®
+, 6);
+
+3014 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99LßdSu³rCÚ¡ruùÜ
+(
+Su³rReã»nû
+*
+su³r_»f
+) {
+
+3015
+DCHECK
+(
+su³r_»f
+ !ð
+NULL
+);
+
+3016
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+3017
+__
+
+Push
+(
+r3
+);
+
+3018
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kG\91PrÙÙy³
+, 1);
+
+3022 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99C®l
+(
+C®l
+*
+ex´
+) {
+
+3023 #ifdeà
+DEBUG
+
+
+3026
+ex´
+->
+»tuº_is_»cÜded_
+ =
+çl£
+;
+
+3029
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Call");
+
+3030
+Ex´essiÚ
+*
+ gÿÎ\93
+ =
+ex´
+->
+ex´essiÚ
+();
+
+3031
+ gC®l
+::
+C®lTy³
+
+ÿÎ_ty³
+ =
+ex´
+->
+G\91C®lTy³
+(
+isީe
+());
+
+3033 ià(
+ gÿÎ_ty³
+ =ð
+C®l
+::
+POSSIBLY_EVAL_CALL
+) {
+
+3038
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3039 \12
+ g¬g_couÁ
+ =
+¬gs
+->
+Ëngth
+();
+
+3042
+P»£rvePos\99iÚScÝe
+
+pos_scÝe
+(
+masm
+()->
+pos\99iÚs_»cÜd\94
+());
+
+3043
+Vis\99FÜS\8fckV®ue
+(
+ÿÎ\93
+);
+
+3044
+__
+
+LßdRoÙ
+(
+r5
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+3045
+__
+
+push
+(
+r5
+);
+
+3048 \ f\12
+ gi
+ = 0; i <
+ g¬g_couÁ
+; i++) {
+
+3049
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(
+i
+));
+
+3054
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, (
+¬g_couÁ
+ + 1è*
+kPo\9a\8brSize
+),
+r0
+);
+
+3055
+__
+
+push
+(
+r4
+);
+
+3056
+Em\99ResÞvePossiblyD\9ceùEv®
+(
+¬g_couÁ
+);
+
+3060
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+, (
+¬g_couÁ
+ + 1è*
+kPo\9a\8brSize
+),
+r0
+);
+
+3061
+__
+
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+,
+¬g_couÁ
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+3063
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+Ev®OrLookupId
+(),
+NO_REGISTERS
+);
+
+3067
+S\91SourûPos\99iÚ
+(
+ex´
+->
+pos\99iÚ
+());
+
+3068
+C®lFunùiÚStub
+
+¡ub
+(
+isީe
+(),
+¬g_couÁ
+,
+NO_CALL_FUNCTION_FLAGS
+);
+
+3069
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, (
+¬g_couÁ
+ + 1è*
+kPo\9a\8brSize
+),
+r0
+);
+
+3070
+__
+
+C®lStub
+(&
+¡ub
+);
+
+3071
+RecÜdJSR\91uºS\99e
+(
+ex´
+);
+
+3073
+__
+
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+3074
+cڋxt
+()->
+DrÝAndPlug
+(1,
+r3
+);
+
+3075 } \vià(
+ gÿÎ_ty³
+ =ð
+C®l
+::
+GLOBAL_CALL
+) {
+
+3076
+Em\99C®lW\99hLßdIC
+(
+ex´
+);
+
+3078 } \vià(
+ gÿÎ_ty³
+ =ð
+C®l
+::
+LOOKUP_SLOT_CALL
+) {
+
+3080
+V¬\9fbËProxy
+*
+´oxy
+ =
+ÿÎ\93
+->
+AsV¬\9fbËProxy
+();
+
+3081
+Lab\96
+
+ g¦ow
+,
+ gdÚe
+;
+
+3084
+P»£rvePos\99iÚScÝe
+
+scÝe
+(
+masm
+()->
+pos\99iÚs_»cÜd\94
+());
+
+3087
+Em\99DyÇmicLookupFa¡Ca£
+(
+´oxy
+,
+NOT_INSIDE_TYPEOF
+, &
+¦ow
+, &
+dÚe
+);
+
+3090
+__
+
+b\9ad
+(&
+¦ow
+);
+
+3093
+DCHECK
+(!
+cÚ\8bxt_»gi¡\94
+().
+is
+(
+r5
+));
+
+3094
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+´oxy
+->
+Çme
+()));
+
+3095
+__
+
+Push
+(
+cÚ\8bxt_»gi¡\94
+(),
+r5
+);
+
+3096
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kLßdLookupSlÙ
+, 2);
+
+3097
+__
+
+Push
+(
+r3
+,
+r4
+);
+
+3098
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+Ev®OrLookupId
+(),
+NO_REGISTERS
+);
+
+3103 ià(
+ gdÚe
+.
+is_l\9aked
+()) {
+
+3104
+Lab\96
+
+ gÿÎ
+;
+
+3105
+__
+
+b
+(&
+ÿÎ
+);
+
+3106
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3108
+__
+
+push
+(
+r3
+);
+
+3111
+__
+
+LßdRoÙ
+(
+r4
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+3112
+__
+
+push
+(
+r4
+);
+
+3113
+__
+
+b\9ad
+(&
+ÿÎ
+);
+
+3118
+Em\99C®l
+(
+ex´
+);
+
+3119 } \vià(
+ gÿÎ_ty³
+ =ð
+C®l
+::
+PROPERTY_CALL
+) {
+
+3120
+Prݔty
+*
+´Ý\94ty
+ =
+ÿÎ\93
+->
+AsPrݔty
+();
+
+3121
+boÞ
+
+ gis_Çmed_ÿÎ
+ =
+´Ý\94ty
+->
+key
+()->
+IsPrݔtyName
+();
+
+3122 ià(
+ g´Ý\94ty
+->
+IsSu³rAcûss
+()) {
+
+3123 ià(
+ gis_Çmed_ÿÎ
+) {
+
+3124
+Em\99Su³rC®lW\99hLßdIC
+(
+ex´
+);
+
+3126
+Em\99KeyedSu³rC®lW\99hLßdIC
+(
+ex´
+);
+
+3130
+P»£rvePos\99iÚScÝe
+
+scÝe
+(
+masm
+()->
+pos\99iÚs_»cÜd\94
+());
+
+3131
+Vis\99FÜS\8fckV®ue
+(
+´Ý\94ty
+->
+obj
+());
+
+3133 ià(
+ gis_Çmed_ÿÎ
+) {
+
+3134
+Em\99C®lW\99hLßdIC
+(
+ex´
+);
+
+3136
+Em\99KeyedC®lW\99hLßdIC
+(
+ex´
+,
+´Ý\94ty
+->
+key
+());
+
+3139 } \vià(
+ gÿÎ_ty³
+ =ð
+C®l
+::
+SUPER_CALL
+) {
+
+3140
+Su³rReã»nû
+*
+su³r_»f
+ =
+ÿÎ\93
+->
+AsSu³rReã»nû
+();
+
+3141
+Em\99LßdSu³rCÚ¡ruùÜ
+(
+su³r_»f
+);
+
+3142
+__
+
+Push
+(
+»suÉ_»gi¡\94
+());
+
+3143
+Vis\99FÜS\8fckV®ue
+(
+su³r_»f
+->
+this_v¬
+());
+
+3144
+Em\99C®l
+(
+ex´
+,
+C®lICS\8f\8b
+::
+METHOD
+);
+
+3146
+DCHECK
+(
+ÿÎ_ty³
+ =ð
+C®l
+::
+OTHER_CALL
+);
+
+3149
+P»£rvePos\99iÚScÝe
+
+scÝe
+(
+masm
+()->
+pos\99iÚs_»cÜd\94
+());
+
+3150
+Vis\99FÜS\8fckV®ue
+(
+ÿÎ\93
+);
+
+3152
+__
+
+LßdRoÙ
+(
+r4
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+3153
+__
+
+push
+(
+r4
+);
+
+3155
+Em\99C®l
+(
+ex´
+);
+
+3158 #ifdeà
+DEBUG
+
+
+3160
+DCHECK
+(
+ex´
+->
+»tuº_is_»cÜded_
+);
+
+3165 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99C®lNew
+(
+C®lNew
+*
+ex´
+) {
+
+3166
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ CallNew");
+
+3174 ià(
+ gex´
+->
+ex´essiÚ
+()->
+IsSu³rReã»nû
+()) {
+
+3175
+Em\99LßdSu³rCÚ¡ruùÜ
+(
+ex´
+->
+ex´essiÚ
+()->
+AsSu³rReã»nû
+());
+
+3176
+__
+
+Push
+(
+»suÉ_»gi¡\94
+());
+
+3178
+Vis\99FÜS\8fckV®ue
+(
+ex´
+->
+ex´essiÚ
+());
+
+3182
+ gZÚeLi¡
+<
+ gEx´essiÚ
+*>*
+ g¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3183 \12
+ g¬g_couÁ
+ =
+¬gs
+->
+Ëngth
+();
+
+3184 \ f\12
+ gi
+ = 0; i <
+ g¬g_couÁ
+; i++) {
+
+3185
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(
+i
+));
+
+3190
+S\91SourûPos\99iÚ
+(
+ex´
+->
+pos\99iÚ
+());
+
+3193
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+¬g_couÁ
+));
+
+3194
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+,
+¬g_couÁ
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+3197 ià(
+ gFLAG_´\91\92ur\9ag_ÿÎ_Ãw
+) {
+
+3198
+Ensu»SlÙCÚ\8f\9asAÎoÿtiÚS\99e
+(
+ex´
+->
+AÎoÿtiÚS\99eF\93dbackSlÙ
+());
+
+3199
+DCHECK
+(
+ex´
+->
+AÎoÿtiÚS\99eF\93dbackSlÙ
+().
+ToIÁ
+() ==
+
+3200
+ex´
+->
+C®lNewF\93dbackSlÙ
+().
+ToIÁ
+() + 1);
+
+3203
+__
+
+Move
+(
+r5
+,
+F\93dbackVeùÜ
+());
+
+3204
+__
+
+LßdSmiL\99\94®
+(
+r6
+,
+SmiFromSlÙ
+(
+ex´
+->
+C®lNewF\93dbackSlÙ
+()));
+
+3206
+C®lCÚ¡ruùStub
+
+¡ub
+(
+isީe
+(),
+RECORD_CONSTRUCTOR_TARGET
+);
+
+3207
+__
+
+C®l
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CONSTRUCT_CALL
+);
+
+3208
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+R\91uºId
+(),
+TOS_REG
+);
+
+3209
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+3213 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IsSmi
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3214
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3215
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3217
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3219
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+3220
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3221
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3222
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3223
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3224 &
+if_çl£
+, &
+çÎ_through
+);
+
+3226
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3227
+__
+
+Te¡IfSmi
+(
+r3
+,
+r0
+);
+
+3228
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+,
+ü0
+);
+
+3230
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3234 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IsNÚNeg©iveSmi
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3235
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3236
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3238
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3240
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+3241
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3242
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3243
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3244
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3245 &
+if_çl£
+, &
+çÎ_through
+);
+
+3247
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3248
+__
+
+Te¡IfPos\99iveSmi
+(
+r3
+,
+r0
+);
+
+3249
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+,
+ü0
+);
+
+3251
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3255 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IsObjeù
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3256
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3257
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3259
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3261
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+3262
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3263
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3264
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3265
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3266 &
+if_çl£
+, &
+çÎ_through
+);
+
+3268
+__
+
+JumpIfSmi
+(
+r3
+,
+if_çl£
+);
+
+3269
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+3270
+__
+
+cmp
+(
+r3
+,
+\9d
+);
+
+3271
+__
+
+beq
+(
+if_\8cue
+);
+
+3272
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3274
+__
+
+lbz
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+M
+::
+kB\99F\9bldOff£t
+));
+
+3275
+__
+
+ªdi
+(
+r0
+,
+r4
+,
+O³¿nd
+(1 <<
+M
+::
+kIsUnd\91eùabË
+));
+
+3276
+__
+
+bÃ
+(
+if_çl£
+,
+ü0
+);
+
+3277
+__
+
+lbz
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3278
+__
+
+cmpi
+(
+r4
+,
+O³¿nd
+(
+FIRST_NONCALLABLE_SPEC_OBJECT_TYPE
+));
+
+3279
+__
+
+bÉ
+(
+if_çl£
+);
+
+3280
+__
+
+cmpi
+(
+r4
+,
+O³¿nd
+(
+LAST_NONCALLABLE_SPEC_OBJECT_TYPE
+));
+
+3281
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3282
+S¶\99
+(
+Ë
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+3284
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3288 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IsS³cObjeù
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3289
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3290
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3292
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3294
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+3295
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3296
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3297
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3298
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3299 &
+if_çl£
+, &
+çÎ_through
+);
+
+3301
+__
+
+JumpIfSmi
+(
+r3
+,
+if_çl£
+);
+
+3302
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,\844,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+3303
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3304
+S¶\99
+(
+ge
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+3306
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3310 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IsUnd\91eùabËObjeù
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3311
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3312
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3314
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3316
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+3317
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3318
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3319
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3320
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3321 &
+if_çl£
+, &
+çÎ_through
+);
+
+3323
+__
+
+JumpIfSmi
+(
+r3
+,
+if_çl£
+);
+
+3324
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3325
+__
+
+lbz
+(
+r4
+,
+F\9bldMemO³¿nd
+Ô4,
+M
+::
+kB\99F\9bldOff£t
+));
+
+3326
+__
+
+ªdi
+(
+r0
+,
+r4
+,
+O³¿nd
+(1 <<
+M
+::
+kIsUnd\91eùabË
+));
+
+3327
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3328
+S¶\99
+(
+Ã
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+,
+ü0
+);
+
+3330
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3334 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IsS\8c\9agW¿µ\94SaãFÜDeçuÉV®ueOf
+(
+
+3335
+C®lRuÁime
+*
+ex´
+) {
+
+3336
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3337
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3339
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3341
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+,
+ gsk\9d_lookup
+;
+
+3342
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3343
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3344
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3345
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3346 &
+if_çl£
+, &
+çÎ_through
+);
+
+3348
+__
+
+As£¹NÙSmi
+(
+r3
+);
+
+3350
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3351
+__
+
+lbz
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+M
+::
+kB\99F\9bld2Off£t
+));
+
+3352
+__
+
+ªdi
+(
+r0
+,
+\9d
+,
+O³¿nd
+(1 <<
+M
+::
+kS\8c\9agW¿µ\94SaãFÜDeçuÉV®ueOf
+));
+
+3353
+__
+
+bÃ
+(&
+sk\9d_lookup
+,
+ü0
+);
+
+3356
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+JSObjeù
+::
+kPrÝ\94t\9bsOff£t
+));
+
+3357
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+Ô5,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3358
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kHashTabËMRoÙIndex
+);
+
+3359
+__
+
+cmp
+(
+r5
+,
+\9d
+);
+
+3360
+__
+
+beq
+(
+if_çl£
+);
+
+3365
+Lab\96
+
+ g\92\8cy
+,
+ gloÝ
+,
+ gdÚe
+;
+
+3368
+__
+
+Numb\94OfOwnDesü\9dtÜs
+(
+r6
+,
+r4
+);
+
+3369
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+::
+Z\94o
+());
+
+3370
+__
+
+beq
+(&
+dÚe
+);
+
+3372
+__
+
+LßdIn¡ªûDesü\9dtÜs
+(
+r4
+,
+r7
+);
+
+3375
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+Desü\9dtÜA¼ay
+::
+kDesü\9dtÜSize
+));
+
+3376
+__
+
+Mul
+(
+r6
+,\846,
+\9d
+);
+
+3378
+__
+
+addi
+(
+r7
+,\847,
+O³¿nd
+(
+Desü\9dtÜA¼ay
+::
+kF\9c¡Off£t
+ -
+kH\97pObjeùTag
+));
+
+3380
+__
+
+mr
+(
+r5
+,
+r7
+);
+
+3381
+__
+
+ShiáLeáImm
+(
+\9d
+,
+r6
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+3382
+__
+
+add
+(
+r5
+,\845,
+\9d
+);
+
+3388
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+v®ue_of_¡r\9ag
+()));
+
+3389
+__
+
+b
+(&
+\92\8cy
+);
+
+3390
+__
+
+b\9ad
+(&
+loÝ
+);
+
+3391
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+r7
+, 0));
+
+3392
+__
+
+cmp
+(
+r6
+,
+\9d
+);
+
+3393
+__
+
+beq
+(
+if_çl£
+);
+
+3394
+__
+
+addi
+(
+r7
+,\847,
+O³¿nd
+(
+Desü\9dtÜA¼ay
+::
+kDesü\9dtÜSize
+ *
+kPo\9a\8brSize
+));
+
+3395
+__
+
+b\9ad
+(&
+\92\8cy
+);
+
+3396
+__
+
+cmp
+(
+r7
+,
+r5
+);
+
+3397
+__
+
+bÃ
+(&
+loÝ
+);
+
+3399
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3402
+__
+
+lbz
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+M
+::
+kB\99F\9bld2Off£t
+));
+
+3403
+__
+
+Üi
+(
+r5
+,\845,
+O³¿nd
+(1 <<
+M
+::
+kS\8c\9agW¿µ\94SaãFÜDeçuÉV®ueOf
+));
+
+3404
+__
+
+¡b
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+M
+::
+kB\99F\9bld2Off£t
+));
+
+3406
+__
+
+b\9ad
+(&
+sk\9d_lookup
+);
+
+3410
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+M
+::
+kPrÙÙy³Off£t
+));
+
+3411
+__
+
+JumpIfSmi
+(
+r5
+,
+if_çl£
+);
+
+3412
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+Ô5,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3413
+__
+
+LßdP
+(
+r6
+,
+CÚ\8bxtO³¿nd
+(
+ý
+,
+Cڋxt
+::
+GLOBAL_OBJECT_INDEX
+));
+
+3414
+__
+
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+Ô6,
+Glob®Objeù
+::
+kN©iveCÚ\8bxtOff£t
+));
+
+3415
+__
+
+LßdP
+(
+r6
+,
+
+3416
+CÚ\8bxtO³¿nd
+(
+r6
+,
+Cڋxt
+::
+STRING_FUNCTION_PROTOTYPE_MAP_INDEX
+));
+
+3417
+__
+
+cmp
+(
+r5
+,
+r6
+);
+
+3418
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3419
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+3421
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3425 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IsFunùiÚ
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3426
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3427
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3429
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3431
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+3432
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3433
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3434
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3435
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3436 &
+if_çl£
+, &
+çÎ_through
+);
+
+3438
+__
+
+JumpIfSmi
+(
+r3
+,
+if_çl£
+);
+
+3439
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,
+r5
+,
+JS_FUNCTION_TYPE
+);
+
+3440
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3441
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+3443
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3447 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IsM\9ausZ\94o
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3448
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3449
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3451
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3453
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+3454
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3455
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3456
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3457
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3458 &
+if_çl£
+, &
+çÎ_through
+);
+
+3460
+__
+
+CheckM
+(
+r3
+,
+r4
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+,
+if_çl£
+,
+DO_SMI_CHECK
+);
+
+3461 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3462
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+3463
+__
+
+li
+(
+r5
+,
+O³¿nd
+(1));
+
+3464
+__
+
+rÙrdi
+(
+r5
+,\845, 1);
+
+3465
+__
+
+cmp
+(
+r4
+,
+r5
+);
+
+3467
+__
+
+lwz
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pNumb\94
+::
+kExpÚ\92tOff£t
+));
+
+3468
+__
+
+lwz
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pNumb\94
+::
+kMªtis§Off£t
+));
+
+3469
+Lab\96
+
+ gsk\9d
+;
+
+3470
+__
+
+lis
+(
+r0
+,
+O³¿nd
+(
+SIGN_EXT_IMM16
+(0x8000)));
+
+3471
+__
+
+cmp
+(
+r5
+,
+r0
+);
+
+3472
+__
+
+bÃ
+(&
+sk\9d
+);
+
+3473
+__
+
+cmpi
+(
+r4
+,
+O³¿nd
+::
+Z\94o
+());
+
+3474
+__
+
+b\9ad
+(&
+sk\9d
+);
+
+3477
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3478
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+3480
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3484 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IsA¼ay
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3485
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3486
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3488
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3490
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+3491
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3492
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3493
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3494
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3495 &
+if_çl£
+, &
+çÎ_through
+);
+
+3497
+__
+
+JumpIfSmi
+(
+r3
+,
+if_çl£
+);
+
+3498
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,\844,
+JS_ARRAY_TYPE
+);
+
+3499
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3500
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+3502
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3506 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IsRegExp
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3507
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3508
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3510
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3512
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+3513
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3514
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3515
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3516
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3517 &
+if_çl£
+, &
+çÎ_through
+);
+
+3519
+__
+
+JumpIfSmi
+(
+r3
+,
+if_çl£
+);
+
+3520
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,\844,
+JS_REGEXP_TYPE
+);
+
+3521
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3522
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+3524
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3528 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IsJSProxy
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3529
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3530
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3532
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3534
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+3535
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3536
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3537
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3538
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3539 &
+if_çl£
+, &
+çÎ_through
+);
+
+3541
+__
+
+JumpIfSmi
+(
+r3
+,
+if_çl£
+);
+
+3542
+Regi¡\94
+
+ gm
+ =
+r4
+;
+
+3543
+Regi¡\94
+
+ gty³_»g
+ =
+r5
+;
+
+3544
+__
+
+LßdP
+(
+m
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3545
+__
+
+lbz
+(
+ty³_»g
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3546
+__
+
+subi
+(
+ty³_»g
+,\81y³_»g,
+O³¿nd
+(
+FIRST_JS_PROXY_TYPE
+));
+
+3547
+__
+
+cm¶i
+(
+ty³_»g
+,
+O³¿nd
+(
+LAST_JS_PROXY_TYPE
+ -
+FIRST_JS_PROXY_TYPE
+));
+
+3548
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3549
+S¶\99
+(
+Ë
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+3551
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3555 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99IsCÚ¡ruùC®l
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3556
+DCHECK
+(
+ex´
+->
+¬gum\92ts
+()->
+Ëngth
+() == 0);
+
+3558
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+3559
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3560
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3561
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3562
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3563 &
+if_çl£
+, &
+çÎ_through
+);
+
+3566
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+3569
+Lab\96
+
+ gcheck_äame_m¬k\94
+;
+
+3570
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+r5
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+3571
+__
+
+CmpSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+),
+r0
+);
+
+3572
+__
+
+bÃ
+(&
+check_äame_m¬k\94
+);
+
+3573
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+Ô5,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+3576
+__
+
+b\9ad
+(&
+check_äame_m¬k\94
+);
+
+3577
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+r5
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kM¬k\94Off£t
+));
+
+3578
+STATIC_ASSERT
+(
+S\8fckF¿me
+::
+CONSTRUCT
+ < 0x4000);
+
+3579
+__
+
+CmpSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+CONSTRUCT
+),
+r0
+);
+
+3580
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3581
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+3583
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3587 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99ObjeùEqu®s
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3588
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3589
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 2);
+
+3592
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(0));
+
+3593
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(1));
+
+3595
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+3596
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+3597
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+3598
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+3599
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+3600 &
+if_çl£
+, &
+çÎ_through
+);
+
+3602
+__
+
+pÝ
+(
+r4
+);
+
+3603
+__
+
+cmp
+(
+r3
+,
+r4
+);
+
+3604
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+3605
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+3607
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+3611 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99Argum\92ts
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3612
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3613
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3617
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3618
+__
+
+mr
+(
+r4
+,
+r3
+);
+
+3619
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+\9afo_
+->
+scÝe
+()->
+num_·¿m\91\94s
+()));
+
+3620
+Argum\92tsAcûssStub
+
+¡ub
+(
+isީe
+(), Argum\92tsAcûssStub::
+READ_ELEMENT
+);
+
+3621
+__
+
+C®lStub
+(&
+¡ub
+);
+
+3622
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+3626 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99Argum\92tsL\92gth
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3627
+DCHECK
+(
+ex´
+->
+¬gum\92ts
+()->
+Ëngth
+() == 0);
+
+3628
+Lab\96
+
+ gex\99
+;
+
+3630
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+\9afo_
+->
+scÝe
+()->
+num_·¿m\91\94s
+()));
+
+3633
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+3634
+__
+
+LßdP
+(
+r6
+,
+MemO³¿nd
+(
+r5
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+3635
+__
+
+CmpSmiL\99\94®
+(
+r6
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+),
+r0
+);
+
+3636
+__
+
+bÃ
+(&
+ex\99
+);
+
+3640
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+r5
+,
+Argum\92tsAdtÜF¿meCÚ¡ªts
+::
+kL\92gthOff£t
+));
+
+3642
+__
+
+b\9ad
+(&
+ex\99
+);
+
+3643
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+3647 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99CÏssOf
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3648
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3649
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3650
+Lab\96
+
+ gdÚe
+,
+ gnuÎ
+,
+ gfunùiÚ
+,
+ gnÚ_funùiÚ_cÚ¡ruùÜ
+;
+
+3652
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3655
+__
+
+JumpIfSmi
+(
+r3
+, &
+nuÎ
+);
+
+3661
+STATIC_ASSERT
+(
+NUM_OF_CALLABLE_SPEC_OBJECT_TYPES
+ == 2);
+
+3662
+__
+
+Com·»ObjeùTy³
+(
+r3
+,\843,
+r4
+,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+3664
+__
+
+bÉ
+(&
+nuÎ
+);
+
+3665
+STATIC_ASSERT
+(
+FIRST_NONCALLABLE_SPEC_OBJECT_TYPE
+ ==
+
+3666
+FIRST_SPEC_OBJECT_TYPE
+ + 1);
+
+3667
+__
+
+beq
+(&
+funùiÚ
+);
+
+3669
+__
+
+cmpi
+(
+r4
+,
+O³¿nd
+(
+LAST_SPEC_OBJECT_TYPE
+));
+
+3670
+STATIC_ASSERT
+(
+LAST_NONCALLABLE_SPEC_OBJECT_TYPE
+ =ð
+LAST_SPEC_OBJECT_TYPE
+ - 1);
+
+3671
+__
+
+beq
+(&
+funùiÚ
+);
+
+3673
+STATIC_ASSERT
+(
+LAST_NONCALLABLE_SPEC_OBJECT_TYPE
+ =ð
+LAST_TYPE
+ - 1);
+
+3676
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+M
+::
+kCÚ¡ruùÜOff£t
+));
+
+3677
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,\844,
+JS_FUNCTION_TYPE
+);
+
+3678
+__
+
+bÃ
+(&
+nÚ_funùiÚ_cÚ¡ruùÜ
+);
+
+3682
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+3683
+__
+
+LßdP
+(
+r3
+,
+
+3684
+F\9bldMemO³¿nd
+(
+r3
+,
+Sh¬edFunùiÚInfo
+::
+kIn¡ªûCÏssNameOff£t
+));
+
+3685
+__
+
+b
+(&
+dÚe
+);
+
+3688
+__
+
+b\9ad
+(&
+funùiÚ
+);
+
+3689
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kFunùiÚ_¡r\9agRoÙIndex
+);
+
+3690
+__
+
+b
+(&
+dÚe
+);
+
+3693
+__
+
+b\9ad
+(&
+nÚ_funùiÚ_cÚ¡ruùÜ
+);
+
+3694
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kObjeù_¡r\9agRoÙIndex
+);
+
+3695
+__
+
+b
+(&
+dÚe
+);
+
+3698
+__
+
+b\9ad
+(&
+nuÎ
+);
+
+3699
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+3702
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3704
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+3708 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99SubS\8c\9ag
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3710
+SubS\8c\9agStub
+
+¡ub
+(
+isީe
+());
+
+3711
+ gZÚeLi¡
+<
+ gEx´essiÚ
+*>*
+ g¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3712
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 3);
+
+3713
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(0));
+
+3714
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(1));
+
+3715
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(2));
+
+3716
+__
+
+C®lStub
+(&
+¡ub
+);
+
+3717
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+3721 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99RegExpExec
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3723
+RegExpExecStub
+
+¡ub
+(
+isީe
+());
+
+3724
+ gZÚeLi¡
+<
+ gEx´essiÚ
+*>*
+ g¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3725
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 4);
+
+3726
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(0));
+
+3727
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(1));
+
+3728
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(2));
+
+3729
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(3));
+
+3730
+__
+
+C®lStub
+(&
+¡ub
+);
+
+3731
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+3735 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99V®ueOf
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3736
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3737
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3738
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3740
+Lab\96
+
+ gdÚe
+;
+
+3742
+__
+
+JumpIfSmi
+(
+r3
+, &
+dÚe
+);
+
+3744
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,\844,
+JS_VALUE_TYPE
+);
+
+3745
+__
+
+bÃ
+(&
+dÚe
+);
+
+3746
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+JSV®ue
+::
+kV®ueOff£t
+));
+
+3748
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3749
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+3753 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99D©eF\9bld
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3754
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3755
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 2);
+
+3756
+DCHECK_NE
+(
+NULL
+,
+¬gs
+->
+©
+(1)->
+AsL\99\94®
+());
+
+3757
+Smi
+*
+ g\9adex
+ = Smi::
+ÿ¡
+(*(
+¬gs
+->
+©
+(1)->
+AsL\99\94®
+()->
+v®ue
+()));
+
+3759
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3761
+Lab\96
+
+ gruÁime
+,
+ gdÚe
+,
+ gnÙ_d©e_objeù
+;
+
+3762
+Regi¡\94
+
+ gobjeù
+ =
+r3
+;
+
+3763
+Regi¡\94
+
+ g»suÉ
+ =
+r3
+;
+
+3764
+Regi¡\94
+
+ gsü©ch0
+ =
+r11
+;
+
+3765
+Regi¡\94
+
+ gsü©ch1
+ =
+r4
+;
+
+3767
+__
+
+JumpIfSmi
+(
+objeù
+, &
+nÙ_d©e_objeù
+);
+
+3768
+__
+
+Com·»ObjeùTy³
+(
+objeù
+,
+sü©ch1
+, sü©ch1,
+JS_DATE_TYPE
+);
+
+3769
+__
+
+bÃ
+(&
+nÙ_d©e_objeù
+);
+
+3771 ià(
+ g\9adex
+->
+v®ue
+() == 0) {
+
+3772
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+JSD©e
+::
+kV®ueOff£t
+));
+
+3773
+__
+
+b
+(&
+dÚe
+);
+
+3775 ià(
+ g\9adex
+->
+v®ue
+(è<
+ gJSD©e
+::
+kF\9c¡UnÿchedF\9bld
+) {
+
+3776
+Ex\8bº®Reã»nû
+
+¡amp
+ = Ex\8bº®Reã»nû::
+d©e_ÿche_¡amp
+(
+isީe
+());
+
+3777
+__
+
+mov
+(
+sü©ch1
+,
+O³¿nd
+(
+¡amp
+));
+
+3778
+__
+
+LßdP
+(
+sü©ch1
+,
+MemO³¿nd
+(scratch1));
+
+3779
+__
+
+LßdP
+(
+sü©ch0
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+JSD©e
+::
+kCacheS\8fmpOff£t
+));
+
+3780
+__
+
+cmp
+(
+sü©ch1
+,
+sü©ch0
+);
+
+3781
+__
+
+bÃ
+(&
+ruÁime
+);
+
+3782
+__
+
+LßdP
+(
+»suÉ
+,
+
+3783
+F\9bldMemO³¿nd
+(
+objeù
+,
+JSD©e
+::
+kV®ueOff£t
+ +
+
+3784
+kPo\9a\8brSize
+ *
+\9adex
+->
+v®ue
+()),
+
+3785
+sü©ch0
+);
+
+3786
+__
+
+b
+(&
+dÚe
+);
+
+3788
+__
+
+b\9ad
+(&
+ruÁime
+);
+
+3789
+__
+
+P»·»C®lCFunùiÚ
+(2,
+sü©ch1
+);
+
+3790
+__
+
+LßdSmiL\99\94®
+(
+r4
+,
+\9adex
+);
+
+3791
+__
+
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+::
+g\91_d©e_f\9bld_funùiÚ
+(
+isީe
+()), 2);
+
+3792
+__
+
+b
+(&
+dÚe
+);
+
+3795
+__
+
+b\9ad
+(&
+nÙ_d©e_objeù
+);
+
+3796
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kThrowNÙD©eE¼Ü
+, 0);
+
+3797
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3798
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+3802 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99OÃBy\8bSeqS\8c\9agS\91Ch¬
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3803
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3804
+DCHECK_EQ
+(3,
+¬gs
+->
+Ëngth
+());
+
+3806
+Regi¡\94
+
+ g¡r\9ag
+ =
+r3
+;
+
+3807
+Regi¡\94
+
+ g\9adex
+ =
+r4
+;
+
+3808
+Regi¡\94
+
+ gv®ue
+ =
+r5
+;
+
+3810
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(0));
+
+3811
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(1));
+
+3812
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(2));
+
+3813
+__
+
+PÝ
+(
+\9adex
+,
+v®ue
+);
+
+3815 ià(
+ gFLAG_debug_code
+) {
+
+3816
+__
+
+Te¡IfSmi
+(
+v®ue
+,
+r0
+);
+
+3817
+__
+
+Check
+(
+eq
+,
+kNÚSmiV®ue
+,
+ü0
+);
+
+3818
+__
+
+Te¡IfSmi
+(
+\9adex
+,
+r0
+);
+
+3819
+__
+
+Check
+(
+eq
+,
+kNÚSmiIndex
+,
+ü0
+);
+
+3820
+__
+
+SmiUÁag
+(
+\9adex
+, index);
+
+3821 \18cڡ
+u\9at32_t
+
+ gÚe_by\8b_£q_ty³
+ =
+kSeqS\8c\9agTag
+ |
+kOÃBy\8bS\8c\9agTag
+;
+
+3822
+__
+
+Em\99SeqS\8c\9agS\91Ch¬Check
+(
+¡r\9ag
+,
+\9adex
+,
+v®ue
+,
+Úe_by\8b_£q_ty³
+);
+
+3823
+__
+
+SmiTag
+(
+\9adex
+, index);
+
+3826
+__
+
+SmiUÁag
+(
+v®ue
+);
+
+3827
+__
+
+addi
+(
+\9d
+,
+¡r\9ag
+,
+O³¿nd
+(
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+3828
+__
+
+SmiToBy\8bA¼ayOff£t
+(
+r0
+,
+\9adex
+);
+
+3829
+__
+
+¡bx
+(
+v®ue
+,
+MemO³¿nd
+(
+\9d
+,
+r0
+));
+
+3830
+cڋxt
+()->
+Plug
+(
+¡r\9ag
+);
+
+3834 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99TwoBy\8bSeqS\8c\9agS\91Ch¬
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3835
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3836
+DCHECK_EQ
+(3,
+¬gs
+->
+Ëngth
+());
+
+3838
+Regi¡\94
+
+ g¡r\9ag
+ =
+r3
+;
+
+3839
+Regi¡\94
+
+ g\9adex
+ =
+r4
+;
+
+3840
+Regi¡\94
+
+ gv®ue
+ =
+r5
+;
+
+3842
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(0));
+
+3843
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(1));
+
+3844
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(2));
+
+3845
+__
+
+PÝ
+(
+\9adex
+,
+v®ue
+);
+
+3847 ià(
+ gFLAG_debug_code
+) {
+
+3848
+__
+
+Te¡IfSmi
+(
+v®ue
+,
+r0
+);
+
+3849
+__
+
+Check
+(
+eq
+,
+kNÚSmiV®ue
+,
+ü0
+);
+
+3850
+__
+
+Te¡IfSmi
+(
+\9adex
+,
+r0
+);
+
+3851
+__
+
+Check
+(
+eq
+,
+kNÚSmiIndex
+,
+ü0
+);
+
+3852
+__
+
+SmiUÁag
+(
+\9adex
+, index);
+
+3853 \18cڡ
+u\9at32_t
+
+ gtwo_by\8b_£q_ty³
+ =
+kSeqS\8c\9agTag
+ |
+kTwoBy\8bS\8c\9agTag
+;
+
+3854
+__
+
+Em\99SeqS\8c\9agS\91Ch¬Check
+(
+¡r\9ag
+,
+\9adex
+,
+v®ue
+,
+two_by\8b_£q_ty³
+);
+
+3855
+__
+
+SmiTag
+(
+\9adex
+, index);
+
+3858
+__
+
+SmiUÁag
+(
+v®ue
+);
+
+3859
+__
+
+addi
+(
+\9d
+,
+¡r\9ag
+,
+O³¿nd
+(
+SeqTwoBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+3860
+__
+
+SmiToShÜtA¼ayOff£t
+(
+r0
+,
+\9adex
+);
+
+3861
+__
+
+¡hx
+(
+v®ue
+,
+MemO³¿nd
+(
+\9d
+,
+r0
+));
+
+3862
+cڋxt
+()->
+Plug
+(
+¡r\9ag
+);
+
+3866 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99M©hPow
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3868
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3869
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 2);
+
+3870
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(0));
+
+3871
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(1));
+
+3872
+M©hPowStub
+
+¡ub
+(
+isީe
+(), M©hPowStub::
+ON_STACK
+);
+
+3873
+__
+
+C®lStub
+(&
+¡ub
+);
+
+3874
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+3878 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99S\91V®ueOf
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3879
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3880
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 2);
+
+3881
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(0));
+
+3882
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(1));
+
+3883
+__
+
+pÝ
+(
+r4
+);
+
+3885
+Lab\96
+
+ gdÚe
+;
+
+3887
+__
+
+JumpIfSmi
+(
+r4
+, &
+dÚe
+);
+
+3890
+__
+
+Com·»ObjeùTy³
+(
+r4
+,
+r5
+,\845,
+JS_VALUE_TYPE
+);
+
+3891
+__
+
+bÃ
+(&
+dÚe
+);
+
+3894
+__
+
+StÜeP
+(
+r3
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSV®ue
+::
+kV®ueOff£t
+),
+r0
+);
+
+3897
+__
+
+mr
+(
+r5
+,
+r3
+);
+
+3898
+__
+
+RecÜdWr\99eF\9bld
+(
+r4
+,
+JSV®ue
+::
+kV®ueOff£t
+,
+r5
+,
+r6
+,
+kLRHasB\93nSaved
+,
+
+3899
+kDÚtSaveFPRegs
+);
+
+3901
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3902
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+3906 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99Numb\94ToS\8c\9ag
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3907
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3908
+DCHECK_EQ
+(
+¬gs
+->
+Ëngth
+(), 1);
+
+3910
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3912
+Numb\94ToS\8c\9agStub
+
+¡ub
+(
+isީe
+());
+
+3913
+__
+
+C®lStub
+(&
+¡ub
+);
+
+3914
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+3918 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99S\8c\9agCh¬FromCode
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3919
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3920
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+3921
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+3923
+Lab\96
+
+ gdÚe
+;
+
+3924
+S\8c\9agCh¬FromCodeG\92\94©Ü
+
+g\92\94©Ü
+(
+r3
+,
+r4
+);
+
+3925
+ gg\92\94©Ü
+.
+G\92\94©eFa¡
+(
+masm_
+);
+
+3926
+__
+
+b
+(&
+dÚe
+);
+
+3928
+NÝRuÁimeC®lH\96³r
+
+ gÿÎ_h\96³r
+;
+
+3929
+ gg\92\94©Ü
+.
+G\92\94©eSlow
+(
+masm_
+,
+ÿÎ_h\96³r
+);
+
+3931
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3932
+cڋxt
+()->
+Plug
+(
+r4
+);
+
+3936 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99S\8c\9agCh¬CodeAt
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3937
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3938
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 2);
+
+3939
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(0));
+
+3940
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(1));
+
+3942
+Regi¡\94
+
+ gobjeù
+ =
+r4
+;
+
+3943
+Regi¡\94
+
+ g\9adex
+ =
+r3
+;
+
+3944
+Regi¡\94
+
+ g»suÉ
+ =
+r6
+;
+
+3946
+__
+
+pÝ
+(
+objeù
+);
+
+3948
+Lab\96
+
+ gÃed_cÚv\94siÚ
+;
+
+3949
+Lab\96
+
+ g\9adex_out_of_¿nge
+;
+
+3950
+Lab\96
+
+ gdÚe
+;
+
+3951
+S\8c\9agCh¬CodeAtG\92\94©Ü
+
+g\92\94©Ü
+(
+objeù
+,
+\9adex
+,
+»suÉ
+, &
+Ãed_cÚv\94siÚ
+,
+
+3952 &
+Ãed_cÚv\94siÚ
+, &
+\9adex_out_of_¿nge
+,
+
+3953
+STRING_INDEX_IS_NUMBER
+);
+
+3954
+ gg\92\94©Ü
+.
+G\92\94©eFa¡
+(
+masm_
+);
+
+3955
+__
+
+b
+(&
+dÚe
+);
+
+3957
+__
+
+b\9ad
+(&
+\9adex_out_of_¿nge
+);
+
+3960
+__
+
+LßdRoÙ
+(
+»suÉ
+,
+H\97p
+::
+kNªV®ueRoÙIndex
+);
+
+3961
+__
+
+b
+(&
+dÚe
+);
+
+3963
+__
+
+b\9ad
+(&
+Ãed_cÚv\94siÚ
+);
+
+3966
+__
+
+LßdRoÙ
+(
+»suÉ
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+3967
+__
+
+b
+(&
+dÚe
+);
+
+3969
+NÝRuÁimeC®lH\96³r
+
+ gÿÎ_h\96³r
+;
+
+3970
+ gg\92\94©Ü
+.
+G\92\94©eSlow
+(
+masm_
+,
+ÿÎ_h\96³r
+);
+
+3972
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3973
+cڋxt
+()->
+Plug
+(
+»suÉ
+);
+
+3977 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99S\8c\9agCh¬At
+(
+C®lRuÁime
+*
+ex´
+) {
+
+3978
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+3979
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 2);
+
+3980
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(0));
+
+3981
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(1));
+
+3983
+Regi¡\94
+
+ gobjeù
+ =
+r4
+;
+
+3984
+Regi¡\94
+
+ g\9adex
+ =
+r3
+;
+
+3985
+Regi¡\94
+
+ gsü©ch
+ =
+r6
+;
+
+3986
+Regi¡\94
+
+ g»suÉ
+ =
+r3
+;
+
+3988
+__
+
+pÝ
+(
+objeù
+);
+
+3990
+Lab\96
+
+ gÃed_cÚv\94siÚ
+;
+
+3991
+Lab\96
+
+ g\9adex_out_of_¿nge
+;
+
+3992
+Lab\96
+
+ gdÚe
+;
+
+3993
+S\8c\9agCh¬AtG\92\94©Ü
+
+g\92\94©Ü
+(
+objeù
+,
+\9adex
+,
+sü©ch
+,
+»suÉ
+,
+
+3994 &
+Ãed_cÚv\94siÚ
+, &need_conversion,
+
+3995 &
+\9adex_out_of_¿nge
+,
+STRING_INDEX_IS_NUMBER
+);
+
+3996
+ gg\92\94©Ü
+.
+G\92\94©eFa¡
+(
+masm_
+);
+
+3997
+__
+
+b
+(&
+dÚe
+);
+
+3999
+__
+
+b\9ad
+(&
+\9adex_out_of_¿nge
+);
+
+4002
+__
+
+LßdRoÙ
+(
+»suÉ
+,
+H\97p
+::
+kem±y_¡r\9agRoÙIndex
+);
+
+4003
+__
+
+b
+(&
+dÚe
+);
+
+4005
+__
+
+b\9ad
+(&
+Ãed_cÚv\94siÚ
+);
+
+4008
+__
+
+LßdSmiL\99\94®
+(
+»suÉ
+,
+Smi
+::
+FromIÁ
+(0));
+
+4009
+__
+
+b
+(&
+dÚe
+);
+
+4011
+NÝRuÁimeC®lH\96³r
+
+ gÿÎ_h\96³r
+;
+
+4012
+ gg\92\94©Ü
+.
+G\92\94©eSlow
+(
+masm_
+,
+ÿÎ_h\96³r
+);
+
+4014
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4015
+cڋxt
+()->
+Plug
+(
+»suÉ
+);
+
+4019 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99S\8c\9agAdd
+(
+C®lRuÁime
+*
+ex´
+) {
+
+4020
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+4021
+DCHECK_EQ
+(2,
+¬gs
+->
+Ëngth
+());
+
+4022
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(0));
+
+4023
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(1));
+
+4025
+__
+
+pÝ
+(
+r4
+);
+
+4026
+S\8c\9agAddStub
+
+¡ub
+(
+isީe
+(),
+STRING_ADD_CHECK_BOTH
+,
+NOT_TENURED
+);
+
+4027
+__
+
+C®lStub
+(&
+¡ub
+);
+
+4028
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4032 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99S\8c\9agCom·»
+(
+C®lRuÁime
+*
+ex´
+) {
+
+4033
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+4034
+DCHECK_EQ
+(2,
+¬gs
+->
+Ëngth
+());
+
+4035
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(0));
+
+4036
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(1));
+
+4038
+S\8c\9agCom·»Stub
+
+¡ub
+(
+isީe
+());
+
+4039
+__
+
+C®lStub
+(&
+¡ub
+);
+
+4040
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4044 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99C®lFunùiÚ
+(
+C®lRuÁime
+*
+ex´
+) {
+
+4045
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+4046
+DCHECK
+(
+¬gs
+->
+Ëngth
+() >= 2);
+
+4048 \12
+ g¬g_couÁ
+ =
+¬gs
+->
+Ëngth
+() - 2;
+
+4049 \ f\12
+ gi
+ = 0; i <
+ g¬g_couÁ
+ + 1; i++) {
+
+4050
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(
+i
+));
+
+4052
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+ϡ
+());
+
+4054
+Lab\96
+
+ gruÁime
+,
+ gdÚe
+;
+
+4056
+__
+
+JumpIfSmi
+(
+r3
+, &
+ruÁime
+);
+
+4057
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,\844,
+JS_FUNCTION_TYPE
+);
+
+4058
+__
+
+bÃ
+(&
+ruÁime
+);
+
+4061
+__
+
+mr
+(
+r4
+,
+»suÉ_»gi¡\94
+());
+
+4062
+P¬am\91\94CouÁ
+
+couÁ
+(
+¬g_couÁ
+);
+
+4063
+__
+
+InvokeFunùiÚ
+(
+r4
+,
+couÁ
+,
+CALL_FUNCTION
+,
+NuÎC®lW¿µ\94
+());
+
+4064
+__
+
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+4065
+__
+
+b
+(&
+dÚe
+);
+
+4067
+__
+
+b\9ad
+(&
+ruÁime
+);
+
+4068
+__
+
+push
+(
+r3
+);
+
+4069
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kC®l
+,
+¬gs
+->
+Ëngth
+());
+
+4070
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4072
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4076 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99RegExpCÚ¡ruùResuÉ
+(
+C®lRuÁime
+*
+ex´
+) {
+
+4077
+RegExpCÚ¡ruùResuÉStub
+
+¡ub
+(
+isީe
+());
+
+4078
+ gZÚeLi¡
+<
+ gEx´essiÚ
+*>*
+ g¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+4079
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 3);
+
+4080
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(0));
+
+4081
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(1));
+
+4082
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(2));
+
+4083
+__
+
+PÝ
+(
+r5
+,
+r4
+);
+
+4084
+__
+
+C®lStub
+(&
+¡ub
+);
+
+4085
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4089 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99G\91FromCache
+(
+C®lRuÁime
+*
+ex´
+) {
+
+4090
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+4091
+DCHECK_EQ
+(2,
+¬gs
+->
+Ëngth
+());
+
+4092
+DCHECK_NE
+(
+NULL
+,
+¬gs
+->
+©
+(0)->
+AsL\99\94®
+());
+
+4093 \12
+ gÿche_id
+ =
+Smi
+::
+ÿ¡
+(*(
+¬gs
+->
+©
+(0)->
+AsL\99\94®
+()->
+v®ue
+()))->value();
+
+4095
+ gHªdË
+<
+ gFixedA¼ay
+>
+jsfunùiÚ_»suÉ_ÿches
+(
+
+4096
+isީe
+()->
+Çtive_cÚ\8bxt
+()->
+jsfunùiÚ_»suÉ_ÿches
+());
+
+4097 ià(
+ gjsfunùiÚ_»suÉ_ÿches
+->
+Ëngth
+(è<ð
+ÿche_id
+) {
+
+4098
+__
+
+AbÜt
+(
+kA\89em±ToU£Undef\9aedCache
+);
+
+4099
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+4100
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4104
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(1));
+
+4106
+Regi¡\94
+
+ gkey
+ =
+r3
+;
+
+4107
+Regi¡\94
+
+ gÿche
+ =
+r4
+;
+
+4108
+__
+
+LßdP
+(
+ÿche
+,
+CÚ\8bxtO³¿nd
+(
+ý
+,
+Cڋxt
+::
+GLOBAL_OBJECT_INDEX
+));
+
+4109
+__
+
+LßdP
+(
+ÿche
+,
+F\9bldMemO³¿nd
+(ÿche,
+Glob®Objeù
+::
+kN©iveCÚ\8bxtOff£t
+));
+
+4110
+__
+
+LßdP
+(
+ÿche
+,
+
+4111
+CÚ\8bxtO³¿nd
+(
+ÿche
+,
+Cڋxt
+::
+JSFUNCTION_RESULT_CACHES_INDEX
+));
+
+4112
+__
+
+LßdP
+(
+ÿche
+,
+
+4113
+F\9bldMemO³¿nd
+(
+ÿche
+,
+FixedA¼ay
+::
+Off£tOfEËm\92tAt
+(
+ÿche_id
+)),
+r0
+);
+
+4115
+Lab\96
+
+ gdÚe
+,
+ gnÙ_found
+;
+
+4116
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+ÿche
+,
+JSFunùiÚResuÉCache
+::
+kF\9ag\94Off£t
+));
+
+4118
+__
+
+addi
+(
+r6
+,
+ÿche
+,
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+4120
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r5
+,\845);
+
+4121
+__
+
+LßdPUX
+(
+r5
+,
+MemO³¿nd
+(
+r6
+,\845));
+
+4123
+__
+
+cmp
+(
+key
+,
+r5
+);
+
+4124
+__
+
+bÃ
+(&
+nÙ_found
+);
+
+4126
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+r6
+,
+kPo\9a\8brSize
+));
+
+4127
+__
+
+b
+(&
+dÚe
+);
+
+4129
+__
+
+b\9ad
+(&
+nÙ_found
+);
+
+4131
+__
+
+Push
+(
+ÿche
+,
+key
+);
+
+4132
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kG\91FromCache
+, 2);
+
+4134
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4135
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4139 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99HasCachedA¼ayIndex
+(
+C®lRuÁime
+*
+ex´
+) {
+
+4140
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+4141
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+4143
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+4144
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+4145
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+4146
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+4147
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+4148 &
+if_çl£
+, &
+çÎ_through
+);
+
+4150
+__
+
+lwz
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+S\8c\9ag
+::
+kHashF\9bldOff£t
+));
+
+4152
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+S\8c\9ag
+::
+kCÚ\8f\9asCachedA¼ayIndexMask
+));
+
+4153
+__
+
+ªd_
+(
+r0
+,
+r3
+,
+\9d
+);
+
+4154
+__
+
+cmpi
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+4155
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+4156
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+4158
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+4162 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99G\91CachedA¼ayIndex
+(
+C®lRuÁime
+*
+ex´
+) {
+
+4163
+ZÚeLi¡
+<
+Ex´essiÚ
+*>*
+¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+4164
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 1);
+
+4165
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+4167
+__
+
+As£¹S\8c\9ag
+(
+r3
+);
+
+4169
+__
+
+lwz
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+S\8c\9ag
+::
+kHashF\9bldOff£t
+));
+
+4170
+__
+
+IndexFromHash
+(
+r3
+,\843);
+
+4172
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4176 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99Fa¡OÃBy\8bA¼ayJo\9a
+(
+C®lRuÁime
+*
+ex´
+) {
+
+4177
+Lab\96
+
+ba\9eout
+,
+ gdÚe
+,
+ gÚe_ch¬_£·¿tÜ
+,
+ glÚg_£·¿tÜ
+,
+ gnÚ_\8civ\9fl_¬¿y
+,
+
+4178
+ gnÙ_size_Úe_¬¿y
+,
+ gloÝ
+,
+ gem±y_£·¿tÜ_loÝ
+,
+ gÚe_ch¬_£·¿tÜ_loÝ
+,
+
+4179
+ gÚe_ch¬_£·¿tÜ_loÝ_\92\8cy
+,
+ glÚg_£·¿tÜ_loÝ
+;
+
+4180
+ gZÚeLi¡
+<
+ gEx´essiÚ
+*>*
+ g¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+4181
+DCHECK
+(
+¬gs
+->
+Ëngth
+() == 2);
+
+4182
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(1));
+
+4183
+Vis\99FÜAccumuÏtÜV®ue
+(
+¬gs
+->
+©
+(0));
+
+4186
+Regi¡\94
+
+ g¬¿y
+ =
+r3
+;
+
+4187
+Regi¡\94
+
+ g\96em\92ts
+ =
+no_»g
+;
+
+4188
+Regi¡\94
+
+ g»suÉ
+ =
+no_»g
+;
+
+4189
+Regi¡\94
+
+ g£·¿tÜ
+ =
+r4
+;
+
+4190
+Regi¡\94
+
+ g¬¿y_Ëngth
+ =
+r5
+;
+
+4191
+Regi¡\94
+
+ g»suÉ_pos
+ =
+no_»g
+;
+
+4192
+Regi¡\94
+
+ g¡r\9ag_Ëngth
+ =
+r6
+;
+
+4193
+Regi¡\94
+
+ g¡r\9ag
+ =
+r7
+;
+
+4194
+Regi¡\94
+
+ g\96em\92t
+ =
+r8
+;
+
+4195
+Regi¡\94
+
+ g\96em\92ts_\92d
+ =
+r9
+;
+
+4196
+Regi¡\94
+
+ gsü©ch1
+ =
+r10
+;
+
+4197
+Regi¡\94
+
+ gsü©ch2
+ =
+r11
+;
+
+4200
+__
+
+pÝ
+(
+£·¿tÜ
+);
+
+4203
+__
+
+JumpIfSmi
+(
+¬¿y
+, &
+ba\9eout
+);
+
+4204
+__
+
+Com·»ObjeùTy³
+(
+¬¿y
+,
+sü©ch1
+,
+sü©ch2
+,
+JS_ARRAY_TYPE
+);
+
+4205
+__
+
+bÃ
+(&
+ba\9eout
+);
+
+4208
+__
+
+CheckFa¡EËm\92ts
+(
+sü©ch1
+,
+sü©ch2
+, &
+ba\9eout
+);
+
+4211
+__
+
+LßdP
+(
+¬¿y_Ëngth
+,
+F\9bldMemO³¿nd
+(
+¬¿y
+,
+JSA¼ay
+::
+kL\92gthOff£t
+));
+
+4212
+__
+
+SmiUÁag
+(
+¬¿y_Ëngth
+);
+
+4213
+__
+
+cmpi
+(
+¬¿y_Ëngth
+,
+O³¿nd
+::
+Z\94o
+());
+
+4214
+__
+
+bÃ
+(&
+nÚ_\8civ\9fl_¬¿y
+);
+
+4215
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kem±y_¡r\9agRoÙIndex
+);
+
+4216
+__
+
+b
+(&
+dÚe
+);
+
+4218
+__
+
+b\9ad
+(&
+nÚ_\8civ\9fl_¬¿y
+);
+
+4221
+ g\96em\92ts
+ =
+¬¿y
+;
+
+4222
+__
+
+LßdP
+(
+\96em\92ts
+,
+F\9bldMemO³¿nd
+(
+¬¿y
+,
+JSA¼ay
+::
+kEËm\92tsOff£t
+));
+
+4223
+ g¬¿y
+ =
+no_»g
+;
+
+4227
+__
+
+li
+(
+¡r\9ag_Ëngth
+,
+O³¿nd
+::
+Z\94o
+());
+
+4228
+__
+
+addi
+(
+\96em\92t
+,
+\96em\92ts
+,
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+4229
+__
+
+ShiáLeáImm
+(
+\96em\92ts_\92d
+,
+¬¿y_Ëngth
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+4230
+__
+
+add
+(
+\96em\92ts_\92d
+,
+\96em\92t
+,\83lements_end);
+
+4239 ià(
+ gg\92\94©e_debug_code_
+) {
+
+4240
+__
+
+cmpi
+(
+¬¿y_Ëngth
+,
+O³¿nd
+::
+Z\94o
+());
+
+4241
+__
+
+As£¹
+(
+gt
+,
+kNoEm±yA¼aysH\94eInEm\99Fa¡OÃBy\8bA¼ayJo\9a
+);
+
+4243
+__
+
+b\9ad
+(&
+loÝ
+);
+
+4244
+__
+
+LßdP
+(
+¡r\9ag
+,
+MemO³¿nd
+(
+\96em\92t
+));
+
+4245
+__
+
+addi
+(
+\96em\92t
+,\83Ëm\92t,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+4246
+__
+
+JumpIfSmi
+(
+¡r\9ag
+, &
+ba\9eout
+);
+
+4247
+__
+
+LßdP
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+4248
+__
+
+lbz
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(sü©ch1,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+4249
+__
+
+JumpIfIn¡ªûTy³IsNÙSequ\92t\9flOÃBy\8b
+(
+sü©ch1
+,
+sü©ch2
+, &
+ba\9eout
+);
+
+4250
+__
+
+LßdP
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+SeqOÃBy\8bS\8c\9ag
+::
+kL\92gthOff£t
+));
+
+4252
+__
+
+AddAndCheckFÜOv\94æow
+(
+¡r\9ag_Ëngth
+, s\8c\9ag_Ëngth,
+sü©ch1
+,
+sü©ch2
+,
+
+4253
+r0
+);
+
+4254
+__
+
+B¿nchOnOv\94æow
+(&
+ba\9eout
+);
+
+4256
+__
+
+cmp
+(
+\96em\92t
+,
+\96em\92ts_\92d
+);
+
+4257
+__
+
+bÉ
+(&
+loÝ
+);
+
+4260
+__
+
+cmpi
+(
+¬¿y_Ëngth
+,
+O³¿nd
+(1));
+
+4261
+__
+
+bÃ
+(&
+nÙ_size_Úe_¬¿y
+);
+
+4262
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+(
+\96em\92ts
+,
+FixedA¼ay
+::
+kH\97d\94Size
+));
+
+4263
+__
+
+b
+(&
+dÚe
+);
+
+4265
+__
+
+b\9ad
+(&
+nÙ_size_Úe_¬¿y
+);
+
+4274
+__
+
+JumpIfSmi
+(
+£·¿tÜ
+, &
+ba\9eout
+);
+
+4275
+__
+
+LßdP
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(
+£·¿tÜ
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+4276
+__
+
+lbz
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(sü©ch1,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+4277
+__
+
+JumpIfIn¡ªûTy³IsNÙSequ\92t\9flOÃBy\8b
+(
+sü©ch1
+,
+sü©ch2
+, &
+ba\9eout
+);
+
+4281
+__
+
+LßdP
+(
+sü©ch1
+,
+
+4282
+F\9bldMemO³¿nd
+(
+£·¿tÜ
+,
+SeqOÃBy\8bS\8c\9ag
+::
+kL\92gthOff£t
+));
+
+4283
+__
+
+sub
+(
+¡r\9ag_Ëngth
+, s\8c\9ag_Ëngth,
+sü©ch1
+);
+
+4284 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4285
+__
+
+SmiUÁag
+(
+sü©ch1
+, scratch1);
+
+4286
+__
+
+Mul
+(
+sü©ch2
+,
+¬¿y_Ëngth
+,
+sü©ch1
+);
+
+4289
+__
+
+ShiáRightImm
+(
+\9d
+,
+sü©ch2
+,
+O³¿nd
+(31),
+S\91RC
+);
+
+4290
+__
+
+bÃ
+(&
+ba\9eout
+,
+ü0
+);
+
+4291
+__
+
+SmiTag
+(
+sü©ch2
+, scratch2);
+
+4294
+__
+
+muÎw
+(
+sü©ch2
+,
+¬¿y_Ëngth
+,
+sü©ch1
+);
+
+4295
+__
+
+mulhw
+(
+\9d
+,
+¬¿y_Ëngth
+,
+sü©ch1
+);
+
+4298
+__
+
+cmpi
+(
+\9d
+,
+O³¿nd
+::
+Z\94o
+());
+
+4299
+__
+
+bÃ
+(&
+ba\9eout
+);
+
+4300
+__
+
+cmpwi
+(
+sü©ch2
+,
+O³¿nd
+::
+Z\94o
+());
+
+4301
+__
+
+bÉ
+(&
+ba\9eout
+);
+
+4304
+__
+
+AddAndCheckFÜOv\94æow
+(
+¡r\9ag_Ëngth
+, s\8c\9ag_Ëngth,
+sü©ch2
+,
+sü©ch1
+,
+
+4305
+r0
+);
+
+4306
+__
+
+B¿nchOnOv\94æow
+(&
+ba\9eout
+);
+
+4307
+__
+
+SmiUÁag
+(
+¡r\9ag_Ëngth
+);
+
+4311
+__
+
+addi
+(
+\96em\92t
+,
+\96em\92ts
+,
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+4312
+ g»suÉ
+ =
+\96em\92ts
+;
+
+4313
+ g\96em\92ts
+ =
+no_»g
+;
+
+4319
+__
+
+AÎoÿ\8bOÃBy\8bS\8c\9ag
+(
+»suÉ
+,
+¡r\9ag_Ëngth
+,
+sü©ch1
+,
+sü©ch2
+,
+
+4320
+\96em\92ts_\92d
+, &
+ba\9eout
+);
+
+4324
+__
+
+ShiáLeáImm
+(
+\96em\92ts_\92d
+,
+¬¿y_Ëngth
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+4325
+__
+
+add
+(
+\96em\92ts_\92d
+,
+\96em\92t
+,\83lements_end);
+
+4326
+ g»suÉ_pos
+ =
+¬¿y_Ëngth
+;
+
+4327
+ g¬¿y_Ëngth
+ =
+no_»g
+;
+
+4328
+__
+
+addi
+(
+»suÉ_pos
+,
+»suÉ
+,
+
+4329
+O³¿nd
+(
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+4332
+__
+
+LßdP
+(
+sü©ch1
+,
+
+4333
+F\9bldMemO³¿nd
+(
+£·¿tÜ
+,
+SeqOÃBy\8bS\8c\9ag
+::
+kL\92gthOff£t
+));
+
+4334
+__
+
+CmpSmiL\99\94®
+(
+sü©ch1
+,
+Smi
+::
+FromIÁ
+(1),
+r0
+);
+
+4335
+__
+
+beq
+(&
+Úe_ch¬_£·¿tÜ
+);
+
+4336
+__
+
+bgt
+(&
+lÚg_£·¿tÜ
+);
+
+4339
+__
+
+b\9ad
+(&
+em±y_£·¿tÜ_loÝ
+);
+
+4346
+__
+
+LßdP
+(
+¡r\9ag
+,
+MemO³¿nd
+(
+\96em\92t
+));
+
+4347
+__
+
+addi
+(
+\96em\92t
+,\83Ëm\92t,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+4348
+__
+
+LßdP
+(
+¡r\9ag_Ëngth
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+4349
+__
+
+SmiUÁag
+(
+¡r\9ag_Ëngth
+);
+
+4350
+__
+
+addi
+(
+¡r\9ag
+, string,
+
+4351
+O³¿nd
+(
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+4352
+__
+
+CÝyBy\8bs
+(
+¡r\9ag
+,
+»suÉ_pos
+,
+¡r\9ag_Ëngth
+,
+sü©ch1
+);
+
+4353
+__
+
+cmp
+(
+\96em\92t
+,
+\96em\92ts_\92d
+);
+
+4354
+__
+
+bÉ
+(&
+em±y_£·¿tÜ_loÝ
+);
+
+4355
+DCHECK
+(
+»suÉ
+.
+is
+(
+r3
+));
+
+4356
+__
+
+b
+(&
+dÚe
+);
+
+4359
+__
+
+b\9ad
+(&
+Úe_ch¬_£·¿tÜ
+);
+
+4361
+__
+
+lbz
+(
+£·¿tÜ
+,
+F\9bldMemO³¿nd
+(£·¿tÜ,
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+));
+
+4364
+__
+
+b
+(&
+Úe_ch¬_£·¿tÜ_loÝ_\92\8cy
+);
+
+4366
+__
+
+b\9ad
+(&
+Úe_ch¬_£·¿tÜ_loÝ
+);
+
+4374
+__
+
+¡b
+(
+£·¿tÜ
+,
+MemO³¿nd
+(
+»suÉ_pos
+));
+
+4375
+__
+
+addi
+(
+»suÉ_pos
+,\84esuÉ_pos,
+O³¿nd
+(1));
+
+4378
+__
+
+b\9ad
+(&
+Úe_ch¬_£·¿tÜ_loÝ_\92\8cy
+);
+
+4379
+__
+
+LßdP
+(
+¡r\9ag
+,
+MemO³¿nd
+(
+\96em\92t
+));
+
+4380
+__
+
+addi
+(
+\96em\92t
+,\83Ëm\92t,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+4381
+__
+
+LßdP
+(
+¡r\9ag_Ëngth
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+4382
+__
+
+SmiUÁag
+(
+¡r\9ag_Ëngth
+);
+
+4383
+__
+
+addi
+(
+¡r\9ag
+, string,
+
+4384
+O³¿nd
+(
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+4385
+__
+
+CÝyBy\8bs
+(
+¡r\9ag
+,
+»suÉ_pos
+,
+¡r\9ag_Ëngth
+,
+sü©ch1
+);
+
+4386
+__
+
+cm¶
+(
+\96em\92t
+,
+\96em\92ts_\92d
+);
+
+4387
+__
+
+bÉ
+(&
+Úe_ch¬_£·¿tÜ_loÝ
+);
+
+4388
+DCHECK
+(
+»suÉ
+.
+is
+(
+r3
+));
+
+4389
+__
+
+b
+(&
+dÚe
+);
+
+4393
+__
+
+b\9ad
+(&
+lÚg_£·¿tÜ_loÝ
+);
+
+4401
+__
+
+LßdP
+(
+¡r\9ag_Ëngth
+,
+F\9bldMemO³¿nd
+(
+£·¿tÜ
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+4402
+__
+
+SmiUÁag
+(
+¡r\9ag_Ëngth
+);
+
+4403
+__
+
+addi
+(
+¡r\9ag
+,
+£·¿tÜ
+,
+
+4404
+O³¿nd
+(
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+4405
+__
+
+CÝyBy\8bs
+(
+¡r\9ag
+,
+»suÉ_pos
+,
+¡r\9ag_Ëngth
+,
+sü©ch1
+);
+
+4407
+__
+
+b\9ad
+(&
+lÚg_£·¿tÜ
+);
+
+4408
+__
+
+LßdP
+(
+¡r\9ag
+,
+MemO³¿nd
+(
+\96em\92t
+));
+
+4409
+__
+
+addi
+(
+\96em\92t
+,\83Ëm\92t,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+4410
+__
+
+LßdP
+(
+¡r\9ag_Ëngth
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+4411
+__
+
+SmiUÁag
+(
+¡r\9ag_Ëngth
+);
+
+4412
+__
+
+addi
+(
+¡r\9ag
+, string,
+
+4413
+O³¿nd
+(
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+4414
+__
+
+CÝyBy\8bs
+(
+¡r\9ag
+,
+»suÉ_pos
+,
+¡r\9ag_Ëngth
+,
+sü©ch1
+);
+
+4415
+__
+
+cm¶
+(
+\96em\92t
+,
+\96em\92ts_\92d
+);
+
+4416
+__
+
+bÉ
+(&
+lÚg_£·¿tÜ_loÝ
+);
+
+4417
+DCHECK
+(
+»suÉ
+.
+is
+(
+r3
+));
+
+4418
+__
+
+b
+(&
+dÚe
+);
+
+4420
+__
+
+b\9ad
+(&
+ba\9eout
+);
+
+4421
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+4422
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4423
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4427 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99DebugIsAùive
+(
+C®lRuÁime
+*
+ex´
+) {
+
+4428
+DCHECK
+(
+ex´
+->
+¬gum\92ts
+()->
+Ëngth
+() == 0);
+
+4429
+Ex\8bº®Reã»nû
+
+ gdebug_is_aùive
+ =
+
+4430
+Ex\8bº®Reã»nû
+::
+debug_is_aùive_add»ss
+(
+isީe
+());
+
+4431
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+debug_is_aùive
+));
+
+4432
+__
+
+lbz
+(
+r3
+,
+MemO³¿nd
+(
+\9d
+));
+
+4433
+__
+
+SmiTag
+(
+r3
+);
+
+4434
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4438 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99C®lRuÁime
+(
+C®lRuÁime
+*
+ex´
+) {
+
+4439 ià(
+ex´
+->
+funùiÚ
+(è!ð
+NULL
+ &&
+
+4440
+ex´
+->
+funùiÚ
+()->
+\9a\8c\9asic_ty³
+ =ð
+RuÁime
+::
+INLINE
+) {
+
+4441
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ InlineRuntimeCall");
+
+4442
+Em\99IÆ\9aeRuÁimeC®l
+(
+ex´
+);
+
+4446
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ CallRuntime");
+
+4447
+ gZÚeLi¡
+<
+ gEx´essiÚ
+*>*
+ g¬gs
+ =
+ex´
+->
+¬gum\92ts
+();
+
+4448 \12
+ g¬g_couÁ
+ =
+¬gs
+->
+Ëngth
+();
+
+4450 ià(
+ gex´
+->
+is_j¤uÁime
+()) {
+
+4452
+Regi¡\94
+
+ g»ûiv\94
+ =
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+();
+
+4453
+__
+
+LßdP
+(
+»ûiv\94
+,
+Glob®ObjeùO³¿nd
+());
+
+4454
+__
+
+LßdP
+(
+»ûiv\94
+,
+
+4455
+F\9bldMemO³¿nd
+(
+»ûiv\94
+,
+Glob®Objeù
+::
+kBu\9et\9asOff£t
+));
+
+4456
+__
+
+push
+(
+»ûiv\94
+);
+
+4459
+__
+
+mov
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+O³¿nd
+(
+ex´
+->
+Çme
+()));
+
+4460 ià(
+ gFLAG_veùÜ_ics
+) {
+
+4461
+__
+
+mov
+(
+VeùÜLßdICDesü\9dtÜ
+::
+SlÙRegi¡\94
+(),
+
+4462
+O³¿nd
+(
+SmiFromSlÙ
+(
+ex´
+->
+C®lRuÁimeF\93dbackSlÙ
+())));
+
+4463
+C®lLßdIC
+(
+NOT_CONTEXTUAL
+);
+
+4465
+C®lLßdIC
+(
+NOT_CONTEXTUAL
+,
+ex´
+->
+C®lRuÁimeF\93dbackId
+());
+
+4469
+__
+
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4470
+__
+
+push
+(
+\9d
+);
+
+4471
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+4474 \12
+ g¬g_couÁ
+ =
+¬gs
+->
+Ëngth
+();
+
+4475 \ f\12
+ gi
+ = 0; i <
+ g¬g_couÁ
+; i++) {
+
+4476
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(
+i
+));
+
+4480
+S\91SourûPos\99iÚ
+(
+ex´
+->
+pos\99iÚ
+());
+
+4481
+C®lFunùiÚStub
+
+¡ub
+(
+isީe
+(),
+¬g_couÁ
+,
+NO_CALL_FUNCTION_FLAGS
+);
+
+4482
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+¥
+, (
+¬g_couÁ
+ + 1è*
+kPo\9a\8brSize
+),
+r0
+);
+
+4483
+__
+
+C®lStub
+(&
+¡ub
+);
+
+4486
+__
+
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+4488
+cڋxt
+()->
+DrÝAndPlug
+(1,
+r3
+);
+
+4491 \ f\12
+ gi
+ = 0; i <
+ g¬g_couÁ
+; i++) {
+
+4492
+Vis\99FÜS\8fckV®ue
+(
+¬gs
+->
+©
+(
+i
+));
+
+4496
+__
+
+C®lRuÁime
+(
+ex´
+->
+funùiÚ
+(),
+¬g_couÁ
+);
+
+4497
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4502 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99UÇryO³¿tiÚ
+(
+UÇryO³¿tiÚ
+*
+ex´
+) {
+
+4503 \1a
+ex´
+->
+Ý
+()) {
+
+4504 \ 4
+Tok\92
+::
+DELETE
+: {
+
+4505
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ UnaryOperation (DELETE)");
+
+4506
+Prݔty
+*
+ g´Ý\94ty
+ =
+ex´
+->
+ex´essiÚ
+()->
+AsPrݔty
+();
+
+4507
+V¬\9fbËProxy
+*
+ g´oxy
+ =
+ex´
+->
+ex´essiÚ
+()->
+AsV¬\9fbËProxy
+();
+
+4509 ià(
+ g´Ý\94ty
+ !ð
+NULL
+) {
+
+4510
+Vis\99FÜS\8fckV®ue
+(
+´Ý\94ty
+->
+obj
+());
+
+4511
+Vis\99FÜS\8fckV®ue
+(
+´Ý\94ty
+->
+key
+());
+
+4512
+__
+
+LßdSmiL\99\94®
+(
+r4
+,
+Smi
+::
+FromIÁ
+(
+¡riù_mode
+()));
+
+4513
+__
+
+push
+(
+r4
+);
+
+4514
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+DELETE
+,
+CALL_FUNCTION
+);
+
+4515
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4516 } \vià(
+ g´oxy
+ !ð
+NULL
+) {
+
+4517
+V¬\9fbË
+*
+v¬
+ =
+´oxy
+->var();
+
+4520
+DCHECK
+(
+¡riù_mode
+(è=ð
+SLOPPY
+ ||
+v¬
+->
+is_this
+());
+
+4521 ià(
+ gv¬
+->
+IsUÇÎoÿ\8bd
+()) {
+
+4522
+__
+
+LßdP
+(
+r5
+,
+Glob®ObjeùO³¿nd
+());
+
+4523
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+v¬
+->
+Çme
+()));
+
+4524
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+SLOPPY
+));
+
+4525
+__
+
+Push
+(
+r5
+,
+r4
+,
+r3
+);
+
+4526
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+DELETE
+,
+CALL_FUNCTION
+);
+
+4527
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4528 } \vià(
+ gv¬
+->
+IsS\8fckAÎoÿ\8bd
+(è|| v¬->
+IsCÚ\8bxtSlÙ
+()) {
+
+4531
+cڋxt
+()->
+Plug
+(
+v¬
+->
+is_this
+());
+
+4535
+DCHECK
+(!
+cÚ\8bxt_»gi¡\94
+().
+is
+(
+r5
+));
+
+4536
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+v¬
+->
+Çme
+()));
+
+4537
+__
+
+Push
+(
+cÚ\8bxt_»gi¡\94
+(),
+r5
+);
+
+4538
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kD\96\91eLookupSlÙ
+, 2);
+
+4539
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4544
+Vis\99FÜEfãù
+(
+ex´
+->
+ex´essiÚ
+());
+
+4545
+cڋxt
+()->
+Plug
+(
+\8cue
+);
+
+4550 \ 4
+ gTok\92
+::
+VOID
+: {
+
+4551
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ UnaryOperation (VOID)");
+
+4552
+Vis\99FÜEfãù
+(
+ex´
+->
+ex´essiÚ
+());
+
+4553
+cڋxt
+()->
+Plug
+(
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+4557 \ 4
+ gTok\92
+::
+NOT
+: {
+
+4558
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ UnaryOperation (NOT)");
+
+4559 ià(
+cڋxt
+()->
+IsEfãù
+()) {
+
+4562
+Vis\99FÜEfãù
+(
+ex´
+->
+ex´essiÚ
+());
+
+4563 } \vià(
+cڋxt
+()->
+IsTe¡
+()) {
+
+4564 cڡ
+Te¡CÚ\8bxt
+*
+ g\8b¡
+ = Te¡CÚ\8bxt::
+ÿ¡
+(
+cڋxt
+());
+
+4566
+Vis\99FÜCÚ\8cÞ
+(
+ex´
+->
+ex´essiÚ
+(),
+\8b¡
+->
+çl£_Ïb\96
+(),
+
+4567
+\8b¡
+->
+\8cue_Ïb\96
+(),\81e¡->
+çÎ_through
+());
+
+4568
+cڋxt
+()->
+Plug
+(
+\8b¡
+->
+\8cue_Ïb\96
+(),\81e¡->
+çl£_Ïb\96
+());
+
+4574
+DCHECK
+(
+cڋxt
+()->
+IsAccumuÏtÜV®ue
+(è|| cÚ\8bxt()->
+IsS\8fckV®ue
+());
+
+4575
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+,
+ gdÚe
+;
+
+4576
+Vis\99FÜCÚ\8cÞ
+(
+ex´
+->
+ex´essiÚ
+(), &
+m©\94\9flize_çl£
+,
+
+4577 &
+m©\94\9flize_\8cue
+, &materialize_true);
+
+4578
+__
+
+b\9ad
+(&
+m©\94\9flize_\8cue
+);
+
+4579
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+M©\94\9flizeTrueId
+(),
+NO_REGISTERS
+);
+
+4580
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+4581 ià(
+cڋxt
+()->
+IsS\8fckV®ue
+()è
+__
+
+push
+(
+r3
+);
+
+4582
+__
+
+b
+(&
+dÚe
+);
+
+4583
+__
+
+b\9ad
+(&
+m©\94\9flize_çl£
+);
+
+4584
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+M©\94\9flizeF®£Id
+(),
+NO_REGISTERS
+);
+
+4585
+__
+
+LßdRoÙ
+(
+r3
+,
+H\97p
+::
+kF®£V®ueRoÙIndex
+);
+
+4586 ià(
+cڋxt
+()->
+IsS\8fckV®ue
+()è
+__
+
+push
+(
+r3
+);
+
+4587
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4592 \ 4
+ gTok\92
+::
+TYPEOF
+: {
+
+4593
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ UnaryOperation (TYPEOF)");
+
+4595
+S\8fckV®ueCÚ\8bxt
+
+cڋxt
+(
+this
+);
+
+4596
+Vis\99FÜTy³ofV®ue
+(
+ex´
+->
+ex´essiÚ
+());
+
+4598
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kTy³of
+, 1);
+
+4599
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4604
+UNREACHABLE
+();
+
+4609 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99CouÁO³¿tiÚ
+(
+CouÁO³¿tiÚ
+*
+ex´
+) {
+
+4610
+DCHECK
+(
+ex´
+->
+ex´essiÚ
+()->
+IsV®idReã»nûEx´essiÚ
+());
+
+4612
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ CountOperation");
+
+4613
+S\91SourûPos\99iÚ
+(
+ex´
+->
+pos\99iÚ
+());
+
+4615
+Prݔty
+*
+ g´Ý
+ =
+ex´
+->
+ex´essiÚ
+()->
+AsPrݔty
+();
+
+4616
+LhsK\9ad
+
+ gassign_ty³
+ =
+G\91AssignTy³
+(
+´Ý
+);
+
+4619 ià(
+ gassign_ty³
+ =ð
+VARIABLE
+) {
+
+4620
+DCHECK
+(
+ex´
+->
+ex´essiÚ
+()->
+AsV¬\9fbËProxy
+()->
+v¬
+(è!ð
+NULL
+);
+
+4621
+AccumuÏtÜV®ueCÚ\8bxt
+
+cڋxt
+(
+this
+);
+
+4622
+Em\99V¬\9fbËLßd
+(
+ex´
+->
+ex´essiÚ
+()->
+AsV¬\9fbËProxy
+());
+
+4625 ià(
+ gex´
+->
+is_po¡fix
+(è&& !
+cڋxt
+()->
+IsEfãù
+()) {
+
+4626
+__
+
+LßdSmiL\99\94®
+(
+\9d
+,
+Smi
+::
+FromIÁ
+(0));
+
+4627
+__
+
+push
+(
+\9d
+);
+
+4629 \1a
+ gassign_ty³
+) {
+
+4630 \ 4
+ gNAMED_PROPERTY
+: {
+
+4632
+Vis\99FÜS\8fckV®ue
+(
+´Ý
+->
+obj
+());
+
+4633
+__
+
+LßdP
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+MemO³¿nd
+(
+¥
+, 0));
+
+4634
+Em\99NamedPrÝ\94tyLßd
+(
+´Ý
+);
+
+4638 \ 4
+ gNAMED_SUPER_PROPERTY
+: {
+
+4639
+Vis\99FÜS\8fckV®ue
+(
+´Ý
+->
+obj
+()->
+AsSu³rReã»nû
+()->
+this_v¬
+());
+
+4640
+Em\99LßdHomeObjeù
+(
+´Ý
+->
+obj
+()->
+AsSu³rReã»nû
+());
+
+4641
+__
+
+Push
+(
+»suÉ_»gi¡\94
+());
+
+4642 cڡ
+Regi¡\94
+
+ gsü©ch
+ =
+r4
+;
+
+4643
+__
+
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+4644
+__
+
+Push
+(
+sü©ch
+,
+»suÉ_»gi¡\94
+());
+
+4645
+Em\99NamedSu³rPrÝ\94tyLßd
+(
+´Ý
+);
+
+4649 \ 4
+ gKEYED_SUPER_PROPERTY
+: {
+
+4650
+Vis\99FÜS\8fckV®ue
+(
+´Ý
+->
+obj
+()->
+AsSu³rReã»nû
+()->
+this_v¬
+());
+
+4651
+Em\99LßdHomeObjeù
+(
+´Ý
+->
+obj
+()->
+AsSu³rReã»nû
+());
+
+4652 cڡ
+Regi¡\94
+
+ gsü©ch
+ =
+r4
+;
+
+4653 cڡ
+Regi¡\94
+
+ gsü©ch1
+ =
+r5
+;
+
+4654
+__
+
+Move
+(
+sü©ch
+,
+»suÉ_»gi¡\94
+());
+
+4655
+Vis\99FÜAccumuÏtÜV®ue
+(
+´Ý
+->
+key
+());
+
+4656
+__
+
+Push
+(
+sü©ch
+,
+»suÉ_»gi¡\94
+());
+
+4657
+__
+
+LßdP
+(
+sü©ch1
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+4658
+__
+
+Push
+(
+sü©ch1
+,
+sü©ch
+,
+»suÉ_»gi¡\94
+());
+
+4659
+Em\99KeyedSu³rPrÝ\94tyLßd
+(
+´Ý
+);
+
+4663 \ 4
+ gKEYED_PROPERTY
+: {
+
+4664
+Vis\99FÜS\8fckV®ue
+(
+´Ý
+->
+obj
+());
+
+4665
+Vis\99FÜS\8fckV®ue
+(
+´Ý
+->
+key
+());
+
+4666
+__
+
+LßdP
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+
+4667
+MemO³¿nd
+(
+¥
+, 1 *
+kPo\9a\8brSize
+));
+
+4668
+__
+
+LßdP
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+MemO³¿nd
+(
+¥
+, 0));
+
+4669
+Em\99KeyedPrÝ\94tyLßd
+(
+´Ý
+);
+
+4673 \ 4
+ gVARIABLE
+:
+
+4674
+UNREACHABLE
+();
+
+4680 ià(
+ gassign_ty³
+ =ð
+VARIABLE
+) {
+
+4681
+P»·»FÜBa\9eout
+(
+ex´
+->
+ex´essiÚ
+(),
+TOS_REG
+);
+
+4683
+P»·»FÜBa\9eoutFÜId
+(
+´Ý
+->
+LßdId
+(),
+TOS_REG
+);
+
+4687
+Lab\96
+
+ g¡ub_ÿÎ
+,
+ gdÚe
+;
+
+4688
+JumpP©chS\99e
+
+·tch_s\99e
+(
+masm_
+);
+
+4690 \12
+ gcouÁ_v®ue
+ =
+ex´
+->
+Ý
+(è=ð
+Tok\92
+::
+INC
+ ? 1 : -1;
+
+4691 ià(
+ShouldIÆ\9aeSmiCa£
+(
+ex´
+->
+Ý
+())) {
+
+4692
+Lab\96
+
+ g¦ow
+;
+
+4693
+ g·tch_s\99e
+.
+Em\99JumpIfNÙSmi
+(
+r3
+, &
+¦ow
+);
+
+4696 ià(
+ gex´
+->
+is_po¡fix
+()) {
+
+4697 ià(!
+cڋxt
+()->
+IsEfãù
+()) {
+
+4701 \1a
+ gassign_ty³
+) {
+
+4702 \ 4
+ gVARIABLE
+:
+
+4703
+__
+
+push
+(
+r3
+);
+
+4705 \ 4
+ gNAMED_PROPERTY
+:
+
+4706
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+4708 \ 4
+ gNAMED_SUPER_PROPERTY
+:
+
+4709
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+4711 \ 4
+ gKEYED_PROPERTY
+:
+
+4712
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+4714 \ 4
+ gKEYED_SUPER_PROPERTY
+:
+
+4715
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+, 3 *
+kPo\9a\8brSize
+));
+
+4721
+Regi¡\94
+
+ gsü©ch1
+ =
+r4
+;
+
+4722
+Regi¡\94
+
+ gsü©ch2
+ =
+r5
+;
+
+4723
+__
+
+LßdSmiL\99\94®
+(
+sü©ch1
+,
+Smi
+::
+FromIÁ
+(
+couÁ_v®ue
+));
+
+4724
+__
+
+AddAndCheckFÜOv\94æow
+(
+r3
+,\843,
+sü©ch1
+,
+sü©ch2
+,
+r0
+);
+
+4725
+__
+
+B¿nchOnNoOv\94æow
+(&
+dÚe
+);
+
+4727
+__
+
+sub
+(
+r3
+,\843,
+sü©ch1
+);
+
+4728
+__
+
+b
+(&
+¡ub_ÿÎ
+);
+
+4729
+__
+
+b\9ad
+(&
+¦ow
+);
+
+4731
+ToNumb\94Stub
+
+cÚv\94t_¡ub
+(
+isީe
+());
+
+4732
+__
+
+C®lStub
+(&
+cÚv\94t_¡ub
+);
+
+4735 ià(
+ gex´
+->
+is_po¡fix
+()) {
+
+4736 ià(!
+cڋxt
+()->
+IsEfãù
+()) {
+
+4740 \1a
+ gassign_ty³
+) {
+
+4741 \ 4
+ gVARIABLE
+:
+
+4742
+__
+
+push
+(
+r3
+);
+
+4744 \ 4
+ gNAMED_PROPERTY
+:
+
+4745
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+4747 \ 4
+ gNAMED_SUPER_PROPERTY
+:
+
+4748
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+4750 \ 4
+ gKEYED_PROPERTY
+:
+
+4751
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+4753 \ 4
+ gKEYED_SUPER_PROPERTY
+:
+
+4754
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+¥
+, 3 *
+kPo\9a\8brSize
+));
+
+4760
+__
+
+b\9ad
+(&
+¡ub_ÿÎ
+);
+
+4761
+__
+
+mr
+(
+r4
+,
+r3
+);
+
+4762
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+couÁ_v®ue
+));
+
+4765
+S\91SourûPos\99iÚ
+(
+ex´
+->
+pos\99iÚ
+());
+
+4767
+ gHªdË
+<
+ gCode
+>
+ gcode
+ =
+
+4768
+CodeFaùÜy
+::
+B\9a¬yOpIC
+(
+isީe
+(),
+Tok\92
+::
+ADD
+,
+NO_OVERWRITE
+).
+code
+();
+
+4769
+C®lIC
+(
+code
+,
+ex´
+->
+CouÁB\9aOpF\93dbackId
+());
+
+4770
+ g·tch_s\99e
+.
+Em\99P©chInfo
+();
+
+4771
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4774 \1a
+ gassign_ty³
+) {
+
+4775 \ 4
+ gVARIABLE
+:
+
+4776 ià(
+ex´
+->
+is_po¡fix
+()) {
+
+4778
+EfãùCÚ\8bxt
+
+cڋxt
+(
+this
+);
+
+4779
+Em\99V¬\9fbËAssignm\92t
+(
+ex´
+->
+ex´essiÚ
+()->
+AsV¬\9fbËProxy
+()->
+v¬
+(),
+
+4780
+Tok\92
+::
+ASSIGN
+);
+
+4781
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+Assignm\92tId
+(),
+TOS_REG
+);
+
+4782
+ gcڋxt
+.
+Plug
+(
+r3
+);
+
+4786 ià(!
+cڋxt
+()->
+IsEfãù
+()) {
+
+4787
+cڋxt
+()->
+PlugTOS
+();
+
+4790
+Em\99V¬\9fbËAssignm\92t
+(
+ex´
+->
+ex´essiÚ
+()->
+AsV¬\9fbËProxy
+()->
+v¬
+(),
+
+4791
+Tok\92
+::
+ASSIGN
+);
+
+4792
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+Assignm\92tId
+(),
+TOS_REG
+);
+
+4793
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4796 \ 4
+ gNAMED_PROPERTY
+: {
+
+4797
+__
+
+mov
+(
+StÜeDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+
+4798
+O³¿nd
+(
+´Ý
+->
+key
+()->
+AsL\99\94®
+()->
+v®ue
+()));
+
+4799
+__
+
+pÝ
+(
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+());
+
+4800
+C®lStÜeIC
+(
+ex´
+->
+CouÁStÜeF\93dbackId
+());
+
+4801
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+Assignm\92tId
+(),
+TOS_REG
+);
+
+4802 ià(
+ gex´
+->
+is_po¡fix
+()) {
+
+4803 ià(!
+cڋxt
+()->
+IsEfãù
+()) {
+
+4804
+cڋxt
+()->
+PlugTOS
+();
+
+4807
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4811 \ 4
+ gNAMED_SUPER_PROPERTY
+: {
+
+4812
+Em\99NamedSu³rPrÝ\94tyStÜe
+(
+´Ý
+);
+
+4813 ià(
+ gex´
+->
+is_po¡fix
+()) {
+
+4814 ià(!
+cڋxt
+()->
+IsEfãù
+()) {
+
+4815
+cڋxt
+()->
+PlugTOS
+();
+
+4818
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4822 \ 4
+ gKEYED_SUPER_PROPERTY
+: {
+
+4823
+Em\99KeyedSu³rPrÝ\94tyStÜe
+(
+´Ý
+);
+
+4824 ià(
+ gex´
+->
+is_po¡fix
+()) {
+
+4825 ià(!
+cڋxt
+()->
+IsEfãù
+()) {
+
+4826
+cڋxt
+()->
+PlugTOS
+();
+
+4829
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4833 \ 4
+ gKEYED_PROPERTY
+: {
+
+4834
+__
+
+PÝ
+(
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+
+4835
+StÜeDesü\9dtÜ
+::
+NameRegi¡\94
+());
+
+4836
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+
+4837
+CodeFaùÜy
+::
+KeyedStÜeIC
+(
+isީe
+(),
+¡riù_mode
+()).
+code
+();
+
+4838
+C®lIC
+(
+ic
+,
+ex´
+->
+CouÁStÜeF\93dbackId
+());
+
+4839
+P»·»FÜBa\9eoutFÜId
+(
+ex´
+->
+Assignm\92tId
+(),
+TOS_REG
+);
+
+4840 ià(
+ gex´
+->
+is_po¡fix
+()) {
+
+4841 ià(!
+cڋxt
+()->
+IsEfãù
+()) {
+
+4842
+cڋxt
+()->
+PlugTOS
+();
+
+4845
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4853 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99FÜTy³ofV®ue
+(
+Ex´essiÚ
+*
+ex´
+) {
+
+4854
+DCHECK
+(!
+cڋxt
+()->
+IsEfãù
+());
+
+4855
+DCHECK
+(!
+cڋxt
+()->
+IsTe¡
+());
+
+4856
+V¬\9fbËProxy
+*
+ g´oxy
+ =
+ex´
+->
+AsV¬\9fbËProxy
+();
+
+4857 ià(
+ g´oxy
+ !ð
+NULL
+ &&
+´oxy
+->
+v¬
+()->
+IsUÇÎoÿ\8bd
+()) {
+
+4858
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Global variable");
+
+4859
+__
+
+LßdP
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(),
+Glob®ObjeùO³¿nd
+());
+
+4860
+__
+
+mov
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+O³¿nd
+(
+´oxy
+->
+Çme
+()));
+
+4861 ià(
+ gFLAG_veùÜ_ics
+) {
+
+4862
+__
+
+mov
+(
+VeùÜLßdICDesü\9dtÜ
+::
+SlÙRegi¡\94
+(),
+
+4863
+O³¿nd
+(
+SmiFromSlÙ
+(
+´oxy
+->
+V¬\9fbËF\93dbackSlÙ
+())));
+
+4867
+C®lLßdIC
+(
+NOT_CONTEXTUAL
+);
+
+4868
+P»·»FÜBa\9eout
+(
+ex´
+,
+TOS_REG
+);
+
+4869
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4870 } \vià(
+ g´oxy
+ !ð
+NULL
+ &&
+´oxy
+->
+v¬
+()->
+IsLookupSlÙ
+()) {
+
+4871
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ Lookup slot");
+
+4872
+Lab\96
+
+ gdÚe
+,
+ g¦ow
+;
+
+4876
+Em\99DyÇmicLookupFa¡Ca£
+(
+´oxy
+,
+INSIDE_TYPEOF
+, &
+¦ow
+, &
+dÚe
+);
+
+4878
+__
+
+b\9ad
+(&
+¦ow
+);
+
+4879
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+´oxy
+->
+Çme
+()));
+
+4880
+__
+
+Push
+(
+ý
+,
+r3
+);
+
+4881
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kLßdLookupSlÙNoReã»nûE¼Ü
+, 2);
+
+4882
+P»·»FÜBa\9eout
+(
+ex´
+,
+TOS_REG
+);
+
+4883
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4885
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+4888
+Vis\99InDu¶iÿ\8bCÚ\8bxt
+(
+ex´
+);
+
+4893 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99L\99\94®Com·»Ty³of
+(
+Ex´essiÚ
+*
+ex´
+,
+
+4894
+Ex´essiÚ
+*
+sub_ex´
+,
+
+4895
+HªdË
+<
+S\8c\9ag
+>
+check
+) {
+
+4896
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+4897
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+4898
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+4899
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+4900
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+4901 &
+if_çl£
+, &
+çÎ_through
+);
+
+4904
+AccumuÏtÜV®ueCÚ\8bxt
+
+cڋxt
+(
+this
+);
+
+4905
+Vis\99FÜTy³ofV®ue
+(
+sub_ex´
+);
+
+4907
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+4909
+FaùÜy
+*
+ gçùÜy
+ =
+isީe
+()->
+çùÜy
+();
+
+4910 ià(
+ gS\8c\9ag
+::
+Equ®s
+(
+check
+,
+çùÜy
+->
+numb\94_¡r\9ag
+())) {
+
+4911
+__
+
+JumpIfSmi
+(
+r3
+,
+if_\8cue
+);
+
+4912
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+H\97pObjeù
+::
+kMOff£t
+));
+
+4913
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+4914
+__
+
+cmp
+(
+r3
+,
+\9d
+);
+
+4915
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+4916 } \vià(
+ gS\8c\9ag
+::
+Equ®s
+(
+check
+,
+çùÜy
+->
+¡r\9ag_¡r\9ag
+())) {
+
+4917
+__
+
+JumpIfSmi
+(
+r3
+,
+if_çl£
+);
+
+4919
+__
+
+Com·»ObjeùTy³
+(
+r3
+,\843,
+r4
+,
+FIRST_NONSTRING_TYPE
+);
+
+4920
+__
+
+bge
+(
+if_çl£
+);
+
+4921
+__
+
+lbz
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+M
+::
+kB\99F\9bldOff£t
+));
+
+4922
+STATIC_ASSERT
+((1 <<
+M
+::
+kIsUnd\91eùabË
+) < 0x8000);
+
+4923
+__
+
+ªdi
+(
+r0
+,
+r4
+,
+O³¿nd
+(1 <<
+M
+::
+kIsUnd\91eùabË
+));
+
+4924
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+,
+ü0
+);
+
+4925 } \vià(
+ gS\8c\9ag
+::
+Equ®s
+(
+check
+,
+çùÜy
+->
+symbÞ_¡r\9ag
+())) {
+
+4926
+__
+
+JumpIfSmi
+(
+r3
+,
+if_çl£
+);
+
+4927
+__
+
+Com·»ObjeùTy³
+(
+r3
+,\843,
+r4
+,
+SYMBOL_TYPE
+);
+
+4928
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+4929 } \vià(
+ gS\8c\9ag
+::
+Equ®s
+(
+check
+,
+çùÜy
+->
+boÞ\97n_¡r\9ag
+())) {
+
+4930
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+4931
+__
+
+beq
+(
+if_\8cue
+);
+
+4932
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kF®£V®ueRoÙIndex
+);
+
+4933
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+4934 } \vià(
+ gS\8c\9ag
+::
+Equ®s
+(
+check
+,
+çùÜy
+->
+undef\9aed_¡r\9ag
+())) {
+
+4935
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+4936
+__
+
+beq
+(
+if_\8cue
+);
+
+4937
+__
+
+JumpIfSmi
+(
+r3
+,
+if_çl£
+);
+
+4939
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+H\97pObjeù
+::
+kMOff£t
+));
+
+4940
+__
+
+lbz
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+M
+::
+kB\99F\9bldOff£t
+));
+
+4941
+__
+
+ªdi
+(
+r0
+,
+r4
+,
+O³¿nd
+(1 <<
+M
+::
+kIsUnd\91eùabË
+));
+
+4942
+S¶\99
+(
+Ã
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+,
+ü0
+);
+
+4944 } \vià(
+ gS\8c\9ag
+::
+Equ®s
+(
+check
+,
+çùÜy
+->
+funùiÚ_¡r\9ag
+())) {
+
+4945
+__
+
+JumpIfSmi
+(
+r3
+,
+if_çl£
+);
+
+4946
+STATIC_ASSERT
+(
+NUM_OF_CALLABLE_SPEC_OBJECT_TYPES
+ == 2);
+
+4947
+__
+
+Com·»ObjeùTy³
+(
+r3
+,\843,
+r4
+,
+JS_FUNCTION_TYPE
+);
+
+4948
+__
+
+beq
+(
+if_\8cue
+);
+
+4949
+__
+
+cmpi
+(
+r4
+,
+O³¿nd
+(
+JS_FUNCTION_PROXY_TYPE
+));
+
+4950
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+4951 } \vià(
+ gS\8c\9ag
+::
+Equ®s
+(
+check
+,
+çùÜy
+->
+objeù_¡r\9ag
+())) {
+
+4952
+__
+
+JumpIfSmi
+(
+r3
+,
+if_çl£
+);
+
+4953
+__
+
+Com·»RoÙ
+(
+r3
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+4954
+__
+
+beq
+(
+if_\8cue
+);
+
+4956
+__
+
+Com·»ObjeùTy³
+(
+r3
+,\843,
+r4
+,
+FIRST_NONCALLABLE_SPEC_OBJECT_TYPE
+);
+
+4957
+__
+
+bÉ
+(
+if_çl£
+);
+
+4958
+__
+
+Com·»In¡ªûTy³
+(
+r3
+,
+r4
+,
+LAST_NONCALLABLE_SPEC_OBJECT_TYPE
+);
+
+4959
+__
+
+bgt
+(
+if_çl£
+);
+
+4961
+__
+
+lbz
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+M
+::
+kB\99F\9bldOff£t
+));
+
+4962
+__
+
+ªdi
+(
+r0
+,
+r4
+,
+O³¿nd
+(1 <<
+M
+::
+kIsUnd\91eùabË
+));
+
+4963
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+,
+ü0
+);
+
+4965 ià(
+ gif_çl£
+ !ð
+çÎ_through
+è
+__
+
+b
+(
+if_çl£
+);
+
+4967
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+4971 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99Com·»O³¿tiÚ
+(
+Com·»O³¿tiÚ
+*
+ex´
+) {
+
+4972
+Comm\92t
+
+cmÁ
+(
+masm_
+, "[ CompareOperation");
+
+4973
+S\91SourûPos\99iÚ
+(
+ex´
+->
+pos\99iÚ
+());
+
+4977 ià(
+TryL\99\94®Com·»
+(
+ex´
+)) \15;
+
+4981
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+4982
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+4983
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+4984
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+4985
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+4986 &
+if_çl£
+, &
+çÎ_through
+);
+
+4988
+ gTok\92
+::
+V®ue
+
+Ý
+ =
+ex´
+->op();
+
+4989
+Vis\99FÜS\8fckV®ue
+(
+ex´
+->
+Ëá
+());
+
+4990 \1a
+ gÝ
+) {
+
+4991 \ 4
+ gTok\92
+::
+IN
+:
+
+4992
+Vis\99FÜS\8fckV®ue
+(
+ex´
+->
+right
+());
+
+4993
+__
+
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+IN
+,
+CALL_FUNCTION
+);
+
+4994
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+çl£
+,
+NULL
+, NULL);
+
+4995
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+4996
+__
+
+cmp
+(
+r3
+,
+\9d
+);
+
+4997
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+5000 \ 4
+ gTok\92
+::
+INSTANCEOF
+: {
+
+5001
+Vis\99FÜS\8fckV®ue
+(
+ex´
+->
+right
+());
+
+5002
+In¡ªûofStub
+
+¡ub
+(
+isީe
+(), In¡ªûofStub::
+kNoFÏgs
+);
+
+5003
+__
+
+C®lStub
+(&
+¡ub
+);
+
+5004
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+5006
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+5007
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+5012
+Vis\99FÜAccumuÏtÜV®ue
+(
+ex´
+->
+right
+());
+
+5013
+CÚd\99iÚ
+
+ gcÚd
+ =
+Com·»IC
+::
+Compu\8bCÚd\99iÚ
+(
+Ý
+);
+
+5014
+__
+
+pÝ
+(
+r4
+);
+
+5016
+boÞ
+
+ g\9al\9ae_smi_code
+ =
+ShouldIÆ\9aeSmiCa£
+(
+Ý
+);
+
+5017
+JumpP©chS\99e
+
+·tch_s\99e
+(
+masm_
+);
+
+5018 ià(
+ g\9al\9ae_smi_code
+) {
+
+5019
+Lab\96
+
+ g¦ow_ÿ£
+;
+
+5020
+__
+
+Üx
+(
+r5
+,
+r3
+,
+r4
+);
+
+5021
+ g·tch_s\99e
+.
+Em\99JumpIfNÙSmi
+(
+r5
+, &
+¦ow_ÿ£
+);
+
+5022
+__
+
+cmp
+(
+r4
+,
+r3
+);
+
+5023
+S¶\99
+(
+cÚd
+,
+if_\8cue
+,
+if_çl£
+,
+NULL
+);
+
+5024
+__
+
+b\9ad
+(&
+¦ow_ÿ£
+);
+
+5028
+S\91SourûPos\99iÚ
+(
+ex´
+->
+pos\99iÚ
+());
+
+5029
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+CodeFaùÜy
+::
+Com·»IC
+(
+isީe
+(),
+Ý
+).
+code
+();
+
+5030
+C®lIC
+(
+ic
+,
+ex´
+->
+Com·»O³¿tiÚF\93dbackId
+());
+
+5031
+ g·tch_s\99e
+.
+Em\99P©chInfo
+();
+
+5032
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+5033
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+5034
+S¶\99
+(
+cÚd
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+5040
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+5044 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Em\99L\99\94®Com·»N\9e
+(
+Com·»O³¿tiÚ
+*
+ex´
+,
+
+5045
+Ex´essiÚ
+*
+sub_ex´
+,
+
+5046
+N\9eV®ue
+
+n\9e
+) {
+
+5047
+Lab\96
+
+ gm©\94\9flize_\8cue
+,
+ gm©\94\9flize_çl£
+;
+
+5048
+Lab\96
+*
+ gif_\8cue
+ =
+NULL
+;
+
+5049
+Lab\96
+*
+ gif_çl£
+ =
+NULL
+;
+
+5050
+Lab\96
+*
+ gçÎ_through
+ =
+NULL
+;
+
+5051
+cڋxt
+()->
+P»·»Te¡
+(&
+m©\94\9flize_\8cue
+, &
+m©\94\9flize_çl£
+, &
+if_\8cue
+,
+
+5052 &
+if_çl£
+, &
+çÎ_through
+);
+
+5054
+Vis\99FÜAccumuÏtÜV®ue
+(
+sub_ex´
+);
+
+5055
+P»·»FÜBa\9eoutBefÜeS¶\99
+(
+ex´
+,
+\8cue
+,
+if_\8cue
+,
+if_çl£
+);
+
+5056 ià(
+ gex´
+->
+Ý
+(è=ð
+Tok\92
+::
+EQ_STRICT
+) {
+
+5057
+H\97p
+::
+RoÙLi¡Index
+
+n\9e_v®ue
+ =
+n\9e
+ =ð
+kNuÎV®ue
+
+
+5058 ?
+H\97p
+::
+kNuÎV®ueRoÙIndex
+
+
+5059 :
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+;
+
+5060
+__
+
+LßdRoÙ
+(
+r4
+,
+n\9e_v®ue
+);
+
+5061
+__
+
+cmp
+(
+r3
+,
+r4
+);
+
+5062
+S¶\99
+(
+eq
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+5064
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+Com·»N\9eICStub
+::
+G\91Un\9a\99\9flized
+(
+isީe
+(),
+n\9e
+);
+
+5065
+C®lIC
+(
+ic
+,
+ex´
+->
+Com·»O³¿tiÚF\93dbackId
+());
+
+5066
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+5067
+S¶\99
+(
+Ã
+,
+if_\8cue
+,
+if_çl£
+,
+çÎ_through
+);
+
+5069
+cڋxt
+()->
+Plug
+(
+if_\8cue
+,
+if_çl£
+);
+
+5073 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Vis\99ThisFunùiÚ
+(
+ThisFunùiÚ
+*
+ex´
+) {
+
+5074
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+5075
+cڋxt
+()->
+Plug
+(
+r3
+);
+
+5079
+Regi¡\94
+
+ gFuÎCodeG\92\94©Ü
+::
+»suÉ_»gi¡\94
+(è{ \15
+r3
+; }
+
+5082
+Regi¡\94
+
+ gFuÎCodeG\92\94©Ü
+::
+cÚ\8bxt_»gi¡\94
+(è{ \15
+ý
+; }
+
+5085 \1e
+ gFuÎCodeG\92\94©Ü
+::
+StÜeToF¿meF\9bld
+(\12
+äame_off£t
+,
+Regi¡\94
+
+v®ue
+) {
+
+5086
+DCHECK_EQ
+(
+¡©ic_ÿ¡
+<\12>(
+POINTER_SIZE_ALIGN
+(
+äame_off£t
+)), frame_offset);
+
+5087
+__
+
+StÜeP
+(
+v®ue
+,
+MemO³¿nd
+(
+å
+,
+äame_off£t
+),
+r0
+);
+
+5091 \1e
+ gFuÎCodeG\92\94©Ü
+::
+LßdCÚ\8bxtF\9bld
+(
+Regi¡\94
+
+d¡
+, \12
+cÚ\8bxt_\9adex
+) {
+
+5092
+__
+
+LßdP
+(
+d¡
+,
+CÚ\8bxtO³¿nd
+(
+ý
+,
+cÚ\8bxt_\9adex
+),
+r0
+);
+
+5096 \1e
+ gFuÎCodeG\92\94©Ü
+::
+PushFunùiÚArgum\92tFÜCÚ\8bxtAÎoÿtiÚ
+() {
+
+5097
+ScÝe
+*
+deþ¬©iÚ_scÝe
+ =
+scÝe
+()->
+Deþ¬©iÚScÝe
+();
+
+5098 ià(
+ gdeþ¬©iÚ_scÝe
+->
+is_glob®_scÝe
+() ||
+
+5099
+ gdeþ¬©iÚ_scÝe
+->
+is_moduË_scÝe
+()) {
+
+5104
+__
+
+LßdSmiL\99\94®
+(
+\9d
+,
+Smi
+::
+FromIÁ
+(0));
+
+5105 } \vià(
+ gdeþ¬©iÚ_scÝe
+->
+is_ev®_scÝe
+()) {
+
+5109
+__
+
+LßdP
+(
+\9d
+,
+CÚ\8bxtO³¿nd
+(
+ý
+,
+Cڋxt
+::
+CLOSURE_INDEX
+));
+
+5111
+DCHECK
+(
+deþ¬©iÚ_scÝe
+->
+is_funùiÚ_scÝe
+());
+
+5112
+__
+
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+5114
+__
+
+push
+(
+\9d
+);
+
+5121 \1e
+ gFuÎCodeG\92\94©Ü
+::
+EÁ\94F\9a®lyBlock
+() {
+
+5122
+DCHECK
+(!
+»suÉ_»gi¡\94
+().
+is
+(
+r4
+));
+
+5124
+__
+
+push
+(
+»suÉ_»gi¡\94
+());
+
+5126
+__
+
+mær
+(
+r4
+);
+
+5127
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+masm_
+->
+CodeObjeù
+()));
+
+5128
+__
+
+sub
+(
+r4
+,\844,
+\9d
+);
+
+5129
+__
+
+SmiTag
+(
+r4
+);
+
+5132
+__
+
+push
+(
+r4
+);
+
+5135
+Ex\8bº®Reã»nû
+
+ g³nd\9ag_mes§ge_obj
+ =
+
+5136
+Ex\8bº®Reã»nû
+::
+add»ss_of_³nd\9ag_mes§ge_obj
+(
+isީe
+());
+
+5137
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+³nd\9ag_mes§ge_obj
+));
+
+5138
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+\9d
+));
+
+5139
+__
+
+push
+(
+r4
+);
+
+5141
+Ex\8bº®Reã»nû
+
+ ghas_³nd\9ag_mes§ge
+ =
+
+5142
+Ex\8bº®Reã»nû
+::
+add»ss_of_has_³nd\9ag_mes§ge
+(
+isީe
+());
+
+5143
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+has_³nd\9ag_mes§ge
+));
+
+5144
+__
+
+lbz
+(
+r4
+,
+MemO³¿nd
+(
+\9d
+));
+
+5145
+__
+
+SmiTag
+(
+r4
+);
+
+5146
+__
+
+push
+(
+r4
+);
+
+5148
+Ex\8bº®Reã»nû
+
+ g³nd\9ag_mes§ge_sü\9dt
+ =
+
+5149
+Ex\8bº®Reã»nû
+::
+add»ss_of_³nd\9ag_mes§ge_sü\9dt
+(
+isީe
+());
+
+5150
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+³nd\9ag_mes§ge_sü\9dt
+));
+
+5151
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+\9d
+));
+
+5152
+__
+
+push
+(
+r4
+);
+
+5156 \1e
+ gFuÎCodeG\92\94©Ü
+::
+Ex\99F\9a®lyBlock
+() {
+
+5157
+DCHECK
+(!
+»suÉ_»gi¡\94
+().
+is
+(
+r4
+));
+
+5159
+__
+
+pÝ
+(
+r4
+);
+
+5160
+Ex\8bº®Reã»nû
+
+ g³nd\9ag_mes§ge_sü\9dt
+ =
+
+5161
+Ex\8bº®Reã»nû
+::
+add»ss_of_³nd\9ag_mes§ge_sü\9dt
+(
+isީe
+());
+
+5162
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+³nd\9ag_mes§ge_sü\9dt
+));
+
+5163
+__
+
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+\9d
+));
+
+5165
+__
+
+pÝ
+(
+r4
+);
+
+5166
+__
+
+SmiUÁag
+(
+r4
+);
+
+5167
+Ex\8bº®Reã»nû
+
+ ghas_³nd\9ag_mes§ge
+ =
+
+5168
+Ex\8bº®Reã»nû
+::
+add»ss_of_has_³nd\9ag_mes§ge
+(
+isީe
+());
+
+5169
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+has_³nd\9ag_mes§ge
+));
+
+5170
+__
+
+¡b
+(
+r4
+,
+MemO³¿nd
+(
+\9d
+));
+
+5172
+__
+
+pÝ
+(
+r4
+);
+
+5173
+Ex\8bº®Reã»nû
+
+ g³nd\9ag_mes§ge_obj
+ =
+
+5174
+Ex\8bº®Reã»nû
+::
+add»ss_of_³nd\9ag_mes§ge_obj
+(
+isީe
+());
+
+5175
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+³nd\9ag_mes§ge_obj
+));
+
+5176
+__
+
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+\9d
+));
+
+5179
+__
+
+pÝ
+(
+r4
+);
+
+5182
+__
+
+pÝ
+(
+»suÉ_»gi¡\94
+());
+
+5183
+__
+
+SmiUÁag
+(
+r4
+);
+
+5184
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+masm_
+->
+CodeObjeù
+()));
+
+5185
+__
+
+add
+(
+\9d
+, ip,
+r4
+);
+
+5186
+__
+
+mtùr
+(
+\9d
+);
+
+5187
+__
+
+bùr
+();
+
+5191 #undeà
+__
+
+
+5193 \ 1
+ #__
+
+ `ACCESS_MASM
+(
+ `masm
+())
+
+ )
+
+5195
+ gFuÎCodeG\92\94©Ü
+::
+Ne¡edS\8f\8bm\92t
+*
+FuÎCodeG\92\94©Ü
+::
+TryF\9a®ly
+::
+Ex\99
+(
+
+5196 \12*
+¡ack_d\95th
+, \12*
+cÚ\8bxt_Ëngth
+) {
+
+5203
+__
+
+DrÝ
+(*
+¡ack_d\95th
+);
+
+5204 ià(*
+ gcÚ\8bxt_Ëngth
+ > 0) {
+
+5206
+__
+
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+¥
+,
+S\8fckHªdËrCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+5207
+__
+
+StÜeP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+5209
+__
+
+PÝTryHªdËr
+();
+
+5210
+__
+
+b
+(
+f\9a®ly_\92\8cy_
+,
+S\91LK
+);
+
+5212 *
+ g¡ack_d\95th
+ = 0;
+
+5213 *
+ gcÚ\8bxt_Ëngth
+ = 0;
+
+5214 \15
+ g´evious_
+;
+
+5217 #undeà
+__
+
+
+5220 \1e
+ gBackEdgeTabË
+::
+P©chAt
+(
+Code
+*
+unÝtimized_code
+,
+Add»ss
+
+pc
+,
+
+5221
+BackEdgeS\8f\8b
+
+\8frg\91_¡©e
+,
+
+5222
+Code
+*
+»¶aûm\92t_code
+) {
+
+5223
+Add»ss
+
+ gmov_add»ss
+ =
+As£mbËr
+::
+\8frg\91_add»ss_äom_»tuº_add»ss
+(
+pc
+);
+
+5224
+Add»ss
+
+ gcmp_add»ss
+ =
+mov_add»ss
+ - 2 *
+As£mbËr
+::
+kIn¡rSize
+;
+
+5225
+CodeP©ch\94
+
+·tch\94
+(
+cmp_add»ss
+, 1);
+
+5227 \1a
+ g\8frg\91_¡©e
+) {
+
+5228 \ 4
+ gINTERRUPT
+: {
+
+5237
+·tch\94
+.
+masm
+()->
+cmpi
+(
+r6
+,
+O³¿nd
+::
+Z\94o
+());
+
+5240 \ 4
+ gON_STACK_REPLACEMENT
+:
+
+5241 \ 4
+OSR_AFTER_STACK_CHECK
+:
+
+5252
+·tch\94
+.
+masm
+()->
+ü£t
+(
+As£mbËr
+::
+\92code_üb\99
+(
+ü7
+,
+CR_LT
+));
+
+5258
+ gAs£mbËr
+::
+£t_\8frg\91_add»ss_©
+(
+mov_add»ss
+,
+unÝtimized_code
+,
+
+5259
+»¶aûm\92t_code
+->
+\92\8cy
+());
+
+5261
+ gunÝtimized_code
+->
+G\91H\97p
+()->
+\9aüem\92\8fl_m¬k\9ag
+()->
+RecÜdCodeT¬g\91P©ch
+(
+
+5262
+unÝtimized_code
+,
+mov_add»ss
+,
+»¶aûm\92t_code
+);
+
+5266
+ gBackEdgeTabË
+::
+BackEdgeS\8f\8b
+
+BackEdgeTabË
+::
+G\91BackEdgeS\8f\8b
+(
+
+5267
+Isީe
+*
+isީe
+,
+Code
+*
+unÝtimized_code
+,
+Add»ss
+
+pc
+) {
+
+5268
+Add»ss
+
+ gmov_add»ss
+ =
+As£mbËr
+::
+\8frg\91_add»ss_äom_»tuº_add»ss
+(
+pc
+);
+
+5269
+Add»ss
+
+ gcmp_add»ss
+ =
+mov_add»ss
+ - 2 *
+As£mbËr
+::
+kIn¡rSize
+;
+
+5270
+Add»ss
+
+ g\9a\8b¼u±_add»ss
+ =
+
+5271
+As£mbËr
+::
+\8frg\91_add»ss_©
+(
+mov_add»ss
+,
+unÝtimized_code
+);
+
+5273 ià(
+ gAs£mbËr
+::
+IsCmpImmed\9f\8b
+(
+As£mbËr
+::
+\9a¡r_©
+(
+cmp_add»ss
+))) {
+
+5274
+DCHECK
+(
+\9a\8b¼u±_add»ss
+ =ð
+isީe
+->
+bu\9et\9as
+()->
+IÁ\94ru±Check
+()->
+\92\8cy
+());
+
+5275 \15
+ gINTERRUPT
+;
+
+5278
+DCHECK
+(
+As£mbËr
+::
+IsCrS\91
+(As£mbËr::
+\9a¡r_©
+(
+cmp_add»ss
+)));
+
+5280 ià(
+ g\9a\8b¼u±_add»ss
+ =ð
+isީe
+->
+bu\9et\9as
+()->
+OnS\8fckR\95Ïûm\92t
+()->
+\92\8cy
+()) {
+
+5281 \15
+ON_STACK_REPLACEMENT
+;
+
+5284
+DCHECK
+(
+\9a\8b¼u±_add»ss
+ ==
+
+5285
+isީe
+->
+bu\9et\9as
+()->
+O¤Aá\94S\8fckCheck
+()->
+\92\8cy
+());
+
+5286 \15
+ gOSR_AFTER_STACK_CHECK
+;
+
+ @interface-descriptors-ppc.cc
+
+5 \ 2
+ ~"¤c/v8.h
+"
+
+7 #ià
+V8_TARGET_ARCH_PPC
+
+
+9 \ 2
+ ~"¤c/\9a\8brçû-desü\9dtÜs.h
+"
+
+11
+Çme¥aû
+
+ gv8
+ {
+
+12
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+14 cڡ
+Regi¡\94
+
+ gC®lIÁ\94çûDesü\9dtÜ
+::
+CÚ\8bxtRegi¡\94
+(è{ \15
+ý
+; }
+
+17 cڡ
+Regi¡\94
+
+ gLßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(è{ \15
+r4
+; }
+
+18 cڡ
+Regi¡\94
+
+ gLßdDesü\9dtÜ
+::
+NameRegi¡\94
+(è{ \15
+r5
+; }
+
+21 cڡ
+Regi¡\94
+
+ gVeùÜLßdICT¿mpÞ\9aeDesü\9dtÜ
+::
+SlÙRegi¡\94
+(è{ \15
+r3
+; }
+
+24 cڡ
+Regi¡\94
+
+ gVeùÜLßdICDesü\9dtÜ
+::
+VeùÜRegi¡\94
+(è{ \15
+r6
+; }
+
+27 cڡ
+Regi¡\94
+
+ gStÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+(è{ \15
+r4
+; }
+
+28 cڡ
+Regi¡\94
+
+ gStÜeDesü\9dtÜ
+::
+NameRegi¡\94
+(è{ \15
+r5
+; }
+
+29 cڡ
+Regi¡\94
+
+ gStÜeDesü\9dtÜ
+::
+V®ueRegi¡\94
+(è{ \15
+r3
+; }
+
+32 cڡ
+Regi¡\94
+
+ gStÜeT¿ns\99iÚDesü\9dtÜ
+::
+MRegi¡\94
+(è{ \15
+r6
+; }
+
+35 cڡ
+Regi¡\94
+
+ gEËm\92tT¿ns\99iÚAndStÜeDesü\9dtÜ
+::
+MRegi¡\94
+(è{ \15
+r6
+; }
+
+38 cڡ
+Regi¡\94
+
+ gIn¡ªûofDesü\9dtÜ
+::
+Ëá
+(è{ \15
+r3
+; }
+
+39 cڡ
+Regi¡\94
+
+ gIn¡ªûofDesü\9dtÜ
+::
+right
+(è{ \15
+r4
+; }
+
+42 cڡ
+Regi¡\94
+
+ gArgum\92tsAcûssR\97dDesü\9dtÜ
+::
+\9adex
+(è{ \15
+r4
+; }
+
+43 cڡ
+Regi¡\94
+
+ gArgum\92tsAcûssR\97dDesü\9dtÜ
+::
+·¿m\91\94_couÁ
+(è{ \15
+r3
+; }
+
+46 cڡ
+Regi¡\94
+
+ gApiG\91\8brDesü\9dtÜ
+::
+funùiÚ_add»ss
+(è{ \15
+r5
+; }
+
+49 cڡ
+Regi¡\94
+
+ gM©hPowTaggedDesü\9dtÜ
+::
+expڒt
+(è{ \15
+r5
+; }
+
+52 cڡ
+Regi¡\94
+
+ gM©hPowIÁeg\94Desü\9dtÜ
+::
+expڒt
+() {
+
+53 \15
+M©hPowTaggedDesü\9dtÜ
+::
+expڒt
+();
+
+57 \1e
+ gFa¡NewClosu»Desü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+58
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r5
+};
+
+59
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+63 \1e
+ gFa¡NewCÚ\8bxtDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+64
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r4
+};
+
+65
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+69 \1e
+ gToNumb\94Desü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+70
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r3
+};
+
+71
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+75 \1e
+ gNumb\94ToS\8c\9agDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+76
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r3
+};
+
+77
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+81 \1e
+ gFa¡ClÚeSh®lowA¼ayDesü\9dtÜ
+::
+In\99\9flize
+(
+
+82
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+83
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r6
+,
+r5
+,
+r4
+};
+
+84
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚs
+[] = {
+
+85
+R\95»£Á©iÚ
+::
+Tagged
+(), R\95»£Á©iÚ::Tagged(), R\95»£Á©iÚ::
+Smi
+(),
+
+86
+R\95»£Á©iÚ
+::
+Tagged
+()};
+
+87
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+»´e£Á©iÚs
+);
+
+91 \1e
+ gFa¡ClÚeSh®lowObjeùDesü\9dtÜ
+::
+In\99\9flize
+(
+
+92
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+93
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r6
+,
+r5
+,
+r4
+,
+r3
+};
+
+94
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+98 \1e
+ gC»©eAÎoÿtiÚS\99eDesü\9dtÜ
+::
+In\99\9flize
+(
+
+99
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+100
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r5
+,
+r6
+};
+
+101
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+105 \1e
+ gStÜeA¼ayL\99\94®EËm\92tDesü\9dtÜ
+::
+In\99\9flize
+(
+
+106
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+107
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r6
+,
+r3
+};
+
+108
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+112 \1e
+ gC®lFunùiÚDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+113
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r4
+};
+
+114
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+118 \1e
+ gC®lFunùiÚW\99hF\93dbackDesü\9dtÜ
+::
+In\99\9flize
+(
+
+119
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+120
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r4
+,
+r6
+};
+
+121
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚs
+[] = {R\95»£Á©iÚ::
+Tagged
+(),
+
+122
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+123
+R\95»£Á©iÚ
+::
+Smi
+()};
+
+124
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+»´e£Á©iÚs
+);
+
+128 \1e
+ gC®lCÚ¡ruùDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+136
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r3
+,
+r4
+,
+r5
+};
+
+137
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+141 \1e
+ gRegExpCÚ¡ruùResuÉDesü\9dtÜ
+::
+In\99\9flize
+(
+
+142
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+143
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r5
+,
+r4
+,
+r3
+};
+
+144
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+148 \1e
+ gT¿ns\99iÚEËm\92tsK\9adDesü\9dtÜ
+::
+In\99\9flize
+(
+
+149
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+150
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r3
+,
+r4
+};
+
+151
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+155 \1e
+ gA¼ayCÚ¡ruùÜCÚ¡ªtArgCouÁDesü\9dtÜ
+::
+In\99\9flize
+(
+
+156
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+162
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r4
+,
+r5
+};
+
+163
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+167 \1e
+ gA¼ayCÚ¡ruùÜDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+169
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r4
+,
+r5
+,
+r3
+};
+
+170
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚs
+[] = {
+
+171
+R\95»£Á©iÚ
+::
+Tagged
+(), Representation::Tagged(),
+
+172
+R\95»£Á©iÚ
+::
+Tagged
+(), R\95»£Á©iÚ::
+IÁeg\9432
+()};
+
+173
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+»´e£Á©iÚs
+);
+
+177 \1e
+ gIÁ\94ÇlA¼ayCÚ¡ruùÜCÚ¡ªtArgCouÁDesü\9dtÜ
+::
+In\99\9flize
+(
+
+178
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+183
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r4
+};
+
+184
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+188 \1e
+ gIÁ\94ÇlA¼ayCÚ¡ruùÜDesü\9dtÜ
+::
+In\99\9flize
+(
+
+189
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+191
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r4
+,
+r3
+};
+
+192
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚs
+[] = {R\95»£Á©iÚ::
+Tagged
+(),
+
+193
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+194
+R\95»£Á©iÚ
+::
+IÁeg\9432
+()};
+
+195
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+»´e£Á©iÚs
+);
+
+199 \1e
+ gCom·»N\9eDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+200
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r3
+};
+
+201
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+205 \1e
+ gToBoÞ\97nDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+206
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r3
+};
+
+207
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+211 \1e
+ gB\9a¬yOpDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+212
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r4
+,
+r3
+};
+
+213
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+217 \1e
+ gB\9a¬yOpW\99hAÎoÿtiÚS\99eDesü\9dtÜ
+::
+In\99\9flize
+(
+
+218
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+219
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r5
+,
+r4
+,
+r3
+};
+
+220
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+224 \1e
+ gS\8c\9agAddDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+225
+Regi¡\94
+
+»gi¡\94s
+[] = {
+ý
+,
+r4
+,
+r3
+};
+
+226
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+NULL
+);
+
+230 \1e
+ gKeyedDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+231
+Regi¡\94
+
+»gi¡\94s
+[] = {
+
+232
+ý
+,
+
+233
+r5
+,
+
+235
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚs
+[] = {
+
+236
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+237
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+239
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+»´e£Á©iÚs
+);
+
+243 \1e
+ gNamedDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+244
+Regi¡\94
+
+»gi¡\94s
+[] = {
+
+245
+ý
+,
+
+246
+r5
+,
+
+248
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚs
+[] = {
+
+249
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+250
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+252
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+»´e£Á©iÚs
+);
+
+256 \1e
+ gC®lHªdËrDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+257
+Regi¡\94
+
+»gi¡\94s
+[] = {
+
+258
+ý
+,
+
+259
+r3
+,
+
+261
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚs
+[] = {
+
+262
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+263
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+265
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+»´e£Á©iÚs
+);
+
+269 \1e
+ gArgum\92tAdtÜDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+270
+Regi¡\94
+
+»gi¡\94s
+[] = {
+
+271
+ý
+,
+
+272
+r4
+,
+
+273
+r3
+,
+
+274
+r5
+,
+
+276
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚs
+[] = {
+
+277
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+278
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+279
+R\95»£Á©iÚ
+::
+IÁeg\9432
+(),
+
+280
+R\95»£Á©iÚ
+::
+IÁeg\9432
+(),
+
+282
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+»´e£Á©iÚs
+);
+
+286 \1e
+ gApiFunùiÚDesü\9dtÜ
+::
+In\99\9flize
+(
+C®lIÁ\94çûDesü\9dtÜD©a
+*
+d©a
+) {
+
+287
+Regi¡\94
+
+»gi¡\94s
+[] = {
+
+288
+ý
+,
+
+289
+r3
+,
+
+290
+r7
+,
+
+291
+r5
+,
+
+292
+r4
+,
+
+294
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚs
+[] = {
+
+295
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+296
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+297
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+298
+R\95»£Á©iÚ
+::
+Tagged
+(),
+
+299
+R\95»£Á©iÚ
+::
+Ex\8bº®
+(),
+
+301
+ gd©a
+->
+In\99\9flize
+(
+¬¿ysize
+(
+»gi¡\94s
+),\84egi¡\94s,
+»´e£Á©iÚs
+);
+
+ @lithium-codegen-ppc.cc
+
+5 \ 2
+ ~"¤c/v8.h
+"
+
+7 \ 2
+ ~"¤c/ba£/b\99s.h
+"
+
+8 \ 2
+ ~"¤c/code-çùÜy.h
+"
+
+9 \ 2
+ ~"¤c/code-¡ubs.h
+"
+
+10 \ 2
+ ~"¤c/hydrog\92-o¤.h
+"
+
+11 \ 2
+ ~"¤c/ic/ic.h
+"
+
+12 \ 2
+ ~"¤c/ic/¡ub-ÿche.h
+"
+
+13 \ 2
+ ~"¤c/µc/l\99hium-codeg\92-µc.h
+"
+
+14 \ 2
+ ~"¤c/µc/l\99hium-g-»sÞv\94-µc.h
+"
+
+16
+Çme¥aû
+
+ gv8
+ {
+
+17
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+20 þas
+ cSaãpo\9atG\92\94©Ü
+
+ gFINAL
+ :
+public
+
+C®lW¿µ\94
+ {
+
+21
+public
+:
+
+22
+Saãpo\9atG\92\94©Ü
+(
+LCodeG\92
+*
+codeg\92
+,
+LPo\9a\8brM
+*
+po\9a\8brs
+,
+
+23
+Saãpo\9at
+::
+DeÝtMode
+
+mode
+)
+
+24 :
+codeg\92_
+(
+codeg\92
+),
+po\9a\8brs_
+(
+po\9a\8brs
+),
+deÝt_mode_
+(
+mode
+) {}
+
+25
+ gv\9ctu®
+ ~
+Saãpo\9atG\92\94©Ü
+() {}
+
+27
+v\9ctu®
+ \1e
+BefÜeC®l
+(\12
+ÿÎ_size
+ècÚ¡
+ gOVERRIDE
+ {}
+
+29
+v\9ctu®
+ \1e
+Aá\94C®l
+(ècÚ¡
+ gOVERRIDE
+ {
+
+30
+ gcodeg\92_
+->
+RecÜdSaãpo\9at
+(
+po\9a\8brs_
+,
+deÝt_mode_
+);
+
+33
+ g´iv©e
+:
+
+34
+LCodeG\92
+*
+codeg\92_
+;
+
+35
+LPo\9a\8brM
+*
+ gpo\9a\8brs_
+;
+
+36
+ gSaãpo\9at
+::
+DeÝtMode
+
+deÝt_mode_
+;
+
+40 \ 1
+ #__
+
+ `masm
+()->
+
+ )
+
+42
+boÞ
+
+ gLCodeG\92
+::
+G\92\94©eCode
+() {
+
+43
+LPha£
+
+pha£
+("Z_Cod\90g\92\94©iÚ",
+chunk
+());
+
+44
+DCHECK
+(
+is_unu£d
+());
+
+45
+ g¡©us_
+ =
+GENERATING
+;
+
+50
+F¿meScÝe
+
+äame_scÝe
+(
+masm_
+,
+S\8fckF¿me
+::
+NONE
+);
+
+52 \15
+G\92\94©ePrÞogue
+(è&&
+G\92\94©eBody
+(è&&
+G\92\94©eDeã¼edCode
+() &&
+
+53
+G\92\94©eJumpTabË
+(è&&
+G\92\94©eSaãpo\9atTabË
+();
+
+57 \1e
+ gLCodeG\92
+::
+F\9aishCode
+(
+HªdË
+<
+Code
+>
+code
+) {
+
+58
+DCHECK
+(
+is_dÚe
+());
+
+59
+ gcode
+->
+£t_¡ack_¦Ùs
+(
+G\91S\8fckSlÙCouÁ
+());
+
+60
+ gcode
+->
+£t_§ãpo\9at_\8fbË_off£t
+(
+§ãpo\9ats_
+.
+G\91CodeOff£t
+());
+
+61 ià(
+ gcode
+->
+is_Ýtimized_code
+()è
+Regi¡\94W\97kObjeùsInO±imizedCode
+(
+code
+);
+
+62
+PÝuÏ\8bDeÝtimiz©iÚD©a
+(
+code
+);
+
+66 \1e
+ gLCodeG\92
+::
+SaveC®ËrDoubËs
+() {
+
+67
+DCHECK
+(
+\9afo
+()->
+§ves_ÿÎ\94_doubËs
+());
+
+68
+DCHECK
+(
+N\93dsEag\94F¿me
+());
+
+69
+Comm\92t
+(";;; Save clobbered callee double\84egisters");
+
+70 \12
+ gcouÁ
+ = 0;
+
+71
+B\99VeùÜ
+*
+ gdoubËs
+ =
+chunk
+()->
+®loÿ\8bd_doubË_»gi¡\94s
+();
+
+72
+ gB\99VeùÜ
+::
+I\8b¿tÜ
+
+§ve_\99\94©Ü
+(
+doubËs
+);
+
+73 \1f!
+ g§ve_\99\94©Ü
+.
+DÚe
+()) {
+
+74
+__
+
+¡fd
+(
+DoubËRegi¡\94
+::
+FromAÎoÿtiÚIndex
+(
+§ve_\99\94©Ü
+.
+Cu¼\92t
+()),
+
+75
+MemO³¿nd
+(
+¥
+,
+couÁ
+ *
+kDoubËSize
+));
+
+76
+ g§ve_\99\94©Ü
+.
+Advªû
+();
+
+77
+ gcouÁ
+++;
+
+82 \1e
+ gLCodeG\92
+::
+Re¡ÜeC®ËrDoubËs
+() {
+
+83
+DCHECK
+(
+\9afo
+()->
+§ves_ÿÎ\94_doubËs
+());
+
+84
+DCHECK
+(
+N\93dsEag\94F¿me
+());
+
+85
+Comm\92t
+(";;; Restore clobbered callee double\84egisters");
+
+86
+B\99VeùÜ
+*
+ gdoubËs
+ =
+chunk
+()->
+®loÿ\8bd_doubË_»gi¡\94s
+();
+
+87
+ gB\99VeùÜ
+::
+I\8b¿tÜ
+
+§ve_\99\94©Ü
+(
+doubËs
+);
+
+88 \12
+ gcouÁ
+ = 0;
+
+89 \1f!
+ g§ve_\99\94©Ü
+.
+DÚe
+()) {
+
+90
+__
+
+lfd
+(
+DoubËRegi¡\94
+::
+FromAÎoÿtiÚIndex
+(
+§ve_\99\94©Ü
+.
+Cu¼\92t
+()),
+
+91
+MemO³¿nd
+(
+¥
+,
+couÁ
+ *
+kDoubËSize
+));
+
+92
+ g§ve_\99\94©Ü
+.
+Advªû
+();
+
+93
+ gcouÁ
+++;
+
+98
+boÞ
+
+ gLCodeG\92
+::
+G\92\94©ePrÞogue
+() {
+
+99
+DCHECK
+(
+is_g\92\94©\9ag
+());
+
+101 ià(
+\9afo
+()->
+IsO±imiz\9ag
+()) {
+
+102
+ gProf\9eeEÁryHookStub
+::
+MaybeC®lEÁryHook
+(
+masm_
+);
+
+104 #ifdeà
+DEBUG
+
+
+105 ià(
+¡¾\92
+(
+FLAG_¡Ý_©
+) > 0 &&
+
+106
+ g\9afo_
+->
+funùiÚ
+()->
+Çme
+()->
+IsUtf8Equ®To
+(
+CS\8cVeùÜ
+(
+FLAG_¡Ý_©
+))) {
+
+107
+__
+
+¡Ý
+("stop_at");
+
+121 ià(
+ g\9afo_
+->
+this_has_u£s
+(è&& info_->
+¡riù_mode
+(è=ð
+SLOPPY
+ &&
+
+122 !
+\9afo_
+->
+is_Çtive
+()) {
+
+123
+Lab\96
+
+ok
+;
+
+124 \12
+ g»ûiv\94_off£t
+ =
+\9afo_
+->
+scÝe
+()->
+num_·¿m\91\94s
+(è*
+kPo\9a\8brSize
+;
+
+125
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+,
+»ûiv\94_off£t
+));
+
+126
+__
+
+Com·»RoÙ
+(
+r5
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+127
+__
+
+bÃ
+(&
+ok
+);
+
+129
+__
+
+LßdP
+(
+r5
+,
+Glob®ObjeùO³¿nd
+());
+
+130
+__
+
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+Ô5,
+Glob®Objeù
+::
+kGlob®ProxyOff£t
+));
+
+132
+__
+
+StÜeP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+,
+»ûiv\94_off£t
+));
+
+134
+__
+
+b\9ad
+(&
+ok
+);
+
+138 \12
+ g´Þogue_off£t
+ =
+masm_
+->
+pc_off£t
+();
+
+140 ià(
+ g´Þogue_off£t
+) {
+
+143
+ g´Þogue_off£t
+ +ð
+In¡ruùiÚ
+::
+kIn¡rSize
+;
+
+144
+__
+
+addi
+(
+\9d
+, ip,
+O³¿nd
+(
+´Þogue_off£t
+));
+
+146
+\9afo
+()->
+£t_´Þogue_off£t
+(
+´Þogue_off£t
+);
+
+147 ià(
+N\93dsEag\94F¿me
+()) {
+
+148 ià(
+\9afo
+()->
+IsStub
+()) {
+
+149
+__
+
+StubPrÞogue
+(
+´Þogue_off£t
+);
+
+151
+__
+
+PrÞogue
+(
+\9afo
+()->
+IsCodeP»Ag\9agAùive
+(),
+´Þogue_off£t
+);
+
+153
+ gäame_is_bu\9et_
+ =
+\8cue
+;
+
+154
+ g\9afo_
+->
+AddNoF¿meRªge
+(0,
+masm_
+->
+pc_off£t
+());
+
+158 \12
+ g¦Ùs
+ =
+G\91S\8fckSlÙCouÁ
+();
+
+159 ià(
+ g¦Ùs
+ > 0) {
+
+160
+__
+
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+¦Ùs
+ *
+kPo\9a\8brSize
+));
+
+161 ià(
+ gFLAG_debug_code
+) {
+
+162
+__
+
+Push
+(
+r3
+,
+r4
+);
+
+163
+__
+
+li
+(
+r0
+,
+O³¿nd
+(
+¦Ùs
+));
+
+164
+__
+
+mtùr
+(
+r0
+);
+
+165
+__
+
+addi
+(
+r3
+,
+¥
+,
+O³¿nd
+((
+¦Ùs
+ + 2è*
+kPo\9a\8brSize
+));
+
+166
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+kSlÙsZV®ue
+));
+
+167
+Lab\96
+
+ gloÝ
+;
+
+168
+__
+
+b\9ad
+(&
+loÝ
+);
+
+169
+__
+
+StÜePU
+(
+r4
+,
+MemO³¿nd
+(
+r3
+, -
+kPo\9a\8brSize
+));
+
+170
+__
+
+bdnz
+(&
+loÝ
+);
+
+171
+__
+
+PÝ
+(
+r3
+,
+r4
+);
+
+175 ià(
+\9afo
+()->
+§ves_ÿÎ\94_doubËs
+()) {
+
+176
+SaveC®ËrDoubËs
+();
+
+180 \12
+ gh\97p_¦Ùs
+ =
+\9afo
+()->
+num_h\97p_¦Ùs
+(è-
+Cڋxt
+::
+MIN_CONTEXT_SLOTS
+;
+
+181 ià(
+ gh\97p_¦Ùs
+ > 0) {
+
+182
+Comm\92t
+(";;; Allocate\86ocal context");
+
+183
+boÞ
+
+ gÃed_wr\99e_b¬r\9br
+ =
+\8cue
+;
+
+185 ià(
+ gh\97p_¦Ùs
+ <ð
+Fa¡NewCÚ\8bxtStub
+::
+kMaximumSlÙs
+) {
+
+186
+Fa¡NewCÚ\8bxtStub
+
+¡ub
+(
+isީe
+(),
+h\97p_¦Ùs
+);
+
+187
+__
+
+C®lStub
+(&
+¡ub
+);
+
+189
+ gÃed_wr\99e_b¬r\9br
+ =
+çl£
+;
+
+191
+__
+
+push
+(
+r4
+);
+
+192
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kNewFunùiÚCÚ\8bxt
+, 1);
+
+194
+RecÜdSaãpo\9at
+(
+Saãpo\9at
+::
+kNoLazyDeÝt
+);
+
+197
+__
+
+mr
+(
+ý
+,
+r3
+);
+
+198
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+200 \12
+ gnum_·¿m\91\94s
+ =
+scÝe
+()->
+num_·¿m\91\94s
+();
+
+201 \ f\12
+ gi
+ = 0; i <
+ gnum_·¿m\91\94s
+; i++) {
+
+202
+V¬\9fbË
+*
+ gv¬
+ =
+scÝe
+()->
+·¿m\91\94
+(
+i
+);
+
+203 ià(
+ gv¬
+->
+IsCÚ\8bxtSlÙ
+()) {
+
+204 \12
+ g·¿m\91\94_off£t
+ =
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrSPOff£t
+ +
+
+205 (
+num_·¿m\91\94s
+ - 1 -
+i
+è*
+kPo\9a\8brSize
+;
+
+207
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+å
+,
+·¿m\91\94_off£t
+));
+
+209
+MemO³¿nd
+
+ g\8frg\91
+ =
+CÚ\8bxtO³¿nd
+(
+ý
+,
+v¬
+->
+\9adex
+());
+
+210
+__
+
+StÜeP
+(
+r3
+,
+\8frg\91
+,
+r0
+);
+
+212 ià(
+ gÃed_wr\99e_b¬r\9br
+) {
+
+213
+__
+
+RecÜdWr\99eCÚ\8bxtSlÙ
+(
+ý
+,
+\8frg\91
+.
+off£t
+(),
+r3
+,
+r6
+,
+
+214
+G\91L\9akRegi¡\94S\8f\8b
+(),
+kSaveFPRegs
+);
+
+215 } \vià(
+ gFLAG_debug_code
+) {
+
+216
+Lab\96
+
+ gdÚe
+;
+
+217
+__
+
+JumpIfInNewS·û
+(
+ý
+,
+r3
+, &
+dÚe
+);
+
+218
+__
+
+AbÜt
+(
+kEx³ùedNewS·ûObjeù
+);
+
+219
+__
+
+b\9ad
+(&
+dÚe
+);
+
+223
+Comm\92t
+(";;; End\87llocate\86ocal context");
+
+227 ià(
+ gFLAG_\8caû
+ &&
+\9afo
+()->
+IsO±imiz\9ag
+()) {
+
+230
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kT¿ûEÁ\94
+, 0);
+
+232 \15 !
+is_ab܋d
+();
+
+236 \1e
+ gLCodeG\92
+::
+G\92\94©eO¤PrÞogue
+() {
+
+239 ià(
+o¤_pc_off£t_
+ >= 0) \15;
+
+241
+ go¤_pc_off£t_
+ =
+masm
+()->
+pc_off£t
+();
+
+245 \12
+ g¦Ùs
+ =
+G\91S\8fckSlÙCouÁ
+(è-
+g¿ph
+()->
+o¤
+()->
+UnÝtimizedF¿meSlÙs
+();
+
+246
+DCHECK
+(
+¦Ùs
+ >= 0);
+
+247
+__
+
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+¦Ùs
+ *
+kPo\9a\8brSize
+));
+
+251 \1e
+ gLCodeG\92
+::
+G\92\94©eBodyIn¡ruùiÚP»
+(
+LIn¡ruùiÚ
+*
+\9a¡r
+) {
+
+252 ià(
+\9a¡r
+->
+IsC®l
+()) {
+
+253
+Ensu»S·ûFÜLazyDeÝt
+(
+DeÝtimiz\94
+::
+·tch_size
+());
+
+255 ià(!
+ g\9a¡r
+->
+IsLazyBa\9eout
+(è&& !\9a¡r->
+IsG
+()) {
+
+256
+ g§ãpo\9ats_
+.
+BumpLa¡LazySaãpo\9atIndex
+();
+
+261
+boÞ
+
+ gLCodeG\92
+::
+G\92\94©eDeã¼edCode
+() {
+
+262
+DCHECK
+(
+is_g\92\94©\9ag
+());
+
+263 ià(
+ gdeã¼ed_
+.
+Ëngth
+() > 0) {
+
+264 \ f\12
+ gi
+ = 0; !
+is_ab܋d
+(è&& i <
+ gdeã¼ed_
+.
+Ëngth
+(); i++) {
+
+265
+LDeã¼edCode
+*
+ gcode
+ =
+deã¼ed_
+[
+i
+];
+
+267
+HV®ue
+*
+ gv®ue
+ =
+
+268
+\9a¡ruùiÚs_
+->
+©
+(
+code
+->
+\9a¡ruùiÚ_\9adex
+())->
+hydrog\92_v®ue
+();
+
+269
+RecÜdAndWr\99ePos\99iÚ
+(
+
+270
+chunk
+()->
+g¿ph
+()->
+SourûPos\99iÚToSü\9dtPos\99iÚ
+(
+v®ue
+->
+pos\99iÚ
+()));
+
+272
+Comm\92t
+(
+
+275
+code
+->
+\9a¡ruùiÚ_\9adex
+(), code->
+\9a¡r
+()->
+hydrog\92_v®ue
+()->
+id
+(),
+
+276
+code
+->
+\9a¡r
+()->
+MÃmÚic
+());
+
+277
+__
+
+b\9ad
+(
+code
+->
+\92\8cy
+());
+
+278 ià(
+N\93dsDeã¼edF¿me
+()) {
+
+279
+Comm\92t
+(";;; Build frame");
+
+280
+DCHECK
+(!
+äame_is_bu\9et_
+);
+
+281
+DCHECK
+(
+\9afo
+()->
+IsStub
+());
+
+282
+ gäame_is_bu\9et_
+ =
+\8cue
+;
+
+283
+__
+
+LßdSmiL\99\94®
+(
+sü©ch0
+(),
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+STUB
+));
+
+284
+__
+
+PushFixedF¿me
+(
+sü©ch0
+());
+
+285
+__
+
+addi
+(
+å
+,
+¥
+,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSizeFromFp
+));
+
+286
+Comm\92t
+(";;; Deferred code");
+
+288
+ gcode
+->
+G\92\94©e
+();
+
+289 ià(
+N\93dsDeã¼edF¿me
+()) {
+
+290
+Comm\92t
+(";;; Destroy frame");
+
+291
+DCHECK
+(
+äame_is_bu\9et_
+);
+
+292
+__
+
+PÝFixedF¿me
+(
+\9d
+);
+
+293
+ gäame_is_bu\9et_
+ =
+çl£
+;
+
+295
+__
+
+b
+(
+code
+->
+ex\99
+());
+
+299 \15 !
+is_ab܋d
+();
+
+303
+boÞ
+
+ gLCodeG\92
+::
+G\92\94©eJumpTabË
+() {
+
+311 ià(!
+is_\9at24
+((
+masm
+()->
+pc_off£t
+(è/
+As£mbËr
+::
+kIn¡rSize
+) +
+
+312
+jump_\8fbË_
+.
+Ëngth
+() * 7)) {
+
+313
+AbÜt
+(
+kG\92\94©edCodeIsTooL¬ge
+);
+
+316 ià(
+ gjump_\8fbË_
+.
+Ëngth
+() > 0) {
+
+317
+Lab\96
+
+ gÃeds_äame
+,
+ gÿÎ_deÝt_\92\8cy
+;
+
+319
+Comm\92t
+(";;; -------------------- Jump\81able --------------------");
+
+320
+Add»ss
+
+ gba£
+ =
+jump_\8fbË_
+[0].
+add»ss
+;
+
+322
+Regi¡\94
+
+ g\92\8cy_off£t
+ =
+sü©ch0
+();
+
+324 \12
+ gËngth
+ =
+jump_\8fbË_
+.
+Ëngth
+();
+
+325 \ f\12
+ gi
+ = 0; i <
+ gËngth
+; i++) {
+
+326
+ gDeÝtimiz\94
+::
+JumpTabËEÁry
+*
+\8fbË_\92\8cy
+ = &
+jump_\8fbË_
+[
+i
+];
+
+327
+__
+
+b\9ad
+(&
+\8fbË_\92\8cy
+->
+Ïb\96
+);
+
+329
+DCHECK_EQ
+(
+jump_\8fbË_
+[0].
+ba\9eout_ty³
+,
+\8fbË_\92\8cy
+->bailout_type);
+
+330
+Add»ss
+
+ g\92\8cy
+ =
+\8fbË_\92\8cy
+->
+add»ss
+;
+
+331
+DeÝtComm\92t
+(
+\8fbË_\92\8cy
+->
+»asÚ
+);
+
+336
+__
+
+mov
+(
+\92\8cy_off£t
+,
+O³¿nd
+(
+\92\8cy
+ -
+ba£
+));
+
+338 ià(
+ g\8fbË_\92\8cy
+->
+ gÃeds_äame
+) {
+
+339
+DCHECK
+(!
+\9afo
+()->
+§ves_ÿÎ\94_doubËs
+());
+
+340 ià(
+ gÃeds_äame
+.
+is_bound
+()) {
+
+341
+__
+
+b
+(&
+Ãeds_äame
+);
+
+343
+__
+
+b\9ad
+(&
+Ãeds_äame
+);
+
+344
+Comm\92t
+(";;; call deopt with frame");
+
+348
+DCHECK
+(
+\9afo
+()->
+IsStub
+());
+
+349
+__
+
+LßdSmiL\99\94®
+(
+\9d
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+STUB
+));
+
+350
+__
+
+PushFixedF¿me
+(
+\9d
+);
+
+351
+__
+
+addi
+(
+å
+,
+¥
+,
+
+352
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSizeFromFp
+));
+
+353
+__
+
+b\9ad
+(&
+ÿÎ_deÝt_\92\8cy
+);
+
+356
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+FÜDeÝtEÁry
+(
+ba£
+)));
+
+357
+__
+
+add
+(
+\9d
+,
+\92\8cy_off£t
+, ip);
+
+358
+__
+
+C®l
+(
+\9d
+);
+
+363
+boÞ
+
+ gÃed_b¿nch
+ = ((
+i
+ + 1è!ð
+Ëngth
+è||
+ÿÎ_deÝt_\92\8cy
+.
+is_bound
+();
+
+365 ià(
+ gÃed_b¿nch
+è
+__
+
+b
+(&
+ÿÎ_deÝt_\92\8cy
+);
+
+369 ià(!
+ gÿÎ_deÝt_\92\8cy
+.
+is_bound
+()) {
+
+370
+Comm\92t
+(";;; call deopt");
+
+371
+__
+
+b\9ad
+(&
+ÿÎ_deÝt_\92\8cy
+);
+
+373 ià(
+\9afo
+()->
+§ves_ÿÎ\94_doubËs
+()) {
+
+374
+DCHECK
+(
+\9afo
+()->
+IsStub
+());
+
+375
+Re¡ÜeC®ËrDoubËs
+();
+
+379
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+FÜDeÝtEÁry
+(
+ba£
+)));
+
+380
+__
+
+add
+(
+\9d
+,
+\92\8cy_off£t
+, ip);
+
+381
+__
+
+C®l
+(
+\9d
+);
+
+387 ià(!
+is_ab܋d
+()è
+ g¡©us_
+ =
+DONE
+;
+
+388 \15 !
+is_ab܋d
+();
+
+392
+boÞ
+
+ gLCodeG\92
+::
+G\92\94©eSaãpo\9atTabË
+() {
+
+393
+DCHECK
+(
+is_dÚe
+());
+
+394
+ g§ãpo\9ats_
+.
+Em\99
+(
+masm
+(),
+G\91S\8fckSlÙCouÁ
+());
+
+395 \15 !
+is_ab܋d
+();
+
+399
+Regi¡\94
+
+ gLCodeG\92
+::
+ToRegi¡\94
+(\12
+\9adex
+) const {
+
+400 \15
+Regi¡\94
+::
+FromAÎoÿtiÚIndex
+(
+\9adex
+);
+
+404
+DoubËRegi¡\94
+
+ gLCodeG\92
+::
+ToDoubËRegi¡\94
+(\12
+\9adex
+) const {
+
+405 \15
+DoubËRegi¡\94
+::
+FromAÎoÿtiÚIndex
+(
+\9adex
+);
+
+409
+Regi¡\94
+
+ gLCodeG\92
+::
+ToRegi¡\94
+(
+LO³¿nd
+*
+Ý
+) const {
+
+410
+DCHECK
+(
+Ý
+->
+IsRegi¡\94
+());
+
+411 \15
+ToRegi¡\94
+(
+Ý
+->
+\9adex
+());
+
+415
+Regi¡\94
+
+ gLCodeG\92
+::
+Em\99LßdRegi¡\94
+(
+LO³¿nd
+*
+Ý
+, Regi¡\94
+sü©ch
+) {
+
+416 ià(
+ gÝ
+->
+IsRegi¡\94
+()) {
+
+417 \15
+ToRegi¡\94
+(
+Ý
+->
+\9adex
+());
+
+418 } \vià(
+ gÝ
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+419
+LCÚ¡ªtO³¿nd
+*
+ gcÚ¡_Ý
+ = LCÚ¡ªtO³¿nd::
+ÿ¡
+(
+Ý
+);
+
+420
+HCÚ¡ªt
+*
+ gcÚ¡ªt
+ =
+chunk_
+->
+LookupCÚ¡ªt
+(
+cÚ¡_Ý
+);
+
+421
+ gHªdË
+<
+ gObjeù
+>
+ gl\99\94®
+ =
+cÚ¡ªt
+->
+hªdË
+(
+isީe
+());
+
+422
+R\95»£Á©iÚ
+
+ gr
+ =
+chunk_
+->
+LookupL\99\94®R\95»£Á©iÚ
+(
+cÚ¡_Ý
+);
+
+423 ià(
+ gr
+.
+IsIÁeg\9432
+()) {
+
+424
+DCHECK
+(
+l\99\94®
+->
+IsNumb\94
+());
+
+425
+__
+
+LßdIÁL\99\94®
+(
+sü©ch
+,
+¡©ic_ÿ¡
+<
+\9at32_t
+>(
+l\99\94®
+->
+Numb\94
+()));
+
+426 } \vià(
+ gr
+.
+IsDoubË
+()) {
+
+427
+AbÜt
+(
+kEm\99LßdRegi¡\94UnsuµÜ\8bdDoubËImmed\9f\8b
+);
+
+429
+DCHECK
+(
+r
+.
+IsSmiOrTagged
+());
+
+430
+__
+
+Move
+(
+sü©ch
+,
+l\99\94®
+);
+
+432 \15
+ gsü©ch
+;
+
+433 } \vià(
+ gÝ
+->
+IsS\8fckSlÙ
+()) {
+
+434
+__
+
+LßdP
+(
+sü©ch
+,
+ToMemO³¿nd
+(
+Ý
+));
+
+435 \15
+ gsü©ch
+;
+
+437
+UNREACHABLE
+();
+
+438 \15
+ gsü©ch
+;
+
+442 \1e
+ gLCodeG\92
+::
+Em\99LßdIÁeg\94CÚ¡ªt
+(
+LCÚ¡ªtO³¿nd
+*
+cÚ¡_Ý
+,
+
+443
+Regi¡\94
+
+d¡
+) {
+
+444
+DCHECK
+(
+IsIÁeg\9432
+(
+cÚ¡_Ý
+));
+
+445
+HCÚ¡ªt
+*
+ gcÚ¡ªt
+ =
+chunk_
+->
+LookupCÚ¡ªt
+(
+cÚ¡_Ý
+);
+
+446
+\9at32_t
+
+ gv®ue
+ =
+cÚ¡ªt
+->
+IÁeg\9432V®ue
+();
+
+447 ià(
+IsSmi
+(
+cÚ¡_Ý
+)) {
+
+448
+__
+
+LßdSmiL\99\94®
+(
+d¡
+,
+Smi
+::
+FromIÁ
+(
+v®ue
+));
+
+450
+__
+
+LßdIÁL\99\94®
+(
+d¡
+,
+v®ue
+);
+
+455
+DoubËRegi¡\94
+
+ gLCodeG\92
+::
+ToDoubËRegi¡\94
+(
+LO³¿nd
+*
+Ý
+) const {
+
+456
+DCHECK
+(
+Ý
+->
+IsDoubËRegi¡\94
+());
+
+457 \15
+ToDoubËRegi¡\94
+(
+Ý
+->
+\9adex
+());
+
+461
+ gHªdË
+<
+ gObjeù
+>
+ gLCodeG\92
+::
+ToHªdË
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+) const {
+
+462
+HCÚ¡ªt
+*
+cÚ¡ªt
+ =
+chunk_
+->
+LookupCÚ¡ªt
+(
+Ý
+);
+
+463
+DCHECK
+(
+chunk_
+->
+LookupL\99\94®R\95»£Á©iÚ
+(
+Ý
+).
+IsSmiOrTagged
+());
+
+464 \15
+ gcÚ¡ªt
+->
+hªdË
+(
+isީe
+());
+
+468
+boÞ
+
+ gLCodeG\92
+::
+IsIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+) const {
+
+469 \15
+chunk_
+->
+LookupL\99\94®R\95»£Á©iÚ
+(
+Ý
+).
+IsSmiOrIÁeg\9432
+();
+
+473
+boÞ
+
+ gLCodeG\92
+::
+IsSmi
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+) const {
+
+474 \15
+chunk_
+->
+LookupL\99\94®R\95»£Á©iÚ
+(
+Ý
+).
+IsSmi
+();
+
+478
+\9at32_t
+
+ gLCodeG\92
+::
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+) const {
+
+479 \15
+ToR\95»£Á©iÚ
+(
+Ý
+,
+R\95»£Á©iÚ
+::
+IÁeg\9432
+());
+
+483
+\9a\8d\8c_t
+
+ gLCodeG\92
+::
+ToR\95»£Á©iÚ
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+,
+
+484 cڡ
+R\95»£Á©iÚ
+&
+r
+) const {
+
+485
+HCÚ¡ªt
+*
+ gcÚ¡ªt
+ =
+chunk_
+->
+LookupCÚ¡ªt
+(
+Ý
+);
+
+486
+\9at32_t
+
+ gv®ue
+ =
+cÚ¡ªt
+->
+IÁeg\9432V®ue
+();
+
+487 ià(
+ gr
+.
+IsIÁeg\9432
+()è\15
+ gv®ue
+;
+
+488
+DCHECK
+(
+r
+.
+IsSmiOrTagged
+());
+
+489 \15
+ g»\9a\8b½»t_ÿ¡
+<
+ g\9a\8d\8c_t
+>(
+ gSmi
+::
+FromIÁ
+(
+v®ue
+));
+
+493
+Smi
+*
+ gLCodeG\92
+::
+ToSmi
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+) const {
+
+494
+HCÚ¡ªt
+*
+cÚ¡ªt
+ =
+chunk_
+->
+LookupCÚ¡ªt
+(
+Ý
+);
+
+495 \15
+ gSmi
+::
+FromIÁ
+(
+cÚ¡ªt
+->
+IÁeg\9432V®ue
+());
+
+499 \b
+ gLCodeG\92
+::
+ToDoubË
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+) const {
+
+500
+HCÚ¡ªt
+*
+cÚ¡ªt
+ =
+chunk_
+->
+LookupCÚ¡ªt
+(
+Ý
+);
+
+501
+DCHECK
+(
+cÚ¡ªt
+->
+HasDoubËV®ue
+());
+
+502 \15
+ gcÚ¡ªt
+->
+DoubËV®ue
+();
+
+506
+O³¿nd
+
+ gLCodeG\92
+::
+ToO³¿nd
+(
+LO³¿nd
+*
+Ý
+) {
+
+507 ià(
+Ý
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+508
+LCÚ¡ªtO³¿nd
+*
+cÚ¡_Ý
+ = LCÚ¡ªtO³¿nd::
+ÿ¡
+(
+Ý
+);
+
+509
+HCÚ¡ªt
+*
+ gcÚ¡ªt
+ =
+chunk
+()->
+LookupCÚ¡ªt
+(
+cÚ¡_Ý
+);
+
+510
+R\95»£Á©iÚ
+
+ gr
+ =
+chunk_
+->
+LookupL\99\94®R\95»£Á©iÚ
+(
+cÚ¡_Ý
+);
+
+511 ià(
+ gr
+.
+IsSmi
+()) {
+
+512
+DCHECK
+(
+cÚ¡ªt
+->
+HasSmiV®ue
+());
+
+513 \15
+O³¿nd
+(
+Smi
+::
+FromIÁ
+(
+cÚ¡ªt
+->
+IÁeg\9432V®ue
+()));
+
+514 } \vià(
+ gr
+.
+IsIÁeg\9432
+()) {
+
+515
+DCHECK
+(
+cÚ¡ªt
+->
+HasIÁeg\9432V®ue
+());
+
+516 \15
+O³¿nd
+(
+cÚ¡ªt
+->
+IÁeg\9432V®ue
+());
+
+517 } \vià(
+ gr
+.
+IsDoubË
+()) {
+
+518
+AbÜt
+(
+kToO³¿ndUnsuµÜ\8bdDoubËImmed\9f\8b
+);
+
+520
+DCHECK
+(
+r
+.
+IsTagged
+());
+
+521 \15
+O³¿nd
+(
+cÚ¡ªt
+->
+hªdË
+(
+isީe
+()));
+
+522 } \vià(
+ gÝ
+->
+IsRegi¡\94
+()) {
+
+523 \15
+O³¿nd
+(
+ToRegi¡\94
+(
+Ý
+));
+
+524 } \vià(
+ gÝ
+->
+IsDoubËRegi¡\94
+()) {
+
+525
+AbÜt
+(
+kToO³¿ndIsDoubËRegi¡\94Unim¶em\92\8bd
+);
+
+526 \15
+ gO³¿nd
+::
+Z\94o
+();
+
+529
+UNREACHABLE
+();
+
+530 \15
+ gO³¿nd
+::
+Z\94o
+();
+
+534 \18\12
+Argum\92tsOff£tW\99houtF¿me
+(\12
+\9adex
+) {
+
+535
+DCHECK
+(
+\9adex
+ < 0);
+
+536 \15 -(
+ g\9adex
+ + 1è*
+ gkPo\9a\8brSize
+;
+
+540
+MemO³¿nd
+
+ gLCodeG\92
+::
+ToMemO³¿nd
+(
+LO³¿nd
+*
+Ý
+) const {
+
+541
+DCHECK
+(!
+Ý
+->
+IsRegi¡\94
+());
+
+542
+DCHECK
+(!
+Ý
+->
+IsDoubËRegi¡\94
+());
+
+543
+DCHECK
+(
+Ý
+->
+IsS\8fckSlÙ
+(è|| op->
+IsDoubËS\8fckSlÙ
+());
+
+544 ià(
+N\93dsEag\94F¿me
+()) {
+
+545 \15
+MemO³¿nd
+(
+å
+,
+S\8fckSlÙOff£t
+(
+Ý
+->
+\9adex
+()));
+
+549 \15
+MemO³¿nd
+(
+¥
+,
+Argum\92tsOff£tW\99houtF¿me
+(
+Ý
+->
+\9adex
+()));
+
+554
+MemO³¿nd
+
+ gLCodeG\92
+::
+ToHighMemO³¿nd
+(
+LO³¿nd
+*
+Ý
+) const {
+
+555
+DCHECK
+(
+Ý
+->
+IsDoubËS\8fckSlÙ
+());
+
+556 ià(
+N\93dsEag\94F¿me
+()) {
+
+557 \15
+MemO³¿nd
+(
+å
+,
+S\8fckSlÙOff£t
+(
+Ý
+->
+\9adex
+()è+
+kPo\9a\8brSize
+);
+
+561 \15
+MemO³¿nd
+(
+¥
+,
+
+562
+Argum\92tsOff£tW\99houtF¿me
+(
+Ý
+->
+\9adex
+()è+
+kPo\9a\8brSize
+);
+
+567 \1e
+ gLCodeG\92
+::
+Wr\99eT¿n¦©iÚ
+(
+LEnv\9cÚm\92t
+*
+\92v\9cÚm\92t
+,
+
+568
+T¿n¦©iÚ
+*
+\8cª¦©iÚ
+) {
+
+569 ià(
+ g\92v\9cÚm\92t
+ =ð
+NULL
+) \15;
+
+572 \12
+ g\8cª¦©iÚ_size
+ =
+\92v\9cÚm\92t
+->
+\8cª¦©iÚ_size
+();
+
+574 \12
+ gheight
+ =
+\8cª¦©iÚ_size
+ -
+\92v\9cÚm\92t
+->
+·¿m\91\94_couÁ
+();
+
+576
+Wr\99eT¿n¦©iÚ
+(
+\92v\9cÚm\92t
+->
+ou\8br
+(),
+\8cª¦©iÚ
+);
+
+577
+boÞ
+
+ ghas_þosu»_id
+ =
+
+578 !
+\9afo
+()->
+þosu»
+().
+is_nuÎ
+() &&
+
+579 !
+\9afo
+()->
+þosu»
+().
+is_id\92tiÿl_to
+(
+\92v\9cÚm\92t
+->closure());
+
+580 \12
+ gþosu»_id
+ =
+has_þosu»_id
+
+
+581 ?
+Def\9aeDeÝtimiz©iÚL\99\94®
+(
+\92v\9cÚm\92t
+->
+þosu»
+())
+
+582 :
+T¿n¦©iÚ
+::
+kS\96fL\99\94®Id
+;
+
+584 \1a
+ g\92v\9cÚm\92t
+->
+äame_ty³
+()) {
+
+585 \ 4
+ gJS_FUNCTION
+:
+
+586
+\8cª¦©iÚ
+->
+Beg\9aJSF¿me
+(
+\92v\9cÚm\92t
+->
+a¡_id
+(),
+þosu»_id
+,
+height
+);
+
+588 \ 4
+ gJS_CONSTRUCT
+:
+
+589
+\8cª¦©iÚ
+->
+Beg\9aCÚ¡ruùStubF¿me
+(
+þosu»_id
+,
+\8cª¦©iÚ_size
+);
+
+591 \ 4
+ gJS_GETTER
+:
+
+592
+DCHECK
+(
+\8cª¦©iÚ_size
+ == 1);
+
+593
+DCHECK
+(
+height
+ == 0);
+
+594
+ g\8cª¦©iÚ
+->
+Beg\9aG\91\8brStubF¿me
+(
+þosu»_id
+);
+
+596 \ 4
+ gJS_SETTER
+:
+
+597
+DCHECK
+(
+\8cª¦©iÚ_size
+ == 2);
+
+598
+DCHECK
+(
+height
+ == 0);
+
+599
+ g\8cª¦©iÚ
+->
+Beg\9aS\91\8brStubF¿me
+(
+þosu»_id
+);
+
+601 \ 4
+ gSTUB
+:
+
+602
+\8cª¦©iÚ
+->
+Beg\9aComp\9eedStubF¿me
+();
+
+604 \ 4
+ gARGUMENTS_ADAPTOR
+:
+
+605
+\8cª¦©iÚ
+->
+Beg\9aArgum\92tsAdtÜF¿me
+(
+þosu»_id
+,
+\8cª¦©iÚ_size
+);
+
+609 \12
+ gobjeù_\9adex
+ = 0;
+
+610 \12
+ gdem©\94\9flized_\9adex
+ = 0;
+
+611 \ f\12
+ gi
+ = 0; i <
+ g\8cª¦©iÚ_size
+; ++i) {
+
+612
+LO³¿nd
+*
+ gv®ue
+ =
+\92v\9cÚm\92t
+->
+v®ues
+()->
+©
+(
+i
+);
+
+613
+AddToT¿n¦©iÚ
+(
+
+614
+\92v\9cÚm\92t
+,
+\8cª¦©iÚ
+,
+v®ue
+,\83nv\9cÚm\92t->
+HasTaggedV®ueAt
+(
+i
+),
+
+615
+\92v\9cÚm\92t
+->
+HasU\9at32V®ueAt
+(
+i
+), &
+objeù_\9adex
+, &
+dem©\94\9flized_\9adex
+);
+
+620 \1e
+ gLCodeG\92
+::
+AddToT¿n¦©iÚ
+(
+LEnv\9cÚm\92t
+*
+\92v\9cÚm\92t
+,
+
+621
+T¿n¦©iÚ
+*
+\8cª¦©iÚ
+,
+LO³¿nd
+*
+Ý
+,
+
+622
+boÞ
+
+is_\8fgged
+, boÞ
+is_u\9at32
+,
+
+623 \12*
+objeù_\9adex_po\9a\8br
+,
+
+624 \12*
+dem©\94\9flized_\9adex_po\9a\8br
+) {
+
+625 ià(
+ gÝ
+ =ð
+LEnv\9cÚm\92t
+::
+m©\94\9fliz©iÚ_m¬k\94
+()) {
+
+626 \12
+objeù_\9adex
+ = (*
+objeù_\9adex_po\9a\8br
+)++;
+
+627 ià(
+ g\92v\9cÚm\92t
+->
+ObjeùIsDu¶iÿ\8bAt
+(
+objeù_\9adex
+)) {
+
+628 \12
+ gdu³_of
+ =
+\92v\9cÚm\92t
+->
+ObjeùDu¶iÿ\8bOfAt
+(
+objeù_\9adex
+);
+
+629
+ g\8cª¦©iÚ
+->
+Du¶iÿ\8bObjeù
+(
+du³_of
+);
+
+632 \12
+ gobjeù_Ëngth
+ =
+\92v\9cÚm\92t
+->
+ObjeùL\92gthAt
+(
+objeù_\9adex
+);
+
+633 ià(
+ g\92v\9cÚm\92t
+->
+ObjeùIsArgum\92tsAt
+(
+objeù_\9adex
+)) {
+
+634
+ g\8cª¦©iÚ
+->
+Beg\9aArgum\92tsObjeù
+(
+objeù_Ëngth
+);
+
+636
+ g\8cª¦©iÚ
+->
+Beg\9aCtu»dObjeù
+(
+objeù_Ëngth
+);
+
+638 \12
+ gdem©\94\9flized_\9adex
+ = *
+dem©\94\9flized_\9adex_po\9a\8br
+;
+
+639 \12
+ g\92v_off£t
+ =
+\92v\9cÚm\92t
+->
+\8cª¦©iÚ_size
+(è+
+dem©\94\9flized_\9adex
+;
+
+640 *
+ gdem©\94\9flized_\9adex_po\9a\8br
+ +ð
+objeù_Ëngth
+;
+
+641 \ f\12
+ gi
+ = 0; i <
+ gobjeù_Ëngth
+; ++i) {
+
+642
+LO³¿nd
+*
+ gv®ue
+ =
+\92v\9cÚm\92t
+->
+v®ues
+()->
+©
+(
+\92v_off£t
+ +
+i
+);
+
+643
+AddToT¿n¦©iÚ
+(
+\92v\9cÚm\92t
+,
+\8cª¦©iÚ
+,
+v®ue
+,
+
+644
+\92v\9cÚm\92t
+->
+HasTaggedV®ueAt
+(
+\92v_off£t
+ +
+i
+),
+
+645
+\92v\9cÚm\92t
+->
+HasU\9at32V®ueAt
+(
+\92v_off£t
+ +
+i
+),
+
+646
+objeù_\9adex_po\9a\8br
+,
+dem©\94\9flized_\9adex_po\9a\8br
+);
+
+651 ià(
+ gÝ
+->
+IsS\8fckSlÙ
+()) {
+
+652 ià(
+ gis_\8fgged
+) {
+
+653
+ g\8cª¦©iÚ
+->
+StÜeS\8fckSlÙ
+(
+Ý
+->
+\9adex
+());
+
+654 } \vià(
+ gis_u\9at32
+) {
+
+655
+ g\8cª¦©iÚ
+->
+StÜeU\9at32S\8fckSlÙ
+(
+Ý
+->
+\9adex
+());
+
+657
+ g\8cª¦©iÚ
+->
+StÜeIÁ32S\8fckSlÙ
+(
+Ý
+->
+\9adex
+());
+
+659 } \vià(
+ gÝ
+->
+IsDoubËS\8fckSlÙ
+()) {
+
+660
+ g\8cª¦©iÚ
+->
+StÜeDoubËS\8fckSlÙ
+(
+Ý
+->
+\9adex
+());
+
+661 } \vià(
+ gÝ
+->
+IsRegi¡\94
+()) {
+
+662
+Regi¡\94
+
+ g»g
+ =
+ToRegi¡\94
+(
+Ý
+);
+
+663 ià(
+ gis_\8fgged
+) {
+
+664
+ g\8cª¦©iÚ
+->
+StÜeRegi¡\94
+(
+»g
+);
+
+665 } \vià(
+ gis_u\9at32
+) {
+
+666
+ g\8cª¦©iÚ
+->
+StÜeU\9at32Regi¡\94
+(
+»g
+);
+
+668
+ g\8cª¦©iÚ
+->
+StÜeIÁ32Regi¡\94
+(
+»g
+);
+
+670 } \vià(
+ gÝ
+->
+IsDoubËRegi¡\94
+()) {
+
+671
+DoubËRegi¡\94
+
+ g»g
+ =
+ToDoubËRegi¡\94
+(
+Ý
+);
+
+672
+ g\8cª¦©iÚ
+->
+StÜeDoubËRegi¡\94
+(
+»g
+);
+
+673 } \vià(
+ gÝ
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+674
+HCÚ¡ªt
+*
+ gcÚ¡ªt
+ =
+chunk
+()->
+LookupCÚ¡ªt
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+Ý
+));
+
+675 \12
+ g¤c_\9adex
+ =
+Def\9aeDeÝtimiz©iÚL\99\94®
+(
+cÚ¡ªt
+->
+hªdË
+(
+isީe
+()));
+
+676
+ g\8cª¦©iÚ
+->
+StÜeL\99\94®
+(
+¤c_\9adex
+);
+
+678
+UNREACHABLE
+();
+
+683 \1e
+ gLCodeG\92
+::
+C®lCode
+(
+HªdË
+<
+Code
+>
+code
+,
+R\96ocInfo
+::
+Mode
+
+mode
+,
+
+684
+LIn¡ruùiÚ
+*
+\9a¡r
+) {
+
+685
+C®lCodeG\92\94ic
+(
+code
+,
+mode
+,
+\9a¡r
+,
+RECORD_SIMPLE_SAFEPOINT
+);
+
+689 \1e
+ gLCodeG\92
+::
+C®lCodeG\92\94ic
+(
+HªdË
+<
+Code
+>
+code
+,
+R\96ocInfo
+::
+Mode
+
+mode
+,
+
+690
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+
+691
+Saãpo\9atMode
+
+§ãpo\9at_mode
+) {
+
+692
+DCHECK
+(
+\9a¡r
+ !ð
+NULL
+);
+
+693
+__
+
+C®l
+(
+code
+,
+mode
+);
+
+694
+RecÜdSaãpo\9atW\99hLazyDeÝt
+(
+\9a¡r
+,
+§ãpo\9at_mode
+);
+
+698 ià(
+ gcode
+->
+k\9ad
+(è=ð
+Code
+::
+BINARY_OP_IC
+ ||
+code
+->k\9ad(è=ðCode::
+COMPARE_IC
+) {
+
+699
+__
+
+nÝ
+();
+
+704 \1e
+ gLCodeG\92
+::
+C®lRuÁime
+(cڡ
+RuÁime
+::
+FunùiÚ
+*
+funùiÚ
+, \12
+num_¬gum\92ts
+,
+
+705
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+SaveFPRegsMode
+
+§ve_doubËs
+) {
+
+706
+DCHECK
+(
+\9a¡r
+ !ð
+NULL
+);
+
+708
+__
+
+C®lRuÁime
+(
+funùiÚ
+,
+num_¬gum\92ts
+,
+§ve_doubËs
+);
+
+710
+RecÜdSaãpo\9atW\99hLazyDeÝt
+(
+\9a¡r
+,
+RECORD_SIMPLE_SAFEPOINT
+);
+
+714 \1e
+ gLCodeG\92
+::
+LßdCÚ\8bxtFromDeã¼ed
+(
+LO³¿nd
+*
+cڋxt
+) {
+
+715 ià(
+cڋxt
+->
+IsRegi¡\94
+()) {
+
+716
+__
+
+Move
+(
+ý
+,
+ToRegi¡\94
+(
+cڋxt
+));
+
+717 } \vià(
+ gcڋxt
+->
+IsS\8fckSlÙ
+()) {
+
+718
+__
+
+LßdP
+(
+ý
+,
+ToMemO³¿nd
+(
+cڋxt
+));
+
+719 } \vià(
+ gcڋxt
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+720
+HCÚ¡ªt
+*
+ gcÚ¡ªt
+ =
+
+721
+chunk_
+->
+LookupCÚ¡ªt
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+cڋxt
+));
+
+722
+__
+
+Move
+(
+ý
+,
+HªdË
+<
+Objeù
+>::
+ÿ¡
+(
+cÚ¡ªt
+->
+hªdË
+(
+isީe
+())));
+
+724
+UNREACHABLE
+();
+
+729 \1e
+ gLCodeG\92
+::
+C®lRuÁimeFromDeã¼ed
+(
+RuÁime
+::
+FunùiÚId
+
+id
+, \12
+¬gc
+,
+
+730
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+LO³¿nd
+*
+cڋxt
+) {
+
+731
+LßdCÚ\8bxtFromDeã¼ed
+(
+cڋxt
+);
+
+732
+__
+
+C®lRuÁimeSaveDoubËs
+(
+id
+);
+
+733
+RecÜdSaãpo\9atW\99hRegi¡\94s
+(
+\9a¡r
+->
+po\9a\8br_m
+(),
+¬gc
+,
+
+734
+Saãpo\9at
+::
+kNoLazyDeÝt
+);
+
+738 \1e
+ gLCodeG\92
+::
+Regi¡\94Env\9cÚm\92tFÜDeÝtimiz©iÚ
+(
+LEnv\9cÚm\92t
+*
+\92v\9cÚm\92t
+,
+
+739
+Saãpo\9at
+::
+DeÝtMode
+
+mode
+) {
+
+740
+\92v\9cÚm\92t
+->
+£t_has_b\93n_u£d
+();
+
+741 ià(!
+ g\92v\9cÚm\92t
+->
+HasB\93nRegi¡\94ed
+()) {
+
+755 \12
+ gäame_couÁ
+ = 0;
+
+756 \12
+ gjsäame_couÁ
+ = 0;
+
+757 \ f
+LEnv\9cÚm\92t
+*
+ ge
+ =
+\92v\9cÚm\92t
+;\83 !ð
+NULL
+;\83 =
+e
+->
+ou\8br
+()) {
+
+758 ++
+äame_couÁ
+;
+
+759 ià(
+ ge
+->
+äame_ty³
+(è=ð
+JS_FUNCTION
+) {
+
+760 ++
+jsäame_couÁ
+;
+
+763
+T¿n¦©iÚ
+
+\8cª¦©iÚ
+(&
+\8cª¦©iÚs_
+,
+äame_couÁ
+,
+jsäame_couÁ
+,
+zÚe
+());
+
+764
+Wr\99eT¿n¦©iÚ
+(
+\92v\9cÚm\92t
+, &
+\8cª¦©iÚ
+);
+
+765 \12
+ gdeÝtimiz©iÚ_\9adex
+ =
+deÝtimiz©iÚs_
+.
+Ëngth
+();
+
+766 \12
+ gpc_off£t
+ =
+masm
+()->
+pc_off£t
+();
+
+767
+ g\92v\9cÚm\92t
+->
+Regi¡\94
+(
+deÝtimiz©iÚ_\9adex
+,
+\8cª¦©iÚ
+.
+\9adex
+(),
+
+768 (
+mode
+ =ð
+Saãpo\9at
+::
+kLazyDeÝt
+è?
+pc_off£t
+ : -1);
+
+769
+ gdeÝtimiz©iÚs_
+.
+Add
+(
+\92v\9cÚm\92t
+,
+zÚe
+());
+
+774 \1e
+ gLCodeG\92
+::
+DeÝtimizeIf
+(
+CÚd\99iÚ
+
+cÚd
+,
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+
+775 cڡ \ 5*
+d\91a\9e
+,
+
+776
+DeÝtimiz\94
+::
+Ba\9eoutTy³
+
+ba\9eout_ty³
+,
+
+777
+CRegi¡\94
+
+ü
+) {
+
+778
+LEnv\9cÚm\92t
+*
+ g\92v\9cÚm\92t
+ =
+\9a¡r
+->
+\92v\9cÚm\92t
+();
+
+779
+Regi¡\94Env\9cÚm\92tFÜDeÝtimiz©iÚ
+(
+\92v\9cÚm\92t
+,
+Saãpo\9at
+::
+kNoLazyDeÝt
+);
+
+780
+DCHECK
+(
+\92v\9cÚm\92t
+->
+HasB\93nRegi¡\94ed
+());
+
+781 \12
+ gid
+ =
+\92v\9cÚm\92t
+->
+deÝtimiz©iÚ_\9adex
+();
+
+782
+DCHECK
+(
+\9afo
+()->
+IsO±imiz\9ag
+(è|| info()->
+IsStub
+());
+
+783
+Add»ss
+
+ g\92\8cy
+ =
+
+784
+DeÝtimiz\94
+::
+G\91DeÝtimiz©iÚEÁry
+(
+isީe
+(),
+id
+,
+ba\9eout_ty³
+);
+
+785 ià(
+ g\92\8cy
+ =ð
+NULL
+) {
+
+786
+AbÜt
+(
+kBa\9eoutWasNÙP»·»d
+);
+
+790 ià(
+ gFLAG_deÝt_ev\94y_n_times
+ !ð0 && !
+\9afo
+()->
+IsStub
+()) {
+
+791
+CRegi¡\94
+
+®t_ü
+ =
+ü6
+;
+
+792
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+793
+Ex\8bº®Reã»nû
+
+ gcouÁ
+ = Ex\8bº®Reã»nû::
+¡»ss_deÝt_couÁ
+(
+isީe
+());
+
+794
+Lab\96
+
+ gno_deÝt
+;
+
+795
+DCHECK
+(!
+®t_ü
+.
+is
+(
+ü
+));
+
+796
+__
+
+Push
+(
+r4
+,
+sü©ch
+);
+
+797
+__
+
+mov
+(
+sü©ch
+,
+O³¿nd
+(
+couÁ
+));
+
+798
+__
+
+lwz
+(
+r4
+,
+MemO³¿nd
+(
+sü©ch
+));
+
+799
+__
+
+subi
+(
+r4
+,\844,
+O³¿nd
+(1));
+
+800
+__
+
+cmpi
+(
+r4
+,
+O³¿nd
+::
+Z\94o
+(),
+®t_ü
+);
+
+801
+__
+
+bÃ
+(&
+no_deÝt
+,
+®t_ü
+);
+
+802
+__
+
+li
+(
+r4
+,
+O³¿nd
+(
+FLAG_deÝt_ev\94y_n_times
+));
+
+803
+__
+
+¡w
+(
+r4
+,
+MemO³¿nd
+(
+sü©ch
+));
+
+804
+__
+
+PÝ
+(
+r4
+,
+sü©ch
+);
+
+806
+__
+
+C®l
+(
+\92\8cy
+,
+R\96ocInfo
+::
+RUNTIME_ENTRY
+);
+
+807
+__
+
+b\9ad
+(&
+no_deÝt
+);
+
+808
+__
+
+¡w
+(
+r4
+,
+MemO³¿nd
+(
+sü©ch
+));
+
+809
+__
+
+PÝ
+(
+r4
+,
+sü©ch
+);
+
+812 ià(
+\9afo
+()->
+ShouldT¿pOnDeÝt
+()) {
+
+813
+__
+
+¡Ý
+("\8c_Ú_deÝt",
+cÚd
+,
+kDeçuÉStÝCode
+,
+ü
+);
+
+816
+ gDeÝtimiz\94
+::
+R\97sÚ
+
+»asÚ
+(
+\9a¡r
+->
+hydrog\92_v®ue
+()->
+pos\99iÚ
+().
+¿w
+(),
+
+817
+\9a¡r
+->
+MÃmÚic
+(),
+d\91a\9e
+);
+
+818
+DCHECK
+(
+\9afo
+()->
+IsStub
+(è||
+äame_is_bu\9et_
+);
+
+821 ià(
+ gcÚd
+ =ð
+®
+ &&
+äame_is_bu\9et_
+ && !
+\9afo
+()->
+§ves_ÿÎ\94_doubËs
+()) {
+
+822
+DeÝtComm\92t
+(
+»asÚ
+);
+
+823
+__
+
+C®l
+(
+\92\8cy
+,
+R\96ocInfo
+::
+RUNTIME_ENTRY
+);
+
+825
+ gDeÝtimiz\94
+::
+JumpTabËEÁry
+
+\8fbË_\92\8cy
+(
+\92\8cy
+,
+»asÚ
+,
+ba\9eout_ty³
+,
+
+826 !
+äame_is_bu\9et_
+);
+
+829 ià(
+ gjump_\8fbË_
+.
+is_em±y
+() ||
+
+830 !
+ g\8fbË_\92\8cy
+.
+IsEquiv®\92tTo
+(
+jump_\8fbË_
+.
+ϡ
+())) {
+
+831
+ gjump_\8fbË_
+.
+Add
+(
+\8fbË_\92\8cy
+,
+zÚe
+());
+
+833
+__
+
+b
+(
+cÚd
+, &
+jump_\8fbË_
+.
+ϡ
+().
+Ïb\96
+,
+ü
+);
+
+838 \1e
+ gLCodeG\92
+::
+DeÝtimizeIf
+(
+CÚd\99iÚ
+
+cÚd\99iÚ
+,
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+
+839 cڡ \ 5*
+d\91a\9e
+,
+CRegi¡\94
+
+ü
+) {
+
+840
+ gDeÝtimiz\94
+::
+Ba\9eoutTy³
+
+ba\9eout_ty³
+ =
+
+841
+\9afo
+()->
+IsStub
+(è?
+DeÝtimiz\94
+::
+LAZY
+ : DeÝtimiz\94::
+EAGER
+;
+
+842
+DeÝtimizeIf
+(
+cÚd\99iÚ
+,
+\9a¡r
+,
+d\91a\9e
+,
+ba\9eout_ty³
+,
+ü
+);
+
+846 \1e
+ gLCodeG\92
+::
+PÝuÏ\8bDeÝtimiz©iÚD©a
+(
+HªdË
+<
+Code
+>
+code
+) {
+
+847 \12
+Ëngth
+ =
+deÝtimiz©iÚs_
+.length();
+
+848 ià(
+ gËngth
+ == 0) \15;
+
+849
+ gHªdË
+<
+ gDeÝtimiz©iÚIÅutD©a
+>
+ gd©a
+ =
+
+850
+DeÝtimiz©iÚIÅutD©a
+::
+New
+(
+isީe
+(),
+Ëngth
+,
+TENURED
+);
+
+852
+ gHªdË
+<
+ gBy\8bA¼ay
+>
+ g\8cª¦©iÚs
+ =
+
+853
+\8cª¦©iÚs_
+.
+C»©eBy\8bA¼ay
+(
+isީe
+()->
+çùÜy
+());
+
+854
+ gd©a
+->
+S\91T¿n¦©iÚBy\8bA¼ay
+(*
+\8cª¦©iÚs
+);
+
+855
+ gd©a
+->
+S\91IÆ\9aedFunùiÚCouÁ
+(
+Smi
+::
+FromIÁ
+(
+\9al\9aed_funùiÚ_couÁ_
+));
+
+856
+ gd©a
+->
+S\91O±imiz©iÚId
+(
+Smi
+::
+FromIÁ
+(
+\9afo_
+->
+Ýtimiz©iÚ_id
+()));
+
+857 ià(
+ g\9afo_
+->
+IsO±imiz\9ag
+()) {
+
+859
+AÎowDeã¼edHªdËD\94eã»nû
+
+ g®low_hªdË_d\94eã»nû
+;
+
+860
+ gd©a
+->
+S\91Sh¬edFunùiÚInfo
+(*
+\9afo_
+->
+sh¬ed_\9afo
+());
+
+862
+ gd©a
+->
+S\91Sh¬edFunùiÚInfo
+(
+Smi
+::
+FromIÁ
+(0));
+
+865
+ gHªdË
+<
+ gFixedA¼ay
+>
+ gl\99\94®s
+ =
+
+866
+çùÜy
+()->
+NewFixedA¼ay
+(
+deÝtimiz©iÚ_l\99\94®s_
+.
+Ëngth
+(),
+TENURED
+);
+
+868
+AÎowDeã¼edHªdËD\94eã»nû
+
+ gcÝy_hªdËs
+;
+
+869 \ f\12
+ gi
+ = 0; i <
+ gdeÝtimiz©iÚ_l\99\94®s_
+.
+Ëngth
+(); i++) {
+
+870
+ gl\99\94®s
+->
+£t
+(
+i
+, *
+deÝtimiz©iÚ_l\99\94®s_
+[i]);
+
+872
+ gd©a
+->
+S\91L\99\94®A¼ay
+(*
+l\99\94®s
+);
+
+875
+ gd©a
+->
+S\91O¤A¡Id
+(
+Smi
+::
+FromIÁ
+(
+\9afo_
+->
+o¤_a¡_id
+().
+ToIÁ
+()));
+
+876
+ gd©a
+->
+S\91O¤PcOff£t
+(
+Smi
+::
+FromIÁ
+(
+o¤_pc_off£t_
+));
+
+879 \ f\12
+ gi
+ = 0; i <
+ gËngth
+; i++) {
+
+880
+LEnv\9cÚm\92t
+*
+ g\92v
+ =
+deÝtimiz©iÚs_
+[
+i
+];
+
+881
+ gd©a
+->
+S\91A¡Id
+(
+i
+,
+\92v
+->
+a¡_id
+());
+
+882
+ gd©a
+->
+S\91T¿n¦©iÚIndex
+(
+i
+,
+Smi
+::
+FromIÁ
+(
+\92v
+->
+\8cª¦©iÚ_\9adex
+()));
+
+883
+ gd©a
+->
+S\91Argum\92tsS\8fckHeight
+(
+i
+,
+
+884
+Smi
+::
+FromIÁ
+(
+\92v
+->
+¬gum\92ts_¡ack_height
+()));
+
+885
+ gd©a
+->
+S\91Pc
+(
+i
+,
+Smi
+::
+FromIÁ
+(
+\92v
+->
+pc_off£t
+()));
+
+887
+ gcode
+->
+£t_deÝtimiz©iÚ_d©a
+(*
+d©a
+);
+
+891 \12
+ gLCodeG\92
+::
+Def\9aeDeÝtimiz©iÚL\99\94®
+(
+HªdË
+<
+Objeù
+>
+l\99\94®
+) {
+
+892 \12
+»suÉ
+ =
+deÝtimiz©iÚ_l\99\94®s_
+.
+Ëngth
+();
+
+893 \ f\12
+ gi
+ = 0; i <
+ gdeÝtimiz©iÚ_l\99\94®s_
+.
+Ëngth
+(); ++i) {
+
+894 ià(
+ gdeÝtimiz©iÚ_l\99\94®s_
+[
+i
+].
+is_id\92tiÿl_to
+(
+l\99\94®
+)è\15
+ gi
+;
+
+896
+ gdeÝtimiz©iÚ_l\99\94®s_
+.
+Add
+(
+l\99\94®
+,
+zÚe
+());
+
+897 \15
+ g»suÉ
+;
+
+901 \1e
+ gLCodeG\92
+::
+PÝuÏ\8bDeÝtimiz©iÚL\99\94®sW\99hIÆ\9aedFunùiÚs
+() {
+
+902
+DCHECK
+(
+deÝtimiz©iÚ_l\99\94®s_
+.
+Ëngth
+() == 0);
+
+904 cڡ
+ gZÚeLi¡
+<
+ gHªdË
+<
+ gJSFunùiÚ
+> >*
+ g\9al\9aed_þosu»s
+ =
+
+905
+chunk
+()->
+\9al\9aed_þosu»s
+();
+
+907 \ f\12
+ gi
+ = 0,
+ gËngth
+ =
+\9al\9aed_þosu»s
+->
+Ëngth
+(); i <\86ength; i++) {
+
+908
+Def\9aeDeÝtimiz©iÚL\99\94®
+(
+\9al\9aed_þosu»s
+->
+©
+(
+i
+));
+
+911
+ g\9al\9aed_funùiÚ_couÁ_
+ =
+deÝtimiz©iÚ_l\99\94®s_
+.
+Ëngth
+();
+
+915 \1e
+ gLCodeG\92
+::
+RecÜdSaãpo\9atW\99hLazyDeÝt
+(
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+
+916
+Saãpo\9atMode
+
+§ãpo\9at_mode
+) {
+
+917 ià(
+ g§ãpo\9at_mode
+ =ð
+RECORD_SIMPLE_SAFEPOINT
+) {
+
+918
+RecÜdSaãpo\9at
+(
+\9a¡r
+->
+po\9a\8br_m
+(),
+Saãpo\9at
+::
+kLazyDeÝt
+);
+
+920
+DCHECK
+(
+§ãpo\9at_mode
+ =ð
+RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
+);
+
+921
+RecÜdSaãpo\9atW\99hRegi¡\94s
+(
+\9a¡r
+->
+po\9a\8br_m
+(), 0,
+
+922
+Saãpo\9at
+::
+kLazyDeÝt
+);
+
+927 \1e
+ gLCodeG\92
+::
+RecÜdSaãpo\9at
+(
+LPo\9a\8brM
+*
+po\9a\8brs
+,
+Saãpo\9at
+::
+K\9ad
+
+k\9ad
+,
+
+928 \12
+¬gum\92ts
+,
+Saãpo\9at
+::
+DeÝtMode
+
+deÝt_mode
+) {
+
+929
+DCHECK
+(
+ex³ùed_§ãpo\9at_k\9ad_
+ =ð
+k\9ad
+);
+
+931 cڡ
+ gZÚeLi¡
+<
+ gLO³¿nd
+*>*
+ gÝ\94ªds
+ =
+po\9a\8brs
+->
+G\91NÜm®izedO³¿nds
+();
+
+932
+Saãpo\9at
+
+ g§ãpo\9at
+ =
+
+933
+§ãpo\9ats_
+.
+Def\9aeSaãpo\9at
+(
+masm
+(),
+k\9ad
+,
+¬gum\92ts
+,
+deÝt_mode
+);
+
+934 \ f\12
+ gi
+ = 0; i <
+ gÝ\94ªds
+->
+Ëngth
+(); i++) {
+
+935
+LO³¿nd
+*
+ gpo\9a\8br
+ =
+Ý\94ªds
+->
+©
+(
+i
+);
+
+936 ià(
+ gpo\9a\8br
+->
+IsS\8fckSlÙ
+()) {
+
+937
+ g§ãpo\9at
+.
+Def\9aePo\9a\8brSlÙ
+(
+po\9a\8br
+->
+\9adex
+(),
+zÚe
+());
+
+938 } \vià(
+ gpo\9a\8br
+->
+IsRegi¡\94
+(è&& (
+ gk\9ad
+ &
+ gSaãpo\9at
+::
+kW\99hRegi¡\94s
+)) {
+
+939
+§ãpo\9at
+.
+Def\9aePo\9a\8brRegi¡\94
+(
+ToRegi¡\94
+(
+po\9a\8br
+),
+zÚe
+());
+
+942 #ià
+V8_OOL_CONSTANT_POOL
+
+
+943 ià(
+ gk\9ad
+ &
+ gSaãpo\9at
+::
+kW\99hRegi¡\94s
+) {
+
+945
+§ãpo\9at
+.
+Def\9aePo\9a\8brRegi¡\94
+(
+kCÚ¡ªtPoÞRegi¡\94
+,
+zÚe
+());
+
+951 \1e
+ gLCodeG\92
+::
+RecÜdSaãpo\9at
+(
+LPo\9a\8brM
+*
+po\9a\8brs
+,
+
+952
+Saãpo\9at
+::
+DeÝtMode
+
+deÝt_mode
+) {
+
+953
+RecÜdSaãpo\9at
+(
+po\9a\8brs
+,
+Saãpo\9at
+::
+kSim¶e
+, 0,
+deÝt_mode
+);
+
+957 \1e
+ gLCodeG\92
+::
+RecÜdSaãpo\9at
+(
+Saãpo\9at
+::
+DeÝtMode
+
+deÝt_mode
+) {
+
+958
+LPo\9a\8brM
+
+em±y_po\9a\8brs
+(
+zÚe
+());
+
+959
+RecÜdSaãpo\9at
+(&
+em±y_po\9a\8brs
+,
+deÝt_mode
+);
+
+963 \1e
+ gLCodeG\92
+::
+RecÜdSaãpo\9atW\99hRegi¡\94s
+(
+LPo\9a\8brM
+*
+po\9a\8brs
+,
+
+964 \12
+¬gum\92ts
+,
+
+965
+Saãpo\9at
+::
+DeÝtMode
+
+deÝt_mode
+) {
+
+966
+RecÜdSaãpo\9at
+(
+po\9a\8brs
+,
+Saãpo\9at
+::
+kW\99hRegi¡\94s
+,
+¬gum\92ts
+,
+deÝt_mode
+);
+
+970 \1e
+ gLCodeG\92
+::
+RecÜdAndWr\99ePos\99iÚ
+(\12
+pos\99iÚ
+) {
+
+971 ià(
+pos\99iÚ
+ =ð
+R\96ocInfo
+::
+kNoPos\99iÚ
+) \15;
+
+972
+masm
+()->
+pos\99iÚs_»cÜd\94
+()->
+RecÜdPos\99iÚ
+(
+pos\99iÚ
+);
+
+973
+masm
+()->
+pos\99iÚs_»cÜd\94
+()->
+Wr\99eRecÜdedPos\99iÚs
+();
+
+977 \18cڡ \ 5*
+Lab\96Ty³
+(
+LLab\96
+*
+Ïb\96
+) {
+
+978 ià(
+ gÏb\96
+->
+is_loÝ_h\97d\94
+()) \15 " (loop header)";
+
+979 ià(
+ gÏb\96
+->
+is_o¤_\92\8cy
+()) \15 " (OSR\83ntry)";
+
+984 \1e
+ gLCodeG\92
+::
+DoLab\96
+(
+LLab\96
+*
+Ïb\96
+) {
+
+985
+Comm\92t
+(";;; <@%d,#%d> -------------------- B%d%s --------------------",
+
+986
+cu¼\92t_\9a¡ruùiÚ_
+,
+Ïb\96
+->
+hydrog\92_v®ue
+()->
+id
+(),
+
+987
+Ïb\96
+->
+block_id
+(),
+Lab\96Ty³
+(label));
+
+988
+__
+
+b\9ad
+(
+Ïb\96
+->label());
+
+989
+ gcu¼\92t_block_
+ =
+Ïb\96
+->
+block_id
+();
+
+990
+DoG
+(
+Ïb\96
+);
+
+994 \1e
+ gLCodeG\92
+::
+DoP¬®ËlMove
+(
+LP¬®ËlMove
+*
+move
+è{
+»sÞv\94_
+.
+ResÞve
+(move); }
+
+997 \1e
+ gLCodeG\92
+::
+DoG
+(
+LG
+*
+g
+) {
+
+998 \ f\12
+i
+ =
+LG
+::
+FIRST_INNER_POSITION
+;
+ gi
+ <ðLG::
+LAST_INNER_POSITION
+;
+
+999
+ gi
+++) {
+
+1000
+ gLG
+::
+IÂ\94Pos\99iÚ
+
+\9aÃr_pos
+ =
+¡©ic_ÿ¡
+<
+LG
+::IÂ\94Pos\99iÚ>(
+i
+);
+
+1001
+LP¬®ËlMove
+*
+ gmove
+ =
+g
+->
+G\91P¬®ËlMove
+(
+\9aÃr_pos
+);
+
+1002 ià(
+ gmove
+ !ð
+NULL
+è
+DoP¬®ËlMove
+(
+move
+);
+
+1007 \1e
+ gLCodeG\92
+::
+DoIn¡ruùiÚG
+(
+LIn¡ruùiÚG
+*
+\9a¡r
+è{
+DoG
+(instr); }
+
+1010 \1e
+ gLCodeG\92
+::
+DoP¬am\91\94
+(
+LP¬am\91\94
+*
+\9a¡r
+) {
+
+1015 \1e
+LCodeG\92
+::
+DoC®lStub
+(
+LC®lStub
+*
+\9a¡r
+) {
+
+1016
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+1017
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()).
+is
+(
+r3
+));
+
+1018 \1a
+ g\9a¡r
+->
+hydrog\92
+()->
+majÜ_key
+()) {
+
+1019 \ 4
+ gCodeStub
+::
+RegExpExec
+: {
+
+1020
+RegExpExecStub
+
+¡ub
+(
+isީe
+());
+
+1021
+C®lCode
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+1024 \ 4
+ gCodeStub
+::
+SubS\8c\9ag
+: {
+
+1025
+SubS\8c\9agStub
+
+¡ub
+(
+isީe
+());
+
+1026
+C®lCode
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+1029 \ 4
+ gCodeStub
+::
+S\8c\9agCom·»
+: {
+
+1030
+S\8c\9agCom·»Stub
+
+¡ub
+(
+isީe
+());
+
+1031
+C®lCode
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+1035
+UNREACHABLE
+();
+
+1040 \1e
+ gLCodeG\92
+::
+DoUnknownOSRV®ue
+(
+LUnknownOSRV®ue
+*
+\9a¡r
+) {
+
+1041
+G\92\94©eO¤PrÞogue
+();
+
+1045 \1e
+ gLCodeG\92
+::
+DoModByPow\94Of2I
+(
+LModByPow\94Of2I
+*
+\9a¡r
+) {
+
+1046
+Regi¡\94
+
+divid\92d
+ =
+ToRegi¡\94
+(
+\9a¡r
+->dividend());
+
+1047
+\9at32_t
+
+ gdivisÜ
+ =
+\9a¡r
+->
+divisÜ
+();
+
+1048
+DCHECK
+(
+divid\92d
+.
+is
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+())));
+
+1056
+HMod
+*
+ ghmod
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+1057
+\9at32_t
+
+ gshiá
+ =
+WhichPow\94Of2Abs
+(
+divisÜ
+);
+
+1058
+Lab\96
+
+ gdivid\92d_is_nÙ_Ãg©ive
+,
+ gdÚe
+;
+
+1059 ià(
+ ghmod
+->
+CheckFÏg
+(
+HV®ue
+::
+kLeáCªBeNeg©ive
+)) {
+
+1060
+__
+
+cmpwi
+(
+divid\92d
+,
+O³¿nd
+::
+Z\94o
+());
+
+1061
+__
+
+bge
+(&
+divid\92d_is_nÙ_Ãg©ive
+);
+
+1062 ià(
+ gshiá
+) {
+
+1064
+__
+
+Ãg
+(
+divid\92d
+, dividend);
+
+1065
+__
+
+Ex\8caùB\99Rªge
+(
+divid\92d
+, divid\92d,
+shiá
+ - 1, 0);
+
+1066
+__
+
+Ãg
+(
+divid\92d
+, divid\92d,
+L\97veOE
+,
+S\91RC
+);
+
+1067 ià(
+ ghmod
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+1068
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "m\9au z\94o",
+ü0
+);
+
+1070 } \vià(!
+ ghmod
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+1071
+__
+
+li
+(
+divid\92d
+,
+O³¿nd
+::
+Z\94o
+());
+
+1073
+DeÝtimizeIf
+(
+®
+,
+\9a¡r
+, "minus zero");
+
+1075
+__
+
+b
+(&
+dÚe
+);
+
+1078
+__
+
+b\9ad
+(&
+divid\92d_is_nÙ_Ãg©ive
+);
+
+1079 ià(
+ gshiá
+) {
+
+1080
+__
+
+Ex\8caùB\99Rªge
+(
+divid\92d
+, divid\92d,
+shiá
+ - 1, 0);
+
+1082
+__
+
+li
+(
+divid\92d
+,
+O³¿nd
+::
+Z\94o
+());
+
+1084
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1088 \1e
+ gLCodeG\92
+::
+DoModByCڡI
+(
+LModByCڡI
+*
+\9a¡r
+) {
+
+1089
+Regi¡\94
+
+divid\92d
+ =
+ToRegi¡\94
+(
+\9a¡r
+->dividend());
+
+1090
+\9at32_t
+
+ gdivisÜ
+ =
+\9a¡r
+->
+divisÜ
+();
+
+1091
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1092
+DCHECK
+(!
+divid\92d
+.
+is
+(
+»suÉ
+));
+
+1094 ià(
+ gdivisÜ
+ == 0) {
+
+1095
+DeÝtimizeIf
+(
+®
+,
+\9a¡r
+, "division by zero");
+
+1099
+__
+
+Trunÿt\9agDiv
+(
+»suÉ
+,
+divid\92d
+,
+Abs
+(
+divisÜ
+));
+
+1100
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+Abs
+(
+divisÜ
+)));
+
+1101
+__
+
+muÎw
+(
+»suÉ
+,\84esuÉ,
+\9d
+);
+
+1102
+__
+
+sub
+(
+»suÉ
+,
+divid\92d
+,\84esuÉ,
+L\97veOE
+,
+S\91RC
+);
+
+1105
+HMod
+*
+ ghmod
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+1106 ià(
+ ghmod
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+1107
+Lab\96
+
+»ma\9ad\94_nÙ_z\94o
+;
+
+1108
+__
+
+bÃ
+(&
+»ma\9ad\94_nÙ_z\94o
+,
+ü0
+);
+
+1109
+__
+
+cmpwi
+(
+divid\92d
+,
+O³¿nd
+::
+Z\94o
+());
+
+1110
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "minus zero");
+
+1111
+__
+
+b\9ad
+(&
+»ma\9ad\94_nÙ_z\94o
+);
+
+1116 \1e
+ gLCodeG\92
+::
+DoModI
+(
+LModI
+*
+\9a¡r
+) {
+
+1117
+HMod
+*
+hmod
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+1118
+Regi¡\94
+
+ gËá_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëá
+());
+
+1119
+Regi¡\94
+
+ gright_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+right
+());
+
+1120
+Regi¡\94
+
+ g»suÉ_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1121
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+1122
+Lab\96
+
+ gdÚe
+;
+
+1124 ià(
+ ghmod
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+)) {
+
+1125
+__
+
+li
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+1126
+__
+
+mtx\94
+(
+r0
+);
+
+1129
+__
+
+divw
+(
+sü©ch
+,
+Ëá_»g
+,
+right_»g
+,
+S\91OE
+,
+S\91RC
+);
+
+1132 ià(
+ ghmod
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªBeDivByZ\94o
+)) {
+
+1133
+__
+
+cmpwi
+(
+right_»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+1134
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "division by zero");
+
+1139 ià(
+ ghmod
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+)) {
+
+1140
+Lab\96
+
+no_ov\94æow_possibË
+;
+
+1141 ià(
+ ghmod
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+1142
+DeÝtimizeIf
+(
+ov\94æow
+,
+\9a¡r
+, "m\9au z\94o",
+ü0
+);
+
+1144
+__
+
+bnoov\94æow
+(&
+no_ov\94æow_possibË
+,
+ü0
+);
+
+1145
+__
+
+li
+(
+»suÉ_»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+1146
+__
+
+b
+(&
+dÚe
+);
+
+1148
+__
+
+b\9ad
+(&
+no_ov\94æow_possibË
+);
+
+1151
+__
+
+muÎw
+(
+sü©ch
+,
+right_»g
+, scratch);
+
+1152
+__
+
+sub
+(
+»suÉ_»g
+,
+Ëá_»g
+,
+sü©ch
+,
+L\97veOE
+,
+S\91RC
+);
+
+1155 ià(
+ ghmod
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+1156
+__
+
+bÃ
+(&
+dÚe
+,
+ü0
+);
+
+1157
+__
+
+cmpwi
+(
+Ëá_»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+1158
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "minus zero");
+
+1161
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1165 \1e
+ gLCodeG\92
+::
+DoDivByPow\94Of2I
+(
+LDivByPow\94Of2I
+*
+\9a¡r
+) {
+
+1166
+Regi¡\94
+
+divid\92d
+ =
+ToRegi¡\94
+(
+\9a¡r
+->dividend());
+
+1167
+\9at32_t
+
+ gdivisÜ
+ =
+\9a¡r
+->
+divisÜ
+();
+
+1168
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1169
+DCHECK
+(
+divisÜ
+ =ð
+kM\9aIÁ
+ ||
+ba£
+::
+b\99s
+::
+IsPow\94OfTwo32
+(
+Abs
+(divisor)));
+
+1170
+DCHECK
+(!
+»suÉ
+.
+is
+(
+divid\92d
+));
+
+1173
+HDiv
+*
+ ghdiv
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+1174 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+è&&
+divisÜ
+ < 0) {
+
+1175
+__
+
+cmpwi
+(
+divid\92d
+,
+O³¿nd
+::
+Z\94o
+());
+
+1176
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "minus zero");
+
+1179 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+è&&
+divisÜ
+ == -1) {
+
+1180
+__
+
+lis
+(
+r0
+,
+O³¿nd
+(
+SIGN_EXT_IMM16
+(0x8000)));
+
+1181
+__
+
+cmpw
+(
+divid\92d
+,
+r0
+);
+
+1182
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "overflow");
+
+1185
+\9at32_t
+
+ gshiá
+ =
+WhichPow\94Of2Abs
+(
+divisÜ
+);
+
+1188 ià(!
+ ghdiv
+->
+CheckFÏg
+(
+HIn¡ruùiÚ
+::
+kAÎU£sTrunÿt\9agToIÁ32
+è&&
+shiá
+) {
+
+1189
+__
+
+Te¡B\99Rªge
+(
+divid\92d
+,
+shiá
+ - 1, 0,
+r0
+);
+
+1190
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "lo¡\85»cisiÚ",
+ü0
+);
+
+1193 ià(
+ gdivisÜ
+ == -1) {
+
+1194
+__
+
+Ãg
+(
+»suÉ
+,
+divid\92d
+);
+
+1197 ià(
+ gshiá
+ == 0) {
+
+1198
+__
+
+mr
+(
+»suÉ
+,
+divid\92d
+);
+
+1200 ià(
+ gshiá
+ == 1) {
+
+1201
+__
+
+¤wi
+(
+»suÉ
+,
+divid\92d
+,
+O³¿nd
+(31));
+
+1203
+__
+
+¤awi
+(
+»suÉ
+,
+divid\92d
+, 31);
+
+1204
+__
+
+¤wi
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(32 -
+shiá
+));
+
+1206
+__
+
+add
+(
+»suÉ
+,
+divid\92d
+,\84esult);
+
+1207
+__
+
+¤awi
+(
+»suÉ
+,\84esuÉ,
+shiá
+);
+
+1209 ià(
+ gdivisÜ
+ < 0è
+__
+
+Ãg
+(
+»suÉ
+,\84esult);
+
+1213 \1e
+ gLCodeG\92
+::
+DoDivByCڡI
+(
+LDivByCڡI
+*
+\9a¡r
+) {
+
+1214
+Regi¡\94
+
+divid\92d
+ =
+ToRegi¡\94
+(
+\9a¡r
+->dividend());
+
+1215
+\9at32_t
+
+ gdivisÜ
+ =
+\9a¡r
+->
+divisÜ
+();
+
+1216
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1217
+DCHECK
+(!
+divid\92d
+.
+is
+(
+»suÉ
+));
+
+1219 ià(
+ gdivisÜ
+ == 0) {
+
+1220
+DeÝtimizeIf
+(
+®
+,
+\9a¡r
+, "division by zero");
+
+1225
+HDiv
+*
+ ghdiv
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+1226 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+è&&
+divisÜ
+ < 0) {
+
+1227
+__
+
+cmpwi
+(
+divid\92d
+,
+O³¿nd
+::
+Z\94o
+());
+
+1228
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "minus zero");
+
+1231
+__
+
+Trunÿt\9agDiv
+(
+»suÉ
+,
+divid\92d
+,
+Abs
+(
+divisÜ
+));
+
+1232 ià(
+ gdivisÜ
+ < 0è
+__
+
+Ãg
+(
+»suÉ
+,\84esult);
+
+1234 ià(!
+ ghdiv
+->
+CheckFÏg
+(
+HIn¡ruùiÚ
+::
+kAÎU£sTrunÿt\9agToIÁ32
+)) {
+
+1235
+Regi¡\94
+
+sü©ch
+ =
+sü©ch0
+();
+
+1236
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+divisÜ
+));
+
+1237
+__
+
+muÎw
+(
+sü©ch
+,
+»suÉ
+,
+\9d
+);
+
+1238
+__
+
+cmpw
+(
+sü©ch
+,
+divid\92d
+);
+
+1239
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "lost\85recision");
+
+1245 \1e
+ gLCodeG\92
+::
+DoDivI
+(
+LDivI
+*
+\9a¡r
+) {
+
+1246
+HB\9a¬yO³¿tiÚ
+*
+hdiv
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+1247 cڡ
+Regi¡\94
+
+ gdivid\92d
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+divid\92d
+());
+
+1248 cڡ
+Regi¡\94
+
+ gdivisÜ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+divisÜ
+());
+
+1249
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1251
+DCHECK
+(!
+divid\92d
+.
+is
+(
+»suÉ
+));
+
+1252
+DCHECK
+(!
+divisÜ
+.
+is
+(
+»suÉ
+));
+
+1254 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+)) {
+
+1255
+__
+
+li
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+1256
+__
+
+mtx\94
+(
+r0
+);
+
+1259
+__
+
+divw
+(
+»suÉ
+,
+divid\92d
+,
+divisÜ
+,
+S\91OE
+,
+S\91RC
+);
+
+1262 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªBeDivByZ\94o
+)) {
+
+1263
+__
+
+cmpwi
+(
+divisÜ
+,
+O³¿nd
+::
+Z\94o
+());
+
+1264
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "division by zero");
+
+1268 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+1269
+Lab\96
+
+divid\92d_nÙ_z\94o
+;
+
+1270
+__
+
+cmpwi
+(
+divid\92d
+,
+O³¿nd
+::
+Z\94o
+());
+
+1271
+__
+
+bÃ
+(&
+divid\92d_nÙ_z\94o
+);
+
+1272
+__
+
+cmpwi
+(
+divisÜ
+,
+O³¿nd
+::
+Z\94o
+());
+
+1273
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "minus zero");
+
+1274
+__
+
+b\9ad
+(&
+divid\92d_nÙ_z\94o
+);
+
+1278 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+)) {
+
+1279
+Lab\96
+
+no_ov\94æow_possibË
+;
+
+1280 ià(!
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kAÎU£sTrunÿt\9agToIÁ32
+)) {
+
+1281
+DeÝtimizeIf
+(
+ov\94æow
+,
+\9a¡r
+, "ov\94æow",
+ü0
+);
+
+1284
+__
+
+bnoov\94æow
+(&
+no_ov\94æow_possibË
+,
+ü0
+);
+
+1285
+__
+
+mr
+(
+»suÉ
+,
+divid\92d
+);
+
+1287
+__
+
+b\9ad
+(&
+no_ov\94æow_possibË
+);
+
+1290 ià(!
+ ghdiv
+->
+CheckFÏg
+(
+HIn¡ruùiÚ
+::
+kAÎU£sTrunÿt\9agToIÁ32
+)) {
+
+1292
+Regi¡\94
+
+sü©ch
+ =
+sü©ch0
+();
+
+1293
+__
+
+muÎw
+(
+sü©ch
+,
+divisÜ
+,
+»suÉ
+);
+
+1294
+__
+
+cmpw
+(
+divid\92d
+,
+sü©ch
+);
+
+1295
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "lost\85recision");
+
+1300 \1e
+ gLCodeG\92
+::
+DoFloÜ\9agDivByPow\94Of2I
+(
+LFloÜ\9agDivByPow\94Of2I
+*
+\9a¡r
+) {
+
+1301
+HB\9a¬yO³¿tiÚ
+*
+hdiv
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+1302
+Regi¡\94
+
+ gdivid\92d
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+divid\92d
+());
+
+1303
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1304
+\9at32_t
+
+ gdivisÜ
+ =
+\9a¡r
+->
+divisÜ
+();
+
+1308
+\9at32_t
+
+ gshiá
+ =
+WhichPow\94Of2Abs
+(
+divisÜ
+);
+
+1309 ià(
+ gdivisÜ
+ > 0) {
+
+1310 ià(
+ gshiá
+ || !
+ g»suÉ
+.
+is
+(
+divid\92d
+)) {
+
+1311
+__
+
+¤awi
+(
+»suÉ
+,
+divid\92d
+,
+shiá
+);
+
+1317
+OEB\99
+
+ gÛ
+ =
+L\97veOE
+;
+
+1318 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1319 ià(
+ gdivisÜ
+ =ð-1 &&
+hdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kLeáCªBeM\9aIÁ
+)) {
+
+1320
+__
+
+lis
+(
+r0
+,
+O³¿nd
+(
+SIGN_EXT_IMM16
+(0x8000)));
+
+1321
+__
+
+cmpw
+(
+divid\92d
+,
+r0
+);
+
+1322
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "overflow");
+
+1325 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kLeáCªBeM\9aIÁ
+)) {
+
+1326
+__
+
+li
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+1327
+__
+
+mtx\94
+(
+r0
+);
+
+1328
+ gÛ
+ =
+S\91OE
+;
+
+1332
+__
+
+Ãg
+(
+»suÉ
+,
+divid\92d
+,
+Û
+,
+S\91RC
+);
+
+1333 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+1334
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "m\9au z\94o",
+ü0
+);
+
+1338 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+1339 ià(!
+ g\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HV®ue
+::
+kLeáCªBeM\9aIÁ
+)) {
+
+1341 ià(
+shiá
+) {
+
+1342
+__
+
+ShiáRightAr\99hImm
+(
+»suÉ
+,\84esuÉ,
+shiá
+);
+
+1345 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+1349 ià(
+ gdivisÜ
+ == -1) {
+
+1350
+DeÝtimizeIf
+(
+ov\94æow
+,
+\9a¡r
+, "ov\94æow",
+ü0
+);
+
+1354
+Lab\96
+
+ gov\94æow
+,
+ gdÚe
+;
+
+1355
+__
+
+bov\94æow
+(&
+ov\94æow
+,
+ü0
+);
+
+1356
+__
+
+¤awi
+(
+»suÉ
+,\84esuÉ,
+shiá
+);
+
+1357
+__
+
+b
+(&
+dÚe
+);
+
+1358
+__
+
+b\9ad
+(&
+ov\94æow
+);
+
+1359
+__
+
+mov
+(
+»suÉ
+,
+O³¿nd
+(
+kM\9aIÁ
+ /
+divisÜ
+));
+
+1360
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1365 \1e
+ gLCodeG\92
+::
+DoFloܚgDivByCڡI
+(
+LFloܚgDivByCڡI
+*
+\9a¡r
+) {
+
+1366
+Regi¡\94
+
+divid\92d
+ =
+ToRegi¡\94
+(
+\9a¡r
+->dividend());
+
+1367
+\9at32_t
+
+ gdivisÜ
+ =
+\9a¡r
+->
+divisÜ
+();
+
+1368
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1369
+DCHECK
+(!
+divid\92d
+.
+is
+(
+»suÉ
+));
+
+1371 ià(
+ gdivisÜ
+ == 0) {
+
+1372
+DeÝtimizeIf
+(
+®
+,
+\9a¡r
+, "division by zero");
+
+1377
+HM©hFloÜOfDiv
+*
+ ghdiv
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+1378 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+è&&
+divisÜ
+ < 0) {
+
+1379
+__
+
+cmpwi
+(
+divid\92d
+,
+O³¿nd
+::
+Z\94o
+());
+
+1380
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "minus zero");
+
+1385 ià((
+ gdivisÜ
+ > 0 && !
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kLeáCªBeNeg©ive
+)) ||
+
+1386 (
+divisÜ
+ < 0 && !
+hdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kLeáCªBePos\99ive
+))) {
+
+1387
+__
+
+Trunÿt\9agDiv
+(
+»suÉ
+,
+divid\92d
+,
+Abs
+(
+divisÜ
+));
+
+1388 ià(
+ gdivisÜ
+ < 0è
+__
+
+Ãg
+(
+»suÉ
+,\84esult);
+
+1394
+Regi¡\94
+
+ g\8bmp
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+1395
+DCHECK
+(!
+\8bmp
+.
+is
+(
+divid\92d
+è&& !\8bmp.is(
+»suÉ
+));
+
+1396
+Lab\96
+
+ gÃeds_adju¡m\92t
+,
+ gdÚe
+;
+
+1397
+__
+
+cmpwi
+(
+divid\92d
+,
+O³¿nd
+::
+Z\94o
+());
+
+1398
+__
+
+b
+(
+divisÜ
+ > 0 ?
+É
+ :
+gt
+, &
+Ãeds_adju¡m\92t
+);
+
+1399
+__
+
+Trunÿt\9agDiv
+(
+»suÉ
+,
+divid\92d
+,
+Abs
+(
+divisÜ
+));
+
+1400 ià(
+ gdivisÜ
+ < 0è
+__
+
+Ãg
+(
+»suÉ
+,\84esult);
+
+1401
+__
+
+b
+(&
+dÚe
+);
+
+1402
+__
+
+b\9ad
+(&
+Ãeds_adju¡m\92t
+);
+
+1403
+__
+
+addi
+(
+\8bmp
+,
+divid\92d
+,
+O³¿nd
+(
+divisÜ
+ > 0 ? 1 : -1));
+
+1404
+__
+
+Trunÿt\9agDiv
+(
+»suÉ
+,
+\8bmp
+,
+Abs
+(
+divisÜ
+));
+
+1405 ià(
+ gdivisÜ
+ < 0è
+__
+
+Ãg
+(
+»suÉ
+,\84esult);
+
+1406
+__
+
+subi
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(1));
+
+1407
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1412 \1e
+ gLCodeG\92
+::
+DoFloܚgDivI
+(
+LFloܚgDivI
+*
+\9a¡r
+) {
+
+1413
+HB\9a¬yO³¿tiÚ
+*
+hdiv
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+1414 cڡ
+Regi¡\94
+
+ gdivid\92d
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+divid\92d
+());
+
+1415 cڡ
+Regi¡\94
+
+ gdivisÜ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+divisÜ
+());
+
+1416
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1418
+DCHECK
+(!
+divid\92d
+.
+is
+(
+»suÉ
+));
+
+1419
+DCHECK
+(!
+divisÜ
+.
+is
+(
+»suÉ
+));
+
+1421 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+)) {
+
+1422
+__
+
+li
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+1423
+__
+
+mtx\94
+(
+r0
+);
+
+1426
+__
+
+divw
+(
+»suÉ
+,
+divid\92d
+,
+divisÜ
+,
+S\91OE
+,
+S\91RC
+);
+
+1429 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªBeDivByZ\94o
+)) {
+
+1430
+__
+
+cmpwi
+(
+divisÜ
+,
+O³¿nd
+::
+Z\94o
+());
+
+1431
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "division by zero");
+
+1435 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+1436
+Lab\96
+
+divid\92d_nÙ_z\94o
+;
+
+1437
+__
+
+cmpwi
+(
+divid\92d
+,
+O³¿nd
+::
+Z\94o
+());
+
+1438
+__
+
+bÃ
+(&
+divid\92d_nÙ_z\94o
+);
+
+1439
+__
+
+cmpwi
+(
+divisÜ
+,
+O³¿nd
+::
+Z\94o
+());
+
+1440
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "minus zero");
+
+1441
+__
+
+b\9ad
+(&
+divid\92d_nÙ_z\94o
+);
+
+1445 ià(
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+)) {
+
+1446
+Lab\96
+
+no_ov\94æow_possibË
+;
+
+1447 ià(!
+ ghdiv
+->
+CheckFÏg
+(
+HV®ue
+::
+kAÎU£sTrunÿt\9agToIÁ32
+)) {
+
+1448
+DeÝtimizeIf
+(
+ov\94æow
+,
+\9a¡r
+, "ov\94æow",
+ü0
+);
+
+1451
+__
+
+bnoov\94æow
+(&
+no_ov\94æow_possibË
+,
+ü0
+);
+
+1452
+__
+
+mr
+(
+»suÉ
+,
+divid\92d
+);
+
+1454
+__
+
+b\9ad
+(&
+no_ov\94æow_possibË
+);
+
+1457
+Lab\96
+
+ gdÚe
+;
+
+1458
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+1460 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1461
+__
+
+xÜ_
+(
+sü©ch
+,
+divid\92d
+,
+divisÜ
+);
+
+1462
+__
+
+cmpwi
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+1463
+__
+
+bge
+(&
+dÚe
+);
+
+1465
+__
+
+xÜ_
+(
+sü©ch
+,
+divid\92d
+,
+divisÜ
+,
+S\91RC
+);
+
+1466
+__
+
+bge
+(&
+dÚe
+,
+ü0
+);
+
+1470
+__
+
+muÎw
+(
+sü©ch
+,
+divisÜ
+,
+»suÉ
+);
+
+1471
+__
+
+cmpw
+(
+divid\92d
+,
+sü©ch
+);
+
+1472
+__
+
+beq
+(&
+dÚe
+);
+
+1475
+__
+
+subi
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(1));
+
+1476
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1480 \1e
+ gLCodeG\92
+::
+DoMuɝlyAddD
+(
+LMuɝlyAddD
+*
+\9a¡r
+) {
+
+1481
+DoubËRegi¡\94
+
+add\92d
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->addend());
+
+1482
+DoubËRegi¡\94
+
+ gmuÉ\9dl\9br
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+muÉ\9dl\9br
+());
+
+1483
+DoubËRegi¡\94
+
+ gmuÉ\9dliÿnd
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+muÉ\9dliÿnd
+());
+
+1484
+DoubËRegi¡\94
+
+ g»suÉ
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1486
+__
+
+fmadd
+(
+»suÉ
+,
+muÉ\9dl\9br
+,
+muÉ\9dliÿnd
+,
+add\92d
+);
+
+1490 \1e
+ gLCodeG\92
+::
+DoMuɝlySubD
+(
+LMuɝlySubD
+*
+\9a¡r
+) {
+
+1491
+DoubËRegi¡\94
+
+m\9au\92d
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->minuend());
+
+1492
+DoubËRegi¡\94
+
+ gmuÉ\9dl\9br
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+muÉ\9dl\9br
+());
+
+1493
+DoubËRegi¡\94
+
+ gmuÉ\9dliÿnd
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+muÉ\9dliÿnd
+());
+
+1494
+DoubËRegi¡\94
+
+ g»suÉ
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1496
+__
+
+fmsub
+(
+»suÉ
+,
+muÉ\9dl\9br
+,
+muÉ\9dliÿnd
+,
+m\9au\92d
+);
+
+1500 \1e
+ gLCodeG\92
+::
+DoMulI
+(
+LMulI
+*
+\9a¡r
+) {
+
+1501
+Regi¡\94
+
+sü©ch
+ =
+sü©ch0
+();
+
+1502
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1504
+Regi¡\94
+
+ gËá
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëá
+());
+
+1505
+LO³¿nd
+*
+ gright_Ý
+ =
+\9a¡r
+->
+right
+();
+
+1507
+boÞ
+
+ gba\9eout_Ú_m\9aus_z\94o
+ =
+
+1508
+\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+);
+
+1509
+boÞ
+
+ gÿn_ov\94æow
+ =
+\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+);
+
+1511 ià(
+ gright_Ý
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+1512
+\9at32_t
+
+ gcÚ¡ªt
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+right_Ý
+));
+
+1514 ià(
+ gba\9eout_Ú_m\9aus_z\94o
+ && (
+ gcÚ¡ªt
+ < 0)) {
+
+1517
+__
+
+cmpi
+(
+Ëá
+,
+O³¿nd
+::
+Z\94o
+());
+
+1518
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "minus zero");
+
+1521 \1a
+ gcÚ¡ªt
+) {
+
+1523 ià(
+ÿn_ov\94æow
+) {
+
+1524 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1525 ià(
+\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+1527
+__
+
+li
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+1528
+__
+
+mtx\94
+(
+r0
+);
+
+1529
+__
+
+Ãg
+(
+»suÉ
+,
+Ëá
+,
+S\91OE
+,
+S\91RC
+);
+
+1530
+DeÝtimizeIf
+(
+ov\94æow
+,
+\9a¡r
+, "ov\94æow",
+ü0
+);
+
+1531 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1533
+__
+
+Ãg
+(
+»suÉ
+,
+Ëá
+);
+
+1534
+__
+
+Te¡IfIÁ32
+(
+»suÉ
+,
+sü©ch
+,
+r0
+);
+
+1535
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "overflow");
+
+1539
+__
+
+Ãg
+(
+»suÉ
+,
+Ëá
+);
+
+1543 ià(
+ba\9eout_Ú_m\9aus_z\94o
+) {
+
+1546 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1547 ià(
+\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+1549
+__
+
+cmpi
+(
+Ëá
+,
+O³¿nd
+::
+Z\94o
+());
+
+1550 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1552
+__
+
+cmpwi
+(
+Ëá
+,
+O³¿nd
+::
+Z\94o
+());
+
+1555
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "minus zero");
+
+1557
+__
+
+li
+(
+»suÉ
+,
+O³¿nd
+::
+Z\94o
+());
+
+1560
+__
+
+Move
+(
+»suÉ
+,
+Ëá
+);
+
+1566
+\9at32_t
+
+mask
+ =
+cÚ¡ªt
+ >> 31;
+
+1567
+u\9at32_t
+
+ gcÚ¡ªt_abs
+ = (
+cÚ¡ªt
+ +
+mask
+) ^ mask;
+
+1569 ià(
+ gba£
+::
+b\99s
+::
+IsPow\94OfTwo32
+(
+cÚ¡ªt_abs
+)) {
+
+1570
+\9at32_t
+
+shiá
+ =
+WhichPow\94Of2
+(
+cÚ¡ªt_abs
+);
+
+1571
+__
+
+ShiáLeáImm
+(
+»suÉ
+,
+Ëá
+,
+O³¿nd
+(
+shiá
+));
+
+1573 ià(
+ gcÚ¡ªt
+ < 0è
+__
+
+Ãg
+(
+»suÉ
+,\84esult);
+
+1574 } \vià(
+ gba£
+::
+b\99s
+::
+IsPow\94OfTwo32
+(
+cÚ¡ªt_abs
+ - 1)) {
+
+1575
+\9at32_t
+
+shiá
+ =
+WhichPow\94Of2
+(
+cÚ¡ªt_abs
+ - 1);
+
+1576
+__
+
+ShiáLeáImm
+(
+sü©ch
+,
+Ëá
+,
+O³¿nd
+(
+shiá
+));
+
+1577
+__
+
+add
+(
+»suÉ
+,
+sü©ch
+,
+Ëá
+);
+
+1579 ià(
+ gcÚ¡ªt
+ < 0è
+__
+
+Ãg
+(
+»suÉ
+,\84esult);
+
+1580 } \vià(
+ gba£
+::
+b\99s
+::
+IsPow\94OfTwo32
+(
+cÚ¡ªt_abs
+ + 1)) {
+
+1581
+\9at32_t
+
+shiá
+ =
+WhichPow\94Of2
+(
+cÚ¡ªt_abs
+ + 1);
+
+1582
+__
+
+ShiáLeáImm
+(
+sü©ch
+,
+Ëá
+,
+O³¿nd
+(
+shiá
+));
+
+1583
+__
+
+sub
+(
+»suÉ
+,
+sü©ch
+,
+Ëá
+);
+
+1585 ià(
+ gcÚ¡ªt
+ < 0è
+__
+
+Ãg
+(
+»suÉ
+,\84esult);
+
+1588
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+cÚ¡ªt
+));
+
+1589
+__
+
+Mul
+(
+»suÉ
+,
+Ëá
+,
+\9d
+);
+
+1594
+DCHECK
+(
+right_Ý
+->
+IsRegi¡\94
+());
+
+1595
+Regi¡\94
+
+ gright
+ =
+ToRegi¡\94
+(
+right_Ý
+);
+
+1597 ià(
+ gÿn_ov\94æow
+) {
+
+1598 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1600 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+1601
+__
+
+SmiUÁag
+(
+»suÉ
+,
+Ëá
+);
+
+1602
+__
+
+SmiUÁag
+(
+sü©ch
+,
+right
+);
+
+1603
+__
+
+Mul
+(
+»suÉ
+,\84esuÉ,
+sü©ch
+);
+
+1605
+__
+
+Mul
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+1607
+__
+
+Te¡IfIÁ32
+(
+»suÉ
+,
+sü©ch
+,
+r0
+);
+
+1608
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "overflow");
+
+1609 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+1610
+__
+
+SmiTag
+(
+»suÉ
+);
+
+1614 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+1615
+__
+
+SmiUÁag
+(
+»suÉ
+,
+Ëá
+);
+
+1616
+__
+
+mulhw
+(
+sü©ch
+,
+»suÉ
+,
+right
+);
+
+1617
+__
+
+muÎw
+(
+»suÉ
+,\84esuÉ,
+right
+);
+
+1619
+__
+
+mulhw
+(
+sü©ch
+,
+Ëá
+,
+right
+);
+
+1620
+__
+
+muÎw
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+1622
+__
+
+Te¡IfIÁ32
+(
+sü©ch
+,
+»suÉ
+,
+r0
+);
+
+1623
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "overflow");
+
+1626 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+1627
+__
+
+SmiUÁag
+(
+»suÉ
+,
+Ëá
+);
+
+1628
+__
+
+Mul
+(
+»suÉ
+,\84esuÉ,
+right
+);
+
+1630
+__
+
+Mul
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+1634 ià(
+ gba\9eout_Ú_m\9aus_z\94o
+) {
+
+1635
+Lab\96
+
+ gdÚe
+;
+
+1636 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1637 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+1639
+__
+
+xÜ_
+(
+r0
+,
+Ëá
+,
+right
+,
+S\91RC
+);
+
+1640
+__
+
+bge
+(&
+dÚe
+,
+ü0
+);
+
+1641 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1643
+__
+
+xÜ_
+(
+r0
+,
+Ëá
+,
+right
+);
+
+1644
+__
+
+cmpwi
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+1645
+__
+
+bge
+(&
+dÚe
+);
+
+1649
+__
+
+cmpi
+(
+»suÉ
+,
+O³¿nd
+::
+Z\94o
+());
+
+1650
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "minus zero");
+
+1651
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1657 \1e
+ gLCodeG\92
+::
+DoB\99I
+(
+LB\99I
+*
+\9a¡r
+) {
+
+1658
+LO³¿nd
+*
+Ëá_Ý
+ =
+\9a¡r
+->
+Ëá
+();
+
+1659
+LO³¿nd
+*
+ gright_Ý
+ =
+\9a¡r
+->
+right
+();
+
+1660
+DCHECK
+(
+Ëá_Ý
+->
+IsRegi¡\94
+());
+
+1661
+Regi¡\94
+
+ gËá
+ =
+ToRegi¡\94
+(
+Ëá_Ý
+);
+
+1662
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1663
+O³¿nd
+
+right
+(
+no_»g
+);
+
+1665 ià(
+ gright_Ý
+->
+IsS\8fckSlÙ
+()) {
+
+1666
+ gright
+ =
+O³¿nd
+(
+Em\99LßdRegi¡\94
+(
+right_Ý
+,
+\9d
+));
+
+1668
+DCHECK
+(
+right_Ý
+->
+IsRegi¡\94
+(è||\84ight_Ý->
+IsCÚ¡ªtO³¿nd
+());
+
+1669
+ gright
+ =
+ToO³¿nd
+(
+right_Ý
+);
+
+1671 ià(
+ gright_Ý
+->
+IsCÚ¡ªtO³¿nd
+(è&&
+is_u\9at16
+(
+right
+.
+immed\9f\8b
+())) {
+
+1672 \1a
+ g\9a¡r
+->
+Ý
+()) {
+
+1673 \ 4
+ gTok\92
+::
+BIT_AND
+:
+
+1674
+__
+
+ªdi
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+1676 \ 4
+ gTok\92
+::
+BIT_OR
+:
+
+1677
+__
+
+Üi
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+1679 \ 4
+ gTok\92
+::
+BIT_XOR
+:
+
+1680
+__
+
+xÜi
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+1683
+UNREACHABLE
+();
+
+1690 \1a
+ g\9a¡r
+->
+Ý
+()) {
+
+1691 \ 4
+ gTok\92
+::
+BIT_AND
+:
+
+1692
+__
+
+And
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+1694 \ 4
+ gTok\92
+::
+BIT_OR
+:
+
+1695
+__
+
+Or
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+1697 \ 4
+ gTok\92
+::
+BIT_XOR
+:
+
+1698 ià(
+right_Ý
+->
+IsCÚ¡ªtO³¿nd
+(è&&
+right
+.
+immed\9f\8b
+(è=ð
+\9at32_t
+(~0)) {
+
+1699
+__
+
+nÙx
+(
+»suÉ
+,
+Ëá
+);
+
+1701
+__
+
+XÜ
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+1705
+UNREACHABLE
+();
+
+1711 \1e
+ gLCodeG\92
+::
+DoShiáI
+(
+LShiáI
+*
+\9a¡r
+) {
+
+1714
+LO³¿nd
+*
+right_Ý
+ =
+\9a¡r
+->
+right
+();
+
+1715
+Regi¡\94
+
+ gËá
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëá
+());
+
+1716
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1717
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+1718 ià(
+ gright_Ý
+->
+IsRegi¡\94
+()) {
+
+1720
+__
+
+ªdi
+(
+sü©ch
+,
+ToRegi¡\94
+(
+right_Ý
+),
+O³¿nd
+(0x1F));
+
+1721 \1a
+ g\9a¡r
+->
+Ý
+()) {
+
+1722 \ 4
+ gTok\92
+::
+ROR
+:
+
+1724
+__
+
+subfic
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(32));
+
+1725
+__
+
+rÙlw
+(
+»suÉ
+,
+Ëá
+,
+sü©ch
+);
+
+1727 \ 4
+ gTok\92
+::
+SAR
+:
+
+1728
+__
+
+¤aw
+(
+»suÉ
+,
+Ëá
+,
+sü©ch
+);
+
+1730 \ 4
+ gTok\92
+::
+SHR
+:
+
+1731 ià(
+\9a¡r
+->
+ÿn_deÝt
+()) {
+
+1732
+__
+
+¤w
+(
+»suÉ
+,
+Ëá
+,
+sü©ch
+,
+S\91RC
+);
+
+1733 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1734
+__
+
+extsw
+(
+»suÉ
+,\84esuÉ,
+S\91RC
+);
+
+1736
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "Ãg©iv\90v®ue",
+ü0
+);
+
+1738
+__
+
+¤w
+(
+»suÉ
+,
+Ëá
+,
+sü©ch
+);
+
+1741 \ 4
+ gTok\92
+::
+SHL
+:
+
+1742
+__
+
+¦w
+(
+»suÉ
+,
+Ëá
+,
+sü©ch
+);
+
+1743 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1744
+__
+
+extsw
+(
+»suÉ
+,\84esult);
+
+1748
+UNREACHABLE
+();
+
+1753 \12
+ gv®ue
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+right_Ý
+));
+
+1754
+u\9at8_t
+
+ gshiá_couÁ
+ =
+¡©ic_ÿ¡
+<u\9at8_t>(
+v®ue
+ & 0x1F);
+
+1755 \1a
+ g\9a¡r
+->
+Ý
+()) {
+
+1756 \ 4
+ gTok\92
+::
+ROR
+:
+
+1757 ià(
+shiá_couÁ
+ != 0) {
+
+1758
+__
+
+rÙrwi
+(
+»suÉ
+,
+Ëá
+,
+shiá_couÁ
+);
+
+1760
+__
+
+Move
+(
+»suÉ
+,
+Ëá
+);
+
+1763 \ 4
+ gTok\92
+::
+SAR
+:
+
+1764 ià(
+shiá_couÁ
+ != 0) {
+
+1765
+__
+
+¤awi
+(
+»suÉ
+,
+Ëá
+,
+shiá_couÁ
+);
+
+1767
+__
+
+Move
+(
+»suÉ
+,
+Ëá
+);
+
+1770 \ 4
+ gTok\92
+::
+SHR
+:
+
+1771 ià(
+shiá_couÁ
+ != 0) {
+
+1772
+__
+
+¤wi
+(
+»suÉ
+,
+Ëá
+,
+O³¿nd
+(
+shiá_couÁ
+));
+
+1774 ià(
+ g\9a¡r
+->
+ÿn_deÝt
+()) {
+
+1775
+__
+
+cmpwi
+(
+Ëá
+,
+O³¿nd
+::
+Z\94o
+());
+
+1776
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "negative value");
+
+1778
+__
+
+Move
+(
+»suÉ
+,
+Ëá
+);
+
+1781 \ 4
+ gTok\92
+::
+SHL
+:
+
+1782 ià(
+shiá_couÁ
+ != 0) {
+
+1783 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1784 ià(
+\9a¡r
+->
+hydrog\92_v®ue
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+1785
+__
+
+¦di
+(
+»suÉ
+,
+Ëá
+,
+O³¿nd
+(
+shiá_couÁ
+));
+
+1787 ià(
+ g\9a¡r
+->
+hydrog\92_v®ue
+()->
+»´e£Á©iÚ
+().
+IsSmi
+() &&
+
+1788
+ g\9a¡r
+->
+ÿn_deÝt
+()) {
+
+1789 ià(
+ gshiá_couÁ
+ != 1) {
+
+1790
+__
+
+¦wi
+(
+»suÉ
+,
+Ëá
+,
+O³¿nd
+(
+shiá_couÁ
+ - 1));
+
+1791
+__
+
+SmiTagCheckOv\94æow
+(
+»suÉ
+,\84esuÉ,
+sü©ch
+);
+
+1793
+__
+
+SmiTagCheckOv\94æow
+(
+»suÉ
+,
+Ëá
+,
+sü©ch
+);
+
+1795
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "ov\94æow",
+ü0
+);
+
+1798
+__
+
+¦wi
+(
+»suÉ
+,
+Ëá
+,
+O³¿nd
+(
+shiá_couÁ
+));
+
+1799 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1800
+__
+
+extsw
+(
+»suÉ
+,\84esult);
+
+1804
+__
+
+Move
+(
+»suÉ
+,
+Ëá
+);
+
+1808
+UNREACHABLE
+();
+
+1815 \1e
+ gLCodeG\92
+::
+DoSubI
+(
+LSubI
+*
+\9a¡r
+) {
+
+1816
+LO³¿nd
+*
+right
+ =
+\9a¡r
+->right();
+
+1817
+Regi¡\94
+
+ gËá
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëá
+());
+
+1818
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1819
+boÞ
+
+ gÿn_ov\94æow
+ =
+\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+);
+
+1820 ià(!
+ gÿn_ov\94æow
+) {
+
+1821 ià(
+ gright
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+1822
+__
+
+Add
+(
+»suÉ
+,
+Ëá
+, -(
+ToO³¿nd
+(
+right
+).
+immed\9f\8b
+()),
+r0
+);
+
+1824
+__
+
+sub
+(
+»suÉ
+,
+Ëá
+,
+Em\99LßdRegi¡\94
+(
+right
+,
+\9d
+));
+
+1827 ià(
+ gright
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+1828
+__
+
+AddAndCheckFÜOv\94æow
+(
+»suÉ
+,
+Ëá
+, -(
+ToO³¿nd
+(
+right
+).
+immed\9f\8b
+()),
+
+1829
+sü©ch0
+(),
+r0
+);
+
+1831
+__
+
+SubAndCheckFÜOv\94æow
+(
+»suÉ
+,
+Ëá
+,
+Em\99LßdRegi¡\94
+(
+right
+,
+\9d
+),
+
+1832
+sü©ch0
+(),
+r0
+);
+
+1835 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1836 ià(!
+ g\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+1837
+__
+
+extsw
+(
+sü©ch0
+(), sü©ch0(),
+S\91RC
+);
+
+1840
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "ov\94æow",
+ü0
+);
+
+1843 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1844 ià(!
+ g\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+1845
+__
+
+extsw
+(
+»suÉ
+,\84esult);
+
+1851 \1e
+ gLCodeG\92
+::
+DoRSubI
+(
+LRSubI
+*
+\9a¡r
+) {
+
+1852
+LO³¿nd
+*
+Ëá
+ =
+\9a¡r
+->left();
+
+1853
+LO³¿nd
+*
+ gright
+ =
+\9a¡r
+->
+right
+();
+
+1854
+LO³¿nd
+*
+ g»suÉ
+ =
+\9a¡r
+->
+»suÉ
+();
+
+1856
+DCHECK
+(!
+\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+) &&
+
+1857
+right
+->
+IsCÚ¡ªtO³¿nd
+());
+
+1859
+O³¿nd
+
+ gright_Ý\94ªd
+ =
+ToO³¿nd
+(
+right
+);
+
+1860 ià(
+is_\9at16
+(
+right_Ý\94ªd
+.
+immed\9f\8b
+())) {
+
+1861
+__
+
+subfic
+(
+ToRegi¡\94
+(
+»suÉ
+), ToRegi¡\94(
+Ëá
+),
+right_Ý\94ªd
+);
+
+1863
+__
+
+mov
+(
+r0
+,
+right_Ý\94ªd
+);
+
+1864
+__
+
+sub
+(
+ToRegi¡\94
+(
+»suÉ
+),
+r0
+, ToRegi¡\94(
+Ëá
+));
+
+1869 \1e
+ gLCodeG\92
+::
+DoCÚ¡ªtI
+(
+LCÚ¡ªtI
+*
+\9a¡r
+) {
+
+1870
+__
+
+mov
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()),
+O³¿nd
+(\9a¡r->
+v®ue
+()));
+
+1874 \1e
+ gLCodeG\92
+::
+DoCÚ¡ªtS
+(
+LCÚ¡ªtS
+*
+\9a¡r
+) {
+
+1875
+__
+
+LßdSmiL\99\94®
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()), in¡r->
+v®ue
+());
+
+1881 \1e
+ gLCodeG\92
+::
+DoCÚ¡ªtD
+(
+LCÚ¡ªtD
+*
+\9a¡r
+) {
+
+1882
+DCHECK
+(
+\9a¡r
+->
+»suÉ
+()->
+IsDoubËRegi¡\94
+());
+
+1883
+DoubËRegi¡\94
+
+ g»suÉ
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1884 \b
+ gv
+ =
+\9a¡r
+->
+v®ue
+();
+
+1885
+__
+
+LßdDoubËL\99\94®
+(
+»suÉ
+,
+v
+,
+sü©ch0
+());
+
+1889 \1e
+ gLCodeG\92
+::
+DoCÚ¡ªtE
+(
+LCÚ¡ªtE
+*
+\9a¡r
+) {
+
+1890
+__
+
+mov
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()),
+O³¿nd
+(\9a¡r->
+v®ue
+()));
+
+1894 \1e
+ gLCodeG\92
+::
+DoCÚ¡ªtT
+(
+LCÚ¡ªtT
+*
+\9a¡r
+) {
+
+1895
+HªdË
+<
+Objeù
+>
+objeù
+ =
+\9a¡r
+->
+v®ue
+(
+isީe
+());
+
+1896
+AÎowDeã¼edHªdËD\94eã»nû
+
+ gsmi_check
+;
+
+1897
+__
+
+Move
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()),
+objeù
+);
+
+1901 \1e
+ gLCodeG\92
+::
+DoMEnumL\92gth
+(
+LMEnumL\92gth
+*
+\9a¡r
+) {
+
+1902
+Regi¡\94
+
+»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->result());
+
+1903
+Regi¡\94
+
+ gm
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+1904
+__
+
+EnumL\92gth
+(
+»suÉ
+,
+m
+);
+
+1908 \1e
+ gLCodeG\92
+::
+DoD©eF\9bld
+(
+LD©eF\9bld
+*
+\9a¡r
+) {
+
+1909
+Regi¡\94
+
+objeù
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+d©e
+());
+
+1910
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1911
+Regi¡\94
+
+ gsü©ch
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+1912
+Smi
+*
+ g\9adex
+ =
+\9a¡r
+->
+\9adex
+();
+
+1913
+Lab\96
+
+ gruÁime
+,
+ gdÚe
+;
+
+1914
+DCHECK
+(
+objeù
+.
+is
+(
+»suÉ
+));
+
+1915
+DCHECK
+(
+objeù
+.
+is
+(
+r3
+));
+
+1916
+DCHECK
+(!
+sü©ch
+.
+is
+(
+sü©ch0
+()));
+
+1917
+DCHECK
+(!
+sü©ch
+.
+is
+(
+objeù
+));
+
+1919
+__
+
+Te¡IfSmi
+(
+objeù
+,
+r0
+);
+
+1920
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "Smi",
+ü0
+);
+
+1921
+__
+
+Com·»ObjeùTy³
+(
+objeù
+,
+sü©ch
+, sü©ch,
+JS_DATE_TYPE
+);
+
+1922
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "not\87 date object");
+
+1924 ià(
+ g\9adex
+->
+v®ue
+() == 0) {
+
+1925
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+JSD©e
+::
+kV®ueOff£t
+));
+
+1927 ià(
+ g\9adex
+->
+v®ue
+(è<
+ gJSD©e
+::
+kF\9c¡UnÿchedF\9bld
+) {
+
+1928
+Ex\8bº®Reã»nû
+
+¡amp
+ = Ex\8bº®Reã»nû::
+d©e_ÿche_¡amp
+(
+isީe
+());
+
+1929
+__
+
+mov
+(
+sü©ch
+,
+O³¿nd
+(
+¡amp
+));
+
+1930
+__
+
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(scratch));
+
+1931
+__
+
+LßdP
+(
+sü©ch0
+(),
+F\9bldMemO³¿nd
+(
+objeù
+,
+JSD©e
+::
+kCacheS\8fmpOff£t
+));
+
+1932
+__
+
+cmp
+(
+sü©ch
+,
+sü©ch0
+());
+
+1933
+__
+
+bÃ
+(&
+ruÁime
+);
+
+1934
+__
+
+LßdP
+(
+»suÉ
+,
+
+1935
+F\9bldMemO³¿nd
+(
+objeù
+,
+JSD©e
+::
+kV®ueOff£t
+ +
+
+1936
+kPo\9a\8brSize
+ *
+\9adex
+->
+v®ue
+()));
+
+1937
+__
+
+b
+(&
+dÚe
+);
+
+1939
+__
+
+b\9ad
+(&
+ruÁime
+);
+
+1940
+__
+
+P»·»C®lCFunùiÚ
+(2,
+sü©ch
+);
+
+1941
+__
+
+LßdSmiL\99\94®
+(
+r4
+,
+\9adex
+);
+
+1942
+__
+
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+::
+g\91_d©e_f\9bld_funùiÚ
+(
+isީe
+()), 2);
+
+1943
+__
+
+b\9ad
+(&
+dÚe
+);
+
+1948
+MemO³¿nd
+
+ gLCodeG\92
+::
+Bu\9edSeqS\8c\9agO³¿nd
+(
+Regi¡\94
+
+¡r\9ag
+,
+LO³¿nd
+*
+\9adex
+,
+
+1949
+S\8c\9ag
+::
+Encod\9ag
+
+\92cod\9ag
+) {
+
+1950 ià(
+\9adex
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+1951 \12
+off£t
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9adex
+));
+
+1952 ià(
+ g\92cod\9ag
+ =ð
+S\8c\9ag
+::
+TWO_BYTE_ENCODING
+) {
+
+1953
+off£t
+ *ð
+kUC16Size
+;
+
+1955
+STATIC_ASSERT
+(
+kCh¬Size
+ == 1);
+
+1956 \15
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+SeqS\8c\9ag
+::
+kH\97d\94Size
+ +
+off£t
+);
+
+1958
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+1959
+DCHECK
+(!
+sü©ch
+.
+is
+(
+¡r\9ag
+));
+
+1960
+DCHECK
+(!
+sü©ch
+.
+is
+(
+ToRegi¡\94
+(
+\9adex
+)));
+
+1961 ià(
+ g\92cod\9ag
+ =ð
+S\8c\9ag
+::
+ONE_BYTE_ENCODING
+) {
+
+1962
+__
+
+add
+(
+sü©ch
+,
+¡r\9ag
+,
+ToRegi¡\94
+(
+\9adex
+));
+
+1964
+STATIC_ASSERT
+(
+kUC16Size
+ == 2);
+
+1965
+__
+
+ShiáLeáImm
+(
+sü©ch
+,
+ToRegi¡\94
+(
+\9adex
+),
+O³¿nd
+(1));
+
+1966
+__
+
+add
+(
+sü©ch
+,
+¡r\9ag
+, scratch);
+
+1968 \15
+F\9bldMemO³¿nd
+(
+sü©ch
+,
+SeqS\8c\9ag
+::
+kH\97d\94Size
+);
+
+1972 \1e
+ gLCodeG\92
+::
+DoSeqS\8c\9agG\91Ch¬
+(
+LSeqS\8c\9agG\91Ch¬
+*
+\9a¡r
+) {
+
+1973
+S\8c\9ag
+::
+Encod\9ag
+
+\92cod\9ag
+ =
+\9a¡r
+->
+hydrog\92
+()->encoding();
+
+1974
+Regi¡\94
+
+ g¡r\9ag
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+¡r\9ag
+());
+
+1975
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+1977 ià(
+ gFLAG_debug_code
+) {
+
+1978
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+1979
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1980
+__
+
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+1982
+__
+
+ªdi
+(
+sü©ch
+, scratch,
+
+1983
+O³¿nd
+(
+kS\8c\9agR\95»£Á©iÚMask
+ |
+kS\8c\9agEncod\9agMask
+));
+
+1984 \18cڡ
+u\9at32_t
+
+ gÚe_by\8b_£q_ty³
+ =
+kSeqS\8c\9agTag
+ |
+kOÃBy\8bS\8c\9agTag
+;
+
+1985 \18cڡ
+u\9at32_t
+
+ gtwo_by\8b_£q_ty³
+ =
+kSeqS\8c\9agTag
+ |
+kTwoBy\8bS\8c\9agTag
+;
+
+1986
+__
+
+cmpi
+(
+sü©ch
+,
+
+1987
+O³¿nd
+(
+\92cod\9ag
+ =ð
+S\8c\9ag
+::
+ONE_BYTE_ENCODING
+ ?
+Úe_by\8b_£q_ty³
+
+
+1988 :
+two_by\8b_£q_ty³
+));
+
+1989
+__
+
+Check
+(
+eq
+,
+kUÃx³ùedS\8c\9agTy³
+);
+
+1992
+MemO³¿nd
+
+ gÝ\94ªd
+ =
+Bu\9edSeqS\8c\9agO³¿nd
+(
+¡r\9ag
+,
+\9a¡r
+->
+\9adex
+(),
+\92cod\9ag
+);
+
+1993 ià(
+ g\92cod\9ag
+ =ð
+S\8c\9ag
+::
+ONE_BYTE_ENCODING
+) {
+
+1994
+__
+
+lbz
+(
+»suÉ
+,
+Ý\94ªd
+);
+
+1996
+__
+
+lhz
+(
+»suÉ
+,
+Ý\94ªd
+);
+
+2001 \1e
+ gLCodeG\92
+::
+DoSeqS\8c\9agS\91Ch¬
+(
+LSeqS\8c\9agS\91Ch¬
+*
+\9a¡r
+) {
+
+2002
+S\8c\9ag
+::
+Encod\9ag
+
+\92cod\9ag
+ =
+\9a¡r
+->
+hydrog\92
+()->encoding();
+
+2003
+Regi¡\94
+
+ g¡r\9ag
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+¡r\9ag
+());
+
+2004
+Regi¡\94
+
+ gv®ue
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2006 ià(
+ gFLAG_debug_code
+) {
+
+2007
+Regi¡\94
+
+ g\9adex
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\9adex
+());
+
+2008 \18cڡ
+u\9at32_t
+
+ gÚe_by\8b_£q_ty³
+ =
+kSeqS\8c\9agTag
+ |
+kOÃBy\8bS\8c\9agTag
+;
+
+2009 \18cڡ
+u\9at32_t
+
+ gtwo_by\8b_£q_ty³
+ =
+kSeqS\8c\9agTag
+ |
+kTwoBy\8bS\8c\9agTag
+;
+
+2010 \12
+ g\92cod\9ag_mask
+ =
+
+2011
+\9a¡r
+->
+hydrog\92
+()->
+\92cod\9ag
+(è=ð
+S\8c\9ag
+::
+ONE_BYTE_ENCODING
+
+
+2012 ?
+Úe_by\8b_£q_ty³
+
+
+2013 :
+two_by\8b_£q_ty³
+;
+
+2014
+__
+
+Em\99SeqS\8c\9agS\91Ch¬Check
+(
+¡r\9ag
+,
+\9adex
+,
+v®ue
+,
+\92cod\9ag_mask
+);
+
+2017
+MemO³¿nd
+
+ gÝ\94ªd
+ =
+Bu\9edSeqS\8c\9agO³¿nd
+(
+¡r\9ag
+,
+\9a¡r
+->
+\9adex
+(),
+\92cod\9ag
+);
+
+2018 ià(
+ g\92cod\9ag
+ =ð
+S\8c\9ag
+::
+ONE_BYTE_ENCODING
+) {
+
+2019
+__
+
+¡b
+(
+v®ue
+,
+Ý\94ªd
+);
+
+2021
+__
+
+¡h
+(
+v®ue
+,
+Ý\94ªd
+);
+
+2026 \1e
+ gLCodeG\92
+::
+DoAddI
+(
+LAddI
+*
+\9a¡r
+) {
+
+2027
+LO³¿nd
+*
+right
+ =
+\9a¡r
+->right();
+
+2028
+Regi¡\94
+
+ gËá
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëá
+());
+
+2029
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+2030
+boÞ
+
+ gÿn_ov\94æow
+ =
+\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+);
+
+2031 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2032
+boÞ
+
+ gisIÁeg\94
+ = !(
+\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsSmi
+() ||
+
+2033
+\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsEx\8bº®
+());
+
+2036 ià(!
+ gÿn_ov\94æow
+) {
+
+2037 ià(
+ gright
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+2038
+__
+
+Add
+(
+»suÉ
+,
+Ëá
+,
+ToO³¿nd
+(
+right
+).
+immed\9f\8b
+(),
+r0
+);
+
+2040
+__
+
+add
+(
+»suÉ
+,
+Ëá
+,
+Em\99LßdRegi¡\94
+(
+right
+,
+\9d
+));
+
+2043 ià(
+ gright
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+2044
+__
+
+AddAndCheckFÜOv\94æow
+(
+»suÉ
+,
+Ëá
+,
+ToO³¿nd
+(
+right
+).
+immed\9f\8b
+(),
+
+2045
+sü©ch0
+(),
+r0
+);
+
+2047
+__
+
+AddAndCheckFÜOv\94æow
+(
+»suÉ
+,
+Ëá
+,
+Em\99LßdRegi¡\94
+(
+right
+,
+\9d
+),
+
+2048
+sü©ch0
+(),
+r0
+);
+
+2051 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2052 ià(
+ gisIÁeg\94
+) {
+
+2053
+__
+
+extsw
+(
+sü©ch0
+(), sü©ch0(),
+S\91RC
+);
+
+2056
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "ov\94æow",
+ü0
+);
+
+2059 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2060 ià(
+ gisIÁeg\94
+) {
+
+2061
+__
+
+extsw
+(
+»suÉ
+,\84esult);
+
+2067 \1e
+ gLCodeG\92
+::
+DoM©hM\9aMax
+(
+LM©hM\9aMax
+*
+\9a¡r
+) {
+
+2068
+LO³¿nd
+*
+Ëá
+ =
+\9a¡r
+->left();
+
+2069
+LO³¿nd
+*
+ gright
+ =
+\9a¡r
+->
+right
+();
+
+2070
+ gHM©hM\9aMax
+::
+O³¿tiÚ
+
+Ý\94©iÚ
+ =
+\9a¡r
+->
+hydrog\92
+()->operation();
+
+2071
+CÚd\99iÚ
+
+ gcÚd
+ = (
+Ý\94©iÚ
+ =ð
+HM©hM\9aMax
+::
+kM©hM\9a
+è?
+Ë
+ :
+ge
+;
+
+2072 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+()) {
+
+2073
+Regi¡\94
+
+ gËá_»g
+ =
+ToRegi¡\94
+(
+Ëá
+);
+
+2074
+Regi¡\94
+
+ gright_»g
+ =
+Em\99LßdRegi¡\94
+(
+right
+,
+\9d
+);
+
+2075
+Regi¡\94
+
+ g»suÉ_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+2076
+Lab\96
+
+ g»tuº_Ëá
+,
+ gdÚe
+;
+
+2077 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2078 ià(
+ g\9a¡r
+->
+hydrog\92_v®ue
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+2080
+__
+
+cmp
+(
+Ëá_»g
+,
+right_»g
+);
+
+2081 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2083
+__
+
+cmpw
+(
+Ëá_»g
+,
+right_»g
+);
+
+2086
+__
+
+b
+(
+cÚd
+, &
+»tuº_Ëá
+);
+
+2087
+__
+
+Move
+(
+»suÉ_»g
+,
+right_»g
+);
+
+2088
+__
+
+b
+(&
+dÚe
+);
+
+2089
+__
+
+b\9ad
+(&
+»tuº_Ëá
+);
+
+2090
+__
+
+Move
+(
+»suÉ_»g
+,
+Ëá_»g
+);
+
+2091
+__
+
+b\9ad
+(&
+dÚe
+);
+
+2093
+DCHECK
+(
+\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+2094
+DoubËRegi¡\94
+
+ gËá_»g
+ =
+ToDoubËRegi¡\94
+(
+Ëá
+);
+
+2095
+DoubËRegi¡\94
+
+ gright_»g
+ =
+ToDoubËRegi¡\94
+(
+right
+);
+
+2096
+DoubËRegi¡\94
+
+ g»suÉ_»g
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+2097
+Lab\96
+
+ gcheck_Çn_Ëá
+,
+ gcheck_z\94o
+,
+ g»tuº_Ëá
+,
+ g»tuº_right
+,
+ gdÚe
+;
+
+2098
+__
+
+fcmpu
+(
+Ëá_»g
+,
+right_»g
+);
+
+2099
+__
+
+bunÜd\94ed
+(&
+check_Çn_Ëá
+);
+
+2100
+__
+
+beq
+(&
+check_z\94o
+);
+
+2101
+__
+
+b
+(
+cÚd
+, &
+»tuº_Ëá
+);
+
+2102
+__
+
+b
+(&
+»tuº_right
+);
+
+2104
+__
+
+b\9ad
+(&
+check_z\94o
+);
+
+2105
+__
+
+fcmpu
+(
+Ëá_»g
+,
+kDoubËRegZ\94o
+);
+
+2106
+__
+
+bÃ
+(&
+»tuº_Ëá
+);
+
+2110 ià(
+ gÝ\94©iÚ
+ =ð
+HM©hM\9aMax
+::
+kM©hM\9a
+) {
+
+2112
+__
+
+âeg
+(
+Ëá_»g
+,\86eft_reg);
+
+2113
+__
+
+fsub
+(
+»suÉ_»g
+,
+Ëá_»g
+,
+right_»g
+);
+
+2114
+__
+
+âeg
+(
+»suÉ_»g
+,\84esult_reg);
+
+2117
+__
+
+çdd
+(
+»suÉ_»g
+,
+Ëá_»g
+,
+right_»g
+);
+
+2119
+__
+
+b
+(&
+dÚe
+);
+
+2121
+__
+
+b\9ad
+(&
+check_Çn_Ëá
+);
+
+2122
+__
+
+fcmpu
+(
+Ëá_»g
+,\86eft_reg);
+
+2123
+__
+
+bunÜd\94ed
+(&
+»tuº_Ëá
+);
+
+2125
+__
+
+b\9ad
+(&
+»tuº_right
+);
+
+2126 ià(!
+ gright_»g
+.
+is
+(
+»suÉ_»g
+)) {
+
+2127
+__
+
+fmr
+(
+»suÉ_»g
+,
+right_»g
+);
+
+2129
+__
+
+b
+(&
+dÚe
+);
+
+2131
+__
+
+b\9ad
+(&
+»tuº_Ëá
+);
+
+2132 ià(!
+ gËá_»g
+.
+is
+(
+»suÉ_»g
+)) {
+
+2133
+__
+
+fmr
+(
+»suÉ_»g
+,
+Ëá_»g
+);
+
+2135
+__
+
+b\9ad
+(&
+dÚe
+);
+
+2140 \1e
+ gLCodeG\92
+::
+DoAr\99hm\91icD
+(
+LAr\99hm\91icD
+*
+\9a¡r
+) {
+
+2141
+DoubËRegi¡\94
+
+Ëá
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->left());
+
+2142
+DoubËRegi¡\94
+
+ gright
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+right
+());
+
+2143
+DoubËRegi¡\94
+
+ g»suÉ
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+2144 \1a
+ g\9a¡r
+->
+Ý
+()) {
+
+2145 \ 4
+ gTok\92
+::
+ADD
+:
+
+2146
+__
+
+çdd
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+2148 \ 4
+ gTok\92
+::
+SUB
+:
+
+2149
+__
+
+fsub
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+2151 \ 4
+ gTok\92
+::
+MUL
+:
+
+2152
+__
+
+fmul
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+2154 \ 4
+ gTok\92
+::
+DIV
+:
+
+2155
+__
+
+fdiv
+(
+»suÉ
+,
+Ëá
+,
+right
+);
+
+2157 \ 4
+ gTok\92
+::
+MOD
+: {
+
+2158
+__
+
+P»·»C®lCFunùiÚ
+(0, 2,
+sü©ch0
+());
+
+2159
+__
+
+MovToFlßtP¬am\91\94s
+(
+Ëá
+,
+right
+);
+
+2160
+__
+
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+::
+mod_two_doubËs_Ý\94©iÚ
+(
+isީe
+()),
+
+2163
+__
+
+MovFromFlßtResuÉ
+(
+»suÉ
+);
+
+2167
+UNREACHABLE
+();
+
+2173 \1e
+ gLCodeG\92
+::
+DoAr\99hm\91icT
+(
+LAr\99hm\91icT
+*
+\9a¡r
+) {
+
+2174
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+2175
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëá
+()).
+is
+(
+r4
+));
+
+2176
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+right
+()).
+is
+(
+r3
+));
+
+2177
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()).
+is
+(
+r3
+));
+
+2179
+ gHªdË
+<
+ gCode
+>
+ gcode
+ =
+
+2180
+CodeFaùÜy
+::
+B\9a¬yOpIC
+(
+isީe
+(),
+\9a¡r
+->
+Ý
+(),
+NO_OVERWRITE
+).
+code
+();
+
+2181
+C®lCode
+(
+code
+,
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+2185
+ g\8bm¶©e
+ <
+þass
+
+ gIn¡rTy³
+>
+
+2186 \1e
+ gLCodeG\92
+::
+Em\99B¿nch
+(
+In¡rTy³
+
+\9a¡r
+,
+CÚd\99iÚ
+
+cÚd
+,
+CRegi¡\94
+
+ü
+) {
+
+2187 \12
+ gËá_block
+ =
+\9a¡r
+->
+TrueDe¡\9a©iÚ
+(
+chunk_
+);
+
+2188 \12
+ gright_block
+ =
+\9a¡r
+->
+F®£De¡\9a©iÚ
+(
+chunk_
+);
+
+2190 \12
+ gÃxt_block
+ =
+G\91NextEm\99\8bdBlock
+();
+
+2192 ià(
+ gright_block
+ =ð
+Ëá_block
+ ||
+cÚd
+ =ð
+®
+) {
+
+2193
+Em\99GÙo
+(
+Ëá_block
+);
+
+2194 } \vià(
+ gËá_block
+ =ð
+Ãxt_block
+) {
+
+2195
+__
+
+b
+(
+Neg©eCÚd\99iÚ
+(
+cÚd
+),
+chunk_
+->
+G\91As£mblyLab\96
+(
+right_block
+),
+ü
+);
+
+2196 } \vià(
+ gright_block
+ =ð
+Ãxt_block
+) {
+
+2197
+__
+
+b
+(
+cÚd
+,
+chunk_
+->
+G\91As£mblyLab\96
+(
+Ëá_block
+),
+ü
+);
+
+2199
+__
+
+b
+(
+cÚd
+,
+chunk_
+->
+G\91As£mblyLab\96
+(
+Ëá_block
+),
+ü
+);
+
+2200
+__
+
+b
+(
+chunk_
+->
+G\91As£mblyLab\96
+(
+right_block
+));
+
+2205
+ g\8bm¶©e
+ <
+þass
+
+ gIn¡rTy³
+>
+
+2206 \1e
+ gLCodeG\92
+::
+Em\99F®£B¿nch
+(
+In¡rTy³
+
+\9a¡r
+,
+CÚd\99iÚ
+
+cÚd
+,
+CRegi¡\94
+
+ü
+) {
+
+2207 \12
+ gçl£_block
+ =
+\9a¡r
+->
+F®£De¡\9a©iÚ
+(
+chunk_
+);
+
+2208
+__
+
+b
+(
+cÚd
+,
+chunk_
+->
+G\91As£mblyLab\96
+(
+çl£_block
+),
+ü
+);
+
+2212 \1e
+ gLCodeG\92
+::
+DoDebugB»ak
+(
+LDebugB»ak
+*
+\9a¡r
+è{
+__
+
+¡Ý
+("LBreak"); }
+
+2215 \1e
+ gLCodeG\92
+::
+DoB¿nch
+(
+LB¿nch
+*
+\9a¡r
+) {
+
+2216
+R\95»£Á©iÚ
+
+r
+ =
+\9a¡r
+->
+hydrog\92
+()->
+v®ue
+()->
+»´e£Á©iÚ
+();
+
+2217
+DoubËRegi¡\94
+
+ gdbl_sü©ch
+ =
+doubË_sü©ch0
+();
+
+2218 cڡ
+u\9at
+
+ güZOrNaNB\99s
+ = (1 << (31 -
+As£mbËr
+::
+\92code_üb\99
+(
+ü7
+,
+CR_EQ
+)) |
+
+2219 1 << (31 -
+ gAs£mbËr
+::
+\92code_üb\99
+(
+ü7
+,
+CR_FU
+)));
+
+2221 ià(
+ gr
+.
+IsIÁeg\9432
+()) {
+
+2222
+DCHECK
+(!
+\9afo
+()->
+IsStub
+());
+
+2223
+Regi¡\94
+
+ g»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2224
+__
+
+cmpwi
+(
+»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+2225
+Em\99B¿nch
+(
+\9a¡r
+,
+Ã
+);
+
+2226 } \vià(
+ gr
+.
+IsSmi
+()) {
+
+2227
+DCHECK
+(!
+\9afo
+()->
+IsStub
+());
+
+2228
+Regi¡\94
+
+ g»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2229
+__
+
+cmpi
+(
+»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+2230
+Em\99B¿nch
+(
+\9a¡r
+,
+Ã
+);
+
+2231 } \vià(
+ gr
+.
+IsDoubË
+()) {
+
+2232
+DCHECK
+(!
+\9afo
+()->
+IsStub
+());
+
+2233
+DoubËRegi¡\94
+
+ g»g
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2235
+__
+
+fcmpu
+(
+»g
+,
+kDoubËRegZ\94o
+,
+ü7
+);
+
+2236
+__
+
+mfü
+(
+r0
+);
+
+2237
+__
+
+ªdi
+(
+r0
+,\840,
+O³¿nd
+(
+üZOrNaNB\99s
+));
+
+2238
+Em\99B¿nch
+(
+\9a¡r
+,
+eq
+,
+ü0
+);
+
+2240
+DCHECK
+(
+r
+.
+IsTagged
+());
+
+2241
+Regi¡\94
+
+ g»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2242
+HTy³
+
+ gty³
+ =
+\9a¡r
+->
+hydrog\92
+()->
+v®ue
+()->
+ty³
+();
+
+2243 ià(
+ gty³
+.
+IsBoޗn
+()) {
+
+2244
+DCHECK
+(!
+\9afo
+()->
+IsStub
+());
+
+2245
+__
+
+Com·»RoÙ
+(
+»g
+,
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+2246
+Em\99B¿nch
+(
+\9a¡r
+,
+eq
+);
+
+2247 } \vià(
+ gty³
+.
+IsSmi
+()) {
+
+2248
+DCHECK
+(!
+\9afo
+()->
+IsStub
+());
+
+2249
+__
+
+cmpi
+(
+»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+2250
+Em\99B¿nch
+(
+\9a¡r
+,
+Ã
+);
+
+2251 } \vià(
+ gty³
+.
+IsJSA¼ay
+()) {
+
+2252
+DCHECK
+(!
+\9afo
+()->
+IsStub
+());
+
+2253
+Em\99B¿nch
+(
+\9a¡r
+,
+®
+);
+
+2254 } \vià(
+ gty³
+.
+IsH\97pNumb\94
+()) {
+
+2255
+DCHECK
+(!
+\9afo
+()->
+IsStub
+());
+
+2256
+__
+
+lfd
+(
+dbl_sü©ch
+,
+F\9bldMemO³¿nd
+(
+»g
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+2258
+__
+
+fcmpu
+(
+dbl_sü©ch
+,
+kDoubËRegZ\94o
+,
+ü7
+);
+
+2259
+__
+
+mfü
+(
+r0
+);
+
+2260
+__
+
+ªdi
+(
+r0
+,\840,
+O³¿nd
+(
+üZOrNaNB\99s
+));
+
+2261
+Em\99B¿nch
+(
+\9a¡r
+,
+eq
+,
+ü0
+);
+
+2262 } \vià(
+ gty³
+.
+IsS\8c\9ag
+()) {
+
+2263
+DCHECK
+(!
+\9afo
+()->
+IsStub
+());
+
+2264
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+»g
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+2265
+__
+
+cmpi
+(
+\9d
+,
+O³¿nd
+::
+Z\94o
+());
+
+2266
+Em\99B¿nch
+(
+\9a¡r
+,
+Ã
+);
+
+2268
+ gToBoޗnStub
+::
+Ty³s
+
+ex³ùed
+ =
+\9a¡r
+->
+hydrog\92
+()->
+ex³ùed_\9aput_ty³s
+();
+
+2270 ià(
+ gex³ùed
+.
+IsEm±y
+()èex³ùed =
+ToBoޗnStub
+::
+Ty³s
+::
+G\92\94ic
+();
+
+2272 ià(
+ gex³ùed
+.
+CÚ\8f\9as
+(
+ToBoޗnStub
+::
+UNDEFINED
+)) {
+
+2274
+__
+
+Com·»RoÙ
+(
+»g
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+2275
+__
+
+beq
+(
+\9a¡r
+->
+F®£Lab\96
+(
+chunk_
+));
+
+2277 ià(
+ gex³ùed
+.
+CÚ\8f\9as
+(
+ToBoޗnStub
+::
+BOOLEAN
+)) {
+
+2279
+__
+
+Com·»RoÙ
+(
+»g
+,
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+2280
+__
+
+beq
+(
+\9a¡r
+->
+TrueLab\96
+(
+chunk_
+));
+
+2281
+__
+
+Com·»RoÙ
+(
+»g
+,
+H\97p
+::
+kF®£V®ueRoÙIndex
+);
+
+2282
+__
+
+beq
+(
+\9a¡r
+->
+F®£Lab\96
+(
+chunk_
+));
+
+2284 ià(
+ gex³ùed
+.
+CÚ\8f\9as
+(
+ToBoޗnStub
+::
+NULL_TYPE
+)) {
+
+2286
+__
+
+Com·»RoÙ
+(
+»g
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+2287
+__
+
+beq
+(
+\9a¡r
+->
+F®£Lab\96
+(
+chunk_
+));
+
+2290 ià(
+ gex³ùed
+.
+CÚ\8f\9as
+(
+ToBoޗnStub
+::
+SMI
+)) {
+
+2292
+__
+
+cmpi
+(
+»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+2293
+__
+
+beq
+(
+\9a¡r
+->
+F®£Lab\96
+(
+chunk_
+));
+
+2294
+__
+
+JumpIfSmi
+(
+»g
+,
+\9a¡r
+->
+TrueLab\96
+(
+chunk_
+));
+
+2295 } \vià(
+ gex³ùed
+.
+N\93dsM
+()) {
+
+2297
+__
+
+Te¡IfSmi
+(
+»g
+,
+r0
+);
+
+2298
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "Smi",
+ü0
+);
+
+2301 cڡ
+Regi¡\94
+
+ gm
+ =
+sü©ch0
+();
+
+2302 ià(
+ gex³ùed
+.
+N\93dsM
+()) {
+
+2303
+__
+
+LßdP
+(
+m
+,
+F\9bldMemO³¿nd
+(
+»g
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2305 ià(
+ gex³ùed
+.
+CªBeUnd\91eùabË
+()) {
+
+2307
+__
+
+lbz
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kB\99F\9bldOff£t
+));
+
+2308
+__
+
+Te¡B\99
+(
+\9d
+,
+M
+::
+kIsUnd\91eùabË
+,
+r0
+);
+
+2309
+__
+
+bÃ
+(
+\9a¡r
+->
+F®£Lab\96
+(
+chunk_
+),
+ü0
+);
+
+2313 ià(
+ gex³ùed
+.
+CÚ\8f\9as
+(
+ToBoޗnStub
+::
+SPEC_OBJECT
+)) {
+
+2315
+__
+
+Com·»In¡ªûTy³
+(
+m
+,
+\9d
+,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+2316
+__
+
+bge
+(
+\9a¡r
+->
+TrueLab\96
+(
+chunk_
+));
+
+2319 ià(
+ gex³ùed
+.
+CÚ\8f\9as
+(
+ToBoޗnStub
+::
+STRING
+)) {
+
+2321
+Lab\96
+
+nÙ_¡r\9ag
+;
+
+2322
+__
+
+Com·»In¡ªûTy³
+(
+m
+,
+\9d
+,
+FIRST_NONSTRING_TYPE
+);
+
+2323
+__
+
+bge
+(&
+nÙ_¡r\9ag
+);
+
+2324
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+»g
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+2325
+__
+
+cmpi
+(
+\9d
+,
+O³¿nd
+::
+Z\94o
+());
+
+2326
+__
+
+bÃ
+(
+\9a¡r
+->
+TrueLab\96
+(
+chunk_
+));
+
+2327
+__
+
+b
+(
+\9a¡r
+->
+F®£Lab\96
+(
+chunk_
+));
+
+2328
+__
+
+b\9ad
+(&
+nÙ_¡r\9ag
+);
+
+2331 ià(
+ gex³ùed
+.
+CÚ\8f\9as
+(
+ToBoޗnStub
+::
+SYMBOL
+)) {
+
+2333
+__
+
+Com·»In¡ªûTy³
+(
+m
+,
+\9d
+,
+SYMBOL_TYPE
+);
+
+2334
+__
+
+beq
+(
+\9a¡r
+->
+TrueLab\96
+(
+chunk_
+));
+
+2337 ià(
+ gex³ùed
+.
+CÚ\8f\9as
+(
+ToBoޗnStub
+::
+HEAP_NUMBER
+)) {
+
+2339
+Lab\96
+
+nÙ_h\97p_numb\94
+;
+
+2340
+__
+
+Com·»RoÙ
+(
+m
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+2341
+__
+
+bÃ
+(&
+nÙ_h\97p_numb\94
+);
+
+2342
+__
+
+lfd
+(
+dbl_sü©ch
+,
+F\9bldMemO³¿nd
+(
+»g
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+2344
+__
+
+fcmpu
+(
+dbl_sü©ch
+,
+kDoubËRegZ\94o
+,
+ü7
+);
+
+2345
+__
+
+mfü
+(
+r0
+);
+
+2346
+__
+
+ªdi
+(
+r0
+,\840,
+O³¿nd
+(
+üZOrNaNB\99s
+));
+
+2347
+__
+
+bÃ
+(
+\9a¡r
+->
+F®£Lab\96
+(
+chunk_
+),
+ü0
+);
+
+2348
+__
+
+b
+(
+\9a¡r
+->
+TrueLab\96
+(
+chunk_
+));
+
+2349
+__
+
+b\9ad
+(&
+nÙ_h\97p_numb\94
+);
+
+2352 ià(!
+ gex³ùed
+.
+IsG\92\94ic
+()) {
+
+2355
+DeÝtimizeIf
+(
+®
+,
+\9a¡r
+, "unexpected object");
+
+2362 \1e
+ gLCodeG\92
+::
+Em\99GÙo
+(\12
+block
+) {
+
+2363 ià(!
+IsNextEm\99\8bdBlock
+(
+block
+)) {
+
+2364
+__
+
+b
+(
+chunk_
+->
+G\91As£mblyLab\96
+(
+LookupDe¡\9a©iÚ
+(
+block
+)));
+
+2369 \1e
+ gLCodeG\92
+::
+DoGÙo
+(
+LGÙo
+*
+\9a¡r
+è{
+Em\99GÙo
+(\9a¡r->
+block_id
+()); }
+
+2372
+CÚd\99iÚ
+
+ gLCodeG\92
+::
+Tok\92ToCÚd\99iÚ
+(
+Tok\92
+::
+V®ue
+
+Ý
+) {
+
+2373
+CÚd\99iÚ
+
+cÚd
+ =
+kNoCÚd\99iÚ
+;
+
+2374 \1a
+ gÝ
+) {
+
+2375 \ 4
+ gTok\92
+::
+EQ
+:
+
+2376 \ 4
+Tok\92
+::
+EQ_STRICT
+:
+
+2377
+cÚd
+ =
+eq
+;
+
+2379 \ 4
+ gTok\92
+::
+NE
+:
+
+2380 \ 4
+Tok\92
+::
+NE_STRICT
+:
+
+2381
+cÚd
+ =
+Ã
+;
+
+2383 \ 4
+ gTok\92
+::
+LT
+:
+
+2384
+cÚd
+ =
+É
+;
+
+2386 \ 4
+ gTok\92
+::
+GT
+:
+
+2387
+cÚd
+ =
+gt
+;
+
+2389 \ 4
+ gTok\92
+::
+LTE
+:
+
+2390
+cÚd
+ =
+Ë
+;
+
+2392 \ 4
+ gTok\92
+::
+GTE
+:
+
+2393
+cÚd
+ =
+ge
+;
+
+2395 \ 4
+ gTok\92
+::
+IN
+:
+
+2396 \ 4
+Tok\92
+::
+INSTANCEOF
+:
+
+2398
+UNREACHABLE
+();
+
+2400 \15
+ gcÚd
+;
+
+2404 \1e
+ gLCodeG\92
+::
+DoCom·»Num\94icAndB¿nch
+(
+LCom·»Num\94icAndB¿nch
+*
+\9a¡r
+) {
+
+2405
+LO³¿nd
+*
+Ëá
+ =
+\9a¡r
+->left();
+
+2406
+LO³¿nd
+*
+ gright
+ =
+\9a¡r
+->
+right
+();
+
+2407
+boÞ
+
+ gis_unsigÃd
+ =
+
+2408
+\9a¡r
+->
+hydrog\92
+()->
+Ëá
+()->
+CheckFÏg
+(
+HIn¡ruùiÚ
+::
+kU\9at32
+) ||
+
+2409
+\9a¡r
+->
+hydrog\92
+()->
+right
+()->
+CheckFÏg
+(
+HIn¡ruùiÚ
+::
+kU\9at32
+);
+
+2410
+CÚd\99iÚ
+
+ gcÚd
+ =
+Tok\92ToCÚd\99iÚ
+(
+\9a¡r
+->
+Ý
+());
+
+2412 ià(
+ gËá
+->
+IsCÚ¡ªtO³¿nd
+(è&&
+ gright
+->IsConstantOperand()) {
+
+2414 \b
+ gËá_v®
+ =
+ToDoubË
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+Ëá
+));
+
+2415 \b
+ gright_v®
+ =
+ToDoubË
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+right
+));
+
+2416 \12
+ gÃxt_block
+ =
+Ev®Com·risÚ
+(
+\9a¡r
+->
+Ý
+(),
+Ëá_v®
+,
+right_v®
+)
+
+2417 ?
+ g\9a¡r
+->
+TrueDe¡\9a©iÚ
+(
+chunk_
+)
+
+2418 :
+\9a¡r
+->
+F®£De¡\9a©iÚ
+(
+chunk_
+);
+
+2419
+Em\99GÙo
+(
+Ãxt_block
+);
+
+2421 ià(
+ g\9a¡r
+->
+is_doubË
+()) {
+
+2424
+__
+
+fcmpu
+(
+ToDoubËRegi¡\94
+(
+Ëá
+), ToDoubËRegi¡\94(
+right
+));
+
+2427
+__
+
+bunÜd\94ed
+(
+\9a¡r
+->
+F®£Lab\96
+(
+chunk_
+));
+
+2429 ià(
+ gright
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+2430
+\9at32_t
+
+ gv®ue
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+right
+));
+
+2431 ià(
+ g\9a¡r
+->
+hydrog\92_v®ue
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+2432 ià(
+ gis_unsigÃd
+) {
+
+2433
+__
+
+Cm¶SmiL\99\94®
+(
+ToRegi¡\94
+(
+Ëá
+),
+Smi
+::
+FromIÁ
+(
+v®ue
+),
+r0
+);
+
+2435
+__
+
+CmpSmiL\99\94®
+(
+ToRegi¡\94
+(
+Ëá
+),
+Smi
+::
+FromIÁ
+(
+v®ue
+),
+r0
+);
+
+2438 ià(
+ gis_unsigÃd
+) {
+
+2439
+__
+
+Cm¶wi
+(
+ToRegi¡\94
+(
+Ëá
+),
+O³¿nd
+(
+v®ue
+),
+r0
+);
+
+2441
+__
+
+Cmpwi
+(
+ToRegi¡\94
+(
+Ëá
+),
+O³¿nd
+(
+v®ue
+),
+r0
+);
+
+2444 } \vià(
+ gËá
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+2445
+\9at32_t
+
+ gv®ue
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+Ëá
+));
+
+2446 ià(
+ g\9a¡r
+->
+hydrog\92_v®ue
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+2447 ià(
+ gis_unsigÃd
+) {
+
+2448
+__
+
+Cm¶SmiL\99\94®
+(
+ToRegi¡\94
+(
+right
+),
+Smi
+::
+FromIÁ
+(
+v®ue
+),
+r0
+);
+
+2450
+__
+
+CmpSmiL\99\94®
+(
+ToRegi¡\94
+(
+right
+),
+Smi
+::
+FromIÁ
+(
+v®ue
+),
+r0
+);
+
+2453 ià(
+ gis_unsigÃd
+) {
+
+2454
+__
+
+Cm¶wi
+(
+ToRegi¡\94
+(
+right
+),
+O³¿nd
+(
+v®ue
+),
+r0
+);
+
+2456
+__
+
+Cmpwi
+(
+ToRegi¡\94
+(
+right
+),
+O³¿nd
+(
+v®ue
+),
+r0
+);
+
+2460
+ gcÚd
+ =
+Commu\8bCÚd\99iÚ
+(
+cÚd
+);
+
+2461 } \vià(
+ g\9a¡r
+->
+hydrog\92_v®ue
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+2462 ià(
+ gis_unsigÃd
+) {
+
+2463
+__
+
+cm¶
+(
+ToRegi¡\94
+(
+Ëá
+), ToRegi¡\94(
+right
+));
+
+2465
+__
+
+cmp
+(
+ToRegi¡\94
+(
+Ëá
+), ToRegi¡\94(
+right
+));
+
+2468 ià(
+ gis_unsigÃd
+) {
+
+2469
+__
+
+cm¶w
+(
+ToRegi¡\94
+(
+Ëá
+), ToRegi¡\94(
+right
+));
+
+2471
+__
+
+cmpw
+(
+ToRegi¡\94
+(
+Ëá
+), ToRegi¡\94(
+right
+));
+
+2475
+Em\99B¿nch
+(
+\9a¡r
+,
+cÚd
+);
+
+2480 \1e
+ gLCodeG\92
+::
+DoCmpObjeùEqAndB¿nch
+(
+LCmpObjeùEqAndB¿nch
+*
+\9a¡r
+) {
+
+2481
+Regi¡\94
+
+Ëá
+ =
+ToRegi¡\94
+(
+\9a¡r
+->left());
+
+2482
+Regi¡\94
+
+ gright
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+right
+());
+
+2484
+__
+
+cmp
+(
+Ëá
+,
+right
+);
+
+2485
+Em\99B¿nch
+(
+\9a¡r
+,
+eq
+);
+
+2489 \1e
+ gLCodeG\92
+::
+DoCmpHÞeAndB¿nch
+(
+LCmpHÞeAndB¿nch
+*
+\9a¡r
+) {
+
+2490 ià(
+\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsTagged
+()) {
+
+2491
+Regi¡\94
+
+\9aput_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+objeù
+());
+
+2492
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+çùÜy
+()->
+the_hÞe_v®ue
+()));
+
+2493
+__
+
+cmp
+(
+\9aput_»g
+,
+\9d
+);
+
+2494
+Em\99B¿nch
+(
+\9a¡r
+,
+eq
+);
+
+2498
+DoubËRegi¡\94
+
+ g\9aput_»g
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+objeù
+());
+
+2499
+__
+
+fcmpu
+(
+\9aput_»g
+, input_reg);
+
+2500
+Em\99F®£B¿nch
+(
+\9a¡r
+,
+Üd\94ed
+);
+
+2502
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+2503
+__
+
+MovDoubËHighToIÁ
+(
+sü©ch
+,
+\9aput_»g
+);
+
+2504
+__
+
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+kHÞeNªUµ\9432
+),
+r0
+);
+
+2505
+Em\99B¿nch
+(
+\9a¡r
+,
+eq
+);
+
+2509 \1e
+ gLCodeG\92
+::
+DoCom·»M\9ausZ\94oAndB¿nch
+(
+LCom·»M\9ausZ\94oAndB¿nch
+*
+\9a¡r
+) {
+
+2510
+R\95»£Á©iÚ
+
+»p
+ =
+\9a¡r
+->
+hydrog\92
+()->
+v®ue
+()->
+»´e£Á©iÚ
+();
+
+2511
+DCHECK
+(!
+»p
+.
+IsIÁeg\9432
+());
+
+2512
+Regi¡\94
+
+ gsü©ch
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+2514 ià(
+ g»p
+.
+IsDoubË
+()) {
+
+2515
+DoubËRegi¡\94
+
+ gv®ue
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2516
+__
+
+fcmpu
+(
+v®ue
+,
+kDoubËRegZ\94o
+);
+
+2517
+Em\99F®£B¿nch
+(
+\9a¡r
+,
+Ã
+);
+
+2518 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2519
+__
+
+MovDoubËToIÁ64
+(
+sü©ch
+,
+v®ue
+);
+
+2521
+__
+
+MovDoubËHighToIÁ
+(
+sü©ch
+,
+v®ue
+);
+
+2523
+__
+
+cmpi
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+2524
+Em\99B¿nch
+(
+\9a¡r
+,
+É
+);
+
+2526
+Regi¡\94
+
+ gv®ue
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2527
+__
+
+CheckM
+(
+v®ue
+,
+sü©ch
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+,
+
+2528
+\9a¡r
+->
+F®£Lab\96
+(
+chunk
+()),
+DO_SMI_CHECK
+);
+
+2529 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2530
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+v®ue
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+2531
+__
+
+li
+(
+\9d
+,
+O³¿nd
+(1));
+
+2532
+__
+
+rÙrdi
+(
+\9d
+, ip, 1);
+
+2533
+__
+
+cmp
+(
+sü©ch
+,
+\9d
+);
+
+2535
+__
+
+lwz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+v®ue
+,
+H\97pNumb\94
+::
+kExpÚ\92tOff£t
+));
+
+2536
+__
+
+lwz
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+v®ue
+,
+H\97pNumb\94
+::
+kMªtis§Off£t
+));
+
+2537
+Lab\96
+
+ gsk\9d
+;
+
+2538
+__
+
+lis
+(
+r0
+,
+O³¿nd
+(
+SIGN_EXT_IMM16
+(0x8000)));
+
+2539
+__
+
+cmp
+(
+sü©ch
+,
+r0
+);
+
+2540
+__
+
+bÃ
+(&
+sk\9d
+);
+
+2541
+__
+
+cmpi
+(
+\9d
+,
+O³¿nd
+::
+Z\94o
+());
+
+2542
+__
+
+b\9ad
+(&
+sk\9d
+);
+
+2544
+Em\99B¿nch
+(
+\9a¡r
+,
+eq
+);
+
+2549
+CÚd\99iÚ
+
+ gLCodeG\92
+::
+Em\99IsObjeù
+(
+Regi¡\94
+
+\9aput
+, Regi¡\94
+\8bmp1
+,
+
+2550
+Lab\96
+*
+is_nÙ_objeù
+, Lab\96*
+is_objeù
+) {
+
+2551
+Regi¡\94
+
+ g\8bmp2
+ =
+sü©ch0
+();
+
+2552
+__
+
+JumpIfSmi
+(
+\9aput
+,
+is_nÙ_objeù
+);
+
+2554
+__
+
+LßdRoÙ
+(
+\8bmp2
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+2555
+__
+
+cmp
+(
+\9aput
+,
+\8bmp2
+);
+
+2556
+__
+
+beq
+(
+is_objeù
+);
+
+2559
+__
+
+LßdP
+(
+\8bmp1
+,
+F\9bldMemO³¿nd
+(
+\9aput
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2561
+__
+
+lbz
+(
+\8bmp2
+,
+F\9bldMemO³¿nd
+(
+\8bmp1
+,
+M
+::
+kB\99F\9bldOff£t
+));
+
+2562
+__
+
+Te¡B\99
+(
+\8bmp2
+,
+M
+::
+kIsUnd\91eùabË
+,
+r0
+);
+
+2563
+__
+
+bÃ
+(
+is_nÙ_objeù
+,
+ü0
+);
+
+2566
+__
+
+lbz
+(
+\8bmp2
+,
+F\9bldMemO³¿nd
+(
+\8bmp1
+,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+2567
+__
+
+cmpi
+(
+\8bmp2
+,
+O³¿nd
+(
+FIRST_NONCALLABLE_SPEC_OBJECT_TYPE
+));
+
+2568
+__
+
+bÉ
+(
+is_nÙ_objeù
+);
+
+2569
+__
+
+cmpi
+(
+\8bmp2
+,
+O³¿nd
+(
+LAST_NONCALLABLE_SPEC_OBJECT_TYPE
+));
+
+2570 \15
+ gË
+;
+
+2574 \1e
+ gLCodeG\92
+::
+DoIsObjeùAndB¿nch
+(
+LIsObjeùAndB¿nch
+*
+\9a¡r
+) {
+
+2575
+Regi¡\94
+
+»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2576
+Regi¡\94
+
+ g\8bmp1
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+2578
+CÚd\99iÚ
+
+ g\8cue_cÚd
+ =
+Em\99IsObjeù
+(
+»g
+,
+\8bmp1
+,
+\9a¡r
+->
+F®£Lab\96
+(
+chunk_
+),
+
+2579
+\9a¡r
+->
+TrueLab\96
+(
+chunk_
+));
+
+2581
+Em\99B¿nch
+(
+\9a¡r
+,
+\8cue_cÚd
+);
+
+2585
+CÚd\99iÚ
+
+ gLCodeG\92
+::
+Em\99IsS\8c\9ag
+(
+Regi¡\94
+
+\9aput
+, Regi¡\94
+\8bmp1
+,
+
+2586
+Lab\96
+*
+is_nÙ_¡r\9ag
+,
+
+2587
+SmiCheck
+
+check_Ãeded
+ =
+INLINE_SMI_CHECK
+) {
+
+2588 ià(
+check_Ãeded
+ =ð
+INLINE_SMI_CHECK
+) {
+
+2589
+__
+
+JumpIfSmi
+(
+\9aput
+,
+is_nÙ_¡r\9ag
+);
+
+2591
+__
+
+Com·»ObjeùTy³
+(
+\9aput
+,
+\8bmp1
+,\81emp1,
+FIRST_NONSTRING_TYPE
+);
+
+2593 \15
+ gÉ
+;
+
+2597 \1e
+ gLCodeG\92
+::
+DoIsS\8c\9agAndB¿nch
+(
+LIsS\8c\9agAndB¿nch
+*
+\9a¡r
+) {
+
+2598
+Regi¡\94
+
+»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2599
+Regi¡\94
+
+ g\8bmp1
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+2601
+SmiCheck
+
+ gcheck_Ãeded
+ =
+\9a¡r
+->
+hydrog\92
+()->
+v®ue
+()->
+ty³
+().
+IsH\97pObjeù
+()
+
+2602 ?
+OMIT_SMI_CHECK
+
+
+2603 :
+INLINE_SMI_CHECK
+;
+
+2604
+CÚd\99iÚ
+
+ g\8cue_cÚd
+ =
+
+2605
+Em\99IsS\8c\9ag
+(
+»g
+,
+\8bmp1
+,
+\9a¡r
+->
+F®£Lab\96
+(
+chunk_
+),
+check_Ãeded
+);
+
+2607
+Em\99B¿nch
+(
+\9a¡r
+,
+\8cue_cÚd
+);
+
+2611 \1e
+ gLCodeG\92
+::
+DoIsSmiAndB¿nch
+(
+LIsSmiAndB¿nch
+*
+\9a¡r
+) {
+
+2612
+Regi¡\94
+
+\9aput_»g
+ =
+Em\99LßdRegi¡\94
+(
+\9a¡r
+->
+v®ue
+(),
+\9d
+);
+
+2613
+__
+
+Te¡IfSmi
+(
+\9aput_»g
+,
+r0
+);
+
+2614
+Em\99B¿nch
+(
+\9a¡r
+,
+eq
+,
+ü0
+);
+
+2618 \1e
+ gLCodeG\92
+::
+DoIsUnd\91eùabËAndB¿nch
+(
+LIsUnd\91eùabËAndB¿nch
+*
+\9a¡r
+) {
+
+2619
+Regi¡\94
+
+\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2620
+Regi¡\94
+
+ g\8bmp
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+2622 ià(!
+ g\9a¡r
+->
+hydrog\92
+()->
+v®ue
+()->
+ty³
+().
+IsH\97pObjeù
+()) {
+
+2623
+__
+
+JumpIfSmi
+(
+\9aput
+,
+\9a¡r
+->
+F®£Lab\96
+(
+chunk_
+));
+
+2625
+__
+
+LßdP
+(
+\8bmp
+,
+F\9bldMemO³¿nd
+(
+\9aput
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2626
+__
+
+lbz
+(
+\8bmp
+,
+F\9bldMemO³¿nd
+Ñemp,
+M
+::
+kB\99F\9bldOff£t
+));
+
+2627
+__
+
+Te¡B\99
+(
+\8bmp
+,
+M
+::
+kIsUnd\91eùabË
+,
+r0
+);
+
+2628
+Em\99B¿nch
+(
+\9a¡r
+,
+Ã
+,
+ü0
+);
+
+2632 \18
+CÚd\99iÚ
+
+Compu\8bCom·»CÚd\99iÚ
+(
+Tok\92
+::
+V®ue
+
+Ý
+) {
+
+2633 \1a
+Ý
+) {
+
+2634 \ 4
+Tok\92
+::
+EQ_STRICT
+:
+
+2635 \ 4
+Tok\92
+::
+EQ
+:
+
+2636 \15
+eq
+;
+
+2637 \ 4
+ gTok\92
+::
+LT
+:
+
+2638 \15
+É
+;
+
+2639 \ 4
+ gTok\92
+::
+GT
+:
+
+2640 \15
+gt
+;
+
+2641 \ 4
+ gTok\92
+::
+LTE
+:
+
+2642 \15
+Ë
+;
+
+2643 \ 4
+ gTok\92
+::
+GTE
+:
+
+2644 \15
+ge
+;
+
+2646
+UNREACHABLE
+();
+
+2647 \15
+ gkNoCÚd\99iÚ
+;
+
+2652 \1e
+ gLCodeG\92
+::
+DoS\8c\9agCom·»AndB¿nch
+(
+LS\8c\9agCom·»AndB¿nch
+*
+\9a¡r
+) {
+
+2653
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+2654
+ gTok\92
+::
+V®ue
+
+Ý
+ =
+\9a¡r
+->op();
+
+2656
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+CodeFaùÜy
+::
+Com·»IC
+(
+isީe
+(),
+Ý
+).
+code
+();
+
+2657
+C®lCode
+(
+ic
+,
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+2659
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+2661
+CÚd\99iÚ
+
+ gcÚd\99iÚ
+ =
+Compu\8bCom·»CÚd\99iÚ
+(
+Ý
+);
+
+2663
+Em\99B¿nch
+(
+\9a¡r
+,
+cÚd\99iÚ
+);
+
+2667 \18
+In¡ªûTy³
+
+Te¡Ty³
+(
+HHasIn¡ªûTy³AndB¿nch
+*
+\9a¡r
+) {
+
+2668
+In¡ªûTy³
+
+ gäom
+ =
+\9a¡r
+->
+äom
+();
+
+2669
+In¡ªûTy³
+
+ gto
+ =
+\9a¡r
+->
+to
+();
+
+2670 ià(
+ gäom
+ =ð
+FIRST_TYPE
+è\15
+to
+;
+
+2671
+DCHECK
+(
+äom
+ =ð
+to
+ ||\81Ø=ð
+LAST_TYPE
+);
+
+2672 \15
+ gäom
+;
+
+2676 \18
+CÚd\99iÚ
+
+B¿nchCÚd\99iÚ
+(
+HHasIn¡ªûTy³AndB¿nch
+*
+\9a¡r
+) {
+
+2677
+In¡ªûTy³
+
+ gäom
+ =
+\9a¡r
+->
+äom
+();
+
+2678
+In¡ªûTy³
+
+ gto
+ =
+\9a¡r
+->
+to
+();
+
+2679 ià(
+ gäom
+ =ð
+to
+è\15
+eq
+;
+
+2680 ià(
+ gto
+ =ð
+LAST_TYPE
+è\15
+ge
+;
+
+2681 ià(
+ gäom
+ =ð
+FIRST_TYPE
+è\15
+Ë
+;
+
+2682
+UNREACHABLE
+();
+
+2683 \15
+ geq
+;
+
+2687 \1e
+ gLCodeG\92
+::
+DoHasIn¡ªûTy³AndB¿nch
+(
+LHasIn¡ªûTy³AndB¿nch
+*
+\9a¡r
+) {
+
+2688
+Regi¡\94
+
+sü©ch
+ =
+sü©ch0
+();
+
+2689
+Regi¡\94
+
+ g\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2691 ià(!
+ g\9a¡r
+->
+hydrog\92
+()->
+v®ue
+()->
+ty³
+().
+IsH\97pObjeù
+()) {
+
+2692
+__
+
+JumpIfSmi
+(
+\9aput
+,
+\9a¡r
+->
+F®£Lab\96
+(
+chunk_
+));
+
+2695
+__
+
+Com·»ObjeùTy³
+(
+\9aput
+,
+sü©ch
+, sü©ch,
+Te¡Ty³
+(
+\9a¡r
+->
+hydrog\92
+()));
+
+2696
+Em\99B¿nch
+(
+\9a¡r
+,
+B¿nchCÚd\99iÚ
+(\9a¡r->
+hydrog\92
+()));
+
+2700 \1e
+ gLCodeG\92
+::
+DoG\91CachedA¼ayIndex
+(
+LG\91CachedA¼ayIndex
+*
+\9a¡r
+) {
+
+2701
+Regi¡\94
+
+\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2702
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+2704
+__
+
+As£¹S\8c\9ag
+(
+\9aput
+);
+
+2706
+__
+
+lwz
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+\9aput
+,
+S\8c\9ag
+::
+kHashF\9bldOff£t
+));
+
+2707
+__
+
+IndexFromHash
+(
+»suÉ
+,\84esult);
+
+2711 \1e
+ gLCodeG\92
+::
+DoHasCachedA¼ayIndexAndB¿nch
+(
+
+2712
+LHasCachedA¼ayIndexAndB¿nch
+*
+\9a¡r
+) {
+
+2713
+Regi¡\94
+
+\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2714
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+2716
+__
+
+lwz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+\9aput
+,
+S\8c\9ag
+::
+kHashF\9bldOff£t
+));
+
+2717
+__
+
+mov
+(
+r0
+,
+O³¿nd
+(
+S\8c\9ag
+::
+kCÚ\8f\9asCachedA¼ayIndexMask
+));
+
+2718
+__
+
+ªd_
+(
+r0
+,
+sü©ch
+,\840,
+S\91RC
+);
+
+2719
+Em\99B¿nch
+(
+\9a¡r
+,
+eq
+,
+ü0
+);
+
+2725 \1e
+ gLCodeG\92
+::
+Em\99CÏssOfTe¡
+(
+Lab\96
+*
+is_\8cue
+, Lab\96*
+is_çl£
+,
+
+2726
+HªdË
+<
+S\8c\9ag
+>
+þass_Çme
+,
+Regi¡\94
+
+\9aput
+,
+
+2727
+Regi¡\94
+
+\8bmp
+, Regi¡\94
+\8bmp2
+) {
+
+2728
+DCHECK
+(!
+\9aput
+.
+is
+(
+\8bmp
+));
+
+2729
+DCHECK
+(!
+\9aput
+.
+is
+(
+\8bmp2
+));
+
+2730
+DCHECK
+(!
+\8bmp
+.
+is
+(
+\8bmp2
+));
+
+2732
+__
+
+JumpIfSmi
+(
+\9aput
+,
+is_çl£
+);
+
+2734 ià(
+ gS\8c\9ag
+::
+Equ®s
+(
+isީe
+()->
+çùÜy
+()->
+FunùiÚ_¡r\9ag
+(),
+þass_Çme
+)) {
+
+2737
+STATIC_ASSERT
+(
+NUM_OF_CALLABLE_SPEC_OBJECT_TYPES
+ == 2);
+
+2738
+STATIC_ASSERT
+(
+FIRST_NONCALLABLE_SPEC_OBJECT_TYPE
+ ==
+
+2739
+FIRST_SPEC_OBJECT_TYPE
+ + 1);
+
+2740
+STATIC_ASSERT
+(
+LAST_NONCALLABLE_SPEC_OBJECT_TYPE
+ ==
+
+2741
+LAST_SPEC_OBJECT_TYPE
+ - 1);
+
+2742
+STATIC_ASSERT
+(
+LAST_SPEC_OBJECT_TYPE
+ =ð
+LAST_TYPE
+);
+
+2743
+__
+
+Com·»ObjeùTy³
+(
+\9aput
+,
+\8bmp
+,
+\8bmp2
+,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+2744
+__
+
+bÉ
+(
+is_çl£
+);
+
+2745
+__
+
+beq
+(
+is_\8cue
+);
+
+2746
+__
+
+cmpi
+(
+\8bmp2
+,
+O³¿nd
+(
+LAST_SPEC_OBJECT_TYPE
+));
+
+2747
+__
+
+beq
+(
+is_\8cue
+);
+
+2751
+__
+
+LßdP
+(
+\8bmp
+,
+F\9bldMemO³¿nd
+(
+\9aput
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2752
+__
+
+lbz
+(
+\8bmp2
+,
+F\9bldMemO³¿nd
+(
+\8bmp
+,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+2753
+__
+
+subi
+(
+\8bmp2
+,\81emp2,
+O³¿nd
+(
+FIRST_NONCALLABLE_SPEC_OBJECT_TYPE
+));
+
+2754
+__
+
+cmpi
+(
+\8bmp2
+,
+O³¿nd
+(
+LAST_NONCALLABLE_SPEC_OBJECT_TYPE
+ -
+
+2755
+FIRST_NONCALLABLE_SPEC_OBJECT_TYPE
+));
+
+2756
+__
+
+bgt
+(
+is_çl£
+);
+
+2761
+__
+
+LßdP
+(
+\8bmp
+,
+F\9bldMemO³¿nd
+Ñemp,
+M
+::
+kCÚ¡ruùÜOff£t
+));
+
+2764
+__
+
+Com·»ObjeùTy³
+(
+\8bmp
+,
+\8bmp2
+,\81emp2,
+JS_FUNCTION_TYPE
+);
+
+2765 ià(
+ gþass_Çme
+->
+IsOÃBy\8bEqu®To
+(
+STATIC_CHAR_VECTOR
+("Object"))) {
+
+2766
+__
+
+bÃ
+(
+is_\8cue
+);
+
+2768
+__
+
+bÃ
+(
+is_çl£
+);
+
+2773
+__
+
+LßdP
+(
+\8bmp
+,
+F\9bldMemO³¿nd
+Ñemp,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+2774
+__
+
+LßdP
+(
+\8bmp
+,
+
+2775
+F\9bldMemO³¿nd
+(
+\8bmp
+,
+Sh¬edFunùiÚInfo
+::
+kIn¡ªûCÏssNameOff£t
+));
+
+2782
+__
+
+Cmpi
+(
+\8bmp
+,
+O³¿nd
+(
+þass_Çme
+),
+r0
+);
+
+2787 \1e
+ gLCodeG\92
+::
+DoCÏssOfTe¡AndB¿nch
+(
+LCÏssOfTe¡AndB¿nch
+*
+\9a¡r
+) {
+
+2788
+Regi¡\94
+
+\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2789
+Regi¡\94
+
+ g\8bmp
+ =
+sü©ch0
+();
+
+2790
+Regi¡\94
+
+ g\8bmp2
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+2791
+ gHªdË
+<
+ gS\8c\9ag
+>
+ gþass_Çme
+ =
+\9a¡r
+->
+hydrog\92
+()->
+þass_Çme
+();
+
+2793
+Em\99CÏssOfTe¡
+(
+\9a¡r
+->
+TrueLab\96
+(
+chunk_
+), in¡r->
+F®£Lab\96
+(chunk_),
+
+2794
+þass_Çme
+,
+\9aput
+,
+\8bmp
+,
+\8bmp2
+);
+
+2796
+Em\99B¿nch
+(
+\9a¡r
+,
+eq
+);
+
+2800 \1e
+ gLCodeG\92
+::
+DoCmpMAndB¿nch
+(
+LCmpMAndB¿nch
+*
+\9a¡r
+) {
+
+2801
+Regi¡\94
+
+»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2802
+Regi¡\94
+
+ g\8bmp
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+2804
+__
+
+LßdP
+(
+\8bmp
+,
+F\9bldMemO³¿nd
+(
+»g
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2805
+__
+
+Cmpi
+(
+\8bmp
+,
+O³¿nd
+(
+\9a¡r
+->
+m
+()),
+r0
+);
+
+2806
+Em\99B¿nch
+(
+\9a¡r
+,
+eq
+);
+
+2810 \1e
+ gLCodeG\92
+::
+DoIn¡ªûOf
+(
+LIn¡ªûOf
+*
+\9a¡r
+) {
+
+2811
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+2812
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëá
+()).
+is
+(
+r3
+));
+
+2813
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+right
+()).
+is
+(
+r4
+));
+
+2815
+In¡ªûofStub
+
+¡ub
+(
+isީe
+(), In¡ªûofStub::
+kArgsInRegi¡\94s
+);
+
+2816
+C®lCode
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+2818
+Lab\96
+
+ gequ®
+,
+ gdÚe
+;
+
+2819
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+2820
+__
+
+beq
+(&
+equ®
+);
+
+2821
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+çùÜy
+()->
+çl£_v®ue
+()));
+
+2822
+__
+
+b
+(&
+dÚe
+);
+
+2824
+__
+
+b\9ad
+(&
+equ®
+);
+
+2825
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+çùÜy
+()->
+\8cue_v®ue
+()));
+
+2826
+__
+
+b\9ad
+(&
+dÚe
+);
+
+2830 \1e
+ gLCodeG\92
+::
+DoIn¡ªûOfKnownGlob®
+(
+LIn¡ªûOfKnownGlob®
+*
+\9a¡r
+) {
+
+2831 þas
+ cDeã¼edIn¡ªûOfKnownGlob®
+
+FINAL
+ :
+public
+
+LDeã¼edCode
+ {
+
+2832
+public
+:
+
+2833
+Deã¼edIn¡ªûOfKnownGlob®
+(
+LCodeG\92
+*
+codeg\92
+,
+
+2834
+LIn¡ªûOfKnownGlob®
+*
+\9a¡r
+)
+
+2835 :
+LDeã¼edCode
+(
+codeg\92
+),
+\9a¡r_
+(
+\9a¡r
+) {}
+
+2836
+v\9ctu®
+ \1e
+G\92\94©e
+(è
+ gOVERRIDE
+ {
+
+2837
+codeg\92
+()->
+DoDeã¼edIn¡ªûOfKnownGlob®
+(
+\9a¡r_
+, &
+m_check_
+);
+
+2839
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+(è
+ gOVERRIDE
+ { \15
+ g\9a¡r_
+; }
+
+2840
+Lab\96
+*
+m_check
+(è{ \15 &
+ gm_check_
+; }
+
+2842
+ g´iv©e
+:
+
+2843
+LIn¡ªûOfKnownGlob®
+*
+\9a¡r_
+;
+
+2844
+Lab\96
+
+ gm_check_
+;
+
+2847
+Deã¼edIn¡ªûOfKnownGlob®
+*
+ gdeã¼ed
+;
+
+2848
+ gdeã¼ed
+ =
+Ãw
+ (
+zÚe
+()è
+Deã¼edIn¡ªûOfKnownGlob®
+(
+this
+,
+\9a¡r
+);
+
+2850
+Lab\96
+
+ gdÚe
+,
+ gçl£_»suÉ
+;
+
+2851
+Regi¡\94
+
+ gobjeù
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2852
+Regi¡\94
+
+ g\8bmp
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+2853
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+2856
+__
+
+JumpIfSmi
+(
+objeù
+, &
+çl£_»suÉ
+);
+
+2861
+Lab\96
+
+ gÿche_miss
+;
+
+2862
+Regi¡\94
+
+ gm
+ =
+\8bmp
+;
+
+2863
+__
+
+LßdP
+(
+m
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2867
+ gAs£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+masm_
+);
+
+2868
+__
+
+b\9ad
+(
+deã¼ed
+->
+m_check
+());
+
+2872
+ gHªdË
+<
+ gC\96l
+>
+ gûÎ
+ =
+çùÜy
+()->
+NewC\96l
+(çùÜy()->
+the_hÞe_v®ue
+());
+
+2873
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+HªdË
+<
+Objeù
+>(
+ûÎ
+)));
+
+2874
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(\9d,
+PrÝ\94tyC\96l
+::
+kV®ueOff£t
+));
+
+2875
+__
+
+cmp
+(
+m
+,
+\9d
+);
+
+2876
+__
+
+bÃ
+(&
+ÿche_miss
+);
+
+2880
+__
+
+mov
+(
+»suÉ
+,
+O³¿nd
+(
+çùÜy
+()->
+the_hÞe_v®ue
+()));
+
+2882
+__
+
+b
+(&
+dÚe
+);
+
+2886
+__
+
+b\9ad
+(&
+ÿche_miss
+);
+
+2888
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+2889
+__
+
+cmp
+(
+objeù
+,
+\9d
+);
+
+2890
+__
+
+beq
+(&
+çl£_»suÉ
+);
+
+2893
+CÚd\99iÚ
+
+ gis_¡r\9ag
+ =
+masm_
+->
+IsObjeùS\8c\9agTy³
+(
+objeù
+,
+\8bmp
+);
+
+2894
+__
+
+b
+(
+is_¡r\9ag
+, &
+çl£_»suÉ
+,
+ü0
+);
+
+2897
+__
+
+b
+(
+deã¼ed
+->
+\92\8cy
+());
+
+2899
+__
+
+b\9ad
+(&
+çl£_»suÉ
+);
+
+2900
+__
+
+LßdRoÙ
+(
+»suÉ
+,
+H\97p
+::
+kF®£V®ueRoÙIndex
+);
+
+2904
+__
+
+b\9ad
+(
+deã¼ed
+->
+ex\99
+());
+
+2905
+__
+
+b\9ad
+(&
+dÚe
+);
+
+2909 \1e
+ gLCodeG\92
+::
+DoDeã¼edIn¡ªûOfKnownGlob®
+(
+LIn¡ªûOfKnownGlob®
+*
+\9a¡r
+,
+
+2910
+Lab\96
+*
+m_check
+) {
+
+2911
+ gIn¡ªûofStub
+::
+FÏgs
+
+æags
+ =
+In¡ªûofStub
+::
+kNoFÏgs
+;
+
+2912
+ gæags
+ =
+¡©ic_ÿ¡
+<
+In¡ªûofStub
+::
+FÏgs
+>(
+æags
+ |
+
+2913
+In¡ªûofStub
+::
+kArgsInRegi¡\94s
+);
+
+2914
+ gæags
+ =
+¡©ic_ÿ¡
+<
+In¡ªûofStub
+::
+FÏgs
+>(
+
+2915
+æags
+ |
+In¡ªûofStub
+::
+kC®lS\99eIÆ\9aeCheck
+);
+
+2916
+ gæags
+ =
+¡©ic_ÿ¡
+<
+In¡ªûofStub
+::
+FÏgs
+>(
+
+2917
+æags
+ |
+In¡ªûofStub
+::
+kR\91uºTrueF®£Objeù
+);
+
+2918
+In¡ªûofStub
+
+¡ub
+(
+isީe
+(),
+æags
+);
+
+2920
+PushSaãpo\9atRegi¡\94sScÝe
+
+scÝe
+(
+this
+);
+
+2921
+LßdCÚ\8bxtFromDeã¼ed
+(
+\9a¡r
+->
+cڋxt
+());
+
+2923
+__
+
+Move
+(
+In¡ªûofStub
+::
+right
+(),
+\9a¡r
+->
+funùiÚ
+());
+
+2925 \18cڡ \12
+ gkAdd\99iÚ®D\96\8f
+ = (2 *
+As£mbËr
+::
+kMovIn¡ruùiÚs
+) + 2;
+
+2926 \12
+ gd\96\8f
+ =
+masm_
+->
+In¡ruùiÚsG\92\94©edS\9aû
+(
+m_check
+è+
+kAdd\99iÚ®D\96\8f
+;
+
+2928
+ gAs£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+masm_
+);
+
+2930
+__
+
+mov
+(
+r8
+,
+O³¿nd
+(
+d\96\8f
+ *
+In¡ruùiÚ
+::
+kIn¡rSize
+));
+
+2932
+C®lCodeG\92\94ic
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+,
+
+2933
+RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
+);
+
+2934
+DCHECK
+(
+d\96\8f
+ =ð
+masm_
+->
+In¡ruùiÚsG\92\94©edS\9aû
+(
+m_check
+));
+
+2935
+LEnv\9cÚm\92t
+*
+ g\92v
+ =
+\9a¡r
+->
+G\91Deã¼edLazyDeÝtimiz©iÚEnv\9cÚm\92t
+();
+
+2936
+ g§ãpo\9ats_
+.
+RecÜdLazyDeÝtimiz©iÚIndex
+(
+\92v
+->
+deÝtimiz©iÚ_\9adex
+());
+
+2939
+__
+
+StÜeToSaãpo\9atRegi¡\94SlÙ
+(
+r3
+,
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()));
+
+2943 \1e
+ gLCodeG\92
+::
+DoCmpT
+(
+LCmpT
+*
+\9a¡r
+) {
+
+2944
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+2945
+ gTok\92
+::
+V®ue
+
+Ý
+ =
+\9a¡r
+->op();
+
+2947
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+CodeFaùÜy
+::
+Com·»IC
+(
+isީe
+(),
+Ý
+).
+code
+();
+
+2948
+C®lCode
+(
+ic
+,
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+2950
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+2952
+CÚd\99iÚ
+
+ gcÚd\99iÚ
+ =
+Compu\8bCom·»CÚd\99iÚ
+(
+Ý
+);
+
+2953
+Lab\96
+
+ g\8cue_v®ue
+,
+ gdÚe
+;
+
+2955
+__
+
+b
+(
+cÚd\99iÚ
+, &
+\8cue_v®ue
+);
+
+2957
+__
+
+LßdRoÙ
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()),
+H\97p
+::
+kF®£V®ueRoÙIndex
+);
+
+2958
+__
+
+b
+(&
+dÚe
+);
+
+2960
+__
+
+b\9ad
+(&
+\8cue_v®ue
+);
+
+2961
+__
+
+LßdRoÙ
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()),
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+2963
+__
+
+b\9ad
+(&
+dÚe
+);
+
+2967 \1e
+ gLCodeG\92
+::
+DoR\91uº
+(
+LR\91uº
+*
+\9a¡r
+) {
+
+2968 ià(
+FLAG_\8caû
+ &&
+\9afo
+()->
+IsO±imiz\9ag
+()) {
+
+2973
+__
+
+push
+(
+r3
+);
+
+2974
+__
+
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+2975
+__
+
+C®lRuÁime
+(
+RuÁime
+::
+kT¿ûEx\99
+, 1);
+
+2977 ià(
+\9afo
+()->
+§ves_ÿÎ\94_doubËs
+()) {
+
+2978
+Re¡ÜeC®ËrDoubËs
+();
+
+2980 \12
+ gno_äame_¡¬t
+ = -1;
+
+2981 ià(
+ g\9a¡r
+->
+has_cÚ¡ªt_·¿m\91\94_couÁ
+()) {
+
+2982 \12
+ g·¿m\91\94_couÁ
+ =
+ToIÁeg\9432
+(
+\9a¡r
+->
+cÚ¡ªt_·¿m\91\94_couÁ
+());
+
+2983
+\9at32_t
+
+ g¥_d\96\8f
+ = (
+·¿m\91\94_couÁ
+ + 1è*
+kPo\9a\8brSize
+;
+
+2984 ià(
+N\93dsEag\94F¿me
+()) {
+
+2985
+ gno_äame_¡¬t
+ =
+masm_
+->
+L\97veF¿me
+(
+S\8fckF¿me
+::
+JAVA_SCRIPT
+,
+¥_d\96\8f
+);
+
+2986 } \vià(
+ g¥_d\96\8f
+ != 0) {
+
+2987
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+¥_d\96\8f
+));
+
+2990
+Regi¡\94
+
+ g»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+·¿m\91\94_couÁ
+());
+
+2992 ià(
+N\93dsEag\94F¿me
+()) {
+
+2993
+ gno_äame_¡¬t
+ =
+masm_
+->
+L\97veF¿me
+(
+S\8fckF¿me
+::
+JAVA_SCRIPT
+);
+
+2995
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r0
+,
+»g
+);
+
+2996
+__
+
+add
+(
+¥
+, sp,
+r0
+);
+
+2999
+__
+
+bÌ
+();
+
+3001 ià(
+ gno_äame_¡¬t
+ != -1) {
+
+3002
+\9afo_
+->
+AddNoF¿meRªge
+(
+no_äame_¡¬t
+,
+masm_
+->
+pc_off£t
+());
+
+3007 \1e
+ gLCodeG\92
+::
+DoLßdGlob®C\96l
+(
+LLßdGlob®C\96l
+*
+\9a¡r
+) {
+
+3008
+Regi¡\94
+
+»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->result());
+
+3009
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+HªdË
+<
+Objeù
+>(
+\9a¡r
+->
+hydrog\92
+()->
+ûÎ
+().
+hªdË
+())));
+
+3010
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+\9d
+,
+C\96l
+::
+kV®ueOff£t
+));
+
+3011 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+Requ\9cesHÞeCheck
+()) {
+
+3012
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+3013
+__
+
+cmp
+(
+»suÉ
+,
+\9d
+);
+
+3014
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "hole");
+
+3019
+ g\8bm¶©e
+ <
+þass
+
+ gT
+>
+
+3020 \1e
+ gLCodeG\92
+::
+Em\99VeùÜLßdICRegi¡\94s
+(
+T
+*
+\9a¡r
+) {
+
+3021
+DCHECK
+(
+FLAG_veùÜ_ics
+);
+
+3022
+Regi¡\94
+
+ gveùÜ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp_veùÜ
+());
+
+3023
+DCHECK
+(
+veùÜ
+.
+is
+(
+VeùÜLßdICDesü\9dtÜ
+::
+VeùÜRegi¡\94
+()));
+
+3024
+__
+
+Move
+(
+veùÜ
+,
+\9a¡r
+->
+hydrog\92
+()->
+ãedback_veùÜ
+());
+
+3026
+DCHECK
+(
+VeùÜLßdICDesü\9dtÜ
+::
+SlÙRegi¡\94
+().
+is
+(
+r3
+));
+
+3027
+__
+
+mov
+(
+VeùÜLßdICDesü\9dtÜ
+::
+SlÙRegi¡\94
+(),
+
+3028
+O³¿nd
+(
+Smi
+::
+FromIÁ
+(
+\9a¡r
+->
+hydrog\92
+()->
+¦Ù
+())));
+
+3032 \1e
+ gLCodeG\92
+::
+DoLßdGlob®G\92\94ic
+(
+LLßdGlob®G\92\94ic
+*
+\9a¡r
+) {
+
+3033
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+3034
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+glob®_objeù
+())
+
+3035 .
+is
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+()));
+
+3036
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()).
+is
+(
+r3
+));
+
+3038
+__
+
+mov
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+O³¿nd
+(
+\9a¡r
+->
+Çme
+()));
+
+3039 ià(
+ gFLAG_veùÜ_ics
+) {
+
+3040
+ gEm\99VeùÜLßdICRegi¡\94s
+<
+ gLLßdGlob®G\92\94ic
+>(
+ g\9a¡r
+);
+
+3042
+CÚ\8bxtu®Mode
+
+ gmode
+ =
+\9a¡r
+->
+fÜ_ty³of
+(è?
+NOT_CONTEXTUAL
+ :
+CONTEXTUAL
+;
+
+3043
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+CodeFaùÜy
+::
+LßdIC
+(
+isީe
+(),
+mode
+).
+code
+();
+
+3044
+C®lCode
+(
+ic
+,
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+3048 \1e
+ gLCodeG\92
+::
+DoStÜeGlob®C\96l
+(
+LStÜeGlob®C\96l
+*
+\9a¡r
+) {
+
+3049
+Regi¡\94
+
+v®ue
+ =
+ToRegi¡\94
+(
+\9a¡r
+->value());
+
+3050
+Regi¡\94
+
+ gûÎ
+ =
+sü©ch0
+();
+
+3053
+__
+
+mov
+(
+ûÎ
+,
+O³¿nd
+(
+\9a¡r
+->
+hydrog\92
+()->ûÎ().
+hªdË
+()));
+
+3059 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+Requ\9cesHÞeCheck
+()) {
+
+3061
+Regi¡\94
+
+ g·ylßd
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+3062
+__
+
+LßdP
+(
+·ylßd
+,
+F\9bldMemO³¿nd
+(
+ûÎ
+,
+C\96l
+::
+kV®ueOff£t
+));
+
+3063
+__
+
+Com·»RoÙ
+(
+·ylßd
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+3064
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "hole");
+
+3068
+__
+
+StÜeP
+(
+v®ue
+,
+F\9bldMemO³¿nd
+(
+ûÎ
+,
+C\96l
+::
+kV®ueOff£t
+),
+r0
+);
+
+3073 \1e
+ gLCodeG\92
+::
+DoLßdCÚ\8bxtSlÙ
+(
+LLßdCÚ\8bxtSlÙ
+*
+\9a¡r
+) {
+
+3074
+Regi¡\94
+
+cڋxt
+ =
+ToRegi¡\94
+(
+\9a¡r
+->context());
+
+3075
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3076
+__
+
+LßdP
+(
+»suÉ
+,
+CÚ\8bxtO³¿nd
+(
+cڋxt
+,
+\9a¡r
+->
+¦Ù_\9adex
+()));
+
+3077 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+Requ\9cesHÞeCheck
+()) {
+
+3078
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+3079
+__
+
+cmp
+(
+»suÉ
+,
+\9d
+);
+
+3080 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+DeÝtimizesOnHÞe
+()) {
+
+3081
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "hole");
+
+3083
+Lab\96
+
+ gsk\9d
+;
+
+3084
+__
+
+bÃ
+(&
+sk\9d
+);
+
+3085
+__
+
+mov
+(
+»suÉ
+,
+O³¿nd
+(
+çùÜy
+()->
+undef\9aed_v®ue
+()));
+
+3086
+__
+
+b\9ad
+(&
+sk\9d
+);
+
+3092 \1e
+ gLCodeG\92
+::
+DoStÜeCÚ\8bxtSlÙ
+(
+LStÜeCÚ\8bxtSlÙ
+*
+\9a¡r
+) {
+
+3093
+Regi¡\94
+
+cڋxt
+ =
+ToRegi¡\94
+(
+\9a¡r
+->context());
+
+3094
+Regi¡\94
+
+ gv®ue
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+3095
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+3096
+MemO³¿nd
+
+ g\8frg\91
+ =
+CÚ\8bxtO³¿nd
+(
+cڋxt
+,
+\9a¡r
+->
+¦Ù_\9adex
+());
+
+3098
+Lab\96
+
+ gsk\9d_assignm\92t
+;
+
+3100 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+Requ\9cesHÞeCheck
+()) {
+
+3101
+__
+
+LßdP
+(
+sü©ch
+,
+\8frg\91
+);
+
+3102
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+3103
+__
+
+cmp
+(
+sü©ch
+,
+\9d
+);
+
+3104 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+DeÝtimizesOnHÞe
+()) {
+
+3105
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "hole");
+
+3107
+__
+
+bÃ
+(&
+sk\9d_assignm\92t
+);
+
+3111
+__
+
+StÜeP
+(
+v®ue
+,
+\8frg\91
+,
+r0
+);
+
+3112 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+N\93dsWr\99eB¬r\9br
+()) {
+
+3113
+SmiCheck
+
+ gcheck_Ãeded
+ =
+\9a¡r
+->
+hydrog\92
+()->
+v®ue
+()->
+ty³
+().
+IsH\97pObjeù
+()
+
+3114 ?
+OMIT_SMI_CHECK
+
+
+3115 :
+INLINE_SMI_CHECK
+;
+
+3116
+__
+
+RecÜdWr\99eCÚ\8bxtSlÙ
+(
+cڋxt
+,
+\8frg\91
+.
+off£t
+(),
+v®ue
+,
+sü©ch
+,
+
+3117
+G\91L\9akRegi¡\94S\8f\8b
+(),
+kSaveFPRegs
+,
+
+3118
+EMIT_REMEMBERED_SET
+,
+check_Ãeded
+);
+
+3121
+__
+
+b\9ad
+(&
+sk\9d_assignm\92t
+);
+
+3125 \1e
+ gLCodeG\92
+::
+DoLßdNamedF\9bld
+(
+LLßdNamedF\9bld
+*
+\9a¡r
+) {
+
+3126
+HObjeùAcûss
+
+acûss
+ =
+\9a¡r
+->
+hydrog\92
+()->access();
+
+3127 \12
+ goff£t
+ =
+acûss
+.
+off£t
+();
+
+3128
+Regi¡\94
+
+ gobjeù
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+objeù
+());
+
+3130 ià(
+ gacûss
+.
+IsEx\8bº®MemÜy
+()) {
+
+3131
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3132
+MemO³¿nd
+
+ gÝ\94ªd
+ = MemO³¿nd(
+objeù
+,
+off£t
+);
+
+3133
+__
+
+LßdR\95»£Á©iÚ
+(
+»suÉ
+,
+Ý\94ªd
+,
+acûss
+.
+»´e£Á©iÚ
+(),
+r0
+);
+
+3137 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+()) {
+
+3138
+DoubËRegi¡\94
+
+ g»suÉ
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3139
+__
+
+lfd
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+off£t
+));
+
+3143
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3144 ià(!
+ gacûss
+.
+IsInobjeù
+()) {
+
+3145
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+JSObjeù
+::
+kPrÝ\94t\9bsOff£t
+));
+
+3146
+ gobjeù
+ =
+»suÉ
+;
+
+3149
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚ
+ =
+acûss
+.
+»´e£Á©iÚ
+();
+
+3151 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3153 ià(
+ g»´e£Á©iÚ
+.
+IsSmi
+() &&
+
+3154
+ g\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsIÁeg\9432
+()) {
+
+3156
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+3157
+STATIC_ASSERT
+(
+kSmiTagSize
+ +
+kSmiShiáSize
+ == 32);
+
+3158 #ià
+V8_TARGET_LITTLE_ENDIAN
+
+
+3159
+ goff£t
+ +ð
+kPo\9a\8brSize
+ / 2;
+
+3161
+ g»´e£Á©iÚ
+ =
+R\95»£Á©iÚ
+::
+IÁeg\9432
+();
+
+3165
+__
+
+LßdR\95»£Á©iÚ
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+off£t
+),
+»´e£Á©iÚ
+,
+
+3166
+r0
+);
+
+3170 \1e
+ gLCodeG\92
+::
+DoLßdNamedG\92\94ic
+(
+LLßdNamedG\92\94ic
+*
+\9a¡r
+) {
+
+3171
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+3172
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+objeù
+()).
+is
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+()));
+
+3173
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()).
+is
+(
+r3
+));
+
+3176
+__
+
+mov
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+O³¿nd
+(
+\9a¡r
+->
+Çme
+()));
+
+3177 ià(
+ gFLAG_veùÜ_ics
+) {
+
+3178
+ gEm\99VeùÜLßdICRegi¡\94s
+<
+ gLLßdNamedG\92\94ic
+>(
+ g\9a¡r
+);
+
+3180
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+CodeFaùÜy
+::
+LßdIC
+(
+isީe
+(),
+NOT_CONTEXTUAL
+).
+code
+();
+
+3181
+C®lCode
+(
+ic
+,
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+3185 \1e
+ gLCodeG\92
+::
+DoLßdFunùiÚPrÙÙy³
+(
+LLßdFunùiÚPrÙÙy³
+*
+\9a¡r
+) {
+
+3186
+Regi¡\94
+
+sü©ch
+ =
+sü©ch0
+();
+
+3187
+Regi¡\94
+
+ gfunùiÚ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+funùiÚ
+());
+
+3188
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3191
+__
+
+LßdP
+(
+»suÉ
+,
+
+3192
+F\9bldMemO³¿nd
+(
+funùiÚ
+,
+JSFunùiÚ
+::
+kPrÙÙy³OrIn\99\9flMOff£t
+));
+
+3195
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+3196
+__
+
+cmp
+(
+»suÉ
+,
+\9d
+);
+
+3197
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "hole");
+
+3200
+Lab\96
+
+ gdÚe
+;
+
+3201
+__
+
+Com·»ObjeùTy³
+(
+»suÉ
+,
+sü©ch
+, sü©ch,
+MAP_TYPE
+);
+
+3202
+__
+
+bÃ
+(&
+dÚe
+);
+
+3205
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+ÔesuÉ,
+M
+::
+kPrÙÙy³Off£t
+));
+
+3208
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3212 \1e
+ gLCodeG\92
+::
+DoLßdRoÙ
+(
+LLßdRoÙ
+*
+\9a¡r
+) {
+
+3213
+Regi¡\94
+
+»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->result());
+
+3214
+__
+
+LßdRoÙ
+(
+»suÉ
+,
+\9a¡r
+->
+\9adex
+());
+
+3218 \1e
+ gLCodeG\92
+::
+DoAcûssArgum\92tsAt
+(
+LAcûssArgum\92tsAt
+*
+\9a¡r
+) {
+
+3219
+Regi¡\94
+
+¬gum\92ts
+ =
+ToRegi¡\94
+(
+\9a¡r
+->arguments());
+
+3220
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3223 ià(
+ g\9a¡r
+->
+Ëngth
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+3224 \12
+ gcÚ¡_Ëngth
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+Ëngth
+()));
+
+3225 ià(
+ g\9a¡r
+->
+\9adex
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+3226 \12
+ gcÚ¡_\9adex
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+\9adex
+()));
+
+3227 \12
+ g\9adex
+ = (
+cÚ¡_Ëngth
+ -
+cÚ¡_\9adex
+) + 1;
+
+3228
+__
+
+LßdP
+(
+»suÉ
+,
+MemO³¿nd
+(
+¬gum\92ts
+,
+\9adex
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+3230
+Regi¡\94
+
+ g\9adex
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\9adex
+());
+
+3231
+__
+
+subfic
+(
+»suÉ
+,
+\9adex
+,
+O³¿nd
+(
+cÚ¡_Ëngth
+ + 1));
+
+3232
+__
+
+ShiáLeáImm
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+3233
+__
+
+LßdPX
+(
+»suÉ
+,
+MemO³¿nd
+(
+¬gum\92ts
+,\84esult));
+
+3235 } \vià(
+ g\9a¡r
+->
+\9adex
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+3236
+Regi¡\94
+
+ gËngth
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëngth
+());
+
+3237 \12
+ gcÚ¡_\9adex
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+\9adex
+()));
+
+3238 \12
+ gloc
+ =
+cÚ¡_\9adex
+ - 1;
+
+3239 ià(
+ gloc
+ != 0) {
+
+3240
+__
+
+subi
+(
+»suÉ
+,
+Ëngth
+,
+O³¿nd
+(
+loc
+));
+
+3241
+__
+
+ShiáLeáImm
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+3242
+__
+
+LßdPX
+(
+»suÉ
+,
+MemO³¿nd
+(
+¬gum\92ts
+,\84esult));
+
+3244
+__
+
+ShiáLeáImm
+(
+»suÉ
+,
+Ëngth
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+3245
+__
+
+LßdPX
+(
+»suÉ
+,
+MemO³¿nd
+(
+¬gum\92ts
+,\84esult));
+
+3248
+Regi¡\94
+
+ gËngth
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëngth
+());
+
+3249
+Regi¡\94
+
+ g\9adex
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\9adex
+());
+
+3250
+__
+
+sub
+(
+»suÉ
+,
+Ëngth
+,
+\9adex
+);
+
+3251
+__
+
+addi
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(1));
+
+3252
+__
+
+ShiáLeáImm
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+3253
+__
+
+LßdPX
+(
+»suÉ
+,
+MemO³¿nd
+(
+¬gum\92ts
+,\84esult));
+
+3258 \1e
+ gLCodeG\92
+::
+DoLßdKeyedEx\8bº®A¼ay
+(
+LLßdKeyed
+*
+\9a¡r
+) {
+
+3259
+Regi¡\94
+
+ex\8bº®_po\9a\8br
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+3260
+Regi¡\94
+
+ gkey
+ =
+no_»g
+;
+
+3261
+EËm\92tsK\9ad
+
+ g\96em\92ts_k\9ad
+ =
+\9a¡r
+->
+\96em\92ts_k\9ad
+();
+
+3262
+boÞ
+
+ gkey_is_cÚ¡ªt
+ =
+\9a¡r
+->
+key
+()->
+IsCÚ¡ªtO³¿nd
+();
+
+3263 \12
+ gcÚ¡ªt_key
+ = 0;
+
+3264 ià(
+ gkey_is_cÚ¡ªt
+) {
+
+3265
+ gcÚ¡ªt_key
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+key
+()));
+
+3266 ià(
+ gcÚ¡ªt_key
+ & 0xF0000000) {
+
+3267
+AbÜt
+(
+kA¼ayIndexCÚ¡ªtV®ueTooBig
+);
+
+3270
+ gkey
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+key
+());
+
+3272 \12
+ g\96em\92t_size_shiá
+ =
+EËm\92tsK\9adToShiáSize
+(
+\96em\92ts_k\9ad
+);
+
+3273
+boÞ
+
+ gkey_is_smi
+ =
+\9a¡r
+->
+hydrog\92
+()->
+key
+()->
+»´e£Á©iÚ
+().
+IsSmi
+();
+
+3274 \12
+ gba£_off£t
+ =
+\9a¡r
+->
+ba£_off£t
+();
+
+3276 ià(
+ g\96em\92ts_k\9ad
+ =ð
+EXTERNAL_FLOAT32_ELEMENTS
+ ||
+
+3277
+\96em\92ts_k\9ad
+ =ð
+FLOAT32_ELEMENTS
+ ||
+
+3278
+\96em\92ts_k\9ad
+ =ð
+EXTERNAL_FLOAT64_ELEMENTS
+ ||
+
+3279
+\96em\92ts_k\9ad
+ =ð
+FLOAT64_ELEMENTS
+) {
+
+3280
+DoubËRegi¡\94
+
+»suÉ
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->result());
+
+3281 ià(
+ gkey_is_cÚ¡ªt
+) {
+
+3282
+__
+
+Add
+(
+sü©ch0
+(),
+ex\8bº®_po\9a\8br
+,
+cÚ¡ªt_key
+ <<
+\96em\92t_size_shiá
+,
+
+3283
+r0
+);
+
+3285
+__
+
+IndexToA¼ayOff£t
+(
+r0
+,
+key
+,
+\96em\92t_size_shiá
+,
+key_is_smi
+);
+
+3286
+__
+
+add
+(
+sü©ch0
+(),
+ex\8bº®_po\9a\8br
+,
+r0
+);
+
+3288 ià(
+ g\96em\92ts_k\9ad
+ =ð
+EXTERNAL_FLOAT32_ELEMENTS
+ ||
+
+3289
+\96em\92ts_k\9ad
+ =ð
+FLOAT32_ELEMENTS
+) {
+
+3290
+__
+
+lfs
+(
+»suÉ
+,
+MemO³¿nd
+(
+sü©ch0
+(),
+ba£_off£t
+));
+
+3292
+__
+
+lfd
+(
+»suÉ
+,
+MemO³¿nd
+(
+sü©ch0
+(),
+ba£_off£t
+));
+
+3295
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3296
+MemO³¿nd
+
+ gmem_Ý\94ªd
+ =
+
+3297
+P»·»KeyedO³¿nd
+(
+key
+,
+ex\8bº®_po\9a\8br
+,
+key_is_cÚ¡ªt
+,
+key_is_smi
+,
+
+3298
+cÚ¡ªt_key
+,
+\96em\92t_size_shiá
+,
+ba£_off£t
+);
+
+3299 \1a
+ g\96em\92ts_k\9ad
+) {
+
+3300 \ 4
+ gEXTERNAL_INT8_ELEMENTS
+:
+
+3301 \ 4
+INT8_ELEMENTS
+:
+
+3302 ià(
+key_is_cÚ¡ªt
+) {
+
+3303
+__
+
+LßdBy\8b
+(
+»suÉ
+,
+mem_Ý\94ªd
+,
+r0
+);
+
+3305
+__
+
+lbzx
+(
+»suÉ
+,
+mem_Ý\94ªd
+);
+
+3307
+__
+
+extsb
+(
+»suÉ
+,\84esult);
+
+3309 \ 4
+ gEXTERNAL_UINT8_CLAMPED_ELEMENTS
+:
+
+3310 \ 4
+EXTERNAL_UINT8_ELEMENTS
+:
+
+3311 \ 4
+UINT8_ELEMENTS
+:
+
+3312 \ 4
+UINT8_CLAMPED_ELEMENTS
+:
+
+3313 ià(
+key_is_cÚ¡ªt
+) {
+
+3314
+__
+
+LßdBy\8b
+(
+»suÉ
+,
+mem_Ý\94ªd
+,
+r0
+);
+
+3316
+__
+
+lbzx
+(
+»suÉ
+,
+mem_Ý\94ªd
+);
+
+3319 \ 4
+ gEXTERNAL_INT16_ELEMENTS
+:
+
+3320 \ 4
+INT16_ELEMENTS
+:
+
+3321 ià(
+key_is_cÚ¡ªt
+) {
+
+3322
+__
+
+LßdH®fWÜd
+(
+»suÉ
+,
+mem_Ý\94ªd
+,
+r0
+);
+
+3324
+__
+
+lhzx
+(
+»suÉ
+,
+mem_Ý\94ªd
+);
+
+3326
+__
+
+extsh
+(
+»suÉ
+,\84esult);
+
+3328 \ 4
+ gEXTERNAL_UINT16_ELEMENTS
+:
+
+3329 \ 4
+UINT16_ELEMENTS
+:
+
+3330 ià(
+key_is_cÚ¡ªt
+) {
+
+3331
+__
+
+LßdH®fWÜd
+(
+»suÉ
+,
+mem_Ý\94ªd
+,
+r0
+);
+
+3333
+__
+
+lhzx
+(
+»suÉ
+,
+mem_Ý\94ªd
+);
+
+3336 \ 4
+ gEXTERNAL_INT32_ELEMENTS
+:
+
+3337 \ 4
+INT32_ELEMENTS
+:
+
+3338 ià(
+key_is_cÚ¡ªt
+) {
+
+3339
+__
+
+LßdWÜd
+(
+»suÉ
+,
+mem_Ý\94ªd
+,
+r0
+);
+
+3341
+__
+
+lwzx
+(
+»suÉ
+,
+mem_Ý\94ªd
+);
+
+3343 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3344
+__
+
+extsw
+(
+»suÉ
+,\84esult);
+
+3347 \ 4
+ gEXTERNAL_UINT32_ELEMENTS
+:
+
+3348 \ 4
+UINT32_ELEMENTS
+:
+
+3349 ià(
+key_is_cÚ¡ªt
+) {
+
+3350
+__
+
+LßdWÜd
+(
+»suÉ
+,
+mem_Ý\94ªd
+,
+r0
+);
+
+3352
+__
+
+lwzx
+(
+»suÉ
+,
+mem_Ý\94ªd
+);
+
+3354 ià(!
+ g\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HIn¡ruùiÚ
+::
+kU\9at32
+)) {
+
+3355
+__
+
+lis
+(
+r0
+,
+O³¿nd
+(
+SIGN_EXT_IMM16
+(0x8000)));
+
+3356
+__
+
+cm¶w
+(
+»suÉ
+,
+r0
+);
+
+3357
+DeÝtimizeIf
+(
+ge
+,
+\9a¡r
+, "negative value");
+
+3360 \ 4
+ gFLOAT32_ELEMENTS
+:
+
+3361 \ 4
+FLOAT64_ELEMENTS
+:
+
+3362 \ 4
+EXTERNAL_FLOAT32_ELEMENTS
+:
+
+3363 \ 4
+EXTERNAL_FLOAT64_ELEMENTS
+:
+
+3364 \ 4
+FAST_HOLEY_DOUBLE_ELEMENTS
+:
+
+3365 \ 4
+FAST_HOLEY_ELEMENTS
+:
+
+3366 \ 4
+FAST_HOLEY_SMI_ELEMENTS
+:
+
+3367 \ 4
+FAST_DOUBLE_ELEMENTS
+:
+
+3368 \ 4
+FAST_ELEMENTS
+:
+
+3369 \ 4
+FAST_SMI_ELEMENTS
+:
+
+3370 \ 4
+DICTIONARY_ELEMENTS
+:
+
+3371 \ 4
+SLOPPY_ARGUMENTS_ELEMENTS
+:
+
+3372
+UNREACHABLE
+();
+
+3379 \1e
+ gLCodeG\92
+::
+DoLßdKeyedFixedDoubËA¼ay
+(
+LLßdKeyed
+*
+\9a¡r
+) {
+
+3380
+Regi¡\94
+
+\96em\92ts
+ =
+ToRegi¡\94
+(
+\9a¡r
+->elements());
+
+3381
+boÞ
+
+ gkey_is_cÚ¡ªt
+ =
+\9a¡r
+->
+key
+()->
+IsCÚ¡ªtO³¿nd
+();
+
+3382
+Regi¡\94
+
+ gkey
+ =
+no_»g
+;
+
+3383
+DoubËRegi¡\94
+
+ g»suÉ
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3384
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+3386 \12
+ g\96em\92t_size_shiá
+ =
+EËm\92tsK\9adToShiáSize
+(
+FAST_DOUBLE_ELEMENTS
+);
+
+3387
+boÞ
+
+ gkey_is_smi
+ =
+\9a¡r
+->
+hydrog\92
+()->
+key
+()->
+»´e£Á©iÚ
+().
+IsSmi
+();
+
+3388 \12
+ gcÚ¡ªt_key
+ = 0;
+
+3389 ià(
+ gkey_is_cÚ¡ªt
+) {
+
+3390
+ gcÚ¡ªt_key
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+key
+()));
+
+3391 ià(
+ gcÚ¡ªt_key
+ & 0xF0000000) {
+
+3392
+AbÜt
+(
+kA¼ayIndexCÚ¡ªtV®ueTooBig
+);
+
+3395
+ gkey
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+key
+());
+
+3398 \12
+ gba£_off£t
+ =
+\9a¡r
+->
+ba£_off£t
+(è+
+cÚ¡ªt_key
+ *
+kDoubËSize
+;
+
+3399 ià(!
+ gkey_is_cÚ¡ªt
+) {
+
+3400
+__
+
+IndexToA¼ayOff£t
+(
+r0
+,
+key
+,
+\96em\92t_size_shiá
+,
+key_is_smi
+);
+
+3401
+__
+
+add
+(
+sü©ch
+,
+\96em\92ts
+,
+r0
+);
+
+3402
+ g\96em\92ts
+ =
+sü©ch
+;
+
+3404 ià(!
+is_\9at16
+(
+ba£_off£t
+)) {
+
+3405
+__
+
+Add
+(
+sü©ch
+,
+\96em\92ts
+,
+ba£_off£t
+,
+r0
+);
+
+3406
+ gba£_off£t
+ = 0;
+
+3407
+ g\96em\92ts
+ =
+sü©ch
+;
+
+3409
+__
+
+lfd
+(
+»suÉ
+,
+MemO³¿nd
+(
+\96em\92ts
+,
+ba£_off£t
+));
+
+3411 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+Requ\9cesHÞeCheck
+()) {
+
+3412 ià(
+is_\9at16
+(
+ba£_off£t
+ +
+Regi¡\94
+::
+kExpÚ\92tOff£t
+)) {
+
+3413
+__
+
+lwz
+(
+sü©ch
+,
+
+3414
+MemO³¿nd
+(
+\96em\92ts
+,
+ba£_off£t
+ +
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+3416
+__
+
+addi
+(
+sü©ch
+,
+\96em\92ts
+,
+O³¿nd
+(
+ba£_off£t
+));
+
+3417
+__
+
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(sü©ch,
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+3419
+__
+
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+kHÞeNªUµ\9432
+),
+r0
+);
+
+3420
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "hole");
+
+3425 \1e
+ gLCodeG\92
+::
+DoLßdKeyedFixedA¼ay
+(
+LLßdKeyed
+*
+\9a¡r
+) {
+
+3426
+HLßdKeyed
+*
+h\9a¡r
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+3427
+Regi¡\94
+
+ g\96em\92ts
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+3428
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3429
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+3430
+Regi¡\94
+
+ g¡Üe_ba£
+ =
+sü©ch
+;
+
+3431 \12
+ goff£t
+ =
+\9a¡r
+->
+ba£_off£t
+();
+
+3433 ià(
+ g\9a¡r
+->
+key
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+3434
+LCÚ¡ªtO³¿nd
+*
+ gcÚ¡_Ý\94ªd
+ = LCÚ¡ªtO³¿nd::
+ÿ¡
+(
+\9a¡r
+->
+key
+());
+
+3435
+ goff£t
+ +ð
+ToIÁeg\9432
+(
+cÚ¡_Ý\94ªd
+è*
+kPo\9a\8brSize
+;
+
+3436
+ g¡Üe_ba£
+ =
+\96em\92ts
+;
+
+3438
+Regi¡\94
+
+ gkey
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+key
+());
+
+3443 ià(
+ gh\9a¡r
+->
+key
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+3444
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r0
+,
+key
+);
+
+3446
+__
+
+ShiáLeáImm
+(
+r0
+,
+key
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+3448
+__
+
+add
+(
+sü©ch
+,
+\96em\92ts
+,
+r0
+);
+
+3451
+boÞ
+
+ g»qu\9ces_hÞe_check
+ =
+h\9a¡r
+->
+Requ\9cesHÞeCheck
+();
+
+3452
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚ
+ =
+h\9a¡r
+->
+»´e£Á©iÚ
+();
+
+3454 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3456 ià(
+ g»´e£Á©iÚ
+.
+IsIÁeg\9432
+() &&
+
+3457
+ gh\9a¡r
+->
+\96em\92ts_k\9ad
+(è=ð
+FAST_SMI_ELEMENTS
+) {
+
+3458
+DCHECK
+(!
+»qu\9ces_hÞe_check
+);
+
+3460
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+3461
+STATIC_ASSERT
+(
+kSmiTagSize
+ +
+kSmiShiáSize
+ == 32);
+
+3462 #ià
+V8_TARGET_LITTLE_ENDIAN
+
+
+3463
+ goff£t
+ +ð
+kPo\9a\8brSize
+ / 2;
+
+3468
+__
+
+LßdR\95»£Á©iÚ
+(
+»suÉ
+,
+MemO³¿nd
+(
+¡Üe_ba£
+,
+off£t
+),
+»´e£Á©iÚ
+,
+
+3469
+r0
+);
+
+3472 ià(
+ g»qu\9ces_hÞe_check
+) {
+
+3473 ià(
+IsFa¡SmiEËm\92tsK\9ad
+(
+h\9a¡r
+->
+\96em\92ts_k\9ad
+())) {
+
+3474
+__
+
+Te¡IfSmi
+(
+»suÉ
+,
+r0
+);
+
+3475
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "nه Smi",
+ü0
+);
+
+3477
+__
+
+LßdRoÙ
+(
+sü©ch
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+3478
+__
+
+cmp
+(
+»suÉ
+,
+sü©ch
+);
+
+3479
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "hole");
+
+3485 \1e
+ gLCodeG\92
+::
+DoLßdKeyed
+(
+LLßdKeyed
+*
+\9a¡r
+) {
+
+3486 ià(
+\9a¡r
+->
+is_ty³d_\96em\92ts
+()) {
+
+3487
+DoLßdKeyedEx\8bº®A¼ay
+(
+\9a¡r
+);
+
+3488 } \vià(
+ g\9a¡r
+->
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+()) {
+
+3489
+DoLßdKeyedFixedDoubËA¼ay
+(
+\9a¡r
+);
+
+3491
+DoLßdKeyedFixedA¼ay
+(
+\9a¡r
+);
+
+3496
+MemO³¿nd
+
+ gLCodeG\92
+::
+P»·»KeyedO³¿nd
+(
+Regi¡\94
+
+key
+, Regi¡\94
+ba£
+,
+
+3497
+boÞ
+
+key_is_cÚ¡ªt
+, boÞ
+key_is_smi
+,
+
+3498 \12
+cÚ¡ªt_key
+,
+
+3499 \12
+\96em\92t_size_shiá
+,
+
+3500 \12
+ba£_off£t
+) {
+
+3501
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+3503 ià(
+ gkey_is_cÚ¡ªt
+) {
+
+3504 \15
+MemO³¿nd
+(
+ba£
+, (
+cÚ¡ªt_key
+ <<
+\96em\92t_size_shiá
+è+
+ba£_off£t
+);
+
+3507
+boÞ
+
+ gÃeds_shiá
+ =
+
+3508 (
+\96em\92t_size_shiá
+ !ð(
+key_is_smi
+ ?
+kSmiTagSize
+ +
+kSmiShiáSize
+ : 0));
+
+3510 ià(!(
+ gba£_off£t
+ ||
+ gÃeds_shiá
+)) {
+
+3511 \15
+MemO³¿nd
+(
+ba£
+,
+key
+);
+
+3514 ià(
+ gÃeds_shiá
+) {
+
+3515
+__
+
+IndexToA¼ayOff£t
+(
+sü©ch
+,
+key
+,
+\96em\92t_size_shiá
+,
+key_is_smi
+);
+
+3516
+ gkey
+ =
+sü©ch
+;
+
+3519 ià(
+ gba£_off£t
+) {
+
+3520
+__
+
+Add
+(
+sü©ch
+,
+key
+,
+ba£_off£t
+,
+r0
+);
+
+3523 \15
+MemO³¿nd
+(
+ba£
+,
+sü©ch
+);
+
+3527 \1e
+ gLCodeG\92
+::
+DoLßdKeyedG\92\94ic
+(
+LLßdKeyedG\92\94ic
+*
+\9a¡r
+) {
+
+3528
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+3529
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+objeù
+()).
+is
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+()));
+
+3530
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+key
+()).
+is
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+()));
+
+3532 ià(
+ gFLAG_veùÜ_ics
+) {
+
+3533
+ gEm\99VeùÜLßdICRegi¡\94s
+<
+ gLLßdKeyedG\92\94ic
+>(
+ g\9a¡r
+);
+
+3536
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+CodeFaùÜy
+::
+KeyedLßdIC
+(
+isީe
+()).
+code
+();
+
+3537
+C®lCode
+(
+ic
+,
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+3541 \1e
+ gLCodeG\92
+::
+DoArgum\92tsEËm\92ts
+(
+LArgum\92tsEËm\92ts
+*
+\9a¡r
+) {
+
+3542
+Regi¡\94
+
+sü©ch
+ =
+sü©ch0
+();
+
+3543
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3545 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+äom_\9al\9aed
+()) {
+
+3546
+__
+
+subi
+(
+»suÉ
+,
+¥
+,
+O³¿nd
+(2 *
+kPo\9a\8brSize
+));
+
+3549
+Lab\96
+
+ gdÚe
+,
+ gad\8bd
+;
+
+3550
+__
+
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+3551
+__
+
+LßdP
+(
+»suÉ
+,
+
+3552
+MemO³¿nd
+(
+sü©ch
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+3553
+__
+
+CmpSmiL\99\94®
+(
+»suÉ
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+),
+r0
+);
+
+3557
+__
+
+beq
+(&
+ad\8bd
+);
+
+3558
+__
+
+mr
+(
+»suÉ
+,
+å
+);
+
+3559
+__
+
+b
+(&
+dÚe
+);
+
+3561
+__
+
+b\9ad
+(&
+ad\8bd
+);
+
+3562
+__
+
+mr
+(
+»suÉ
+,
+sü©ch
+);
+
+3563
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3568 \1e
+ gLCodeG\92
+::
+DoArgum\92tsL\92gth
+(
+LArgum\92tsL\92gth
+*
+\9a¡r
+) {
+
+3569
+Regi¡\94
+
+\96em
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+3570
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3572
+Lab\96
+
+ gdÚe
+;
+
+3575
+__
+
+cmp
+(
+å
+,
+\96em
+);
+
+3576
+__
+
+mov
+(
+»suÉ
+,
+O³¿nd
+(
+scÝe
+()->
+num_·¿m\91\94s
+()));
+
+3577
+__
+
+beq
+(&
+dÚe
+);
+
+3580
+__
+
+LßdP
+(
+»suÉ
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+3581
+__
+
+LßdP
+(
+»suÉ
+,
+
+3582
+MemO³¿nd
+(
+»suÉ
+,
+Argum\92tsAdtÜF¿meCÚ¡ªts
+::
+kL\92gthOff£t
+));
+
+3583
+__
+
+SmiUÁag
+(
+»suÉ
+);
+
+3586
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3590 \1e
+ gLCodeG\92
+::
+DoW¿pReûiv\94
+(
+LW¿pReûiv\94
+*
+\9a¡r
+) {
+
+3591
+Regi¡\94
+
+»ûiv\94
+ =
+ToRegi¡\94
+(
+\9a¡r
+->receiver());
+
+3592
+Regi¡\94
+
+ gfunùiÚ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+funùiÚ
+());
+
+3593
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3594
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+3599
+Lab\96
+
+ gglob®_objeù
+,
+ g»suÉ_\9a_»ûiv\94
+;
+
+3601 ià(!
+ g\9a¡r
+->
+hydrog\92
+()->
+known_funùiÚ
+()) {
+
+3604
+__
+
+LßdP
+(
+sü©ch
+,
+
+3605
+F\9bldMemO³¿nd
+(
+funùiÚ
+,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+3606
+__
+
+lwz
+(
+sü©ch
+,
+
+3607
+F\9bldMemO³¿nd
+(
+sü©ch
+,
+Sh¬edFunùiÚInfo
+::
+kComp\9e\94H\9atsOff£t
+));
+
+3608
+__
+
+Te¡B\99
+(
+sü©ch
+,
+
+3609 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3610
+Sh¬edFunùiÚInfo
+::
+kS\8ciùModeFunùiÚ
+,
+
+3612
+Sh¬edFunùiÚInfo
+::
+kS\8ciùModeFunùiÚ
+ +
+kSmiTagSize
+,
+
+3614
+r0
+);
+
+3615
+__
+
+bÃ
+(&
+»suÉ_\9a_»ûiv\94
+,
+ü0
+);
+
+3618
+__
+
+Te¡B\99
+(
+sü©ch
+,
+
+3619 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3620
+Sh¬edFunùiÚInfo
+::
+kN©ive
+,
+
+3622
+Sh¬edFunùiÚInfo
+::
+kN©ive
+ +
+kSmiTagSize
+,
+
+3624
+r0
+);
+
+3625
+__
+
+bÃ
+(&
+»suÉ_\9a_»ûiv\94
+,
+ü0
+);
+
+3629
+__
+
+LßdRoÙ
+(
+sü©ch
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+3630
+__
+
+cmp
+(
+»ûiv\94
+,
+sü©ch
+);
+
+3631
+__
+
+beq
+(&
+glob®_objeù
+);
+
+3632
+__
+
+LßdRoÙ
+(
+sü©ch
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+3633
+__
+
+cmp
+(
+»ûiv\94
+,
+sü©ch
+);
+
+3634
+__
+
+beq
+(&
+glob®_objeù
+);
+
+3637
+__
+
+Te¡IfSmi
+(
+»ûiv\94
+,
+r0
+);
+
+3638
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "Smi");
+
+3639
+__
+
+Com·»ObjeùTy³
+(
+»ûiv\94
+,
+sü©ch
+, sü©ch,
+FIRST_SPEC_OBJECT_TYPE
+);
+
+3640
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "not\87 JavaScript object");
+
+3642
+__
+
+b
+(&
+»suÉ_\9a_»ûiv\94
+);
+
+3643
+__
+
+b\9ad
+(&
+glob®_objeù
+);
+
+3644
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+funùiÚ
+,
+JSFunùiÚ
+::
+kCÚ\8bxtOff£t
+));
+
+3645
+__
+
+LßdP
+(
+»suÉ
+,
+CÚ\8bxtO³¿nd
+ÔesuÉ,
+Cڋxt
+::
+GLOBAL_OBJECT_INDEX
+));
+
+3646
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+ÔesuÉ,
+Glob®Objeù
+::
+kGlob®ProxyOff£t
+));
+
+3647 ià(
+ g»suÉ
+.
+is
+(
+»ûiv\94
+)) {
+
+3648
+__
+
+b\9ad
+(&
+»suÉ_\9a_»ûiv\94
+);
+
+3650
+Lab\96
+
+ g»suÉ_ok
+;
+
+3651
+__
+
+b
+(&
+»suÉ_ok
+);
+
+3652
+__
+
+b\9ad
+(&
+»suÉ_\9a_»ûiv\94
+);
+
+3653
+__
+
+mr
+(
+»suÉ
+,
+»ûiv\94
+);
+
+3654
+__
+
+b\9ad
+(&
+»suÉ_ok
+);
+
+3659 \1e
+ gLCodeG\92
+::
+DoAµlyArgum\92ts
+(
+LAµlyArgum\92ts
+*
+\9a¡r
+) {
+
+3660
+Regi¡\94
+
+»ûiv\94
+ =
+ToRegi¡\94
+(
+\9a¡r
+->receiver());
+
+3661
+Regi¡\94
+
+ gfunùiÚ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+funùiÚ
+());
+
+3662
+Regi¡\94
+
+ gËngth
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëngth
+());
+
+3663
+Regi¡\94
+
+ g\96em\92ts
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+3664
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+3665
+DCHECK
+(
+»ûiv\94
+.
+is
+(
+r3
+));
+
+3666
+DCHECK
+(
+funùiÚ
+.
+is
+(
+r4
+));
+
+3667
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()).
+is
+(
+r3
+));
+
+3671 cڡ
+u\9at32_t
+
+ gkArgum\92tsLim\99
+ = 1 *
+KB
+;
+
+3672
+__
+
+cm¶i
+(
+Ëngth
+,
+O³¿nd
+(
+kArgum\92tsLim\99
+));
+
+3673
+DeÝtimizeIf
+(
+gt
+,
+\9a¡r
+, "too many\87rguments");
+
+3677
+__
+
+push
+(
+»ûiv\94
+);
+
+3678
+__
+
+mr
+(
+»ûiv\94
+,
+Ëngth
+);
+
+3680
+__
+
+addi
+(
+\96em\92ts
+,\83Ëm\92ts,
+O³¿nd
+(1 *
+kPo\9a\8brSize
+));
+
+3684
+Lab\96
+
+ g\9avoke
+,
+ gloÝ
+;
+
+3686
+__
+
+cmpi
+(
+Ëngth
+,
+O³¿nd
+::
+Z\94o
+());
+
+3687
+__
+
+beq
+(&
+\9avoke
+);
+
+3688
+__
+
+mtùr
+(
+Ëngth
+);
+
+3689
+__
+
+b\9ad
+(&
+loÝ
+);
+
+3690
+__
+
+ShiáLeáImm
+(
+r0
+,
+Ëngth
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+3691
+__
+
+LßdPX
+(
+sü©ch
+,
+MemO³¿nd
+(
+\96em\92ts
+,
+r0
+));
+
+3692
+__
+
+push
+(
+sü©ch
+);
+
+3693
+__
+
+addi
+(
+Ëngth
+,\86\92gth,
+O³¿nd
+(-1));
+
+3694
+__
+
+bdnz
+(&
+loÝ
+);
+
+3696
+__
+
+b\9ad
+(&
+\9avoke
+);
+
+3697
+DCHECK
+(
+\9a¡r
+->
+HasPo\9a\8brM
+());
+
+3698
+LPo\9a\8brM
+*
+ gpo\9a\8brs
+ =
+\9a¡r
+->
+po\9a\8br_m
+();
+
+3699
+Saãpo\9atG\92\94©Ü
+
+§ãpo\9at_g\92\94©Ü
+(
+this
+,
+po\9a\8brs
+,
+Saãpo\9at
+::
+kLazyDeÝt
+);
+
+3702
+P¬am\91\94CouÁ
+
+aùu®
+(
+»ûiv\94
+);
+
+3703
+__
+
+InvokeFunùiÚ
+(
+funùiÚ
+,
+aùu®
+,
+CALL_FUNCTION
+,
+§ãpo\9at_g\92\94©Ü
+);
+
+3707 \1e
+ gLCodeG\92
+::
+DoPushArgum\92t
+(
+LPushArgum\92t
+*
+\9a¡r
+) {
+
+3708
+LO³¿nd
+*
+¬gum\92t
+ =
+\9a¡r
+->
+v®ue
+();
+
+3709 ià(
+ g¬gum\92t
+->
+IsDoubËRegi¡\94
+(è||\87rgum\92t->
+IsDoubËS\8fckSlÙ
+()) {
+
+3710
+AbÜt
+(
+kDoPushArgum\92tNÙIm¶em\92\8bdFÜDoubËTy³
+);
+
+3712
+Regi¡\94
+
+ g¬gum\92t_»g
+ =
+Em\99LßdRegi¡\94
+(
+¬gum\92t
+,
+\9d
+);
+
+3713
+__
+
+push
+(
+¬gum\92t_»g
+);
+
+3718 \1e
+ gLCodeG\92
+::
+DoDrÝ
+(
+LDrÝ
+*
+\9a¡r
+è{
+__
+
+DrÝ
+(\9a¡r->
+couÁ
+()); }
+
+3721 \1e
+ gLCodeG\92
+::
+DoThisFunùiÚ
+(
+LThisFunùiÚ
+*
+\9a¡r
+) {
+
+3722
+Regi¡\94
+
+»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->result());
+
+3723
+__
+
+LßdP
+(
+»suÉ
+,
+MemO³¿nd
+(
+å
+,
+JavaSü\9dtF¿meCÚ¡ªts
+::
+kFunùiÚOff£t
+));
+
+3727 \1e
+ gLCodeG\92
+::
+DoCڋxt
+(
+LCڋxt
+*
+\9a¡r
+) {
+
+3729
+Regi¡\94
+
+»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->result());
+
+3730 ià(
+\9afo
+()->
+IsO±imiz\9ag
+()) {
+
+3731
+__
+
+LßdP
+(
+»suÉ
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+3734
+DCHECK
+(
+»suÉ
+.
+is
+(
+ý
+));
+
+3739 \1e
+ gLCodeG\92
+::
+DoDeþ¬eGlob®s
+(
+LDeþ¬eGlob®s
+*
+\9a¡r
+) {
+
+3740
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+3741
+__
+
+push
+(
+ý
+);
+
+3742
+__
+
+Move
+(
+sü©ch0
+(),
+\9a¡r
+->
+hydrog\92
+()->
+·\9cs
+());
+
+3743
+__
+
+push
+(
+sü©ch0
+());
+
+3744
+__
+
+LßdSmiL\99\94®
+(
+sü©ch0
+(),
+Smi
+::
+FromIÁ
+(
+\9a¡r
+->
+hydrog\92
+()->
+æags
+()));
+
+3745
+__
+
+push
+(
+sü©ch0
+());
+
+3746
+C®lRuÁime
+(
+RuÁime
+::
+kDeþ¬eGlob®s
+, 3,
+\9a¡r
+);
+
+3750 \1e
+ gLCodeG\92
+::
+C®lKnownFunùiÚ
+(
+HªdË
+<
+JSFunùiÚ
+>
+funùiÚ
+,
+
+3751 \12
+fÜm®_·¿m\91\94_couÁ
+, \12
+¬\99y
+,
+
+3752
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+R4S\8f\8b
+
+r4_¡©e
+) {
+
+3753
+boÞ
+
+ gdÚt_adt_¬gum\92ts
+ =
+
+3754
+fÜm®_·¿m\91\94_couÁ
+ =ð
+Sh¬edFunùiÚInfo
+::
+kDÚtAdtArgum\92tsS\92t\9a\96
+;
+
+3755
+boÞ
+
+ gÿn_\9avoke_d\9ceùly
+ =
+
+3756
+dÚt_adt_¬gum\92ts
+ ||
+fÜm®_·¿m\91\94_couÁ
+ =ð
+¬\99y
+;
+
+3758
+LPo\9a\8brM
+*
+ gpo\9a\8brs
+ =
+\9a¡r
+->
+po\9a\8br_m
+();
+
+3760 ià(
+ gÿn_\9avoke_d\9ceùly
+) {
+
+3761 ià(
+ gr4_¡©e
+ =ð
+R4_UNINITIALIZED
+) {
+
+3762
+__
+
+Move
+(
+r4
+,
+funùiÚ
+);
+
+3766
+__
+
+LßdP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCÚ\8bxtOff£t
+));
+
+3770 ià(
+ gdÚt_adt_¬gum\92ts
+) {
+
+3771
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+¬\99y
+));
+
+3774
+boÞ
+
+ gis_£lf_ÿÎ
+ =
+funùiÚ
+.
+is_id\92tiÿl_to
+(
+\9afo
+()->
+þosu»
+());
+
+3777 ià(
+ gis_£lf_ÿÎ
+) {
+
+3778
+__
+
+C®lS\96f
+();
+
+3780
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCodeEÁryOff£t
+));
+
+3781
+__
+
+C®lJSEÁry
+(
+\9d
+);
+
+3785
+RecÜdSaãpo\9atW\99hLazyDeÝt
+(
+\9a¡r
+,
+RECORD_SIMPLE_SAFEPOINT
+);
+
+3787
+Saãpo\9atG\92\94©Ü
+
+g\92\94©Ü
+(
+this
+,
+po\9a\8brs
+,
+Saãpo\9at
+::
+kLazyDeÝt
+);
+
+3788
+P¬am\91\94CouÁ
+
+couÁ
+(
+¬\99y
+);
+
+3789
+P¬am\91\94CouÁ
+
+ex³ùed
+(
+fÜm®_·¿m\91\94_couÁ
+);
+
+3790
+__
+
+InvokeFunùiÚ
+(
+funùiÚ
+,
+ex³ùed
+,
+couÁ
+,
+CALL_FUNCTION
+,
+g\92\94©Ü
+);
+
+3795 \1e
+ gLCodeG\92
+::
+DoDeã¼edM©hAbsTaggedH\97pNumb\94
+(
+LM©hAbs
+*
+\9a¡r
+) {
+
+3796
+DCHECK
+(
+\9a¡r
+->
+cڋxt
+(è!ð
+NULL
+);
+
+3797
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+3798
+Regi¡\94
+
+ g\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+3799
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3800
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+3803
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+\9aput
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3804
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+3805
+__
+
+cmp
+(
+sü©ch
+,
+\9d
+);
+
+3806
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "not\87 heap\82umber");
+
+3808
+Lab\96
+
+ gdÚe
+;
+
+3809
+Regi¡\94
+
+ gexpڒt
+ =
+sü©ch0
+();
+
+3810
+ gsü©ch
+ =
+no_»g
+;
+
+3811
+__
+
+lwz
+(
+expڒt
+,
+F\9bldMemO³¿nd
+(
+\9aput
+,
+H\97pNumb\94
+::
+kExpÚ\92tOff£t
+));
+
+3814
+__
+
+cmpwi
+(
+expڒt
+,
+O³¿nd
+::
+Z\94o
+());
+
+3816
+__
+
+Move
+(
+»suÉ
+,
+\9aput
+);
+
+3817
+__
+
+bge
+(&
+dÚe
+);
+
+3822
+PushSaãpo\9atRegi¡\94sScÝe
+
+scÝe
+(
+this
+);
+
+3826
+Regi¡\94
+
+ gtmp1
+ =
+\9aput
+.
+is
+(
+r4
+è?
+r3
+ :\844;
+
+3827
+Regi¡\94
+
+ gtmp2
+ =
+\9aput
+.
+is
+(
+r5
+è?
+r3
+ :\845;
+
+3828
+Regi¡\94
+
+ gtmp3
+ =
+\9aput
+.
+is
+(
+r6
+è?
+r3
+ :\846;
+
+3829
+Regi¡\94
+
+ gtmp4
+ =
+\9aput
+.
+is
+(
+r7
+è?
+r3
+ :\847;
+
+3833
+Lab\96
+
+ g®loÿ\8bd
+,
+ g¦ow
+;
+
+3834
+__
+
+LßdRoÙ
+(
+tmp4
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+3835
+__
+
+AÎoÿ\8bH\97pNumb\94
+(
+tmp1
+,
+tmp2
+,
+tmp3
+,
+tmp4
+, &
+¦ow
+);
+
+3836
+__
+
+b
+(&
+®loÿ\8bd
+);
+
+3839
+__
+
+b\9ad
+(&
+¦ow
+);
+
+3841
+C®lRuÁimeFromDeã¼ed
+(
+RuÁime
+::
+kAÎoÿ\8bH\97pNumb\94
+, 0,
+\9a¡r
+,
+
+3842
+\9a¡r
+->
+cڋxt
+());
+
+3844 ià(!
+ gtmp1
+.
+is
+(
+r3
+)è
+__
+
+mr
+(
+tmp1
+,\843);
+
+3846
+__
+
+LßdFromSaãpo\9atRegi¡\94SlÙ
+(
+\9aput
+, input);
+
+3847
+__
+
+lwz
+(
+expڒt
+,
+F\9bldMemO³¿nd
+(
+\9aput
+,
+H\97pNumb\94
+::
+kExpÚ\92tOff£t
+));
+
+3849
+__
+
+b\9ad
+(&
+®loÿ\8bd
+);
+
+3852
+STATIC_ASSERT
+(
+H\97pNumb\94
+::
+kSignMask
+ == 0x80000000u);
+
+3853
+__
+
+þ¾wi
+(
+expڒt
+,\83xpÚ\92t,
+O³¿nd
+(1));
+
+3854
+__
+
+¡w
+(
+expڒt
+,
+F\9bldMemO³¿nd
+(
+tmp1
+,
+H\97pNumb\94
+::
+kExpÚ\92tOff£t
+));
+
+3855
+__
+
+lwz
+(
+tmp2
+,
+F\9bldMemO³¿nd
+(
+\9aput
+,
+H\97pNumb\94
+::
+kMªtis§Off£t
+));
+
+3856
+__
+
+¡w
+(
+tmp2
+,
+F\9bldMemO³¿nd
+(
+tmp1
+,
+H\97pNumb\94
+::
+kMªtis§Off£t
+));
+
+3858
+__
+
+StÜeToSaãpo\9atRegi¡\94SlÙ
+(
+tmp1
+,
+»suÉ
+);
+
+3861
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3865 \1e
+ gLCodeG\92
+::
+Em\99M©hAbs
+(
+LM©hAbs
+*
+\9a¡r
+) {
+
+3866
+Regi¡\94
+
+\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+3867
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3868
+Lab\96
+
+ gdÚe
+;
+
+3869
+__
+
+cmpi
+(
+\9aput
+,
+O³¿nd
+::
+Z\94o
+());
+
+3870
+__
+
+Move
+(
+»suÉ
+,
+\9aput
+);
+
+3871
+__
+
+bge
+(&
+dÚe
+);
+
+3872
+__
+
+li
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+3873
+__
+
+mtx\94
+(
+r0
+);
+
+3874
+__
+
+Ãg
+(
+»suÉ
+,\84esuÉ,
+S\91OE
+,
+S\91RC
+);
+
+3876
+DeÝtimizeIf
+(
+ov\94æow
+,
+\9a¡r
+, "ov\94æow",
+ü0
+);
+
+3877
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3881 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3882 \1e
+ gLCodeG\92
+::
+Em\99IÁeg\9432M©hAbs
+(
+LM©hAbs
+*
+\9a¡r
+) {
+
+3883
+Regi¡\94
+
+\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+3884
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3885
+Lab\96
+
+ gdÚe
+;
+
+3886
+__
+
+cmpwi
+(
+\9aput
+,
+O³¿nd
+::
+Z\94o
+());
+
+3887
+__
+
+Move
+(
+»suÉ
+,
+\9aput
+);
+
+3888
+__
+
+bge
+(&
+dÚe
+);
+
+3891
+__
+
+lis
+(
+r0
+,
+O³¿nd
+(
+SIGN_EXT_IMM16
+(0x8000)));
+
+3892
+__
+
+cmpw
+(
+\9aput
+,
+r0
+);
+
+3893
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "overflow");
+
+3895
+__
+
+Ãg
+(
+»suÉ
+,\84esult);
+
+3896
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3901 \1e
+ gLCodeG\92
+::
+DoM©hAbs
+(
+LM©hAbs
+*
+\9a¡r
+) {
+
+3903 þas
+ cDeã¼edM©hAbsTaggedH\97pNumb\94
+
+FINAL
+ :
+public
+
+LDeã¼edCode
+ {
+
+3904
+public
+:
+
+3905
+Deã¼edM©hAbsTaggedH\97pNumb\94
+(
+LCodeG\92
+*
+codeg\92
+,
+LM©hAbs
+*
+\9a¡r
+)
+
+3906 :
+LDeã¼edCode
+(
+codeg\92
+),
+\9a¡r_
+(
+\9a¡r
+) {}
+
+3907
+v\9ctu®
+ \1e
+G\92\94©e
+(è
+ gOVERRIDE
+ {
+
+3908
+codeg\92
+()->
+DoDeã¼edM©hAbsTaggedH\97pNumb\94
+(
+\9a¡r_
+);
+
+3910
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+(è
+ gOVERRIDE
+ { \15
+ g\9a¡r_
+; }
+
+3912
+ g´iv©e
+:
+
+3913
+LM©hAbs
+*
+\9a¡r_
+;
+
+3916
+R\95»£Á©iÚ
+
+ gr
+ =
+\9a¡r
+->
+hydrog\92
+()->
+v®ue
+()->
+»´e£Á©iÚ
+();
+
+3917 ià(
+ gr
+.
+IsDoubË
+()) {
+
+3918
+DoubËRegi¡\94
+
+ g\9aput
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+3919
+DoubËRegi¡\94
+
+ g»suÉ
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3920
+__
+
+çbs
+(
+»suÉ
+,
+\9aput
+);
+
+3921 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3922 } \vià(
+ gr
+.
+IsIÁeg\9432
+()) {
+
+3923
+Em\99IÁeg\9432M©hAbs
+(
+\9a¡r
+);
+
+3924 } \vià(
+ gr
+.
+IsSmi
+()) {
+
+3926 } \vià(
+ gr
+.
+IsSmiOrIÁeg\9432
+()) {
+
+3928
+Em\99M©hAbs
+(
+\9a¡r
+);
+
+3931
+Deã¼edM©hAbsTaggedH\97pNumb\94
+*
+ gdeã¼ed
+ =
+
+3932
+Ãw
+ (
+zÚe
+()è
+Deã¼edM©hAbsTaggedH\97pNumb\94
+(
+this
+,
+\9a¡r
+);
+
+3933
+Regi¡\94
+
+ g\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+3935
+__
+
+JumpIfNÙSmi
+(
+\9aput
+,
+deã¼ed
+->
+\92\8cy
+());
+
+3937
+Em\99M©hAbs
+(
+\9a¡r
+);
+
+3938
+__
+
+b\9ad
+(
+deã¼ed
+->
+ex\99
+());
+
+3943 \1e
+ gLCodeG\92
+::
+DoM©hFloÜ
+(
+LM©hFloÜ
+*
+\9a¡r
+) {
+
+3944
+DoubËRegi¡\94
+
+\9aput
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+3945
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3946
+Regi¡\94
+
+ g\9aput_high
+ =
+sü©ch0
+();
+
+3947
+Regi¡\94
+
+ gsü©ch
+ =
+\9d
+;
+
+3948
+Lab\96
+
+ gdÚe
+,
+ gexaù
+;
+
+3950
+__
+
+TryIÁ32FloÜ
+(
+»suÉ
+,
+\9aput
+,
+\9aput_high
+,
+sü©ch
+,
+doubË_sü©ch0
+(), &
+dÚe
+,
+
+3951 &
+exaù
+);
+
+3952
+DeÝtimizeIf
+(
+®
+,
+\9a¡r
+, "lost\85recision or NaN");
+
+3954
+__
+
+b\9ad
+(&
+exaù
+);
+
+3955 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+3957
+__
+
+cmpi
+(
+»suÉ
+,
+O³¿nd
+::
+Z\94o
+());
+
+3958
+__
+
+bÃ
+(&
+dÚe
+);
+
+3959
+__
+
+cmpwi
+(
+\9aput_high
+,
+O³¿nd
+::
+Z\94o
+());
+
+3960
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "minus zero");
+
+3962
+__
+
+b\9ad
+(&
+dÚe
+);
+
+3966 \1e
+ gLCodeG\92
+::
+DoM©hRound
+(
+LM©hRound
+*
+\9a¡r
+) {
+
+3967
+DoubËRegi¡\94
+
+\9aput
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+3968
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+3969
+DoubËRegi¡\94
+
+ gdoubË_sü©ch1
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+3970
+DoubËRegi¡\94
+
+ g\9aput_¶us_dÙ_five
+ =
+doubË_sü©ch1
+;
+
+3971
+Regi¡\94
+
+ gsü©ch1
+ =
+sü©ch0
+();
+
+3972
+Regi¡\94
+
+ gsü©ch2
+ =
+\9d
+;
+
+3973
+DoubËRegi¡\94
+
+ gdÙ_five
+ =
+doubË_sü©ch0
+();
+
+3974
+Lab\96
+
+ gcÚv\94t
+,
+ gdÚe
+;
+
+3976
+__
+
+LßdDoubËL\99\94®
+(
+dÙ_five
+, 0.5,
+r0
+);
+
+3977
+__
+
+çbs
+(
+doubË_sü©ch1
+,
+\9aput
+);
+
+3978
+__
+
+fcmpu
+(
+doubË_sü©ch1
+,
+dÙ_five
+);
+
+3979
+DeÝtimizeIf
+(
+unÜd\94ed
+,
+\9a¡r
+, "lost\85recision or NaN");
+
+3983
+__
+
+bgt
+(&
+cÚv\94t
+);
+
+3984 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+3985 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3986
+__
+
+MovDoubËToIÁ64
+(
+sü©ch1
+,
+\9aput
+);
+
+3988
+__
+
+MovDoubËHighToIÁ
+(
+sü©ch1
+,
+\9aput
+);
+
+3990
+__
+
+cmpi
+(
+sü©ch1
+,
+O³¿nd
+::
+Z\94o
+());
+
+3992
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "minus zero");
+
+3994
+Lab\96
+
+ g»tuº_z\94o
+;
+
+3995
+__
+
+fcmpu
+(
+\9aput
+,
+dÙ_five
+);
+
+3996
+__
+
+bÃ
+(&
+»tuº_z\94o
+);
+
+3997
+__
+
+li
+(
+»suÉ
+,
+O³¿nd
+(1));
+
+3998
+__
+
+b
+(&
+dÚe
+);
+
+4001
+__
+
+b\9ad
+(&
+»tuº_z\94o
+);
+
+4002
+__
+
+li
+(
+»suÉ
+,
+O³¿nd
+::
+Z\94o
+());
+
+4003
+__
+
+b
+(&
+dÚe
+);
+
+4005
+__
+
+b\9ad
+(&
+cÚv\94t
+);
+
+4006
+__
+
+çdd
+(
+\9aput_¶us_dÙ_five
+,
+\9aput
+,
+dÙ_five
+);
+
+4008
+__
+
+TryIÁ32FloÜ
+(
+»suÉ
+,
+\9aput_¶us_dÙ_five
+,
+sü©ch1
+,
+sü©ch2
+,
+
+4009
+doubË_sü©ch0
+(), &
+dÚe
+, &done);
+
+4010
+DeÝtimizeIf
+(
+®
+,
+\9a¡r
+, "lost\85recision or NaN");
+
+4011
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4015 \1e
+ gLCodeG\92
+::
+DoM©hFround
+(
+LM©hFround
+*
+\9a¡r
+) {
+
+4016
+DoubËRegi¡\94
+
+\9aput_»g
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+4017
+DoubËRegi¡\94
+
+ gou\8dut_»g
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+4018
+__
+
+ä¥
+(
+ou\8dut_»g
+,
+\9aput_»g
+);
+
+4022 \1e
+ gLCodeG\92
+::
+DoM©hSq¹
+(
+LM©hSq¹
+*
+\9a¡r
+) {
+
+4023
+DoubËRegi¡\94
+
+\9aput
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+4024
+DoubËRegi¡\94
+
+ g»suÉ
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+4025
+__
+
+fsq¹
+(
+»suÉ
+,
+\9aput
+);
+
+4029 \1e
+ gLCodeG\92
+::
+DoM©hPowH®f
+(
+LM©hPowH®f
+*
+\9a¡r
+) {
+
+4030
+DoubËRegi¡\94
+
+\9aput
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+4031
+DoubËRegi¡\94
+
+ g»suÉ
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+4032
+DoubËRegi¡\94
+
+ g\8bmp
+ =
+doubË_sü©ch0
+();
+
+4037
+Lab\96
+
+ gsk\9d
+,
+ gdÚe
+;
+
+4039
+__
+
+LßdDoubËL\99\94®
+(
+\8bmp
+, -
+V8_INFINITY
+,
+sü©ch0
+());
+
+4040
+__
+
+fcmpu
+(
+\9aput
+,
+\8bmp
+);
+
+4041
+__
+
+bÃ
+(&
+sk\9d
+);
+
+4042
+__
+
+âeg
+(
+»suÉ
+,
+\8bmp
+);
+
+4043
+__
+
+b
+(&
+dÚe
+);
+
+4046
+__
+
+b\9ad
+(&
+sk\9d
+);
+
+4047
+__
+
+çdd
+(
+»suÉ
+,
+\9aput
+,
+kDoubËRegZ\94o
+);
+
+4048
+__
+
+fsq¹
+(
+»suÉ
+,\84esult);
+
+4049
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4053 \1e
+ gLCodeG\92
+::
+DoPow\94
+(
+LPow\94
+*
+\9a¡r
+) {
+
+4054
+R\95»£Á©iÚ
+
+expÚ\92t_ty³
+ =
+\9a¡r
+->
+hydrog\92
+()->
+right
+()->
+»´e£Á©iÚ
+();
+
+4057 #ifdeà
+DEBUG
+
+
+4058
+Regi¡\94
+
+ g\8fgged_expÚ\92t
+ =
+M©hPowTaggedDesü\9dtÜ
+::
+expڒt
+();
+
+4060
+DCHECK
+(!
+\9a¡r
+->
+right
+()->
+IsDoubËRegi¡\94
+() ||
+
+4061
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+right
+()).
+is
+(
+d2
+));
+
+4062
+DCHECK
+(!
+\9a¡r
+->
+right
+()->
+IsRegi¡\94
+() ||
+
+4063
+ToRegi¡\94
+(
+\9a¡r
+->
+right
+()).
+is
+(
+\8fgged_expÚ\92t
+));
+
+4064
+DCHECK
+(
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+Ëá
+()).
+is
+(
+d1
+));
+
+4065
+DCHECK
+(
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()).
+is
+(
+d3
+));
+
+4067 ià(
+ gexpÚ\92t_ty³
+.
+IsSmi
+()) {
+
+4068
+M©hPowStub
+
+¡ub
+(
+isީe
+(), M©hPowStub::
+TAGGED
+);
+
+4069
+__
+
+C®lStub
+(&
+¡ub
+);
+
+4070 } \vià(
+ gexpÚ\92t_ty³
+.
+IsTagged
+()) {
+
+4071
+Lab\96
+
+ gno_deÝt
+;
+
+4072
+__
+
+JumpIfSmi
+(
+r5
+, &
+no_deÝt
+);
+
+4073
+__
+
+LßdP
+(
+r10
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+4074
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+4075
+__
+
+cmp
+(
+r10
+,
+\9d
+);
+
+4076
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "not\87 heap\82umber");
+
+4077
+__
+
+b\9ad
+(&
+no_deÝt
+);
+
+4078
+M©hPowStub
+
+¡ub
+(
+isީe
+(), M©hPowStub::
+TAGGED
+);
+
+4079
+__
+
+C®lStub
+(&
+¡ub
+);
+
+4080 } \vià(
+ gexpÚ\92t_ty³
+.
+IsIÁeg\9432
+()) {
+
+4081
+M©hPowStub
+
+¡ub
+(
+isީe
+(), M©hPowStub::
+INTEGER
+);
+
+4082
+__
+
+C®lStub
+(&
+¡ub
+);
+
+4084
+DCHECK
+(
+expÚ\92t_ty³
+.
+IsDoubË
+());
+
+4085
+M©hPowStub
+
+¡ub
+(
+isީe
+(), M©hPowStub::
+DOUBLE
+);
+
+4086
+__
+
+C®lStub
+(&
+¡ub
+);
+
+4091 \1e
+ gLCodeG\92
+::
+DoM©hExp
+(
+LM©hExp
+*
+\9a¡r
+) {
+
+4092
+DoubËRegi¡\94
+
+\9aput
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+4093
+DoubËRegi¡\94
+
+ g»suÉ
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+4094
+DoubËRegi¡\94
+
+ gdoubË_sü©ch1
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+doubË_\8bmp
+());
+
+4095
+DoubËRegi¡\94
+
+ gdoubË_sü©ch2
+ =
+doubË_sü©ch0
+();
+
+4096
+Regi¡\94
+
+ g\8bmp1
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp1
+());
+
+4097
+Regi¡\94
+
+ g\8bmp2
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp2
+());
+
+4099
+ gM©hExpG\92\94©Ü
+::
+Em\99M©hExp
+(
+masm
+(),
+\9aput
+,
+»suÉ
+,
+doubË_sü©ch1
+,
+
+4100
+doubË_sü©ch2
+,
+\8bmp1
+,
+\8bmp2
+,
+sü©ch0
+());
+
+4104 \1e
+ gLCodeG\92
+::
+DoM©hLog
+(
+LM©hLog
+*
+\9a¡r
+) {
+
+4105
+__
+
+P»·»C®lCFunùiÚ
+(0, 1,
+sü©ch0
+());
+
+4106
+__
+
+MovToFlßtP¬am\91\94
+(
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+()));
+
+4107
+__
+
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+::
+m©h_log_doubË_funùiÚ
+(
+isީe
+()), 0,
+
+4109
+__
+
+MovFromFlßtResuÉ
+(
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()));
+
+4113 \1e
+ gLCodeG\92
+::
+DoM©hClz32
+(
+LM©hClz32
+*
+\9a¡r
+) {
+
+4114
+Regi¡\94
+
+\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+4115
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+4116
+__
+
+ú\8ezw_
+(
+»suÉ
+,
+\9aput
+);
+
+4120 \1e
+ gLCodeG\92
+::
+DoInvokeFunùiÚ
+(
+LInvokeFunùiÚ
+*
+\9a¡r
+) {
+
+4121
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+4122
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+funùiÚ
+()).
+is
+(
+r4
+));
+
+4123
+DCHECK
+(
+\9a¡r
+->
+HasPo\9a\8brM
+());
+
+4125
+ gHªdË
+<
+ gJSFunùiÚ
+>
+ gknown_funùiÚ
+ =
+\9a¡r
+->
+hydrog\92
+()->
+known_funùiÚ
+();
+
+4126 ià(
+ gknown_funùiÚ
+.
+is_nuÎ
+()) {
+
+4127
+LPo\9a\8brM
+*
+ gpo\9a\8brs
+ =
+\9a¡r
+->
+po\9a\8br_m
+();
+
+4128
+Saãpo\9atG\92\94©Ü
+
+g\92\94©Ü
+(
+this
+,
+po\9a\8brs
+,
+Saãpo\9at
+::
+kLazyDeÝt
+);
+
+4129
+P¬am\91\94CouÁ
+
+couÁ
+(
+\9a¡r
+->
+¬\99y
+());
+
+4130
+__
+
+InvokeFunùiÚ
+(
+r4
+,
+couÁ
+,
+CALL_FUNCTION
+,
+g\92\94©Ü
+);
+
+4132
+C®lKnownFunùiÚ
+(
+known_funùiÚ
+,
+
+4133
+\9a¡r
+->
+hydrog\92
+()->
+fÜm®_·¿m\91\94_couÁ
+(),
+
+4134
+\9a¡r
+->
+¬\99y
+(), in¡r,
+R4_CONTAINS_TARGET
+);
+
+4139 \1e
+ gLCodeG\92
+::
+DoTa\9eC®lThroughMegamÜphicCache
+(
+
+4140
+LTa\9eC®lThroughMegamÜphicCache
+*
+\9a¡r
+) {
+
+4141
+Regi¡\94
+
+»ûiv\94
+ =
+ToRegi¡\94
+(
+\9a¡r
+->receiver());
+
+4142
+Regi¡\94
+
+ gÇme
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+Çme
+());
+
+4143
+DCHECK
+(
+»ûiv\94
+.
+is
+(
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+()));
+
+4144
+DCHECK
+(
+Çme
+.
+is
+(
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+()));
+
+4145
+DCHECK
+(
+»ûiv\94
+.
+is
+(
+r4
+));
+
+4146
+DCHECK
+(
+Çme
+.
+is
+(
+r5
+));
+
+4148
+Regi¡\94
+
+ gsü©ch
+ =
+r6
+;
+
+4149
+Regi¡\94
+
+ gex\8ca
+ =
+r7
+;
+
+4150
+Regi¡\94
+
+ gex\8ca2
+ =
+r8
+;
+
+4151
+Regi¡\94
+
+ gex\8ca3
+ =
+r9
+;
+
+4154
+boÞ
+
+ gmu¡_\8b¬down_äame
+ =
+N\93dsEag\94F¿me
+();
+
+4157
+isީe
+()->
+¡ub_ÿche
+()->
+G\92\94©eProbe
+(
+masm
+(),
+\9a¡r
+->
+hydrog\92
+()->
+æags
+(),
+
+4158
+mu¡_\8b¬down_äame
+,
+»ûiv\94
+,
+Çme
+,
+
+4159
+sü©ch
+,
+ex\8ca
+,
+ex\8ca2
+,
+ex\8ca3
+);
+
+4162 ià(
+ gmu¡_\8b¬down_äame
+è
+__
+
+L\97veF¿me
+(
+S\8fckF¿me
+::
+INTERNAL
+);
+
+4163
+ gLßdIC
+::
+G\92\94©eMiss
+(
+masm
+());
+
+4167 \1e
+ gLCodeG\92
+::
+DoC®lW\99hDesü\9dtÜ
+(
+LC®lW\99hDesü\9dtÜ
+*
+\9a¡r
+) {
+
+4168
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()).
+is
+(
+r3
+));
+
+4170
+LPo\9a\8brM
+*
+ gpo\9a\8brs
+ =
+\9a¡r
+->
+po\9a\8br_m
+();
+
+4171
+Saãpo\9atG\92\94©Ü
+
+g\92\94©Ü
+(
+this
+,
+po\9a\8brs
+,
+Saãpo\9at
+::
+kLazyDeÝt
+);
+
+4173 ià(
+ g\9a¡r
+->
+\8frg\91
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+4174
+LCÚ¡ªtO³¿nd
+*
+ g\8frg\91
+ = LCÚ¡ªtO³¿nd::
+ÿ¡
+(
+\9a¡r
+->
+\8frg\91
+());
+
+4175
+ gHªdË
+<
+ gCode
+>
+ gcode
+ =
+HªdË
+<
+Code
+>::
+ÿ¡
+(
+ToHªdË
+(
+\8frg\91
+));
+
+4176
+ gg\92\94©Ü
+.
+BefÜeC®l
+(
+__
+
+C®lSize
+(
+code
+,
+R\96ocInfo
+::
+CODE_TARGET
+));
+
+4177
+__
+
+C®l
+(
+code
+,
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+4179
+DCHECK
+(
+\9a¡r
+->
+\8frg\91
+()->
+IsRegi¡\94
+());
+
+4180
+Regi¡\94
+
+ g\8frg\91
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8frg\91
+());
+
+4181
+ gg\92\94©Ü
+.
+BefÜeC®l
+(
+__
+
+C®lSize
+(
+\8frg\91
+));
+
+4182
+__
+
+addi
+(
+\9d
+,
+\8frg\91
+,
+O³¿nd
+(
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+4183
+__
+
+C®lJSEÁry
+(
+\9d
+);
+
+4185
+ gg\92\94©Ü
+.
+Aá\94C®l
+();
+
+4189 \1e
+ gLCodeG\92
+::
+DoC®lJSFunùiÚ
+(
+LC®lJSFunùiÚ
+*
+\9a¡r
+) {
+
+4190
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+funùiÚ
+()).
+is
+(
+r4
+));
+
+4191
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()).
+is
+(
+r3
+));
+
+4193 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+·ss_¬gum\92t_couÁ
+()) {
+
+4194
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+\9a¡r
+->
+¬\99y
+()));
+
+4198
+__
+
+LßdP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCÚ\8bxtOff£t
+));
+
+4200
+boÞ
+
+ gis_£lf_ÿÎ
+ =
+çl£
+;
+
+4201 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+funùiÚ
+()->
+IsCÚ¡ªt
+()) {
+
+4202
+HCÚ¡ªt
+*
+ gfun_cڡ
+ = HCÚ¡ªt::
+ÿ¡
+(
+\9a¡r
+->
+hydrog\92
+()->
+funùiÚ
+());
+
+4203
+ gHªdË
+<
+ gJSFunùiÚ
+>
+ gjsfun
+ =
+
+4204
+HªdË
+<
+JSFunùiÚ
+>::
+ÿ¡
+(
+fun_cڡ
+->
+hªdË
+(
+isީe
+()));
+
+4205
+ gis_£lf_ÿÎ
+ =
+jsfun
+.
+is_id\92tiÿl_to
+(
+\9afo
+()->
+þosu»
+());
+
+4208 ià(
+ gis_£lf_ÿÎ
+) {
+
+4209
+__
+
+C®lS\96f
+();
+
+4211
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCodeEÁryOff£t
+));
+
+4212
+__
+
+C®lJSEÁry
+(
+\9d
+);
+
+4215
+RecÜdSaãpo\9atW\99hLazyDeÝt
+(
+\9a¡r
+,
+RECORD_SIMPLE_SAFEPOINT
+);
+
+4219 \1e
+ gLCodeG\92
+::
+DoC®lFunùiÚ
+(
+LC®lFunùiÚ
+*
+\9a¡r
+) {
+
+4220
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+4221
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+funùiÚ
+()).
+is
+(
+r4
+));
+
+4222
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()).
+is
+(
+r3
+));
+
+4224 \12
+ g¬\99y
+ =
+\9a¡r
+->
+¬\99y
+();
+
+4225
+C®lFunùiÚStub
+
+¡ub
+(
+isީe
+(),
+¬\99y
+,
+\9a¡r
+->
+hydrog\92
+()->
+funùiÚ_æags
+());
+
+4226
+C®lCode
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+4230 \1e
+ gLCodeG\92
+::
+DoC®lNew
+(
+LC®lNew
+*
+\9a¡r
+) {
+
+4231
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+4232
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cÚ¡ruùÜ
+()).
+is
+(
+r4
+));
+
+4233
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()).
+is
+(
+r3
+));
+
+4235
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+\9a¡r
+->
+¬\99y
+()));
+
+4237
+__
+
+LßdRoÙ
+(
+r5
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+4238
+C®lCÚ¡ruùStub
+
+¡ub
+(
+isީe
+(),
+NO_CALL_CONSTRUCTOR_FLAGS
+);
+
+4239
+C®lCode
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CONSTRUCT_CALL
+,
+\9a¡r
+);
+
+4243 \1e
+ gLCodeG\92
+::
+DoC®lNewA¼ay
+(
+LC®lNewA¼ay
+*
+\9a¡r
+) {
+
+4244
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+4245
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cÚ¡ruùÜ
+()).
+is
+(
+r4
+));
+
+4246
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()).
+is
+(
+r3
+));
+
+4248
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+\9a¡r
+->
+¬\99y
+()));
+
+4249
+__
+
+LßdRoÙ
+(
+r5
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+4250
+EËm\92tsK\9ad
+
+ gk\9ad
+ =
+\9a¡r
+->
+hydrog\92
+()->
+\96em\92ts_k\9ad
+();
+
+4251
+AÎoÿtiÚS\99eOv\94rideMode
+
+ gov\94ride_mode
+ =
+
+4252 (
+AÎoÿtiÚS\99e
+::
+G\91Mode
+(
+k\9ad
+è=ð
+TRACK_ALLOCATION_SITE
+)
+
+4253 ?
+DISABLE_ALLOCATION_SITES
+
+
+4254 :
+DONT_OVERRIDE
+;
+
+4256 ià(
+ g\9a¡r
+->
+¬\99y
+() == 0) {
+
+4257
+A¼ayNoArgum\92tCÚ¡ruùÜStub
+
+¡ub
+(
+isީe
+(),
+k\9ad
+,
+ov\94ride_mode
+);
+
+4258
+C®lCode
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CONSTRUCT_CALL
+,
+\9a¡r
+);
+
+4259 } \vià(
+ g\9a¡r
+->
+¬\99y
+() == 1) {
+
+4260
+Lab\96
+
+dÚe
+;
+
+4261 ià(
+IsFa¡PackedEËm\92tsK\9ad
+(
+k\9ad
+)) {
+
+4262
+Lab\96
+
+ g·cked_ÿ£
+;
+
+4265
+__
+
+LßdP
+(
+r8
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4266
+__
+
+cmpi
+(
+r8
+,
+O³¿nd
+::
+Z\94o
+());
+
+4267
+__
+
+beq
+(&
+·cked_ÿ£
+);
+
+4269
+EËm\92tsK\9ad
+
+ ghÞey_k\9ad
+ =
+G\91HÞeyEËm\92tsK\9ad
+(
+k\9ad
+);
+
+4270
+A¼ayS\9agËArgum\92tCÚ¡ruùÜStub
+
+¡ub
+(
+isީe
+(),
+hÞey_k\9ad
+,
+
+4271
+ov\94ride_mode
+);
+
+4272
+C®lCode
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CONSTRUCT_CALL
+,
+\9a¡r
+);
+
+4273
+__
+
+b
+(&
+dÚe
+);
+
+4274
+__
+
+b\9ad
+(&
+·cked_ÿ£
+);
+
+4277
+A¼ayS\9agËArgum\92tCÚ¡ruùÜStub
+
+¡ub
+(
+isީe
+(),
+k\9ad
+,
+ov\94ride_mode
+);
+
+4278
+C®lCode
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CONSTRUCT_CALL
+,
+\9a¡r
+);
+
+4279
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4281
+A¼ayNArgum\92tsCÚ¡ruùÜStub
+
+¡ub
+(
+isީe
+(),
+k\9ad
+,
+ov\94ride_mode
+);
+
+4282
+C®lCode
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CONSTRUCT_CALL
+,
+\9a¡r
+);
+
+4287 \1e
+ gLCodeG\92
+::
+DoC®lRuÁime
+(
+LC®lRuÁime
+*
+\9a¡r
+) {
+
+4288
+C®lRuÁime
+(
+\9a¡r
+->
+funùiÚ
+(), in¡r->
+¬\99y
+(), instr);
+
+4292 \1e
+ gLCodeG\92
+::
+DoStÜeCodeEÁry
+(
+LStÜeCodeEÁry
+*
+\9a¡r
+) {
+
+4293
+Regi¡\94
+
+funùiÚ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->function());
+
+4294
+Regi¡\94
+
+ gcode_objeù
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+code_objeù
+());
+
+4295
+__
+
+addi
+(
+code_objeù
+, code_object,
+
+4296
+O³¿nd
+(
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+4297
+__
+
+StÜeP
+(
+code_objeù
+,
+
+4298
+F\9bldMemO³¿nd
+(
+funùiÚ
+,
+JSFunùiÚ
+::
+kCodeEÁryOff£t
+),
+r0
+);
+
+4302 \1e
+ gLCodeG\92
+::
+DoIÂ\94AÎoÿ\8bdObjeù
+(
+LIÂ\94AÎoÿ\8bdObjeù
+*
+\9a¡r
+) {
+
+4303
+Regi¡\94
+
+»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->result());
+
+4304
+Regi¡\94
+
+ gba£
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+ba£_objeù
+());
+
+4305 ià(
+ g\9a¡r
+->
+off£t
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+4306
+LCÚ¡ªtO³¿nd
+*
+ goff£t
+ = LCÚ¡ªtO³¿nd::
+ÿ¡
+(
+\9a¡r
+->
+off£t
+());
+
+4307
+__
+
+Add
+(
+»suÉ
+,
+ba£
+,
+ToIÁeg\9432
+(
+off£t
+),
+r0
+);
+
+4309
+Regi¡\94
+
+ goff£t
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+off£t
+());
+
+4310
+__
+
+add
+(
+»suÉ
+,
+ba£
+,
+off£t
+);
+
+4315 \1e
+ gLCodeG\92
+::
+DoStÜeNamedF\9bld
+(
+LStÜeNamedF\9bld
+*
+\9a¡r
+) {
+
+4316
+HStÜeNamedF\9bld
+*
+h\9a¡r
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+4317
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚ
+ =
+\9a¡r
+->
+»´e£Á©iÚ
+();
+
+4319
+Regi¡\94
+
+ gobjeù
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+objeù
+());
+
+4320
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+4321
+HObjeùAcûss
+
+ gacûss
+ =
+h\9a¡r
+->
+acûss
+();
+
+4322 \12
+ goff£t
+ =
+acûss
+.
+off£t
+();
+
+4324 ià(
+ gacûss
+.
+IsEx\8bº®MemÜy
+()) {
+
+4325
+Regi¡\94
+
+ gv®ue
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+4326
+MemO³¿nd
+
+ gÝ\94ªd
+ = MemO³¿nd(
+objeù
+,
+off£t
+);
+
+4327
+__
+
+StÜeR\95»£Á©iÚ
+(
+v®ue
+,
+Ý\94ªd
+,
+»´e£Á©iÚ
+,
+r0
+);
+
+4331
+__
+
+As£¹NÙSmi
+(
+objeù
+);
+
+4333 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4334
+DCHECK
+(!
+»´e£Á©iÚ
+.
+IsSmi
+(è|| !
+\9a¡r
+->
+v®ue
+()->
+IsCÚ¡ªtO³¿nd
+() ||
+
+4335
+IsIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+v®ue
+())));
+
+4337
+DCHECK
+(!
+»´e£Á©iÚ
+.
+IsSmi
+(è|| !
+\9a¡r
+->
+v®ue
+()->
+IsCÚ¡ªtO³¿nd
+() ||
+
+4338
+IsSmi
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+v®ue
+())));
+
+4340 ià(
+ g»´e£Á©iÚ
+.
+IsDoubË
+()) {
+
+4341
+DCHECK
+(
+acûss
+.
+IsInobjeù
+());
+
+4342
+DCHECK
+(!
+h\9a¡r
+->
+has_\8cªs\99iÚ
+());
+
+4343
+DCHECK
+(!
+h\9a¡r
+->
+N\93dsWr\99eB¬r\9br
+());
+
+4344
+DoubËRegi¡\94
+
+ gv®ue
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+4345
+__
+
+¡fd
+(
+v®ue
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+off£t
+));
+
+4349 ià(
+ gh\9a¡r
+->
+has_\8cªs\99iÚ
+()) {
+
+4350
+ gHªdË
+<
+ gM
+>
+ g\8cªs\99iÚ
+ =
+h\9a¡r
+->
+\8cªs\99iÚ_m
+();
+
+4351
+AddD\95»ÿtiÚD\95\92d\92cy
+(
+\8cªs\99iÚ
+);
+
+4352
+__
+
+mov
+(
+sü©ch
+,
+O³¿nd
+(
+\8cªs\99iÚ
+));
+
+4353
+__
+
+StÜeP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pObjeù
+::
+kMOff£t
+),
+r0
+);
+
+4354 ià(
+ gh\9a¡r
+->
+N\93dsWr\99eB¬r\9brFÜM
+()) {
+
+4355
+Regi¡\94
+
+ g\8bmp
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+4357
+__
+
+RecÜdWr\99eFÜM
+(
+objeù
+,
+sü©ch
+,
+\8bmp
+,
+G\91L\9akRegi¡\94S\8f\8b
+(),
+
+4358
+kSaveFPRegs
+);
+
+4363
+Regi¡\94
+
+ gv®ue
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+4365 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4367 ià(
+ g»´e£Á©iÚ
+.
+IsSmi
+() &&
+
+4368
+ gh\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsIÁeg\9432
+()) {
+
+4369
+DCHECK
+(
+h\9a¡r
+->
+¡Üe_mode
+(è=ð
+STORE_TO_INITIALIZED_ENTRY
+);
+
+4371
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+4372
+STATIC_ASSERT
+(
+kSmiTagSize
+ +
+kSmiShiáSize
+ == 32);
+
+4373 #ià
+V8_TARGET_LITTLE_ENDIAN
+
+
+4374
+ goff£t
+ +ð
+kPo\9a\8brSize
+ / 2;
+
+4376
+ g»´e£Á©iÚ
+ =
+R\95»£Á©iÚ
+::
+IÁeg\9432
+();
+
+4380 ià(
+ gacûss
+.
+IsInobjeù
+()) {
+
+4381
+MemO³¿nd
+
+ gÝ\94ªd
+ =
+F\9bldMemO³¿nd
+(
+objeù
+,
+off£t
+);
+
+4382
+__
+
+StÜeR\95»£Á©iÚ
+(
+v®ue
+,
+Ý\94ªd
+,
+»´e£Á©iÚ
+,
+r0
+);
+
+4383 ià(
+ gh\9a¡r
+->
+N\93dsWr\99eB¬r\9br
+()) {
+
+4385
+__
+
+RecÜdWr\99eF\9bld
+(
+
+4386
+objeù
+,
+off£t
+,
+v®ue
+,
+sü©ch
+,
+G\91L\9akRegi¡\94S\8f\8b
+(),
+kSaveFPRegs
+,
+
+4387
+EMIT_REMEMBERED_SET
+,
+h\9a¡r
+->
+SmiCheckFÜWr\99eB¬r\9br
+(),
+
+4388
+h\9a¡r
+->
+Po\9a\8brsToH\94eCheckFÜV®ue
+());
+
+4391
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+JSObjeù
+::
+kPrÝ\94t\9bsOff£t
+));
+
+4392
+MemO³¿nd
+
+ gÝ\94ªd
+ =
+F\9bldMemO³¿nd
+(
+sü©ch
+,
+off£t
+);
+
+4393
+__
+
+StÜeR\95»£Á©iÚ
+(
+v®ue
+,
+Ý\94ªd
+,
+»´e£Á©iÚ
+,
+r0
+);
+
+4394 ià(
+ gh\9a¡r
+->
+N\93dsWr\99eB¬r\9br
+()) {
+
+4397
+__
+
+RecÜdWr\99eF\9bld
+(
+
+4398
+sü©ch
+,
+off£t
+,
+v®ue
+,
+objeù
+,
+G\91L\9akRegi¡\94S\8f\8b
+(),
+kSaveFPRegs
+,
+
+4399
+EMIT_REMEMBERED_SET
+,
+h\9a¡r
+->
+SmiCheckFÜWr\99eB¬r\9br
+(),
+
+4400
+h\9a¡r
+->
+Po\9a\8brsToH\94eCheckFÜV®ue
+());
+
+4406 \1e
+ gLCodeG\92
+::
+DoStÜeNamedG\92\94ic
+(
+LStÜeNamedG\92\94ic
+*
+\9a¡r
+) {
+
+4407
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+4408
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+objeù
+()).
+is
+(
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+()));
+
+4409
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+()).
+is
+(
+StÜeDesü\9dtÜ
+::
+V®ueRegi¡\94
+()));
+
+4411
+__
+
+mov
+(
+StÜeDesü\9dtÜ
+::
+NameRegi¡\94
+(),
+O³¿nd
+(
+\9a¡r
+->
+Çme
+()));
+
+4412
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+StÜeIC
+::
+\9a\99\9flize_¡ub
+(
+isީe
+(),
+\9a¡r
+->
+¡riù_mode
+());
+
+4413
+C®lCode
+(
+ic
+,
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+4417 \1e
+ gLCodeG\92
+::
+DoBoundsCheck
+(
+LBoundsCheck
+*
+\9a¡r
+) {
+
+4418
+R\95»£Á©iÚ
+
+»´e£Á©iÚ
+ =
+\9a¡r
+->
+hydrog\92
+()->
+Ëngth
+()->representation();
+
+4419
+DCHECK
+(
+»´e£Á©iÚ
+.
+Equ®s
+(
+\9a¡r
+->
+hydrog\92
+()->
+\9adex
+()->representation()));
+
+4420
+DCHECK
+(
+»´e£Á©iÚ
+.
+IsSmiOrIÁeg\9432
+());
+
+4422
+CÚd\99iÚ
+
+ gcc
+ =
+\9a¡r
+->
+hydrog\92
+()->
+®low_equ®\99y
+(è?
+É
+ :
+Ë
+;
+
+4423 ià(
+ g\9a¡r
+->
+Ëngth
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+4424
+\9at32_t
+
+ gËngth
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+Ëngth
+()));
+
+4425
+Regi¡\94
+
+ g\9adex
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\9adex
+());
+
+4426 ià(
+ g»´e£Á©iÚ
+.
+IsSmi
+()) {
+
+4427
+__
+
+Cm¶i
+(
+\9adex
+,
+O³¿nd
+(
+Smi
+::
+FromIÁ
+(
+Ëngth
+)),
+r0
+);
+
+4429
+__
+
+Cm¶wi
+(
+\9adex
+,
+O³¿nd
+(
+Ëngth
+),
+r0
+);
+
+4431
+ gcc
+ =
+Commu\8bCÚd\99iÚ
+(
+cc
+);
+
+4432 } \vià(
+ g\9a¡r
+->
+\9adex
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+4433
+\9at32_t
+
+ g\9adex
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+\9adex
+()));
+
+4434
+Regi¡\94
+
+ gËngth
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëngth
+());
+
+4435 ià(
+ g»´e£Á©iÚ
+.
+IsSmi
+()) {
+
+4436
+__
+
+Cm¶i
+(
+Ëngth
+,
+O³¿nd
+(
+Smi
+::
+FromIÁ
+(
+\9adex
+)),
+r0
+);
+
+4438
+__
+
+Cm¶wi
+(
+Ëngth
+,
+O³¿nd
+(
+\9adex
+),
+r0
+);
+
+4441
+Regi¡\94
+
+ g\9adex
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\9adex
+());
+
+4442
+Regi¡\94
+
+ gËngth
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëngth
+());
+
+4443 ià(
+ g»´e£Á©iÚ
+.
+IsSmi
+()) {
+
+4444
+__
+
+cm¶
+(
+Ëngth
+,
+\9adex
+);
+
+4446
+__
+
+cm¶w
+(
+Ëngth
+,
+\9adex
+);
+
+4449 ià(
+ gFLAG_debug_code
+ &&
+ g\9a¡r
+->
+hydrog\92
+()->
+sk\9d_check
+()) {
+
+4450
+Lab\96
+
+ gdÚe
+;
+
+4451
+__
+
+b
+(
+Neg©eCÚd\99iÚ
+(
+cc
+), &
+dÚe
+);
+
+4452
+__
+
+¡Ý
+("eliminated bounds check failed");
+
+4453
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4455
+DeÝtimizeIf
+(
+cc
+,
+\9a¡r
+, "out of bounds");
+
+4460 \1e
+ gLCodeG\92
+::
+DoStÜeKeyedEx\8bº®A¼ay
+(
+LStÜeKeyed
+*
+\9a¡r
+) {
+
+4461
+Regi¡\94
+
+ex\8bº®_po\9a\8br
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+4462
+Regi¡\94
+
+ gkey
+ =
+no_»g
+;
+
+4463
+EËm\92tsK\9ad
+
+ g\96em\92ts_k\9ad
+ =
+\9a¡r
+->
+\96em\92ts_k\9ad
+();
+
+4464
+boÞ
+
+ gkey_is_cÚ¡ªt
+ =
+\9a¡r
+->
+key
+()->
+IsCÚ¡ªtO³¿nd
+();
+
+4465 \12
+ gcÚ¡ªt_key
+ = 0;
+
+4466 ià(
+ gkey_is_cÚ¡ªt
+) {
+
+4467
+ gcÚ¡ªt_key
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+key
+()));
+
+4468 ià(
+ gcÚ¡ªt_key
+ & 0xF0000000) {
+
+4469
+AbÜt
+(
+kA¼ayIndexCÚ¡ªtV®ueTooBig
+);
+
+4472
+ gkey
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+key
+());
+
+4474 \12
+ g\96em\92t_size_shiá
+ =
+EËm\92tsK\9adToShiáSize
+(
+\96em\92ts_k\9ad
+);
+
+4475
+boÞ
+
+ gkey_is_smi
+ =
+\9a¡r
+->
+hydrog\92
+()->
+key
+()->
+»´e£Á©iÚ
+().
+IsSmi
+();
+
+4476 \12
+ gba£_off£t
+ =
+\9a¡r
+->
+ba£_off£t
+();
+
+4478 ià(
+ g\96em\92ts_k\9ad
+ =ð
+EXTERNAL_FLOAT32_ELEMENTS
+ ||
+
+4479
+\96em\92ts_k\9ad
+ =ð
+FLOAT32_ELEMENTS
+ ||
+
+4480
+\96em\92ts_k\9ad
+ =ð
+EXTERNAL_FLOAT64_ELEMENTS
+ ||
+
+4481
+\96em\92ts_k\9ad
+ =ð
+FLOAT64_ELEMENTS
+) {
+
+4482
+Regi¡\94
+
+add»ss
+ =
+sü©ch0
+();
+
+4483
+DoubËRegi¡\94
+
+v®ue
+(
+ToDoubËRegi¡\94
+(
+\9a¡r
+->value()));
+
+4484 ià(
+ gkey_is_cÚ¡ªt
+) {
+
+4485 ià(
+ gcÚ¡ªt_key
+ != 0) {
+
+4486
+__
+
+Add
+(
+add»ss
+,
+ex\8bº®_po\9a\8br
+,
+cÚ¡ªt_key
+ <<
+\96em\92t_size_shiá
+,
+
+4487
+r0
+);
+
+4489
+ gadd»ss
+ =
+ex\8bº®_po\9a\8br
+;
+
+4492
+__
+
+IndexToA¼ayOff£t
+(
+r0
+,
+key
+,
+\96em\92t_size_shiá
+,
+key_is_smi
+);
+
+4493
+__
+
+add
+(
+add»ss
+,
+ex\8bº®_po\9a\8br
+,
+r0
+);
+
+4495 ià(
+ g\96em\92ts_k\9ad
+ =ð
+EXTERNAL_FLOAT32_ELEMENTS
+ ||
+
+4496
+\96em\92ts_k\9ad
+ =ð
+FLOAT32_ELEMENTS
+) {
+
+4497
+__
+
+ä¥
+(
+doubË_sü©ch0
+(),
+v®ue
+);
+
+4498
+__
+
+¡fs
+(
+doubË_sü©ch0
+(),
+MemO³¿nd
+(
+add»ss
+,
+ba£_off£t
+));
+
+4500
+__
+
+¡fd
+(
+v®ue
+,
+MemO³¿nd
+(
+add»ss
+,
+ba£_off£t
+));
+
+4503
+Regi¡\94
+
+v®ue
+(
+ToRegi¡\94
+(
+\9a¡r
+->value()));
+
+4504
+MemO³¿nd
+
+ gmem_Ý\94ªd
+ =
+
+4505
+P»·»KeyedO³¿nd
+(
+key
+,
+ex\8bº®_po\9a\8br
+,
+key_is_cÚ¡ªt
+,
+key_is_smi
+,
+
+4506
+cÚ¡ªt_key
+,
+\96em\92t_size_shiá
+,
+ba£_off£t
+);
+
+4507 \1a
+ g\96em\92ts_k\9ad
+) {
+
+4508 \ 4
+ gEXTERNAL_UINT8_CLAMPED_ELEMENTS
+:
+
+4509 \ 4
+EXTERNAL_INT8_ELEMENTS
+:
+
+4510 \ 4
+EXTERNAL_UINT8_ELEMENTS
+:
+
+4511 \ 4
+UINT8_ELEMENTS
+:
+
+4512 \ 4
+UINT8_CLAMPED_ELEMENTS
+:
+
+4513 \ 4
+INT8_ELEMENTS
+:
+
+4514 ià(
+key_is_cÚ¡ªt
+) {
+
+4515
+__
+
+StÜeBy\8b
+(
+v®ue
+,
+mem_Ý\94ªd
+,
+r0
+);
+
+4517
+__
+
+¡bx
+(
+v®ue
+,
+mem_Ý\94ªd
+);
+
+4520 \ 4
+ gEXTERNAL_INT16_ELEMENTS
+:
+
+4521 \ 4
+EXTERNAL_UINT16_ELEMENTS
+:
+
+4522 \ 4
+INT16_ELEMENTS
+:
+
+4523 \ 4
+UINT16_ELEMENTS
+:
+
+4524 ià(
+key_is_cÚ¡ªt
+) {
+
+4525
+__
+
+StÜeH®fWÜd
+(
+v®ue
+,
+mem_Ý\94ªd
+,
+r0
+);
+
+4527
+__
+
+¡hx
+(
+v®ue
+,
+mem_Ý\94ªd
+);
+
+4530 \ 4
+ gEXTERNAL_INT32_ELEMENTS
+:
+
+4531 \ 4
+EXTERNAL_UINT32_ELEMENTS
+:
+
+4532 \ 4
+INT32_ELEMENTS
+:
+
+4533 \ 4
+UINT32_ELEMENTS
+:
+
+4534 ià(
+key_is_cÚ¡ªt
+) {
+
+4535
+__
+
+StÜeWÜd
+(
+v®ue
+,
+mem_Ý\94ªd
+,
+r0
+);
+
+4537
+__
+
+¡wx
+(
+v®ue
+,
+mem_Ý\94ªd
+);
+
+4540 \ 4
+ gFLOAT32_ELEMENTS
+:
+
+4541 \ 4
+FLOAT64_ELEMENTS
+:
+
+4542 \ 4
+EXTERNAL_FLOAT32_ELEMENTS
+:
+
+4543 \ 4
+EXTERNAL_FLOAT64_ELEMENTS
+:
+
+4544 \ 4
+FAST_DOUBLE_ELEMENTS
+:
+
+4545 \ 4
+FAST_ELEMENTS
+:
+
+4546 \ 4
+FAST_SMI_ELEMENTS
+:
+
+4547 \ 4
+FAST_HOLEY_DOUBLE_ELEMENTS
+:
+
+4548 \ 4
+FAST_HOLEY_ELEMENTS
+:
+
+4549 \ 4
+FAST_HOLEY_SMI_ELEMENTS
+:
+
+4550 \ 4
+DICTIONARY_ELEMENTS
+:
+
+4551 \ 4
+SLOPPY_ARGUMENTS_ELEMENTS
+:
+
+4552
+UNREACHABLE
+();
+
+4559 \1e
+ gLCodeG\92
+::
+DoStÜeKeyedFixedDoubËA¼ay
+(
+LStÜeKeyed
+*
+\9a¡r
+) {
+
+4560
+DoubËRegi¡\94
+
+v®ue
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->value());
+
+4561
+Regi¡\94
+
+ g\96em\92ts
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+4562
+Regi¡\94
+
+ gkey
+ =
+no_»g
+;
+
+4563
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+4564
+DoubËRegi¡\94
+
+ gdoubË_sü©ch
+ =
+doubË_sü©ch0
+();
+
+4565
+boÞ
+
+ gkey_is_cÚ¡ªt
+ =
+\9a¡r
+->
+key
+()->
+IsCÚ¡ªtO³¿nd
+();
+
+4566 \12
+ gcÚ¡ªt_key
+ = 0;
+
+4570 ià(
+ gkey_is_cÚ¡ªt
+) {
+
+4571
+ gcÚ¡ªt_key
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+key
+()));
+
+4572 ià(
+ gcÚ¡ªt_key
+ & 0xF0000000) {
+
+4573
+AbÜt
+(
+kA¼ayIndexCÚ¡ªtV®ueTooBig
+);
+
+4576
+ gkey
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+key
+());
+
+4578 \12
+ g\96em\92t_size_shiá
+ =
+EËm\92tsK\9adToShiáSize
+(
+FAST_DOUBLE_ELEMENTS
+);
+
+4579
+boÞ
+
+ gkey_is_smi
+ =
+\9a¡r
+->
+hydrog\92
+()->
+key
+()->
+»´e£Á©iÚ
+().
+IsSmi
+();
+
+4580 \12
+ gba£_off£t
+ =
+\9a¡r
+->
+ba£_off£t
+(è+
+cÚ¡ªt_key
+ *
+kDoubËSize
+;
+
+4581 ià(!
+ gkey_is_cÚ¡ªt
+) {
+
+4582
+__
+
+IndexToA¼ayOff£t
+(
+sü©ch
+,
+key
+,
+\96em\92t_size_shiá
+,
+key_is_smi
+);
+
+4583
+__
+
+add
+(
+sü©ch
+,
+\96em\92ts
+, scratch);
+
+4584
+ g\96em\92ts
+ =
+sü©ch
+;
+
+4586 ià(!
+is_\9at16
+(
+ba£_off£t
+)) {
+
+4587
+__
+
+Add
+(
+sü©ch
+,
+\96em\92ts
+,
+ba£_off£t
+,
+r0
+);
+
+4588
+ gba£_off£t
+ = 0;
+
+4589
+ g\96em\92ts
+ =
+sü©ch
+;
+
+4592 ià(
+ g\9a¡r
+->
+N\93dsCªÚiÿliz©iÚ
+()) {
+
+4594
+__
+
+CªÚiÿlizeNaN
+(
+doubË_sü©ch
+,
+v®ue
+);
+
+4595
+__
+
+¡fd
+(
+doubË_sü©ch
+,
+MemO³¿nd
+(
+\96em\92ts
+,
+ba£_off£t
+));
+
+4597
+__
+
+¡fd
+(
+v®ue
+,
+MemO³¿nd
+(
+\96em\92ts
+,
+ba£_off£t
+));
+
+4602 \1e
+ gLCodeG\92
+::
+DoStÜeKeyedFixedA¼ay
+(
+LStÜeKeyed
+*
+\9a¡r
+) {
+
+4603
+HStÜeKeyed
+*
+h\9a¡r
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+4604
+Regi¡\94
+
+ gv®ue
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+4605
+Regi¡\94
+
+ g\96em\92ts
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+4606
+Regi¡\94
+
+ gkey
+ =
+\9a¡r
+->
+key
+()->
+IsRegi¡\94
+(è?
+ToRegi¡\94
+(\9a¡r->key()è:
+no_»g
+;
+
+4607
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+4608
+Regi¡\94
+
+ g¡Üe_ba£
+ =
+sü©ch
+;
+
+4609 \12
+ goff£t
+ =
+\9a¡r
+->
+ba£_off£t
+();
+
+4612 ià(
+ g\9a¡r
+->
+key
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+4613
+DCHECK
+(!
+h\9a¡r
+->
+N\93dsWr\99eB¬r\9br
+());
+
+4614
+LCÚ¡ªtO³¿nd
+*
+ gcÚ¡_Ý\94ªd
+ = LCÚ¡ªtO³¿nd::
+ÿ¡
+(
+\9a¡r
+->
+key
+());
+
+4615
+ goff£t
+ +ð
+ToIÁeg\9432
+(
+cÚ¡_Ý\94ªd
+è*
+kPo\9a\8brSize
+;
+
+4616
+ g¡Üe_ba£
+ =
+\96em\92ts
+;
+
+4622 ià(
+ gh\9a¡r
+->
+key
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+4623
+__
+
+SmiToP\8cA¼ayOff£t
+(
+sü©ch
+,
+key
+);
+
+4625
+__
+
+ShiáLeáImm
+(
+sü©ch
+,
+key
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+4627
+__
+
+add
+(
+sü©ch
+,
+\96em\92ts
+, scratch);
+
+4630
+R\95»£Á©iÚ
+
+ g»´e£Á©iÚ
+ =
+h\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+();
+
+4632 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4634 ià(
+ g»´e£Á©iÚ
+.
+IsIÁeg\9432
+()) {
+
+4635
+DCHECK
+(
+h\9a¡r
+->
+¡Üe_mode
+(è=ð
+STORE_TO_INITIALIZED_ENTRY
+);
+
+4636
+DCHECK
+(
+h\9a¡r
+->
+\96em\92ts_k\9ad
+(è=ð
+FAST_SMI_ELEMENTS
+);
+
+4638
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+4639
+STATIC_ASSERT
+(
+kSmiTagSize
+ +
+kSmiShiáSize
+ == 32);
+
+4640 #ià
+V8_TARGET_LITTLE_ENDIAN
+
+
+4641
+ goff£t
+ +ð
+kPo\9a\8brSize
+ / 2;
+
+4646
+__
+
+StÜeR\95»£Á©iÚ
+(
+v®ue
+,
+MemO³¿nd
+(
+¡Üe_ba£
+,
+off£t
+),
+»´e£Á©iÚ
+,
+
+4647
+r0
+);
+
+4649 ià(
+ gh\9a¡r
+->
+N\93dsWr\99eB¬r\9br
+()) {
+
+4650
+SmiCheck
+
+ gcheck_Ãeded
+ =
+h\9a¡r
+->
+v®ue
+()->
+ty³
+().
+IsH\97pObjeù
+()
+
+4651 ?
+OMIT_SMI_CHECK
+
+
+4652 :
+INLINE_SMI_CHECK
+;
+
+4654
+__
+
+Add
+(
+key
+,
+¡Üe_ba£
+,
+off£t
+,
+r0
+);
+
+4655
+__
+
+RecÜdWr\99e
+(
+\96em\92ts
+,
+key
+,
+v®ue
+,
+G\91L\9akRegi¡\94S\8f\8b
+(),
+kSaveFPRegs
+,
+
+4656
+EMIT_REMEMBERED_SET
+,
+check_Ãeded
+,
+
+4657
+h\9a¡r
+->
+Po\9a\8brsToH\94eCheckFÜV®ue
+());
+
+4662 \1e
+ gLCodeG\92
+::
+DoStÜeKeyed
+(
+LStÜeKeyed
+*
+\9a¡r
+) {
+
+4664 ià(
+\9a¡r
+->
+is_ty³d_\96em\92ts
+()) {
+
+4665
+DoStÜeKeyedEx\8bº®A¼ay
+(
+\9a¡r
+);
+
+4666 } \vià(
+ g\9a¡r
+->
+hydrog\92
+()->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+()) {
+
+4667
+DoStÜeKeyedFixedDoubËA¼ay
+(
+\9a¡r
+);
+
+4669
+DoStÜeKeyedFixedA¼ay
+(
+\9a¡r
+);
+
+4674 \1e
+ gLCodeG\92
+::
+DoStÜeKeyedG\92\94ic
+(
+LStÜeKeyedG\92\94ic
+*
+\9a¡r
+) {
+
+4675
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+4676
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+objeù
+()).
+is
+(
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+()));
+
+4677
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+key
+()).
+is
+(
+StÜeDesü\9dtÜ
+::
+NameRegi¡\94
+()));
+
+4678
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+()).
+is
+(
+StÜeDesü\9dtÜ
+::
+V®ueRegi¡\94
+()));
+
+4680
+ gHªdË
+<
+ gCode
+>
+ gic
+ =
+
+4681
+CodeFaùÜy
+::
+KeyedStÜeIC
+(
+isީe
+(),
+\9a¡r
+->
+¡riù_mode
+()).
+code
+();
+
+4682
+C®lCode
+(
+ic
+,
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+4686 \1e
+ gLCodeG\92
+::
+DoT¿ns\99iÚEËm\92tsK\9ad
+(
+LT¿ns\99iÚEËm\92tsK\9ad
+*
+\9a¡r
+) {
+
+4687
+Regi¡\94
+
+objeù_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+objeù
+());
+
+4688
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+4690
+ gHªdË
+<
+ gM
+>
+ gäom_m
+ =
+\9a¡r
+->
+Üig\9a®_m
+();
+
+4691
+ gHªdË
+<
+ gM
+>
+ gto_m
+ =
+\9a¡r
+->
+\8cªs\99iÚed_m
+();
+
+4692
+EËm\92tsK\9ad
+
+ gäom_k\9ad
+ =
+\9a¡r
+->
+äom_k\9ad
+();
+
+4693
+EËm\92tsK\9ad
+
+ gto_k\9ad
+ =
+\9a¡r
+->
+to_k\9ad
+();
+
+4695
+Lab\96
+
+ gnÙ_¶iÿbË
+;
+
+4696
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+objeù_»g
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+4697
+__
+
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+äom_m
+),
+r0
+);
+
+4698
+__
+
+bÃ
+(&
+nÙ_¶iÿbË
+);
+
+4700 ià(
+IsSim¶eMChªgeT¿ns\99iÚ
+(
+äom_k\9ad
+,
+to_k\9ad
+)) {
+
+4701
+Regi¡\94
+
+ gÃw_m_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+Ãw_m_\8bmp
+());
+
+4702
+__
+
+mov
+(
+Ãw_m_»g
+,
+O³¿nd
+(
+to_m
+));
+
+4703
+__
+
+StÜeP
+(
+Ãw_m_»g
+,
+F\9bldMemO³¿nd
+(
+objeù_»g
+,
+H\97pObjeù
+::
+kMOff£t
+),
+
+4704
+r0
+);
+
+4706
+__
+
+RecÜdWr\99eFÜM
+(
+objeù_»g
+,
+Ãw_m_»g
+,
+sü©ch
+,
+
+4707
+G\91L\9akRegi¡\94S\8f\8b
+(),
+kDÚtSaveFPRegs
+);
+
+4709
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+4710
+DCHECK
+(
+objeù_»g
+.
+is
+(
+r3
+));
+
+4711
+PushSaãpo\9atRegi¡\94sScÝe
+
+scÝe
+(
+this
+);
+
+4712
+__
+
+Move
+(
+r4
+,
+to_m
+);
+
+4713
+boÞ
+
+ gis_js_¬¿y
+ =
+äom_m
+->
+\9a¡ªû_ty³
+(è=ð
+JS_ARRAY_TYPE
+;
+
+4714
+T¿ns\99iÚEËm\92tsK\9adStub
+
+¡ub
+(
+isީe
+(),
+äom_k\9ad
+,
+to_k\9ad
+,
+is_js_¬¿y
+);
+
+4715
+__
+
+C®lStub
+(&
+¡ub
+);
+
+4716
+RecÜdSaãpo\9atW\99hRegi¡\94s
+(
+\9a¡r
+->
+po\9a\8br_m
+(), 0,
+
+4717
+Saãpo\9at
+::
+kLazyDeÝt
+);
+
+4719
+__
+
+b\9ad
+(&
+nÙ_¶iÿbË
+);
+
+4723 \1e
+ gLCodeG\92
+::
+DoT¿pAÎoÿtiÚMem\92to
+(
+LT¿pAÎoÿtiÚMem\92to
+*
+\9a¡r
+) {
+
+4724
+Regi¡\94
+
+objeù
+ =
+ToRegi¡\94
+(
+\9a¡r
+->object());
+
+4725
+Regi¡\94
+
+ g\8bmp
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+4726
+Lab\96
+
+ gno_mem\92to_found
+;
+
+4727
+__
+
+Te¡JSA¼ayFÜAÎoÿtiÚMem\92to
+(
+objeù
+,
+\8bmp
+, &
+no_mem\92to_found
+);
+
+4728
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "memento found");
+
+4729
+__
+
+b\9ad
+(&
+no_mem\92to_found
+);
+
+4733 \1e
+ gLCodeG\92
+::
+DoS\8c\9agAdd
+(
+LS\8c\9agAdd
+*
+\9a¡r
+) {
+
+4734
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+4735
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+Ëá
+()).
+is
+(
+r4
+));
+
+4736
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+right
+()).
+is
+(
+r3
+));
+
+4737
+S\8c\9agAddStub
+
+¡ub
+(
+isީe
+(),
+\9a¡r
+->
+hydrog\92
+()->
+æags
+(),
+
+4738
+\9a¡r
+->
+hydrog\92
+()->
+´\91\92u»_æag
+());
+
+4739
+C®lCode
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+4743 \1e
+ gLCodeG\92
+::
+DoS\8c\9agCh¬CodeAt
+(
+LS\8c\9agCh¬CodeAt
+*
+\9a¡r
+) {
+
+4744 þas
+ cDeã¼edS\8c\9agCh¬CodeAt
+
+FINAL
+ :
+public
+
+LDeã¼edCode
+ {
+
+4745
+public
+:
+
+4746
+Deã¼edS\8c\9agCh¬CodeAt
+(
+LCodeG\92
+*
+codeg\92
+,
+LS\8c\9agCh¬CodeAt
+*
+\9a¡r
+)
+
+4747 :
+LDeã¼edCode
+(
+codeg\92
+),
+\9a¡r_
+(
+\9a¡r
+) {}
+
+4748
+v\9ctu®
+ \1e
+G\92\94©e
+(è
+ gOVERRIDE
+ {
+
+4749
+codeg\92
+()->
+DoDeã¼edS\8c\9agCh¬CodeAt
+(
+\9a¡r_
+);
+
+4751
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+(è
+ gOVERRIDE
+ { \15
+ g\9a¡r_
+; }
+
+4753
+ g´iv©e
+:
+
+4754
+LS\8c\9agCh¬CodeAt
+*
+\9a¡r_
+;
+
+4757
+Deã¼edS\8c\9agCh¬CodeAt
+*
+ gdeã¼ed
+ =
+
+4758
+Ãw
+ (
+zÚe
+()è
+Deã¼edS\8c\9agCh¬CodeAt
+(
+this
+,
+\9a¡r
+);
+
+4760
+ gS\8c\9agCh¬LßdG\92\94©Ü
+::
+G\92\94©e
+(
+
+4761
+masm
+(),
+ToRegi¡\94
+(
+\9a¡r
+->
+¡r\9ag
+()), ToRegi¡\94(\9a¡r->
+\9adex
+()),
+
+4762
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+()),
+deã¼ed
+->
+\92\8cy
+());
+
+4763
+__
+
+b\9ad
+(
+deã¼ed
+->
+ex\99
+());
+
+4767 \1e
+ gLCodeG\92
+::
+DoDeã¼edS\8c\9agCh¬CodeAt
+(
+LS\8c\9agCh¬CodeAt
+*
+\9a¡r
+) {
+
+4768
+Regi¡\94
+
+¡r\9ag
+ =
+ToRegi¡\94
+(
+\9a¡r
+->string());
+
+4769
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+4770
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+4775
+__
+
+li
+(
+»suÉ
+,
+O³¿nd
+::
+Z\94o
+());
+
+4777
+PushSaãpo\9atRegi¡\94sScÝe
+
+scÝe
+(
+this
+);
+
+4778
+__
+
+push
+(
+¡r\9ag
+);
+
+4781 ià(
+ g\9a¡r
+->
+\9adex
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+4782 \12
+ gcÚ¡_\9adex
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+\9adex
+()));
+
+4783
+__
+
+LßdSmiL\99\94®
+(
+sü©ch
+,
+Smi
+::
+FromIÁ
+(
+cÚ¡_\9adex
+));
+
+4784
+__
+
+push
+(
+sü©ch
+);
+
+4786
+Regi¡\94
+
+ g\9adex
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\9adex
+());
+
+4787
+__
+
+SmiTag
+(
+\9adex
+);
+
+4788
+__
+
+push
+(
+\9adex
+);
+
+4790
+C®lRuÁimeFromDeã¼ed
+(
+RuÁime
+::
+kS\8c\9agCh¬CodeAtRT
+, 2,
+\9a¡r
+,
+
+4791
+\9a¡r
+->
+cڋxt
+());
+
+4792
+__
+
+As£¹Smi
+(
+r3
+);
+
+4793
+__
+
+SmiUÁag
+(
+r3
+);
+
+4794
+__
+
+StÜeToSaãpo\9atRegi¡\94SlÙ
+(
+r3
+,
+»suÉ
+);
+
+4798 \1e
+ gLCodeG\92
+::
+DoS\8c\9agCh¬FromCode
+(
+LS\8c\9agCh¬FromCode
+*
+\9a¡r
+) {
+
+4799 þas
+ cDeã¼edS\8c\9agCh¬FromCode
+
+FINAL
+ :
+public
+
+LDeã¼edCode
+ {
+
+4800
+public
+:
+
+4801
+Deã¼edS\8c\9agCh¬FromCode
+(
+LCodeG\92
+*
+codeg\92
+,
+LS\8c\9agCh¬FromCode
+*
+\9a¡r
+)
+
+4802 :
+LDeã¼edCode
+(
+codeg\92
+),
+\9a¡r_
+(
+\9a¡r
+) {}
+
+4803
+v\9ctu®
+ \1e
+G\92\94©e
+(è
+ gOVERRIDE
+ {
+
+4804
+codeg\92
+()->
+DoDeã¼edS\8c\9agCh¬FromCode
+(
+\9a¡r_
+);
+
+4806
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+(è
+ gOVERRIDE
+ { \15
+ g\9a¡r_
+; }
+
+4808
+ g´iv©e
+:
+
+4809
+LS\8c\9agCh¬FromCode
+*
+\9a¡r_
+;
+
+4812
+Deã¼edS\8c\9agCh¬FromCode
+*
+ gdeã¼ed
+ =
+
+4813
+Ãw
+ (
+zÚe
+()è
+Deã¼edS\8c\9agCh¬FromCode
+(
+this
+,
+\9a¡r
+);
+
+4815
+DCHECK
+(
+\9a¡r
+->
+hydrog\92
+()->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsIÁeg\9432
+());
+
+4816
+Regi¡\94
+
+ gch¬_code
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+ch¬_code
+());
+
+4817
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+4818
+DCHECK
+(!
+ch¬_code
+.
+is
+(
+»suÉ
+));
+
+4820
+__
+
+cm¶i
+(
+ch¬_code
+,
+O³¿nd
+(
+S\8c\9ag
+::
+kMaxOÃBy\8bCh¬Code
+));
+
+4821
+__
+
+bgt
+(
+deã¼ed
+->
+\92\8cy
+());
+
+4822
+__
+
+LßdRoÙ
+(
+»suÉ
+,
+H\97p
+::
+kS\9agËCh¬aù\94S\8c\9agCacheRoÙIndex
+);
+
+4823
+__
+
+ShiáLeáImm
+(
+r0
+,
+ch¬_code
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+4824
+__
+
+add
+(
+»suÉ
+,\84esuÉ,
+r0
+);
+
+4825
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+ÔesuÉ,
+FixedA¼ay
+::
+kH\97d\94Size
+));
+
+4826
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+4827
+__
+
+cmp
+(
+»suÉ
+,
+\9d
+);
+
+4828
+__
+
+beq
+(
+deã¼ed
+->
+\92\8cy
+());
+
+4829
+__
+
+b\9ad
+(
+deã¼ed
+->
+ex\99
+());
+
+4833 \1e
+ gLCodeG\92
+::
+DoDeã¼edS\8c\9agCh¬FromCode
+(
+LS\8c\9agCh¬FromCode
+*
+\9a¡r
+) {
+
+4834
+Regi¡\94
+
+ch¬_code
+ =
+ToRegi¡\94
+(
+\9a¡r
+->char_code());
+
+4835
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+4840
+__
+
+li
+(
+»suÉ
+,
+O³¿nd
+::
+Z\94o
+());
+
+4842
+PushSaãpo\9atRegi¡\94sScÝe
+
+scÝe
+(
+this
+);
+
+4843
+__
+
+SmiTag
+(
+ch¬_code
+);
+
+4844
+__
+
+push
+(
+ch¬_code
+);
+
+4845
+C®lRuÁimeFromDeã¼ed
+(
+RuÁime
+::
+kCh¬FromCode
+, 1,
+\9a¡r
+, in¡r->
+cڋxt
+());
+
+4846
+__
+
+StÜeToSaãpo\9atRegi¡\94SlÙ
+(
+r3
+,
+»suÉ
+);
+
+4850 \1e
+ gLCodeG\92
+::
+DoIÁeg\9432ToDoubË
+(
+LIÁeg\9432ToDoubË
+*
+\9a¡r
+) {
+
+4851
+LO³¿nd
+*
+\9aput
+ =
+\9a¡r
+->
+v®ue
+();
+
+4852
+DCHECK
+(
+\9aput
+->
+IsRegi¡\94
+(è|| iÅut->
+IsS\8fckSlÙ
+());
+
+4853
+LO³¿nd
+*
+ gou\8dut
+ =
+\9a¡r
+->
+»suÉ
+();
+
+4854
+DCHECK
+(
+ou\8dut
+->
+IsDoubËRegi¡\94
+());
+
+4855 ià(
+ g\9aput
+->
+IsS\8fckSlÙ
+()) {
+
+4856
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+4857
+__
+
+LßdP
+(
+sü©ch
+,
+ToMemO³¿nd
+(
+\9aput
+));
+
+4858
+__
+
+CÚv\94tIÁToDoubË
+(
+sü©ch
+,
+ToDoubËRegi¡\94
+(
+ou\8dut
+));
+
+4860
+__
+
+CÚv\94tIÁToDoubË
+(
+ToRegi¡\94
+(
+\9aput
+),
+ToDoubËRegi¡\94
+(
+ou\8dut
+));
+
+4865 \1e
+ gLCodeG\92
+::
+DoU\9at32ToDoubË
+(
+LU\9at32ToDoubË
+*
+\9a¡r
+) {
+
+4866
+LO³¿nd
+*
+\9aput
+ =
+\9a¡r
+->
+v®ue
+();
+
+4867
+LO³¿nd
+*
+ gou\8dut
+ =
+\9a¡r
+->
+»suÉ
+();
+
+4868
+__
+
+CÚv\94tUnsigÃdIÁToDoubË
+(
+ToRegi¡\94
+(
+\9aput
+),
+ToDoubËRegi¡\94
+(
+ou\8dut
+));
+
+4872 \1e
+ gLCodeG\92
+::
+DoNumb\94TagI
+(
+LNumb\94TagI
+*
+\9a¡r
+) {
+
+4873 þas
+ cDeã¼edNumb\94TagI
+
+FINAL
+ :
+public
+
+LDeã¼edCode
+ {
+
+4874
+public
+:
+
+4875
+Deã¼edNumb\94TagI
+(
+LCodeG\92
+*
+codeg\92
+,
+LNumb\94TagI
+*
+\9a¡r
+)
+
+4876 :
+LDeã¼edCode
+(
+codeg\92
+),
+\9a¡r_
+(
+\9a¡r
+) {}
+
+4877
+v\9ctu®
+ \1e
+G\92\94©e
+(è
+ gOVERRIDE
+ {
+
+4878
+codeg\92
+()->
+DoDeã¼edNumb\94TagIU
+(
+\9a¡r_
+, in¡r_->
+v®ue
+(), in¡r_->
+\8bmp1
+(),
+
+4879
+\9a¡r_
+->
+\8bmp2
+(),
+SIGNED_INT32
+);
+
+4881
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+(è
+ gOVERRIDE
+ { \15
+ g\9a¡r_
+; }
+
+4883
+ g´iv©e
+:
+
+4884
+LNumb\94TagI
+*
+\9a¡r_
+;
+
+4887
+Regi¡\94
+
+ g¤c
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+4888
+Regi¡\94
+
+ gd¡
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+4890
+Deã¼edNumb\94TagI
+*
+ gdeã¼ed
+ =
+Ãw
+ (
+zÚe
+()èDeã¼edNumb\94TagI(
+this
+,
+\9a¡r
+);
+
+4891 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4892
+__
+
+SmiTag
+(
+d¡
+,
+¤c
+);
+
+4894
+__
+
+SmiTagCheckOv\94æow
+(
+d¡
+,
+¤c
+,
+r0
+);
+
+4895
+__
+
+B¿nchOnOv\94æow
+(
+deã¼ed
+->
+\92\8cy
+());
+
+4897
+__
+
+b\9ad
+(
+deã¼ed
+->
+ex\99
+());
+
+4901 \1e
+ gLCodeG\92
+::
+DoNumb\94TagU
+(
+LNumb\94TagU
+*
+\9a¡r
+) {
+
+4902 þas
+ cDeã¼edNumb\94TagU
+
+FINAL
+ :
+public
+
+LDeã¼edCode
+ {
+
+4903
+public
+:
+
+4904
+Deã¼edNumb\94TagU
+(
+LCodeG\92
+*
+codeg\92
+,
+LNumb\94TagU
+*
+\9a¡r
+)
+
+4905 :
+LDeã¼edCode
+(
+codeg\92
+),
+\9a¡r_
+(
+\9a¡r
+) {}
+
+4906
+v\9ctu®
+ \1e
+G\92\94©e
+(è
+ gOVERRIDE
+ {
+
+4907
+codeg\92
+()->
+DoDeã¼edNumb\94TagIU
+(
+\9a¡r_
+, in¡r_->
+v®ue
+(), in¡r_->
+\8bmp1
+(),
+
+4908
+\9a¡r_
+->
+\8bmp2
+(),
+UNSIGNED_INT32
+);
+
+4910
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+(è
+ gOVERRIDE
+ { \15
+ g\9a¡r_
+; }
+
+4912
+ g´iv©e
+:
+
+4913
+LNumb\94TagU
+*
+\9a¡r_
+;
+
+4916
+Regi¡\94
+
+ g\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+4917
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+4919
+Deã¼edNumb\94TagU
+*
+ gdeã¼ed
+ =
+Ãw
+ (
+zÚe
+()èDeã¼edNumb\94TagU(
+this
+,
+\9a¡r
+);
+
+4920
+__
+
+Cm¶i
+(
+\9aput
+,
+O³¿nd
+(
+Smi
+::
+kMaxV®ue
+),
+r0
+);
+
+4921
+__
+
+bgt
+(
+deã¼ed
+->
+\92\8cy
+());
+
+4922
+__
+
+SmiTag
+(
+»suÉ
+,
+\9aput
+);
+
+4923
+__
+
+b\9ad
+(
+deã¼ed
+->
+ex\99
+());
+
+4927 \1e
+ gLCodeG\92
+::
+DoDeã¼edNumb\94TagIU
+(
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+LO³¿nd
+*
+v®ue
+,
+
+4928
+LO³¿nd
+*
+\8bmp1
+, LO³¿nd*
+\8bmp2
+,
+
+4929
+IÁeg\94SigÃdÃss
+
+sigÃdÃss
+) {
+
+4930
+Lab\96
+
+ gdÚe
+,
+ g¦ow
+;
+
+4931
+Regi¡\94
+
+ g¤c
+ =
+ToRegi¡\94
+(
+v®ue
+);
+
+4932
+Regi¡\94
+
+ gd¡
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+4933
+Regi¡\94
+
+ gtmp1
+ =
+sü©ch0
+();
+
+4934
+Regi¡\94
+
+ gtmp2
+ =
+ToRegi¡\94
+(
+\8bmp1
+);
+
+4935
+Regi¡\94
+
+ gtmp3
+ =
+ToRegi¡\94
+(
+\8bmp2
+);
+
+4936
+DoubËRegi¡\94
+
+ gdbl_sü©ch
+ =
+doubË_sü©ch0
+();
+
+4938 ià(
+ gsigÃdÃss
+ =ð
+SIGNED_INT32
+) {
+
+4942 ià(
+d¡
+.
+is
+(
+¤c
+)) {
+
+4943
+__
+
+SmiUÁag
+(
+¤c
+,
+d¡
+);
+
+4944
+__
+
+xÜis
+(
+¤c
+, src,
+O³¿nd
+(
+H\97pNumb\94
+::
+kSignMask
+ >> 16));
+
+4946
+__
+
+CÚv\94tIÁToDoubË
+(
+¤c
+,
+dbl_sü©ch
+);
+
+4948
+__
+
+CÚv\94tUnsigÃdIÁToDoubË
+(
+¤c
+,
+dbl_sü©ch
+);
+
+4951 ià(
+ gFLAG_\9al\9ae_Ãw
+) {
+
+4952
+__
+
+LßdRoÙ
+(
+tmp3
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+4953
+__
+
+AÎoÿ\8bH\97pNumb\94
+(
+d¡
+,
+tmp1
+,
+tmp2
+,
+tmp3
+, &
+¦ow
+);
+
+4954
+__
+
+b
+(&
+dÚe
+);
+
+4958
+__
+
+b\9ad
+(&
+¦ow
+);
+
+4963
+__
+
+li
+(
+d¡
+,
+O³¿nd
+::
+Z\94o
+());
+
+4966
+PushSaãpo\9atRegi¡\94sScÝe
+
+scÝe
+(
+this
+);
+
+4973
+__
+
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+4974
+__
+
+C®lRuÁimeSaveDoubËs
+(
+RuÁime
+::
+kAÎoÿ\8bH\97pNumb\94
+);
+
+4975
+RecÜdSaãpo\9atW\99hRegi¡\94s
+(
+\9a¡r
+->
+po\9a\8br_m
+(), 0,
+
+4976
+Saãpo\9at
+::
+kNoLazyDeÝt
+);
+
+4977
+__
+
+StÜeToSaãpo\9atRegi¡\94SlÙ
+(
+r3
+,
+d¡
+);
+
+4982
+__
+
+b\9ad
+(&
+dÚe
+);
+
+4983
+__
+
+¡fd
+(
+dbl_sü©ch
+,
+F\9bldMemO³¿nd
+(
+d¡
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+4987 \1e
+ gLCodeG\92
+::
+DoNumb\94TagD
+(
+LNumb\94TagD
+*
+\9a¡r
+) {
+
+4988 þas
+ cDeã¼edNumb\94TagD
+
+FINAL
+ :
+public
+
+LDeã¼edCode
+ {
+
+4989
+public
+:
+
+4990
+Deã¼edNumb\94TagD
+(
+LCodeG\92
+*
+codeg\92
+,
+LNumb\94TagD
+*
+\9a¡r
+)
+
+4991 :
+LDeã¼edCode
+(
+codeg\92
+),
+\9a¡r_
+(
+\9a¡r
+) {}
+
+4992
+v\9ctu®
+ \1e
+G\92\94©e
+(è
+ gOVERRIDE
+ {
+
+4993
+codeg\92
+()->
+DoDeã¼edNumb\94TagD
+(
+\9a¡r_
+);
+
+4995
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+(è
+ gOVERRIDE
+ { \15
+ g\9a¡r_
+; }
+
+4997
+ g´iv©e
+:
+
+4998
+LNumb\94TagD
+*
+\9a¡r_
+;
+
+5001
+DoubËRegi¡\94
+
+ g\9aput_»g
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+5002
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+5003
+Regi¡\94
+
+ g»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+5004
+Regi¡\94
+
+ g\8bmp1
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+5005
+Regi¡\94
+
+ g\8bmp2
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp2
+());
+
+5007
+Deã¼edNumb\94TagD
+*
+ gdeã¼ed
+ =
+Ãw
+ (
+zÚe
+()èDeã¼edNumb\94TagD(
+this
+,
+\9a¡r
+);
+
+5008 ià(
+ gFLAG_\9al\9ae_Ãw
+) {
+
+5009
+__
+
+LßdRoÙ
+(
+sü©ch
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+5010
+__
+
+AÎoÿ\8bH\97pNumb\94
+(
+»g
+,
+\8bmp1
+,
+\8bmp2
+,
+sü©ch
+,
+deã¼ed
+->
+\92\8cy
+());
+
+5012
+__
+
+b
+(
+deã¼ed
+->
+\92\8cy
+());
+
+5014
+__
+
+b\9ad
+(
+deã¼ed
+->
+ex\99
+());
+
+5015
+__
+
+¡fd
+(
+\9aput_»g
+,
+F\9bldMemO³¿nd
+(
+»g
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+5019 \1e
+ gLCodeG\92
+::
+DoDeã¼edNumb\94TagD
+(
+LNumb\94TagD
+*
+\9a¡r
+) {
+
+5023
+Regi¡\94
+
+»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+5024
+__
+
+li
+(
+»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+5026
+PushSaãpo\9atRegi¡\94sScÝe
+
+scÝe
+(
+this
+);
+
+5032
+__
+
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+5033
+__
+
+C®lRuÁimeSaveDoubËs
+(
+RuÁime
+::
+kAÎoÿ\8bH\97pNumb\94
+);
+
+5034
+RecÜdSaãpo\9atW\99hRegi¡\94s
+(
+\9a¡r
+->
+po\9a\8br_m
+(), 0,
+
+5035
+Saãpo\9at
+::
+kNoLazyDeÝt
+);
+
+5036
+__
+
+StÜeToSaãpo\9atRegi¡\94SlÙ
+(
+r3
+,
+»g
+);
+
+5040 \1e
+ gLCodeG\92
+::
+DoSmiTag
+(
+LSmiTag
+*
+\9a¡r
+) {
+
+5041
+HChªge
+*
+hchªge
+ =
+\9a¡r
+->
+hydrog\92
+();
+
+5042
+Regi¡\94
+
+ g\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+5043
+Regi¡\94
+
+ gou\8dut
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+5044 ià(
+ ghchªge
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+) &&
+
+5045
+hchªge
+->
+v®ue
+()->
+CheckFÏg
+(
+HV®ue
+::
+kU\9at32
+)) {
+
+5046
+__
+
+Te¡UnsigÃdSmiCªdid©e
+(
+\9aput
+,
+r0
+);
+
+5047
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "ov\94æow",
+ü0
+);
+
+5049 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+5050 ià(
+ ghchªge
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+) &&
+
+5051 !
+hchªge
+->
+v®ue
+()->
+CheckFÏg
+(
+HV®ue
+::
+kU\9at32
+)) {
+
+5052
+__
+
+SmiTagCheckOv\94æow
+(
+ou\8dut
+,
+\9aput
+,
+r0
+);
+
+5053
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "ov\94æow",
+ü0
+);
+
+5056
+__
+
+SmiTag
+(
+ou\8dut
+,
+\9aput
+);
+
+5057 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+5063 \1e
+ gLCodeG\92
+::
+DoSmiUÁag
+(
+LSmiUÁag
+*
+\9a¡r
+) {
+
+5064
+Regi¡\94
+
+sü©ch
+ =
+sü©ch0
+();
+
+5065
+Regi¡\94
+
+ g\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+5066
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+5067 ià(
+ g\9a¡r
+->
+Ãeds_check
+()) {
+
+5068
+STATIC_ASSERT
+(
+kH\97pObjeùTag
+ == 1);
+
+5070
+__
+
+ªdi
+(
+sü©ch
+,
+\9aput
+,
+O³¿nd
+(
+kH\97pObjeùTag
+));
+
+5071
+__
+
+SmiUÁag
+(
+»suÉ
+,
+\9aput
+);
+
+5072
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "nه Smi",
+ü0
+);
+
+5074
+__
+
+SmiUÁag
+(
+»suÉ
+,
+\9aput
+);
+
+5079 \1e
+ gLCodeG\92
+::
+Em\99Numb\94UÁagD
+(
+LNumb\94UÁagD
+*
+\9a¡r
+,
+Regi¡\94
+
+\9aput_»g
+,
+
+5080
+DoubËRegi¡\94
+
+»suÉ_»g
+,
+
+5081
+Numb\94UÁagDMode
+
+mode
+) {
+
+5082
+boÞ
+
+ gÿn_cÚv\94t_undef\9aed_to_Çn
+ =
+
+5083
+\9a¡r
+->
+hydrog\92
+()->
+ÿn_cÚv\94t_undef\9aed_to_Çn
+();
+
+5084
+boÞ
+
+ gdeÝtimize_Ú_m\9aus_z\94o
+ =
+\9a¡r
+->
+hydrog\92
+()->
+deÝtimize_Ú_m\9aus_z\94o
+();
+
+5086
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+5087
+DCHECK
+(!
+»suÉ_»g
+.
+is
+(
+doubË_sü©ch0
+()));
+
+5089
+Lab\96
+
+ gcÚv\94t
+,
+ glßd_smi
+,
+ gdÚe
+;
+
+5091 ià(
+ gmode
+ =ð
+NUMBER_CANDIDATE_IS_ANY_TAGGED
+) {
+
+5093
+__
+
+UÁagAndJumpIfSmi
+(
+sü©ch
+,
+\9aput_»g
+, &
+lßd_smi
+);
+
+5096
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+\9aput_»g
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+5097
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+5098
+__
+
+cmp
+(
+sü©ch
+,
+\9d
+);
+
+5099 ià(
+ gÿn_cÚv\94t_undef\9aed_to_Çn
+) {
+
+5100
+__
+
+bÃ
+(&
+cÚv\94t
+);
+
+5102
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "not\87 heap\82umber");
+
+5105
+__
+
+lfd
+(
+»suÉ_»g
+,
+F\9bldMemO³¿nd
+(
+\9aput_»g
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+5106 ià(
+ gdeÝtimize_Ú_m\9aus_z\94o
+) {
+
+5107 #ià
+V8_TARGET_ARCH_PPC64
+
+
+5108
+__
+
+MovDoubËToIÁ64
+(
+sü©ch
+,
+»suÉ_»g
+);
+
+5110
+__
+
+¾diþ
+(
+sü©ch
+, scratch, 1, 0);
+
+5111
+__
+
+cmpi
+(
+sü©ch
+,
+O³¿nd
+(1));
+
+5113
+__
+
+MovDoubËToIÁ64
+(
+sü©ch
+,
+\9d
+,
+»suÉ_»g
+);
+
+5114
+__
+
+cmpi
+(
+\9d
+,
+O³¿nd
+::
+Z\94o
+());
+
+5115
+__
+
+bÃ
+(&
+dÚe
+);
+
+5116
+__
+
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+H\97pNumb\94
+::
+kSignMask
+),
+r0
+);
+
+5118
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "minus zero");
+
+5120
+__
+
+b
+(&
+dÚe
+);
+
+5121 ià(
+ gÿn_cÚv\94t_undef\9aed_to_Çn
+) {
+
+5122
+__
+
+b\9ad
+(&
+cÚv\94t
+);
+
+5124
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+5125
+__
+
+cmp
+(
+\9aput_»g
+,
+\9d
+);
+
+5126
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "not\87 heap\82umber/undefined");
+
+5127
+__
+
+LßdRoÙ
+(
+sü©ch
+,
+H\97p
+::
+kNªV®ueRoÙIndex
+);
+
+5128
+__
+
+lfd
+(
+»suÉ_»g
+,
+F\9bldMemO³¿nd
+(
+sü©ch
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+5129
+__
+
+b
+(&
+dÚe
+);
+
+5132
+__
+
+SmiUÁag
+(
+sü©ch
+,
+\9aput_»g
+);
+
+5133
+DCHECK
+(
+mode
+ =ð
+NUMBER_CANDIDATE_IS_SMI
+);
+
+5136
+__
+
+b\9ad
+(&
+lßd_smi
+);
+
+5138
+__
+
+CÚv\94tIÁToDoubË
+(
+sü©ch
+,
+»suÉ_»g
+);
+
+5139
+__
+
+b\9ad
+(&
+dÚe
+);
+
+5143 \1e
+ gLCodeG\92
+::
+DoDeã¼edTaggedToI
+(
+LTaggedToI
+*
+\9a¡r
+) {
+
+5144
+Regi¡\94
+
+\9aput_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+5145
+Regi¡\94
+
+ gsü©ch1
+ =
+sü©ch0
+();
+
+5146
+Regi¡\94
+
+ gsü©ch2
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+5147
+DoubËRegi¡\94
+
+ gdoubË_sü©ch
+ =
+doubË_sü©ch0
+();
+
+5148
+DoubËRegi¡\94
+
+ gdoubË_sü©ch2
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+\8bmp2
+());
+
+5150
+DCHECK
+(!
+sü©ch1
+.
+is
+(
+\9aput_»g
+è&& !sü©ch1.is(
+sü©ch2
+));
+
+5151
+DCHECK
+(!
+sü©ch2
+.
+is
+(
+\9aput_»g
+è&& !sü©ch2.is(
+sü©ch1
+));
+
+5153
+Lab\96
+
+ gdÚe
+;
+
+5156
+__
+
+LßdP
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(
+\9aput_»g
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+5157
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+5158
+__
+
+cmp
+(
+sü©ch1
+,
+\9d
+);
+
+5160 ià(
+ g\9a¡r
+->
+\8cunÿt\9ag
+()) {
+
+5163
+Lab\96
+
+ gno_h\97p_numb\94
+,
+ gcheck_boÞs
+,
+ gcheck_çl£
+;
+
+5164
+__
+
+bÃ
+(&
+no_h\97p_numb\94
+);
+
+5165
+__
+
+mr
+(
+sü©ch2
+,
+\9aput_»g
+);
+
+5166
+__
+
+Trunÿ\8bH\97pNumb\94ToI
+(
+\9aput_»g
+,
+sü©ch2
+);
+
+5167
+__
+
+b
+(&
+dÚe
+);
+
+5171
+__
+
+b\9ad
+(&
+no_h\97p_numb\94
+);
+
+5172
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+5173
+__
+
+cmp
+(
+\9aput_»g
+,
+\9d
+);
+
+5174
+__
+
+bÃ
+(&
+check_boÞs
+);
+
+5175
+__
+
+li
+(
+\9aput_»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+5176
+__
+
+b
+(&
+dÚe
+);
+
+5178
+__
+
+b\9ad
+(&
+check_boÞs
+);
+
+5179
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+5180
+__
+
+cmp
+(
+\9aput_»g
+,
+\9d
+);
+
+5181
+__
+
+bÃ
+(&
+check_çl£
+);
+
+5182
+__
+
+li
+(
+\9aput_»g
+,
+O³¿nd
+(1));
+
+5183
+__
+
+b
+(&
+dÚe
+);
+
+5185
+__
+
+b\9ad
+(&
+check_çl£
+);
+
+5186
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kF®£V®ueRoÙIndex
+);
+
+5187
+__
+
+cmp
+(
+\9aput_»g
+,
+\9d
+);
+
+5188
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "nÙ\87 h\97°numb\94/undef\9aed/\8cue/çl£",
+ü7
+);
+
+5189
+__
+
+li
+(
+\9aput_»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+5191
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "nÙ\87 h\97°numb\94",
+ü7
+);
+
+5193
+__
+
+lfd
+(
+doubË_sü©ch2
+,
+
+5194
+F\9bldMemO³¿nd
+(
+\9aput_»g
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+5195 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+5197
+__
+
+mr
+(
+sü©ch2
+,
+\9aput_»g
+);
+
+5199
+__
+
+TryDoubËToIÁ32Exaù
+(
+\9aput_»g
+,
+doubË_sü©ch2
+,
+sü©ch1
+,
+
+5200
+doubË_sü©ch
+);
+
+5201
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "lo¡\85»cisiÚ o¸NaN",
+ü7
+);
+
+5203 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+5204
+__
+
+cmpi
+(
+\9aput_»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+5205
+__
+
+bÃ
+(&
+dÚe
+);
+
+5206
+__
+
+lwz
+(
+sü©ch1
+,
+
+5207
+F\9bldMemO³¿nd
+(
+sü©ch2
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+ +
+
+5208
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+5209
+__
+
+cmpwi
+(
+sü©ch1
+,
+O³¿nd
+::
+Z\94o
+());
+
+5210
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "m\9au z\94o",
+ü7
+);
+
+5213
+__
+
+b\9ad
+(&
+dÚe
+);
+
+5217 \1e
+ gLCodeG\92
+::
+DoTaggedToI
+(
+LTaggedToI
+*
+\9a¡r
+) {
+
+5218 þas
+ cDeã¼edTaggedToI
+
+FINAL
+ :
+public
+
+LDeã¼edCode
+ {
+
+5219
+public
+:
+
+5220
+Deã¼edTaggedToI
+(
+LCodeG\92
+*
+codeg\92
+,
+LTaggedToI
+*
+\9a¡r
+)
+
+5221 :
+LDeã¼edCode
+(
+codeg\92
+),
+\9a¡r_
+(
+\9a¡r
+) {}
+
+5222
+v\9ctu®
+ \1e
+G\92\94©e
+(è
+ gOVERRIDE
+ {
+codeg\92
+()->
+DoDeã¼edTaggedToI
+(
+\9a¡r_
+); }
+
+5223
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+(è
+ gOVERRIDE
+ { \15
+ g\9a¡r_
+; }
+
+5225
+ g´iv©e
+:
+
+5226
+LTaggedToI
+*
+\9a¡r_
+;
+
+5229
+LO³¿nd
+*
+ g\9aput
+ =
+\9a¡r
+->
+v®ue
+();
+
+5230
+DCHECK
+(
+\9aput
+->
+IsRegi¡\94
+());
+
+5231
+DCHECK
+(
+\9aput
+->
+Equ®s
+(
+\9a¡r
+->
+»suÉ
+()));
+
+5233
+Regi¡\94
+
+ g\9aput_»g
+ =
+ToRegi¡\94
+(
+\9aput
+);
+
+5235 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsSmi
+()) {
+
+5236
+__
+
+SmiUÁag
+(
+\9aput_»g
+);
+
+5238
+Deã¼edTaggedToI
+*
+ gdeã¼ed
+ =
+Ãw
+ (
+zÚe
+()èDeã¼edTaggedToI(
+this
+,
+\9a¡r
+);
+
+5241
+__
+
+JumpIfNÙSmi
+(
+\9aput_»g
+,
+deã¼ed
+->
+\92\8cy
+());
+
+5243
+__
+
+SmiUÁag
+(
+\9aput_»g
+);
+
+5244
+__
+
+b\9ad
+(
+deã¼ed
+->
+ex\99
+());
+
+5249 \1e
+ gLCodeG\92
+::
+DoNumb\94UÁagD
+(
+LNumb\94UÁagD
+*
+\9a¡r
+) {
+
+5250
+LO³¿nd
+*
+\9aput
+ =
+\9a¡r
+->
+v®ue
+();
+
+5251
+DCHECK
+(
+\9aput
+->
+IsRegi¡\94
+());
+
+5252
+LO³¿nd
+*
+ g»suÉ
+ =
+\9a¡r
+->
+»suÉ
+();
+
+5253
+DCHECK
+(
+»suÉ
+->
+IsDoubËRegi¡\94
+());
+
+5255
+Regi¡\94
+
+ g\9aput_»g
+ =
+ToRegi¡\94
+(
+\9aput
+);
+
+5256
+DoubËRegi¡\94
+
+ g»suÉ_»g
+ =
+ToDoubËRegi¡\94
+(
+»suÉ
+);
+
+5258
+HV®ue
+*
+ gv®ue
+ =
+\9a¡r
+->
+hydrog\92
+()->
+v®ue
+();
+
+5259
+Numb\94UÁagDMode
+
+ gmode
+ =
+v®ue
+->
+»´e£Á©iÚ
+().
+IsSmi
+()
+
+5260 ?
+NUMBER_CANDIDATE_IS_SMI
+
+
+5261 :
+NUMBER_CANDIDATE_IS_ANY_TAGGED
+;
+
+5263
+Em\99Numb\94UÁagD
+(
+\9a¡r
+,
+\9aput_»g
+,
+»suÉ_»g
+,
+mode
+);
+
+5267 \1e
+ gLCodeG\92
+::
+DoDoubËToI
+(
+LDoubËToI
+*
+\9a¡r
+) {
+
+5268
+Regi¡\94
+
+»suÉ_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+5269
+Regi¡\94
+
+ gsü©ch1
+ =
+sü©ch0
+();
+
+5270
+DoubËRegi¡\94
+
+ gdoubË_\9aput
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+5271
+DoubËRegi¡\94
+
+ gdoubË_sü©ch
+ =
+doubË_sü©ch0
+();
+
+5273 ià(
+ g\9a¡r
+->
+\8cunÿt\9ag
+()) {
+
+5274
+__
+
+Trunÿ\8bDoubËToI
+(
+»suÉ_»g
+,
+doubË_\9aput
+);
+
+5276
+__
+
+TryDoubËToIÁ32Exaù
+(
+»suÉ_»g
+,
+doubË_\9aput
+,
+sü©ch1
+,
+
+5277
+doubË_sü©ch
+);
+
+5279
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "lost\85recision or NaN");
+
+5280 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+5281
+Lab\96
+
+dÚe
+;
+
+5282
+__
+
+cmpi
+(
+»suÉ_»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+5283
+__
+
+bÃ
+(&
+dÚe
+);
+
+5284 #ià
+V8_TARGET_ARCH_PPC64
+
+
+5285
+__
+
+MovDoubËToIÁ64
+(
+sü©ch1
+,
+doubË_\9aput
+);
+
+5287
+__
+
+MovDoubËHighToIÁ
+(
+sü©ch1
+,
+doubË_\9aput
+);
+
+5289
+__
+
+cmpi
+(
+sü©ch1
+,
+O³¿nd
+::
+Z\94o
+());
+
+5290
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "minus zero");
+
+5291
+__
+
+b\9ad
+(&
+dÚe
+);
+
+5297 \1e
+ gLCodeG\92
+::
+DoDoubËToSmi
+(
+LDoubËToSmi
+*
+\9a¡r
+) {
+
+5298
+Regi¡\94
+
+»suÉ_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+5299
+Regi¡\94
+
+ gsü©ch1
+ =
+sü©ch0
+();
+
+5300
+DoubËRegi¡\94
+
+ gdoubË_\9aput
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+5301
+DoubËRegi¡\94
+
+ gdoubË_sü©ch
+ =
+doubË_sü©ch0
+();
+
+5303 ià(
+ g\9a¡r
+->
+\8cunÿt\9ag
+()) {
+
+5304
+__
+
+Trunÿ\8bDoubËToI
+(
+»suÉ_»g
+,
+doubË_\9aput
+);
+
+5306
+__
+
+TryDoubËToIÁ32Exaù
+(
+»suÉ_»g
+,
+doubË_\9aput
+,
+sü©ch1
+,
+
+5307
+doubË_sü©ch
+);
+
+5309
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "lost\85recision or NaN");
+
+5310 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+5311
+Lab\96
+
+dÚe
+;
+
+5312
+__
+
+cmpi
+(
+»suÉ_»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+5313
+__
+
+bÃ
+(&
+dÚe
+);
+
+5314 #ià
+V8_TARGET_ARCH_PPC64
+
+
+5315
+__
+
+MovDoubËToIÁ64
+(
+sü©ch1
+,
+doubË_\9aput
+);
+
+5317
+__
+
+MovDoubËHighToIÁ
+(
+sü©ch1
+,
+doubË_\9aput
+);
+
+5319
+__
+
+cmpi
+(
+sü©ch1
+,
+O³¿nd
+::
+Z\94o
+());
+
+5320
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "minus zero");
+
+5321
+__
+
+b\9ad
+(&
+dÚe
+);
+
+5324 #ià
+V8_TARGET_ARCH_PPC64
+
+
+5325
+__
+
+SmiTag
+(
+»suÉ_»g
+);
+
+5327
+__
+
+SmiTagCheckOv\94æow
+(
+»suÉ_»g
+,
+r0
+);
+
+5328
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "ov\94æow",
+ü0
+);
+
+5333 \1e
+ gLCodeG\92
+::
+DoCheckSmi
+(
+LCheckSmi
+*
+\9a¡r
+) {
+
+5334
+LO³¿nd
+*
+\9aput
+ =
+\9a¡r
+->
+v®ue
+();
+
+5335
+__
+
+Te¡IfSmi
+(
+ToRegi¡\94
+(
+\9aput
+),
+r0
+);
+
+5336
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "nه Smi",
+ü0
+);
+
+5340 \1e
+ gLCodeG\92
+::
+DoCheckNÚSmi
+(
+LCheckNÚSmi
+*
+\9a¡r
+) {
+
+5341 ià(!
+\9a¡r
+->
+hydrog\92
+()->
+v®ue
+()->
+ty³
+().
+IsH\97pObjeù
+()) {
+
+5342
+LO³¿nd
+*
+\9aput
+ =
+\9a¡r
+->
+v®ue
+();
+
+5343
+__
+
+Te¡IfSmi
+(
+ToRegi¡\94
+(
+\9aput
+),
+r0
+);
+
+5344
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "Smi",
+ü0
+);
+
+5349 \1e
+ gLCodeG\92
+::
+DoCheckIn¡ªûTy³
+(
+LCheckIn¡ªûTy³
+*
+\9a¡r
+) {
+
+5350
+Regi¡\94
+
+\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+5351
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+5353
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+\9aput
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+5354
+__
+
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+5356 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+is_\9a\8brv®_check
+()) {
+
+5357
+In¡ªûTy³
+
+ gf\9c¡
+;
+
+5358
+In¡ªûTy³
+
+ gϡ
+;
+
+5359
+ g\9a¡r
+->
+hydrog\92
+()->
+G\91CheckIÁ\94v®
+(&
+f\9c¡
+, &
+ϡ
+);
+
+5361
+__
+
+cm¶i
+(
+sü©ch
+,
+O³¿nd
+(
+f\9c¡
+));
+
+5364 ià(
+ gf\9c¡
+ =ð
+ϡ
+) {
+
+5365
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "wrong instance\81ype");
+
+5367
+DeÝtimizeIf
+(
+É
+,
+\9a¡r
+, "wrong instance\81ype");
+
+5369 ià(
+ gϡ
+ !ð
+LAST_TYPE
+) {
+
+5370
+__
+
+cm¶i
+(
+sü©ch
+,
+O³¿nd
+(
+ϡ
+));
+
+5371
+DeÝtimizeIf
+(
+gt
+,
+\9a¡r
+, "wrong instance\81ype");
+
+5375
+u\9at8_t
+
+ gmask
+;
+
+5376
+u\9at8_t
+
+ g\8fg
+;
+
+5377
+ g\9a¡r
+->
+hydrog\92
+()->
+G\91CheckMaskAndTag
+(&
+mask
+, &
+\8fg
+);
+
+5379 ià(
+ gba£
+::
+b\99s
+::
+IsPow\94OfTwo32
+(
+mask
+)) {
+
+5380
+DCHECK
+(
+\8fg
+ =ð0 ||
+ba£
+::
+b\99s
+::
+IsPow\94OfTwo32
+(tag));
+
+5381
+__
+
+ªdi
+(
+r0
+,
+sü©ch
+,
+O³¿nd
+(
+mask
+));
+
+5382
+DeÝtimizeIf
+(
+\8fg
+ =ð0 ?
+Ã
+ :
+eq
+,
+\9a¡r
+, "wrÚg in¡ªû\81y³",
+ü0
+);
+
+5384
+__
+
+ªdi
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+mask
+));
+
+5385
+__
+
+cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+\8fg
+));
+
+5386
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "wrong instance\81ype");
+
+5392 \1e
+ gLCodeG\92
+::
+DoCheckV®ue
+(
+LCheckV®ue
+*
+\9a¡r
+) {
+
+5393
+Regi¡\94
+
+»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+5394
+ gHªdË
+<
+ gH\97pObjeù
+>
+ gobjeù
+ =
+\9a¡r
+->
+hydrog\92
+()->
+objeù
+().
+hªdË
+();
+
+5395
+AÎowDeã¼edHªdËD\94eã»nû
+
+ gsmi_check
+;
+
+5396 ià(
+isީe
+()->
+h\97p
+()->
+InNewS·û
+(*
+objeù
+)) {
+
+5397
+Regi¡\94
+
+ g»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+5398
+ gHªdË
+<
+ gC\96l
+>
+ gûÎ
+ =
+isީe
+()->
+çùÜy
+()->
+NewC\96l
+(
+objeù
+);
+
+5399
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+HªdË
+<
+Objeù
+>(
+ûÎ
+)));
+
+5400
+__
+
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(\9d,
+C\96l
+::
+kV®ueOff£t
+));
+
+5401
+__
+
+cmp
+(
+»g
+,
+\9d
+);
+
+5403
+__
+
+Cmpi
+(
+»g
+,
+O³¿nd
+(
+objeù
+),
+r0
+);
+
+5405
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "value mismatch");
+
+5409 \1e
+ gLCodeG\92
+::
+DoDeã¼edIn¡ªûMig¿tiÚ
+(
+LCheckMs
+*
+\9a¡r
+,
+Regi¡\94
+
+objeù
+) {
+
+5411
+PushSaãpo\9atRegi¡\94sScÝe
+
+scÝe
+(
+this
+);
+
+5412
+__
+
+push
+(
+objeù
+);
+
+5413
+__
+
+li
+(
+ý
+,
+O³¿nd
+::
+Z\94o
+());
+
+5414
+__
+
+C®lRuÁimeSaveDoubËs
+(
+RuÁime
+::
+kTryMig¿\8bIn¡ªû
+);
+
+5415
+RecÜdSaãpo\9atW\99hRegi¡\94s
+(
+\9a¡r
+->
+po\9a\8br_m
+(), 1,
+
+5416
+Saãpo\9at
+::
+kNoLazyDeÝt
+);
+
+5417
+__
+
+StÜeToSaãpo\9atRegi¡\94SlÙ
+(
+r3
+,
+sü©ch0
+());
+
+5419
+__
+
+Te¡IfSmi
+(
+sü©ch0
+(),
+r0
+);
+
+5420
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "\9a¡ªû mig¿tiÚ fa\9eed",
+ü0
+);
+
+5424 \1e
+ gLCodeG\92
+::
+DoCheckMs
+(
+LCheckMs
+*
+\9a¡r
+) {
+
+5425 þas
+ cDeã¼edCheckMs
+
+FINAL
+ :
+public
+
+LDeã¼edCode
+ {
+
+5426
+public
+:
+
+5427
+Deã¼edCheckMs
+(
+LCodeG\92
+*
+codeg\92
+,
+LCheckMs
+*
+\9a¡r
+,
+Regi¡\94
+
+objeù
+)
+
+5428 :
+LDeã¼edCode
+(
+codeg\92
+),
+\9a¡r_
+(
+\9a¡r
+),
+objeù_
+(
+objeù
+) {
+
+5429
+S\91Ex\99
+(
+check_ms
+());
+
+5431
+v\9ctu®
+ \1e
+G\92\94©e
+(è
+ gOVERRIDE
+ {
+
+5432
+codeg\92
+()->
+DoDeã¼edIn¡ªûMig¿tiÚ
+(
+\9a¡r_
+,
+objeù_
+);
+
+5434
+Lab\96
+*
+check_ms
+(è{ \15 &
+ gcheck_ms_
+; }
+
+5435
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+(è
+ gOVERRIDE
+ { \15
+ g\9a¡r_
+; }
+
+5437
+ g´iv©e
+:
+
+5438
+LCheckMs
+*
+\9a¡r_
+;
+
+5439
+Lab\96
+
+ gcheck_ms_
+;
+
+5440
+Regi¡\94
+
+ gobjeù_
+;
+
+5443 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+IsS\8fb\9e\99yCheck
+()) {
+
+5444 cڡ
+ gUniqueS\91
+<
+ gM
+>*
+ gms
+ =
+\9a¡r
+->
+hydrog\92
+()->
+ms
+();
+
+5445 \ f\12
+ gi
+ = 0; i <
+ gms
+->
+size
+(); ++i) {
+
+5446
+AddS\8fb\9e\99yD\95\92d\92cy
+(
+ms
+->
+©
+(
+i
+).
+hªdË
+());
+
+5451
+Regi¡\94
+
+ gm_»g
+ =
+sü©ch0
+();
+
+5453
+LO³¿nd
+*
+ g\9aput
+ =
+\9a¡r
+->
+v®ue
+();
+
+5454
+DCHECK
+(
+\9aput
+->
+IsRegi¡\94
+());
+
+5455
+Regi¡\94
+
+ g»g
+ =
+ToRegi¡\94
+(
+\9aput
+);
+
+5457
+__
+
+LßdP
+(
+m_»g
+,
+F\9bldMemO³¿nd
+(
+»g
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+5459
+Deã¼edCheckMs
+*
+ gdeã¼ed
+ =
+NULL
+;
+
+5460 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+HasMig¿tiÚT¬g\91
+()) {
+
+5461
+ gdeã¼ed
+ =
+Ãw
+ (
+zÚe
+()è
+Deã¼edCheckMs
+(
+this
+,
+\9a¡r
+,
+»g
+);
+
+5462
+__
+
+b\9ad
+(
+deã¼ed
+->
+check_ms
+());
+
+5465 cڡ
+ gUniqueS\91
+<
+ gM
+>*
+ gms
+ =
+\9a¡r
+->
+hydrog\92
+()->
+ms
+();
+
+5466
+Lab\96
+
+ gsucûss
+;
+
+5467 \ f\12
+ gi
+ = 0; i <
+ gms
+->
+size
+() - 1; i++) {
+
+5468
+ gHªdË
+<
+ gM
+>
+ gm
+ =
+ms
+->
+©
+(
+i
+).
+hªdË
+();
+
+5469
+__
+
+Com·»M
+(
+m_»g
+,
+m
+, &
+sucûss
+);
+
+5470
+__
+
+beq
+(&
+sucûss
+);
+
+5473
+ gHªdË
+<
+ gM
+>
+ gm
+ =
+ms
+->
+©
+(ms->
+size
+(è- 1).
+hªdË
+();
+
+5474
+__
+
+Com·»M
+(
+m_»g
+,
+m
+, &
+sucûss
+);
+
+5475 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+HasMig¿tiÚT¬g\91
+()) {
+
+5476
+__
+
+bÃ
+(
+deã¼ed
+->
+\92\8cy
+());
+
+5478
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "wrong map");
+
+5481
+__
+
+b\9ad
+(&
+sucûss
+);
+
+5485 \1e
+ gLCodeG\92
+::
+DoCÏmpDToU\9at8
+(
+LCÏmpDToU\9at8
+*
+\9a¡r
+) {
+
+5486
+DoubËRegi¡\94
+
+v®ue_»g
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+unþam³d
+());
+
+5487
+Regi¡\94
+
+ g»suÉ_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+5488
+__
+
+CÏmpDoubËToU\9at8
+(
+»suÉ_»g
+,
+v®ue_»g
+,
+doubË_sü©ch0
+());
+
+5492 \1e
+ gLCodeG\92
+::
+DoCÏmpIToU\9at8
+(
+LCÏmpIToU\9at8
+*
+\9a¡r
+) {
+
+5493
+Regi¡\94
+
+unþam³d_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+unþam³d
+());
+
+5494
+Regi¡\94
+
+ g»suÉ_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+5495
+__
+
+CÏmpU\9at8
+(
+»suÉ_»g
+,
+unþam³d_»g
+);
+
+5499 \1e
+ gLCodeG\92
+::
+DoCÏmpTToU\9at8
+(
+LCÏmpTToU\9at8
+*
+\9a¡r
+) {
+
+5500
+Regi¡\94
+
+sü©ch
+ =
+sü©ch0
+();
+
+5501
+Regi¡\94
+
+ g\9aput_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+unþam³d
+());
+
+5502
+Regi¡\94
+
+ g»suÉ_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+5503
+DoubËRegi¡\94
+
+ g\8bmp_»g
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+5504
+Lab\96
+
+ gis_smi
+,
+ gdÚe
+,
+ gh\97p_numb\94
+;
+
+5507
+__
+
+UÁagAndJumpIfSmi
+(
+»suÉ_»g
+,
+\9aput_»g
+, &
+is_smi
+);
+
+5510
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+\9aput_»g
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+5511
+__
+
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+çùÜy
+()->
+h\97p_numb\94_m
+()),
+r0
+);
+
+5512
+__
+
+beq
+(&
+h\97p_numb\94
+);
+
+5516
+__
+
+Cmpi
+(
+\9aput_»g
+,
+O³¿nd
+(
+çùÜy
+()->
+undef\9aed_v®ue
+()),
+r0
+);
+
+5517
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "not\87 heap\82umber/undefined");
+
+5518
+__
+
+li
+(
+»suÉ_»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+5519
+__
+
+b
+(&
+dÚe
+);
+
+5522
+__
+
+b\9ad
+(&
+h\97p_numb\94
+);
+
+5523
+__
+
+lfd
+(
+\8bmp_»g
+,
+F\9bldMemO³¿nd
+(
+\9aput_»g
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+5524
+__
+
+CÏmpDoubËToU\9at8
+(
+»suÉ_»g
+,
+\8bmp_»g
+,
+doubË_sü©ch0
+());
+
+5525
+__
+
+b
+(&
+dÚe
+);
+
+5528
+__
+
+b\9ad
+(&
+is_smi
+);
+
+5529
+__
+
+CÏmpU\9at8
+(
+»suÉ_»g
+,\84esult_reg);
+
+5531
+__
+
+b\9ad
+(&
+dÚe
+);
+
+5535 \1e
+ gLCodeG\92
+::
+DoDoubËB\99s
+(
+LDoubËB\99s
+*
+\9a¡r
+) {
+
+5536
+DoubËRegi¡\94
+
+v®ue_»g
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+5537
+Regi¡\94
+
+ g»suÉ_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+5539 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+b\99s
+(è=ð
+HDoubËB\99s
+::
+HIGH
+) {
+
+5540
+__
+
+MovDoubËHighToIÁ
+(
+»suÉ_»g
+,
+v®ue_»g
+);
+
+5542
+__
+
+MovDoubËLowToIÁ
+(
+»suÉ_»g
+,
+v®ue_»g
+);
+
+5547 \1e
+ gLCodeG\92
+::
+DoCÚ¡ruùDoubË
+(
+LCÚ¡ruùDoubË
+*
+\9a¡r
+) {
+
+5548
+Regi¡\94
+
+hi_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+hi
+());
+
+5549
+Regi¡\94
+
+ glo_»g
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+lo
+());
+
+5550
+DoubËRegi¡\94
+
+ g»suÉ_»g
+ =
+ToDoubËRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+5551 #ià
+V8_TARGET_ARCH_PPC64
+
+
+5552
+__
+
+MovIÁ64CompÚ\92tsToDoubË
+(
+»suÉ_»g
+,
+hi_»g
+,
+lo_»g
+,
+r0
+);
+
+5554
+__
+
+MovIÁ64ToDoubË
+(
+»suÉ_»g
+,
+hi_»g
+,
+lo_»g
+);
+
+5559 \1e
+ gLCodeG\92
+::
+DoAÎoÿ\8b
+(
+LAÎoÿ\8b
+*
+\9a¡r
+) {
+
+5560 þas
+ cDeã¼edAÎoÿ\8b
+
+FINAL
+ :
+public
+
+LDeã¼edCode
+ {
+
+5561
+public
+:
+
+5562
+Deã¼edAÎoÿ\8b
+(
+LCodeG\92
+*
+codeg\92
+,
+LAÎoÿ\8b
+*
+\9a¡r
+)
+
+5563 :
+LDeã¼edCode
+(
+codeg\92
+),
+\9a¡r_
+(
+\9a¡r
+) {}
+
+5564
+v\9ctu®
+ \1e
+G\92\94©e
+(è
+ gOVERRIDE
+ {
+codeg\92
+()->
+DoDeã¼edAÎoÿ\8b
+(
+\9a¡r_
+); }
+
+5565
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+(è
+ gOVERRIDE
+ { \15
+ g\9a¡r_
+; }
+
+5567
+ g´iv©e
+:
+
+5568
+LAÎoÿ\8b
+*
+\9a¡r_
+;
+
+5571
+Deã¼edAÎoÿ\8b
+*
+ gdeã¼ed
+ =
+Ãw
+ (
+zÚe
+()èDeã¼edAÎoÿ\8b(
+this
+,
+\9a¡r
+);
+
+5573
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+5574
+Regi¡\94
+
+ gsü©ch
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp1
+());
+
+5575
+Regi¡\94
+
+ gsü©ch2
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp2
+());
+
+5578
+AÎoÿtiÚFÏgs
+
+ gæags
+ =
+TAG_OBJECT
+;
+
+5579 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+Mu¡AÎoÿ\8bDoubËAligÃd
+()) {
+
+5580
+ gæags
+ =
+¡©ic_ÿ¡
+<
+AÎoÿtiÚFÏgs
+>(
+æags
+ |
+DOUBLE_ALIGNMENT
+);
+
+5582 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+IsOldPo\9a\8brS·ûAÎoÿtiÚ
+()) {
+
+5583
+DCHECK
+(!
+\9a¡r
+->
+hydrog\92
+()->
+IsOldD©aS·ûAÎoÿtiÚ
+());
+
+5584
+DCHECK
+(!
+\9a¡r
+->
+hydrog\92
+()->
+IsNewS·ûAÎoÿtiÚ
+());
+
+5585
+ gæags
+ =
+¡©ic_ÿ¡
+<
+AÎoÿtiÚFÏgs
+>(
+æags
+ |
+PRETENURE_OLD_POINTER_SPACE
+);
+
+5586 } \vià(
+ g\9a¡r
+->
+hydrog\92
+()->
+IsOldD©aS·ûAÎoÿtiÚ
+()) {
+
+5587
+DCHECK
+(!
+\9a¡r
+->
+hydrog\92
+()->
+IsNewS·ûAÎoÿtiÚ
+());
+
+5588
+ gæags
+ =
+¡©ic_ÿ¡
+<
+AÎoÿtiÚFÏgs
+>(
+æags
+ |
+PRETENURE_OLD_DATA_SPACE
+);
+
+5591 ià(
+ g\9a¡r
+->
+size
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+5592
+\9at32_t
+
+ gsize
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+size
+()));
+
+5593 ià(
+ gsize
+ <ð
+Page
+::
+kMaxReguÏrH\97pObjeùSize
+) {
+
+5594
+__
+
+AÎoÿ\8b
+(
+size
+,
+»suÉ
+,
+sü©ch
+,
+sü©ch2
+,
+deã¼ed
+->
+\92\8cy
+(),
+æags
+);
+
+5596
+__
+
+b
+(
+deã¼ed
+->
+\92\8cy
+());
+
+5599
+Regi¡\94
+
+ gsize
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+size
+());
+
+5600
+__
+
+AÎoÿ\8b
+(
+size
+,
+»suÉ
+,
+sü©ch
+,
+sü©ch2
+,
+deã¼ed
+->
+\92\8cy
+(),
+æags
+);
+
+5603
+__
+
+b\9ad
+(
+deã¼ed
+->
+ex\99
+());
+
+5605 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+Mu¡P»f\9elW\99hF\9eËr
+()) {
+
+5606
+STATIC_ASSERT
+(
+kH\97pObjeùTag
+ == 1);
+
+5607 ià(
+ g\9a¡r
+->
+size
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+5608
+\9at32_t
+
+ gsize
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+size
+()));
+
+5609
+__
+
+LßdIÁL\99\94®
+(
+sü©ch
+,
+size
+ -
+kH\97pObjeùTag
+);
+
+5611
+__
+
+subi
+(
+sü©ch
+,
+ToRegi¡\94
+(
+\9a¡r
+->
+size
+()),
+O³¿nd
+(
+kH\97pObjeùTag
+));
+
+5613
+__
+
+mov
+(
+sü©ch2
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+Úe_po\9a\8br_f\9eËr_m
+()));
+
+5614
+Lab\96
+
+ gloÝ
+;
+
+5615
+__
+
+b\9ad
+(&
+loÝ
+);
+
+5616
+__
+
+subi
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+5617
+__
+
+StÜePX
+(
+sü©ch2
+,
+MemO³¿nd
+(
+»suÉ
+,
+sü©ch
+));
+
+5618
+__
+
+cmpi
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+5619
+__
+
+bge
+(&
+loÝ
+);
+
+5624 \1e
+ gLCodeG\92
+::
+DoDeã¼edAÎoÿ\8b
+(
+LAÎoÿ\8b
+*
+\9a¡r
+) {
+
+5625
+Regi¡\94
+
+»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->result());
+
+5630
+__
+
+LßdSmiL\99\94®
+(
+»suÉ
+,
+Smi
+::
+FromIÁ
+(0));
+
+5632
+PushSaãpo\9atRegi¡\94sScÝe
+
+scÝe
+(
+this
+);
+
+5633 ià(
+ g\9a¡r
+->
+size
+()->
+IsRegi¡\94
+()) {
+
+5634
+Regi¡\94
+
+ gsize
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+size
+());
+
+5635
+DCHECK
+(!
+size
+.
+is
+(
+»suÉ
+));
+
+5636
+__
+
+SmiTag
+(
+size
+);
+
+5637
+__
+
+push
+(
+size
+);
+
+5639
+\9at32_t
+
+ gsize
+ =
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+\9a¡r
+->
+size
+()));
+
+5640 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+5641 ià(
+ gsize
+ >ð0 &&
+size
+ <ð
+Smi
+::
+kMaxV®ue
+) {
+
+5643
+__
+
+Push
+(
+Smi
+::
+FromIÁ
+(
+size
+));
+
+5644 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+5647
+__
+
+¡Ý
+("invalid\87llocation size");
+
+5653 \12
+ gæags
+ =
+AÎoÿ\8bDoubËAlignFÏg
+::
+\92code
+(
+
+5654
+\9a¡r
+->
+hydrog\92
+()->
+Mu¡AÎoÿ\8bDoubËAligÃd
+());
+
+5655 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+IsOldPo\9a\8brS·ûAÎoÿtiÚ
+()) {
+
+5656
+DCHECK
+(!
+\9a¡r
+->
+hydrog\92
+()->
+IsOldD©aS·ûAÎoÿtiÚ
+());
+
+5657
+DCHECK
+(!
+\9a¡r
+->
+hydrog\92
+()->
+IsNewS·ûAÎoÿtiÚ
+());
+
+5658
+ gæags
+ =
+AÎoÿ\8bT¬g\91S·û
+::
+upd©e
+(
+æags
+,
+OLD_POINTER_SPACE
+);
+
+5659 } \vià(
+ g\9a¡r
+->
+hydrog\92
+()->
+IsOldD©aS·ûAÎoÿtiÚ
+()) {
+
+5660
+DCHECK
+(!
+\9a¡r
+->
+hydrog\92
+()->
+IsNewS·ûAÎoÿtiÚ
+());
+
+5661
+ gæags
+ =
+AÎoÿ\8bT¬g\91S·û
+::
+upd©e
+(
+æags
+,
+OLD_DATA_SPACE
+);
+
+5663
+ gæags
+ =
+AÎoÿ\8bT¬g\91S·û
+::
+upd©e
+(
+æags
+,
+NEW_SPACE
+);
+
+5665
+__
+
+Push
+(
+Smi
+::
+FromIÁ
+(
+æags
+));
+
+5667
+C®lRuÁimeFromDeã¼ed
+(
+RuÁime
+::
+kAÎoÿ\8bInT¬g\91S·û
+, 2,
+\9a¡r
+,
+
+5668
+\9a¡r
+->
+cڋxt
+());
+
+5669
+__
+
+StÜeToSaãpo\9atRegi¡\94SlÙ
+(
+r3
+,
+»suÉ
+);
+
+5673 \1e
+ gLCodeG\92
+::
+DoToFa¡PrÝ\94t\9bs
+(
+LToFa¡PrÝ\94t\9bs
+*
+\9a¡r
+) {
+
+5674
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+()).
+is
+(
+r3
+));
+
+5675
+__
+
+push
+(
+r3
+);
+
+5676
+C®lRuÁime
+(
+RuÁime
+::
+kToFa¡PrÝ\94t\9bs
+, 1,
+\9a¡r
+);
+
+5680 \1e
+ gLCodeG\92
+::
+DoRegExpL\99\94®
+(
+LRegExpL\99\94®
+*
+\9a¡r
+) {
+
+5681
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+5682
+Lab\96
+
+ gm©\94\9flized
+;
+
+5688 \12
+ gl\99\94®_off£t
+ =
+
+5689
+FixedA¼ay
+::
+Off£tOfEËm\92tAt
+(
+\9a¡r
+->
+hydrog\92
+()->
+l\99\94®_\9adex
+());
+
+5690
+__
+
+Move
+(
+r10
+,
+\9a¡r
+->
+hydrog\92
+()->
+l\99\94®s
+());
+
+5691
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r10
+,
+l\99\94®_off£t
+));
+
+5692
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+5693
+__
+
+cmp
+(
+r4
+,
+\9d
+);
+
+5694
+__
+
+bÃ
+(&
+m©\94\9flized
+);
+
+5698
+__
+
+LßdSmiL\99\94®
+(
+r9
+,
+Smi
+::
+FromIÁ
+(
+\9a¡r
+->
+hydrog\92
+()->
+l\99\94®_\9adex
+()));
+
+5699
+__
+
+mov
+(
+r8
+,
+O³¿nd
+(
+\9a¡r
+->
+hydrog\92
+()->
+·\89\94n
+()));
+
+5700
+__
+
+mov
+(
+r7
+,
+O³¿nd
+(
+\9a¡r
+->
+hydrog\92
+()->
+æags
+()));
+
+5701
+__
+
+Push
+(
+r10
+,
+r9
+,
+r8
+,
+r7
+);
+
+5702
+C®lRuÁime
+(
+RuÁime
+::
+kM©\94\9flizeRegExpL\99\94®
+, 4,
+\9a¡r
+);
+
+5703
+__
+
+mr
+(
+r4
+,
+r3
+);
+
+5705
+__
+
+b\9ad
+(&
+m©\94\9flized
+);
+
+5706 \12
+ gsize
+ =
+JSRegExp
+::
+kSize
+ + JSRegExp::
+kInObjeùF\9bldCouÁ
+ *
+kPo\9a\8brSize
+;
+
+5707
+Lab\96
+
+ g®loÿ\8bd
+,
+ gruÁime_®loÿ\8b
+;
+
+5709
+__
+
+AÎoÿ\8b
+(
+size
+,
+r3
+,
+r5
+,
+r6
+, &
+ruÁime_®loÿ\8b
+,
+TAG_OBJECT
+);
+
+5710
+__
+
+b
+(&
+®loÿ\8bd
+);
+
+5712
+__
+
+b\9ad
+(&
+ruÁime_®loÿ\8b
+);
+
+5713
+__
+
+LßdSmiL\99\94®
+(
+r3
+,
+Smi
+::
+FromIÁ
+(
+size
+));
+
+5714
+__
+
+Push
+(
+r4
+,
+r3
+);
+
+5715
+C®lRuÁime
+(
+RuÁime
+::
+kAÎoÿ\8bInNewS·û
+, 1,
+\9a¡r
+);
+
+5716
+__
+
+pÝ
+(
+r4
+);
+
+5718
+__
+
+b\9ad
+(&
+®loÿ\8bd
+);
+
+5720
+__
+
+CÝyF\9blds
+(
+r3
+,
+r4
+,
+r5
+.
+b\99
+(),
+size
+ /
+kPo\9a\8brSize
+);
+
+5724 \1e
+ gLCodeG\92
+::
+DoFunùiÚL\99\94®
+(
+LFunùiÚL\99\94®
+*
+\9a¡r
+) {
+
+5725
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+5728
+boÞ
+
+ g´\91\92u»
+ =
+\9a¡r
+->
+hydrog\92
+()->
+´\91\92u»
+();
+
+5729 ià(!
+ g´\91\92u»
+ &&
+ g\9a¡r
+->
+hydrog\92
+()->
+has_no_l\99\94®s
+()) {
+
+5730
+Fa¡NewClosu»Stub
+
+¡ub
+(
+isީe
+(),
+\9a¡r
+->
+hydrog\92
+()->
+¡riù_mode
+(),
+
+5731
+\9a¡r
+->
+hydrog\92
+()->
+k\9ad
+());
+
+5732
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+\9a¡r
+->
+hydrog\92
+()->
+sh¬ed_\9afo
+()));
+
+5733
+C®lCode
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+,
+\9a¡r
+);
+
+5735
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+\9a¡r
+->
+hydrog\92
+()->
+sh¬ed_\9afo
+()));
+
+5736
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+´\91\92u»
+ ?
+çùÜy
+()->
+\8cue_v®ue
+()
+
+5737 :
+çùÜy
+()->
+çl£_v®ue
+()));
+
+5738
+__
+
+Push
+(
+ý
+,
+r5
+,
+r4
+);
+
+5739
+C®lRuÁime
+(
+RuÁime
+::
+kNewClosu»
+, 3,
+\9a¡r
+);
+
+5744 \1e
+ gLCodeG\92
+::
+DoTy³of
+(
+LTy³of
+*
+\9a¡r
+) {
+
+5745
+Regi¡\94
+
+\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+5746
+__
+
+push
+(
+\9aput
+);
+
+5747
+C®lRuÁime
+(
+RuÁime
+::
+kTy³of
+, 1,
+\9a¡r
+);
+
+5751 \1e
+ gLCodeG\92
+::
+DoTy³ofIsAndB¿nch
+(
+LTy³ofIsAndB¿nch
+*
+\9a¡r
+) {
+
+5752
+Regi¡\94
+
+\9aput
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+5754
+CÚd\99iÚ
+
+ gf\9a®_b¿nch_cÚd\99iÚ
+ =
+
+5755
+Em\99Ty³ofIs
+(
+\9a¡r
+->
+TrueLab\96
+(
+chunk_
+), in¡r->
+F®£Lab\96
+(chunk_),
+\9aput
+,
+
+5756
+\9a¡r
+->
+ty³_l\99\94®
+());
+
+5757 ià(
+ gf\9a®_b¿nch_cÚd\99iÚ
+ !ð
+kNoCÚd\99iÚ
+) {
+
+5758
+Em\99B¿nch
+(
+\9a¡r
+,
+f\9a®_b¿nch_cÚd\99iÚ
+);
+
+5763
+CÚd\99iÚ
+
+ gLCodeG\92
+::
+Em\99Ty³ofIs
+(
+Lab\96
+*
+\8cue_Ïb\96
+, Lab\96*
+çl£_Ïb\96
+,
+
+5764
+Regi¡\94
+
+\9aput
+,
+HªdË
+<
+S\8c\9ag
+>
+ty³_Çme
+) {
+
+5765
+CÚd\99iÚ
+
+ gf\9a®_b¿nch_cÚd\99iÚ
+ =
+kNoCÚd\99iÚ
+;
+
+5766
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+5767
+FaùÜy
+*
+ gçùÜy
+ =
+isީe
+()->
+çùÜy
+();
+
+5768 ià(
+ gS\8c\9ag
+::
+Equ®s
+(
+ty³_Çme
+,
+çùÜy
+->
+numb\94_¡r\9ag
+())) {
+
+5769
+__
+
+JumpIfSmi
+(
+\9aput
+,
+\8cue_Ïb\96
+);
+
+5770
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+\9aput
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+5771
+__
+
+Com·»RoÙ
+(
+sü©ch
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+5772
+ gf\9a®_b¿nch_cÚd\99iÚ
+ =
+eq
+;
+
+5774 } \vià(
+ gS\8c\9ag
+::
+Equ®s
+(
+ty³_Çme
+,
+çùÜy
+->
+¡r\9ag_¡r\9ag
+())) {
+
+5775
+__
+
+JumpIfSmi
+(
+\9aput
+,
+çl£_Ïb\96
+);
+
+5776
+__
+
+Com·»ObjeùTy³
+(
+\9aput
+,
+sü©ch
+,
+no_»g
+,
+FIRST_NONSTRING_TYPE
+);
+
+5777
+__
+
+bge
+(
+çl£_Ïb\96
+);
+
+5778
+__
+
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+M
+::
+kB\99F\9bldOff£t
+));
+
+5779
+__
+
+Ex\8caùB\99
+(
+r0
+,
+sü©ch
+,
+M
+::
+kIsUnd\91eùabË
+);
+
+5780
+__
+
+cmpi
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+5781
+ gf\9a®_b¿nch_cÚd\99iÚ
+ =
+eq
+;
+
+5783 } \vià(
+ gS\8c\9ag
+::
+Equ®s
+(
+ty³_Çme
+,
+çùÜy
+->
+symbÞ_¡r\9ag
+())) {
+
+5784
+__
+
+JumpIfSmi
+(
+\9aput
+,
+çl£_Ïb\96
+);
+
+5785
+__
+
+Com·»ObjeùTy³
+(
+\9aput
+,
+sü©ch
+,
+no_»g
+,
+SYMBOL_TYPE
+);
+
+5786
+ gf\9a®_b¿nch_cÚd\99iÚ
+ =
+eq
+;
+
+5788 } \vià(
+ gS\8c\9ag
+::
+Equ®s
+(
+ty³_Çme
+,
+çùÜy
+->
+boÞ\97n_¡r\9ag
+())) {
+
+5789
+__
+
+Com·»RoÙ
+(
+\9aput
+,
+H\97p
+::
+kTrueV®ueRoÙIndex
+);
+
+5790
+__
+
+beq
+(
+\8cue_Ïb\96
+);
+
+5791
+__
+
+Com·»RoÙ
+(
+\9aput
+,
+H\97p
+::
+kF®£V®ueRoÙIndex
+);
+
+5792
+ gf\9a®_b¿nch_cÚd\99iÚ
+ =
+eq
+;
+
+5794 } \vià(
+ gS\8c\9ag
+::
+Equ®s
+(
+ty³_Çme
+,
+çùÜy
+->
+undef\9aed_¡r\9ag
+())) {
+
+5795
+__
+
+Com·»RoÙ
+(
+\9aput
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+5796
+__
+
+beq
+(
+\8cue_Ïb\96
+);
+
+5797
+__
+
+JumpIfSmi
+(
+\9aput
+,
+çl£_Ïb\96
+);
+
+5799
+__
+
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+\9aput
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+5800
+__
+
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+M
+::
+kB\99F\9bldOff£t
+));
+
+5801
+__
+
+Ex\8caùB\99
+(
+r0
+,
+sü©ch
+,
+M
+::
+kIsUnd\91eùabË
+);
+
+5802
+__
+
+cmpi
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+5803
+ gf\9a®_b¿nch_cÚd\99iÚ
+ =
+Ã
+;
+
+5805 } \vià(
+ gS\8c\9ag
+::
+Equ®s
+(
+ty³_Çme
+,
+çùÜy
+->
+funùiÚ_¡r\9ag
+())) {
+
+5806
+STATIC_ASSERT
+(
+NUM_OF_CALLABLE_SPEC_OBJECT_TYPES
+ == 2);
+
+5807
+Regi¡\94
+
+ gty³_»g
+ =
+sü©ch
+;
+
+5808
+__
+
+JumpIfSmi
+(
+\9aput
+,
+çl£_Ïb\96
+);
+
+5809
+__
+
+Com·»ObjeùTy³
+(
+\9aput
+,
+sü©ch
+,
+ty³_»g
+,
+JS_FUNCTION_TYPE
+);
+
+5810
+__
+
+beq
+(
+\8cue_Ïb\96
+);
+
+5811
+__
+
+cmpi
+(
+ty³_»g
+,
+O³¿nd
+(
+JS_FUNCTION_PROXY_TYPE
+));
+
+5812
+ gf\9a®_b¿nch_cÚd\99iÚ
+ =
+eq
+;
+
+5814 } \vià(
+ gS\8c\9ag
+::
+Equ®s
+(
+ty³_Çme
+,
+çùÜy
+->
+objeù_¡r\9ag
+())) {
+
+5815
+Regi¡\94
+
+ gm
+ =
+sü©ch
+;
+
+5816
+__
+
+JumpIfSmi
+(
+\9aput
+,
+çl£_Ïb\96
+);
+
+5817
+__
+
+Com·»RoÙ
+(
+\9aput
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+5818
+__
+
+beq
+(
+\8cue_Ïb\96
+);
+
+5819
+__
+
+CheckObjeùTy³Rªge
+(
+\9aput
+,
+m
+,
+FIRST_NONCALLABLE_SPEC_OBJECT_TYPE
+,
+
+5820
+LAST_NONCALLABLE_SPEC_OBJECT_TYPE
+,
+çl£_Ïb\96
+);
+
+5822
+__
+
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kB\99F\9bldOff£t
+));
+
+5823
+__
+
+Ex\8caùB\99
+(
+r0
+,
+sü©ch
+,
+M
+::
+kIsUnd\91eùabË
+);
+
+5824
+__
+
+cmpi
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+5825
+ gf\9a®_b¿nch_cÚd\99iÚ
+ =
+eq
+;
+
+5828
+__
+
+b
+(
+çl£_Ïb\96
+);
+
+5831 \15
+ gf\9a®_b¿nch_cÚd\99iÚ
+;
+
+5835 \1e
+ gLCodeG\92
+::
+DoIsCÚ¡ruùC®lAndB¿nch
+(
+LIsCÚ¡ruùC®lAndB¿nch
+*
+\9a¡r
+) {
+
+5836
+Regi¡\94
+
+\8bmp1
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\8bmp
+());
+
+5838
+Em\99IsCÚ¡ruùC®l
+(
+\8bmp1
+,
+sü©ch0
+());
+
+5839
+Em\99B¿nch
+(
+\9a¡r
+,
+eq
+);
+
+5843 \1e
+ gLCodeG\92
+::
+Em\99IsCÚ¡ruùC®l
+(
+Regi¡\94
+
+\8bmp1
+, Regi¡\94
+\8bmp2
+) {
+
+5844
+DCHECK
+(!
+\8bmp1
+.
+is
+(
+\8bmp2
+));
+
+5846
+__
+
+LßdP
+(
+\8bmp1
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+5849
+Lab\96
+
+ gcheck_äame_m¬k\94
+;
+
+5850
+__
+
+LßdP
+(
+\8bmp2
+,
+MemO³¿nd
+(
+\8bmp1
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+5851
+__
+
+CmpSmiL\99\94®
+(
+\8bmp2
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+ARGUMENTS_ADAPTOR
+),
+r0
+);
+
+5852
+__
+
+bÃ
+(&
+check_äame_m¬k\94
+);
+
+5853
+__
+
+LßdP
+(
+\8bmp1
+,
+MemO³¿nd
+Ñemp1,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+5856
+__
+
+b\9ad
+(&
+check_äame_m¬k\94
+);
+
+5857
+__
+
+LßdP
+(
+\8bmp1
+,
+MemO³¿nd
+Ñemp1,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kM¬k\94Off£t
+));
+
+5858
+__
+
+CmpSmiL\99\94®
+(
+\8bmp1
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+CONSTRUCT
+),
+r0
+);
+
+5862 \1e
+ gLCodeG\92
+::
+Ensu»S·ûFÜLazyDeÝt
+(\12
+¥aû_Ãeded
+) {
+
+5863 ià(!
+\9afo
+()->
+IsStub
+()) {
+
+5866 \12
+cu¼\92t_pc
+ =
+masm
+()->
+pc_off£t
+();
+
+5867 ià(
+ gcu¼\92t_pc
+ <
+ gÏ¡_Ïzy_deÝt_pc_
+ +
+ g¥aû_Ãeded
+) {
+
+5868 \12
+ g·dd\9ag_size
+ =
+Ï¡_Ïzy_deÝt_pc_
+ +
+¥aû_Ãeded
+ -
+cu¼\92t_pc
+;
+
+5869
+DCHECK_EQ
+(0,
+·dd\9ag_size
+ %
+As£mbËr
+::
+kIn¡rSize
+);
+
+5870 \1f
+ g·dd\9ag_size
+ > 0) {
+
+5871
+__
+
+nÝ
+();
+
+5872
+ g·dd\9ag_size
+ -ð
+As£mbËr
+::
+kIn¡rSize
+;
+
+5876
+ gÏ¡_Ïzy_deÝt_pc_
+ =
+masm
+()->
+pc_off£t
+();
+
+5880 \1e
+ gLCodeG\92
+::
+DoLazyBa\9eout
+(
+LLazyBa\9eout
+*
+\9a¡r
+) {
+
+5881
+Ï¡_Ïzy_deÝt_pc_
+ =
+masm
+()->
+pc_off£t
+();
+
+5882
+DCHECK
+(
+\9a¡r
+->
+HasEnv\9cÚm\92t
+());
+
+5883
+LEnv\9cÚm\92t
+*
+ g\92v
+ =
+\9a¡r
+->
+\92v\9cÚm\92t
+();
+
+5884
+Regi¡\94Env\9cÚm\92tFÜDeÝtimiz©iÚ
+(
+\92v
+,
+Saãpo\9at
+::
+kLazyDeÝt
+);
+
+5885
+ g§ãpo\9ats_
+.
+RecÜdLazyDeÝtimiz©iÚIndex
+(
+\92v
+->
+deÝtimiz©iÚ_\9adex
+());
+
+5889 \1e
+ gLCodeG\92
+::
+DoDeÝtimize
+(
+LDeÝtimize
+*
+\9a¡r
+) {
+
+5890
+DeÝtimiz\94
+::
+Ba\9eoutTy³
+
+ty³
+ =
+\9a¡r
+->
+hydrog\92
+()->type();
+
+5895 ià(
+\9afo
+()->
+IsStub
+(è&&
+ gty³
+ =ð
+DeÝtimiz\94
+::
+EAGER
+) {
+
+5896
+ty³
+ =
+DeÝtimiz\94
+::
+LAZY
+;
+
+5899
+DeÝtimizeIf
+(
+®
+,
+\9a¡r
+, in¡r->
+hydrog\92
+()->
+»asÚ
+(),
+ty³
+);
+
+5903 \1e
+ gLCodeG\92
+::
+DoDummy
+(
+LDummy
+*
+\9a¡r
+) {
+
+5908 \1e
+LCodeG\92
+::
+DoDummyU£
+(
+LDummyU£
+*
+\9a¡r
+) {
+
+5913 \1e
+LCodeG\92
+::
+DoDeã¼edS\8fckCheck
+(
+LS\8fckCheck
+*
+\9a¡r
+) {
+
+5914
+PushSaãpo\9atRegi¡\94sScÝe
+
+scÝe
+(
+this
+);
+
+5915
+LßdCÚ\8bxtFromDeã¼ed
+(
+\9a¡r
+->
+cڋxt
+());
+
+5916
+__
+
+C®lRuÁimeSaveDoubËs
+(
+RuÁime
+::
+kS\8fckGu¬d
+);
+
+5917
+RecÜdSaãpo\9atW\99hLazyDeÝt
+(
+
+5918
+\9a¡r
+,
+RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
+);
+
+5919
+DCHECK
+(
+\9a¡r
+->
+HasEnv\9cÚm\92t
+());
+
+5920
+LEnv\9cÚm\92t
+*
+ g\92v
+ =
+\9a¡r
+->
+\92v\9cÚm\92t
+();
+
+5921
+ g§ãpo\9ats_
+.
+RecÜdLazyDeÝtimiz©iÚIndex
+(
+\92v
+->
+deÝtimiz©iÚ_\9adex
+());
+
+5925 \1e
+ gLCodeG\92
+::
+DoS\8fckCheck
+(
+LS\8fckCheck
+*
+\9a¡r
+) {
+
+5926 þas
+ cDeã¼edS\8fckCheck
+
+FINAL
+ :
+public
+
+LDeã¼edCode
+ {
+
+5927
+public
+:
+
+5928
+Deã¼edS\8fckCheck
+(
+LCodeG\92
+*
+codeg\92
+,
+LS\8fckCheck
+*
+\9a¡r
+)
+
+5929 :
+LDeã¼edCode
+(
+codeg\92
+),
+\9a¡r_
+(
+\9a¡r
+) {}
+
+5930
+v\9ctu®
+ \1e
+G\92\94©e
+(è
+ gOVERRIDE
+ {
+
+5931
+codeg\92
+()->
+DoDeã¼edS\8fckCheck
+(
+\9a¡r_
+);
+
+5933
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+(è
+ gOVERRIDE
+ { \15
+ g\9a¡r_
+; }
+
+5935
+ g´iv©e
+:
+
+5936
+LS\8fckCheck
+*
+\9a¡r_
+;
+
+5939
+DCHECK
+(
+\9a¡r
+->
+HasEnv\9cÚm\92t
+());
+
+5940
+LEnv\9cÚm\92t
+*
+ g\92v
+ =
+\9a¡r
+->
+\92v\9cÚm\92t
+();
+
+5943 ià(
+ g\9a¡r
+->
+hydrog\92
+()->
+is_funùiÚ_\92\8cy
+()) {
+
+5945
+Lab\96
+
+ gdÚe
+;
+
+5946
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kS\8fckLim\99RoÙIndex
+);
+
+5947
+__
+
+cm¶
+(
+¥
+,
+\9d
+);
+
+5948
+__
+
+bge
+(&
+dÚe
+);
+
+5949
+DCHECK
+(
+\9a¡r
+->
+cڋxt
+()->
+IsRegi¡\94
+());
+
+5950
+DCHECK
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+()).
+is
+(
+ý
+));
+
+5951
+C®lCode
+(
+isީe
+()->
+bu\9et\9as
+()->
+S\8fckCheck
+(),
+R\96ocInfo
+::
+CODE_TARGET
+,
+
+5952
+\9a¡r
+);
+
+5953
+__
+
+b\9ad
+(&
+dÚe
+);
+
+5955
+DCHECK
+(
+\9a¡r
+->
+hydrog\92
+()->
+is_backw¬ds_b¿nch
+());
+
+5957
+Deã¼edS\8fckCheck
+*
+ gdeã¼ed_¡ack_check
+ =
+
+5958
+Ãw
+ (
+zÚe
+()è
+Deã¼edS\8fckCheck
+(
+this
+,
+\9a¡r
+);
+
+5959
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kS\8fckLim\99RoÙIndex
+);
+
+5960
+__
+
+cm¶
+(
+¥
+,
+\9d
+);
+
+5961
+__
+
+bÉ
+(
+deã¼ed_¡ack_check
+->
+\92\8cy
+());
+
+5962
+Ensu»S·ûFÜLazyDeÝt
+(
+DeÝtimiz\94
+::
+·tch_size
+());
+
+5963
+__
+
+b\9ad
+(
+\9a¡r
+->
+dÚe_Ïb\96
+());
+
+5964
+ gdeã¼ed_¡ack_check
+->
+S\91Ex\99
+(
+\9a¡r
+->
+dÚe_Ïb\96
+());
+
+5965
+Regi¡\94Env\9cÚm\92tFÜDeÝtimiz©iÚ
+(
+\92v
+,
+Saãpo\9at
+::
+kLazyDeÝt
+);
+
+5973 \1e
+ gLCodeG\92
+::
+DoO¤EÁry
+(
+LO¤EÁry
+*
+\9a¡r
+) {
+
+5977
+LEnv\9cÚm\92t
+*
+\92v\9cÚm\92t
+ =
+\9a¡r
+->environment();
+
+5981
+DCHECK
+(!
+\92v\9cÚm\92t
+->
+HasB\93nRegi¡\94ed
+());
+
+5982
+Regi¡\94Env\9cÚm\92tFÜDeÝtimiz©iÚ
+(
+\92v\9cÚm\92t
+,
+Saãpo\9at
+::
+kNoLazyDeÝt
+);
+
+5984
+G\92\94©eO¤PrÞogue
+();
+
+5988 \1e
+ gLCodeG\92
+::
+DoFÜInP»·»M
+(
+LFÜInP»·»M
+*
+\9a¡r
+) {
+
+5989
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+5990
+__
+
+cmp
+(
+r3
+,
+\9d
+);
+
+5991
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "undefined");
+
+5993
+Regi¡\94
+
+ gnuÎ_v®ue
+ =
+r8
+;
+
+5994
+__
+
+LßdRoÙ
+(
+nuÎ_v®ue
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+5995
+__
+
+cmp
+(
+r3
+,
+nuÎ_v®ue
+);
+
+5996
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "null");
+
+5998
+__
+
+Te¡IfSmi
+(
+r3
+,
+r0
+);
+
+5999
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "Smi",
+ü0
+);
+
+6001
+STATIC_ASSERT
+(
+FIRST_JS_PROXY_TYPE
+ =ð
+FIRST_SPEC_OBJECT_TYPE
+);
+
+6002
+__
+
+Com·»ObjeùTy³
+(
+r3
+,
+r4
+,\844,
+LAST_JS_PROXY_TYPE
+);
+
+6003
+DeÝtimizeIf
+(
+Ë
+,
+\9a¡r
+, "wrong instance\81ype");
+
+6005
+Lab\96
+
+ gu£_ÿche
+,
+ gÿÎ_ruÁime
+;
+
+6006
+__
+
+CheckEnumCache
+(
+nuÎ_v®ue
+, &
+ÿÎ_ruÁime
+);
+
+6008
+__
+
+LßdP
+(
+r3
+,
+F\9bldMemO³¿nd
+Ô3,
+H\97pObjeù
+::
+kMOff£t
+));
+
+6009
+__
+
+b
+(&
+u£_ÿche
+);
+
+6012
+__
+
+b\9ad
+(&
+ÿÎ_ruÁime
+);
+
+6013
+__
+
+push
+(
+r3
+);
+
+6014
+C®lRuÁime
+(
+RuÁime
+::
+kG\91PrÝ\94tyNamesFa¡
+, 1,
+\9a¡r
+);
+
+6016
+__
+
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r3
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+6017
+__
+
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kM\91aMRoÙIndex
+);
+
+6018
+__
+
+cmp
+(
+r4
+,
+\9d
+);
+
+6019
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "wrong map");
+
+6020
+__
+
+b\9ad
+(&
+u£_ÿche
+);
+
+6024 \1e
+ gLCodeG\92
+::
+DoFÜInCacheA¼ay
+(
+LFÜInCacheA¼ay
+*
+\9a¡r
+) {
+
+6025
+Regi¡\94
+
+m
+ =
+ToRegi¡\94
+(
+\9a¡r
+->map());
+
+6026
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+6027
+Lab\96
+
+ glßd_ÿche
+,
+ gdÚe
+;
+
+6028
+__
+
+EnumL\92gth
+(
+»suÉ
+,
+m
+);
+
+6029
+__
+
+CmpSmiL\99\94®
+(
+»suÉ
+,
+Smi
+::
+FromIÁ
+(0),
+r0
+);
+
+6030
+__
+
+bÃ
+(&
+lßd_ÿche
+);
+
+6031
+__
+
+mov
+(
+»suÉ
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+em±y_fixed_¬¿y
+()));
+
+6032
+__
+
+b
+(&
+dÚe
+);
+
+6034
+__
+
+b\9ad
+(&
+lßd_ÿche
+);
+
+6035
+__
+
+LßdIn¡ªûDesü\9dtÜs
+(
+m
+,
+»suÉ
+);
+
+6036
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+ÔesuÉ,
+Desü\9dtÜA¼ay
+::
+kEnumCacheOff£t
+));
+
+6037
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+ÔesuÉ,
+FixedA¼ay
+::
+SizeFÜ
+(
+\9a¡r
+->
+idx
+())));
+
+6038
+__
+
+cmpi
+(
+»suÉ
+,
+O³¿nd
+::
+Z\94o
+());
+
+6039
+DeÝtimizeIf
+(
+eq
+,
+\9a¡r
+, "no cache");
+
+6041
+__
+
+b\9ad
+(&
+dÚe
+);
+
+6045 \1e
+ gLCodeG\92
+::
+DoCheckMV®ue
+(
+LCheckMV®ue
+*
+\9a¡r
+) {
+
+6046
+Regi¡\94
+
+objeù
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+6047
+Regi¡\94
+
+ gm
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+m
+());
+
+6048
+__
+
+LßdP
+(
+sü©ch0
+(),
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+6049
+__
+
+cmp
+(
+m
+,
+sü©ch0
+());
+
+6050
+DeÝtimizeIf
+(
+Ã
+,
+\9a¡r
+, "wrong map");
+
+6054 \1e
+ gLCodeG\92
+::
+DoDeã¼edLßdMu\8fbËDoubË
+(
+LLßdF\9bldByIndex
+*
+\9a¡r
+,
+
+6055
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+objeù
+,
+
+6056
+Regi¡\94
+
+\9adex
+) {
+
+6057
+PushSaãpo\9atRegi¡\94sScÝe
+
+scÝe
+(
+this
+);
+
+6058
+__
+
+Push
+(
+objeù
+,
+\9adex
+);
+
+6059
+__
+
+li
+(
+ý
+,
+O³¿nd
+::
+Z\94o
+());
+
+6060
+__
+
+C®lRuÁimeSaveDoubËs
+(
+RuÁime
+::
+kLßdMu\8fbËDoubË
+);
+
+6061
+RecÜdSaãpo\9atW\99hRegi¡\94s
+(
+\9a¡r
+->
+po\9a\8br_m
+(), 2,
+
+6062
+Saãpo\9at
+::
+kNoLazyDeÝt
+);
+
+6063
+__
+
+StÜeToSaãpo\9atRegi¡\94SlÙ
+(
+r3
+,
+»suÉ
+);
+
+6067 \1e
+ gLCodeG\92
+::
+DoLßdF\9bldByIndex
+(
+LLßdF\9bldByIndex
+*
+\9a¡r
+) {
+
+6068 þas
+ cDeã¼edLßdMu\8fbËDoubË
+
+FINAL
+ :
+public
+
+LDeã¼edCode
+ {
+
+6069
+public
+:
+
+6070
+Deã¼edLßdMu\8fbËDoubË
+(
+LCodeG\92
+*
+codeg\92
+,
+LLßdF\9bldByIndex
+*
+\9a¡r
+,
+
+6071
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+objeù
+, Regi¡\94
+\9adex
+)
+
+6072 :
+LDeã¼edCode
+(
+codeg\92
+),
+
+6073
+\9a¡r_
+(
+\9a¡r
+),
+
+6074
+»suÉ_
+(
+»suÉ
+),
+
+6075
+objeù_
+(
+objeù
+),
+
+6076
+\9adex_
+(
+\9adex
+) {}
+
+6077
+v\9ctu®
+ \1e
+G\92\94©e
+(è
+ gOVERRIDE
+ {
+
+6078
+codeg\92
+()->
+DoDeã¼edLßdMu\8fbËDoubË
+(
+\9a¡r_
+,
+»suÉ_
+,
+objeù_
+,
+\9adex_
+);
+
+6080
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+(è
+ gOVERRIDE
+ { \15
+ g\9a¡r_
+; }
+
+6082
+ g´iv©e
+:
+
+6083
+LLßdF\9bldByIndex
+*
+\9a¡r_
+;
+
+6084
+Regi¡\94
+
+ g»suÉ_
+;
+
+6085
+Regi¡\94
+
+ gobjeù_
+;
+
+6086
+Regi¡\94
+
+ g\9adex_
+;
+
+6089
+Regi¡\94
+
+ gobjeù
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+objeù
+());
+
+6090
+Regi¡\94
+
+ g\9adex
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+\9adex
+());
+
+6091
+Regi¡\94
+
+ g»suÉ
+ =
+ToRegi¡\94
+(
+\9a¡r
+->
+»suÉ
+());
+
+6092
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch0
+();
+
+6094
+Deã¼edLßdMu\8fbËDoubË
+*
+ gdeã¼ed
+;
+
+6095
+ gdeã¼ed
+ =
+Ãw
+ (
+zÚe
+())
+
+6096
+Deã¼edLßdMu\8fbËDoubË
+(
+this
+,
+\9a¡r
+,
+»suÉ
+,
+objeù
+,
+\9adex
+);
+
+6098
+Lab\96
+
+ gout_of_objeù
+,
+ gdÚe
+;
+
+6100
+__
+
+Te¡B\99Mask
+(
+\9adex
+,
+»\9a\8b½»t_ÿ¡
+<
+u\9a\8d\8c_t
+>(
+Smi
+::
+FromIÁ
+(1)),
+r0
+);
+
+6101
+__
+
+bÃ
+(
+deã¼ed
+->
+\92\8cy
+(),
+ü0
+);
+
+6102
+__
+
+ShiáRightAr\99hImm
+(
+\9adex
+, index, 1);
+
+6104
+__
+
+cmpi
+(
+\9adex
+,
+O³¿nd
+::
+Z\94o
+());
+
+6105
+__
+
+bÉ
+(&
+out_of_objeù
+);
+
+6107
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r0
+,
+\9adex
+);
+
+6108
+__
+
+add
+(
+sü©ch
+,
+objeù
+,
+r0
+);
+
+6109
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+sü©ch
+,
+JSObjeù
+::
+kH\97d\94Size
+));
+
+6111
+__
+
+b
+(&
+dÚe
+);
+
+6113
+__
+
+b\9ad
+(&
+out_of_objeù
+);
+
+6114
+__
+
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+JSObjeù
+::
+kPrÝ\94t\9bsOff£t
+));
+
+6116
+__
+
+SmiToP\8cA¼ayOff£t
+(
+r0
+,
+\9adex
+);
+
+6117
+__
+
+sub
+(
+sü©ch
+,
+»suÉ
+,
+r0
+);
+
+6118
+__
+
+LßdP
+(
+»suÉ
+,
+
+6119
+F\9bldMemO³¿nd
+(
+sü©ch
+,
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kPo\9a\8brSize
+));
+
+6120
+__
+
+b\9ad
+(
+deã¼ed
+->
+ex\99
+());
+
+6121
+__
+
+b\9ad
+(&
+dÚe
+);
+
+6125 \1e
+ gLCodeG\92
+::
+DoStÜeF¿meCÚ\8bxt
+(
+LStÜeF¿meCÚ\8bxt
+*
+\9a¡r
+) {
+
+6126
+Regi¡\94
+
+cڋxt
+ =
+ToRegi¡\94
+(
+\9a¡r
+->context());
+
+6127
+__
+
+StÜeP
+(
+cڋxt
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+6131 \1e
+ gLCodeG\92
+::
+DoAÎoÿ\8bBlockCÚ\8bxt
+(
+LAÎoÿ\8bBlockCÚ\8bxt
+*
+\9a¡r
+) {
+
+6132
+HªdË
+<
+ScÝeInfo
+>
+scÝe_\9afo
+ =
+\9a¡r
+->scope_info();
+
+6133
+__
+
+Push
+(
+scÝe_\9afo
+);
+
+6134
+__
+
+push
+(
+ToRegi¡\94
+(
+\9a¡r
+->
+funùiÚ
+()));
+
+6135
+C®lRuÁime
+(
+RuÁime
+::
+kPushBlockCڋxt
+, 2,
+\9a¡r
+);
+
+6136
+RecÜdSaãpo\9at
+(
+Saãpo\9at
+::
+kNoLazyDeÝt
+);
+
+6140 #undeà
+__
+
+
+ @lithium-codegen-ppc.h
+
+5 #iâdeà
+V8_PPC_LITHIUM_CODEGEN_PPC_H_
+
+
+6 \ 1
+ #V8_PPC_LITHIUM_CODEGEN_PPC_H_
+
+
+ )
+
+8 \ 2
+ ~"¤c/µc/l\99hium-µc.h
+"
+
+10 \ 2
+ ~"¤c/µc/l\99hium-g-»sÞv\94-µc.h
+"
+
+11 \ 2
+ ~"¤c/deÝtimiz\94.h
+"
+
+12 \ 2
+ ~"¤c/l\99hium-codeg\92.h
+"
+
+13 \ 2
+ ~"¤c/§ãpo\9at-\8fbË.h
+"
+
+14 \ 2
+ ~"¤c/scÝes.h
+"
+
+15 \ 2
+ ~"¤c/ut\9es.h
+"
+
+17
+Çme¥aû
+
+ gv8
+ {
+
+18
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+21
+þass
+
+ gLDeã¼edCode
+;
+
+22
+þass
+
+ gSaãpo\9atG\92\94©Ü
+;
+
+24 þas
+ cLCodeG\92
+ :
+public
+
+LCodeG\92Ba£
+ {
+
+25
+public
+:
+
+26
+LCodeG\92
+(
+LChunk
+*
+chunk
+,
+MaüoAs£mbËr
+*
+as£mbËr
+,
+Comp\9e©iÚInfo
+*
+\9afo
+)
+
+27 :
+LCodeG\92Ba£
+(
+chunk
+,
+as£mbËr
+,
+\9afo
+),
+
+28
+deÝtimiz©iÚs_
+(4,
+\9afo
+->
+zÚe
+()),
+
+29
+jump_\8fbË_
+(4,
+\9afo
+->
+zÚe
+()),
+
+30
+deÝtimiz©iÚ_l\99\94®s_
+(8,
+\9afo
+->
+zÚe
+()),
+
+31
+\9al\9aed_funùiÚ_couÁ_
+(0),
+
+32
+scÝe_
+(
+\9afo
+->
+scÝe
+()),
+
+33
+\8cª¦©iÚs_
+(
+\9afo
+->
+zÚe
+()),
+
+34
+deã¼ed_
+(8,
+\9afo
+->
+zÚe
+()),
+
+35
+o¤_pc_off£t_
+(-1),
+
+36
+äame_is_bu\9et_
+(
+çl£
+),
+
+37
+§ãpo\9ats_
+(
+\9afo
+->
+zÚe
+()),
+
+38
+»sÞv\94_
+(
+this
+),
+
+39
+ex³ùed_§ãpo\9at_k\9ad_
+(
+Saãpo\9at
+::
+kSim¶e
+) {
+
+40
+PÝuÏ\8bDeÝtimiz©iÚL\99\94®sW\99hIÆ\9aedFunùiÚs
+();
+
+44 \12
+LookupDe¡\9a©iÚ
+(\12
+block_id
+) const {
+
+45 \15
+chunk
+()->
+LookupDe¡\9a©iÚ
+(
+block_id
+);
+
+48
+boÞ
+
+IsNextEm\99\8bdBlock
+(\12
+block_id
+) const {
+
+49 \15
+LookupDe¡\9a©iÚ
+(
+block_id
+è=ð
+G\91NextEm\99\8bdBlock
+();
+
+52
+boÞ
+
+N\93dsEag\94F¿me
+() const {
+
+53 \15
+G\91S\8fckSlÙCouÁ
+(è> 0 ||
+\9afo
+()->
+is_nÚ_deã¼ed_ÿÎ\9ag
+() ||
+
+54 !
+\9afo
+()->
+IsStub
+(è|| info()->
+»qu\9ces_äame
+();
+
+56
+boÞ
+
+N\93dsDeã¼edF¿me
+() const {
+
+57 \15 !
+N\93dsEag\94F¿me
+(è&&
+\9afo
+()->
+is_deã¼ed_ÿÎ\9ag
+();
+
+60
+L\9akRegi¡\94S\8ftus
+
+G\91L\9akRegi¡\94S\8f\8b
+() const {
+
+61 \15
+ gäame_is_bu\9et_
+ ?
+ gkLRHasB\93nSaved
+ :
+kLRHasNÙB\93nSaved
+;
+
+66
+Regi¡\94
+
+ToRegi¡\94
+(
+LO³¿nd
+*
+Ý
+) const;
+
+69
+Regi¡\94
+
+Em\99LßdRegi¡\94
+(
+LO³¿nd
+*
+Ý
+, Regi¡\94
+sü©ch
+);
+
+72 \1e
+Em\99LßdIÁeg\94CÚ¡ªt
+(
+LCÚ¡ªtO³¿nd
+*
+cÚ¡_Ý
+,
+Regi¡\94
+
+d¡
+);
+
+75
+DoubËRegi¡\94
+
+ToDoubËRegi¡\94
+(
+LO³¿nd
+*
+Ý
+) const;
+
+77
+\9a\8d\8c_t
+
+ToR\95»£Á©iÚ
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+,
+
+78 cڡ
+R\95»£Á©iÚ
+&
+r
+) const;
+
+79
+\9at32_t
+
+ToIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+) const;
+
+80
+Smi
+*
+ToSmi
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+) const;
+
+81 \b
+ToDoubË
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+) const;
+
+82
+O³¿nd
+
+ToO³¿nd
+(
+LO³¿nd
+*
+Ý
+);
+
+83
+MemO³¿nd
+
+ToMemO³¿nd
+(
+LO³¿nd
+*
+Ý
+) const;
+
+85
+MemO³¿nd
+
+ToHighMemO³¿nd
+(
+LO³¿nd
+*
+Ý
+) const;
+
+87
+boÞ
+
+IsIÁeg\9432
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+) const;
+
+88
+boÞ
+
+IsSmi
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+) const;
+
+89
+ gHªdË
+<
+ gObjeù
+>
+ToHªdË
+(
+LCÚ¡ªtO³¿nd
+*
+Ý
+) const;
+
+94
+boÞ
+
+G\92\94©eCode
+();
+
+98 \1e
+F\9aishCode
+(
+HªdË
+<
+Code
+>
+code
+);
+
+101 \1e
+DoDeã¼edNumb\94TagD
+(
+LNumb\94TagD
+*
+\9a¡r
+);
+
+103 \f
+ eIÁeg\94SigÃdÃss
+ {
+ gSIGNED_INT32
+,
+ gUNSIGNED_INT32
+ };
+
+104 \1e
+DoDeã¼edNumb\94TagIU
+(
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+LO³¿nd
+*
+v®ue
+,
+
+105
+LO³¿nd
+*
+\8bmp1
+, LO³¿nd*
+\8bmp2
+,
+
+106
+IÁeg\94SigÃdÃss
+
+sigÃdÃss
+);
+
+108 \1e
+DoDeã¼edTaggedToI
+(
+LTaggedToI
+*
+\9a¡r
+);
+
+109 \1e
+DoDeã¼edM©hAbsTaggedH\97pNumb\94
+(
+LM©hAbs
+*
+\9a¡r
+);
+
+110 \1e
+DoDeã¼edS\8fckCheck
+(
+LS\8fckCheck
+*
+\9a¡r
+);
+
+111 \1e
+DoDeã¼edS\8c\9agCh¬CodeAt
+(
+LS\8c\9agCh¬CodeAt
+*
+\9a¡r
+);
+
+112 \1e
+DoDeã¼edS\8c\9agCh¬FromCode
+(
+LS\8c\9agCh¬FromCode
+*
+\9a¡r
+);
+
+113 \1e
+DoDeã¼edAÎoÿ\8b
+(
+LAÎoÿ\8b
+*
+\9a¡r
+);
+
+114 \1e
+DoDeã¼edIn¡ªûOfKnownGlob®
+(
+LIn¡ªûOfKnownGlob®
+*
+\9a¡r
+,
+
+115
+Lab\96
+*
+m_check
+);
+
+116 \1e
+DoDeã¼edIn¡ªûMig¿tiÚ
+(
+LCheckMs
+*
+\9a¡r
+,
+Regi¡\94
+
+objeù
+);
+
+117 \1e
+DoDeã¼edLßdMu\8fbËDoubË
+(
+LLßdF\9bldByIndex
+*
+\9a¡r
+,
+Regi¡\94
+
+»suÉ
+,
+
+118
+Regi¡\94
+
+objeù
+, Regi¡\94
+\9adex
+);
+
+121 \1e
+DoP¬®ËlMove
+(
+LP¬®ËlMove
+*
+move
+);
+
+122 \1e
+DoG
+(
+LG
+*
+\9a¡r
+);
+
+124
+MemO³¿nd
+
+P»·»KeyedO³¿nd
+(
+Regi¡\94
+
+key
+, Regi¡\94
+ba£
+,
+
+125
+boÞ
+
+key_is_cÚ¡ªt
+, boÞ
+key_is_\8fgged
+,
+
+126 \12
+cÚ¡ªt_key
+, \12
+\96em\92t_size_shiá
+,
+
+127 \12
+ba£_off£t
+);
+
+130 \1e
+Wr\99eT¿n¦©iÚ
+(
+LEnv\9cÚm\92t
+*
+\92v\9cÚm\92t
+,
+T¿n¦©iÚ
+*
+\8cª¦©iÚ
+);
+
+133 \ 1
+ #DECLARE_DO
+(
+ty³
+è\1e
+Do
+##
+ `ty³
+(
+L
+##ty³*
+node
+);
+
+ )
+
+134
+LITHIUM_CONCRETE_INSTRUCTION_LIST
+(
+DECLARE_DO
+)
+
+135 #undeà
+DECLARE_DO
+
+
+137
+ g´iv©e
+:
+
+138
+S\8ciùMode
+
+¡riù_mode
+(ècÚ¡ { \15
+\9afo
+()->strict_mode(); }
+
+140
+ScÝe
+*
+scÝe
+(ècÚ¡ { \15
+ gscÝe_
+; }
+
+142
+Regi¡\94
+
+sü©ch0
+(è{ \15
+ gr11
+; }
+
+143
+DoubËRegi¡\94
+
+doubË_sü©ch0
+(è{ \15
+ gkSü©chDoubËReg
+; }
+
+145
+LIn¡ruùiÚ
+*
+G\91NextIn¡ruùiÚ
+();
+
+147 \1e
+Em\99CÏssOfTe¡
+(
+Lab\96
+*
+if_\8cue
+, Lab\96*
+if_çl£
+,
+
+148
+HªdË
+<
+S\8c\9ag
+>
+þass_Çme
+,
+Regi¡\94
+
+\9aput
+,
+
+149
+Regi¡\94
+
+\8bmpܬy
+, Regi¡\94
+\8bmpܬy2
+);
+
+151 \12
+G\91S\8fckSlÙCouÁ
+(ècÚ¡ { \15
+chunk
+()->
+¥\9el_¦Ù_couÁ
+(); }
+
+153 \1e
+AddDeã¼edCode
+(
+LDeã¼edCode
+*
+code
+è{
+ gdeã¼ed_
+.
+Add
+(code,
+zÚe
+()); }
+
+155 \1e
+SaveC®ËrDoubËs
+();
+
+156 \1e
+Re¡ÜeC®ËrDoubËs
+();
+
+160 \1e
+G\92\94©eBodyIn¡ruùiÚP»
+(
+LIn¡ruùiÚ
+*
+\9a¡r
+è
+ gOVERRIDE
+;
+
+161
+boÞ
+
+G\92\94©ePrÞogue
+();
+
+162
+boÞ
+
+G\92\94©eDeã¼edCode
+();
+
+163
+boÞ
+
+G\92\94©eJumpTabË
+();
+
+164
+boÞ
+
+G\92\94©eSaãpo\9atTabË
+();
+
+167 \1e
+G\92\94©eO¤PrÞogue
+();
+
+169 \f
+ eSaãpo\9atMode
+ {
+
+170
+ gRECORD_SIMPLE_SAFEPOINT
+,
+
+171
+ gRECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
+
+
+174 \1e
+C®lCode
+(
+HªdË
+<
+Code
+>
+code
+,
+R\96ocInfo
+::
+Mode
+
+mode
+,
+LIn¡ruùiÚ
+*
+\9a¡r
+);
+
+176 \1e
+C®lCodeG\92\94ic
+(
+HªdË
+<
+Code
+>
+code
+,
+R\96ocInfo
+::
+Mode
+
+mode
+,
+
+177
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+Saãpo\9atMode
+
+§ãpo\9at_mode
+);
+
+179 \1e
+C®lRuÁime
+(cڡ
+RuÁime
+::
+FunùiÚ
+*
+funùiÚ
+, \12
+num_¬gum\92ts
+,
+
+180
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+
+181
+SaveFPRegsMode
+
+§ve_doubËs
+ =
+kDÚtSaveFPRegs
+);
+
+183 \1e
+C®lRuÁime
+(
+RuÁime
+::
+FunùiÚId
+
+id
+, \12
+num_¬gum\92ts
+,
+
+184
+LIn¡ruùiÚ
+*
+\9a¡r
+) {
+
+185 cڡ
+ gRuÁime
+::
+FunùiÚ
+*
+funùiÚ
+ =
+RuÁime
+::
+FunùiÚFÜId
+(
+id
+);
+
+186
+C®lRuÁime
+(
+funùiÚ
+,
+num_¬gum\92ts
+,
+\9a¡r
+);
+
+189 \1e
+LßdCÚ\8bxtFromDeã¼ed
+(
+LO³¿nd
+*
+cڋxt
+);
+
+190 \1e
+C®lRuÁimeFromDeã¼ed
+(
+RuÁime
+::
+FunùiÚId
+
+id
+, \12
+¬gc
+,
+
+191
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+LO³¿nd
+*
+cڋxt
+);
+
+193 \f
+ eR4S\8f\8b
+ {
+ gR4_UNINITIALIZED
+,
+ gR4_CONTAINS_TARGET
+ };
+
+197 \1e
+C®lKnownFunùiÚ
+(
+HªdË
+<
+JSFunùiÚ
+>
+funùiÚ
+,
+
+198 \12
+fÜm®_·¿m\91\94_couÁ
+, \12
+¬\99y
+,
+
+199
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+R4S\8f\8b
+
+r4_¡©e
+);
+
+201 \1e
+RecÜdSaãpo\9atW\99hLazyDeÝt
+(
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+
+202
+Saãpo\9atMode
+
+§ãpo\9at_mode
+);
+
+204 \1e
+Regi¡\94Env\9cÚm\92tFÜDeÝtimiz©iÚ
+(
+LEnv\9cÚm\92t
+*
+\92v\9cÚm\92t
+,
+
+205
+Saãpo\9at
+::
+DeÝtMode
+
+mode
+);
+
+206 \1e
+DeÝtimizeIf
+(
+CÚd\99iÚ
+
+cÚd\99iÚ
+,
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+
+207 cڡ \ 5*
+d\91a\9e
+,
+DeÝtimiz\94
+::
+Ba\9eoutTy³
+
+ba\9eout_ty³
+,
+
+208
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+209 \1e
+DeÝtimizeIf
+(
+CÚd\99iÚ
+
+cÚd\99iÚ
+,
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+
+210 cڡ \ 5*
+d\91a\9e
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+212 \1e
+AddToT¿n¦©iÚ
+(
+LEnv\9cÚm\92t
+*
+\92v\9cÚm\92t
+,
+T¿n¦©iÚ
+*
+\8cª¦©iÚ
+,
+
+213
+LO³¿nd
+*
+Ý
+,
+boÞ
+
+is_\8fgged
+, boÞ
+is_u\9at32
+,
+
+214 \12*
+objeù_\9adex_po\9a\8br
+,
+
+215 \12*
+dem©\94\9flized_\9adex_po\9a\8br
+);
+
+216 \1e
+PÝuÏ\8bDeÝtimiz©iÚD©a
+(
+HªdË
+<
+Code
+>
+code
+);
+
+217 \12
+Def\9aeDeÝtimiz©iÚL\99\94®
+(
+HªdË
+<
+Objeù
+>
+l\99\94®
+);
+
+219 \1e
+PÝuÏ\8bDeÝtimiz©iÚL\99\94®sW\99hIÆ\9aedFunùiÚs
+();
+
+221
+Regi¡\94
+
+ToRegi¡\94
+(\12
+\9adex
+) const;
+
+222
+DoubËRegi¡\94
+
+ToDoubËRegi¡\94
+(\12
+\9adex
+) const;
+
+224
+MemO³¿nd
+
+Bu\9edSeqS\8c\9agO³¿nd
+(
+Regi¡\94
+
+¡r\9ag
+,
+LO³¿nd
+*
+\9adex
+,
+
+225
+S\8c\9ag
+::
+Encod\9ag
+
+\92cod\9ag
+);
+
+227 \1e
+Em\99M©hAbs
+(
+LM©hAbs
+*
+\9a¡r
+);
+
+228 #ià
+V8_TARGET_ARCH_PPC64
+
+
+229 \1e
+Em\99IÁeg\9432M©hAbs
+(
+LM©hAbs
+*
+\9a¡r
+);
+
+233 \1e
+RecÜdSaãpo\9at
+(
+LPo\9a\8brM
+*
+po\9a\8brs
+,
+Saãpo\9at
+::
+K\9ad
+
+k\9ad
+,
+
+234 \12
+¬gum\92ts
+,
+Saãpo\9at
+::
+DeÝtMode
+
+mode
+);
+
+235 \1e
+RecÜdSaãpo\9at
+(
+LPo\9a\8brM
+*
+po\9a\8brs
+,
+Saãpo\9at
+::
+DeÝtMode
+
+mode
+);
+
+236 \1e
+RecÜdSaãpo\9at
+(
+Saãpo\9at
+::
+DeÝtMode
+
+mode
+);
+
+237 \1e
+RecÜdSaãpo\9atW\99hRegi¡\94s
+(
+LPo\9a\8brM
+*
+po\9a\8brs
+, \12
+¬gum\92ts
+,
+
+238
+Saãpo\9at
+::
+DeÝtMode
+
+mode
+);
+
+240 \1e
+RecÜdAndWr\99ePos\99iÚ
+(\12
+pos\99iÚ
+è
+ gOVERRIDE
+;
+
+242 \18
+CÚd\99iÚ
+
+Tok\92ToCÚd\99iÚ
+(
+Tok\92
+::
+V®ue
+
+Ý
+);
+
+243 \1e
+Em\99GÙo
+(\12
+block
+);
+
+246
+ g\8bm¶©e
+ <
+þass
+
+ gIn¡rTy³
+>
+
+247 \1e
+Em\99B¿nch
+(
+In¡rTy³
+
+\9a¡r
+,
+CÚd\99iÚ
+
+cÚd\99iÚ
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+248
+ g\8bm¶©e
+ <
+þass
+
+ gIn¡rTy³
+>
+
+249 \1e
+Em\99F®£B¿nch
+(
+In¡rTy³
+
+\9a¡r
+,
+CÚd\99iÚ
+
+cÚd\99iÚ
+,
+
+250
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+251 \1e
+Em\99Numb\94UÁagD
+(
+LNumb\94UÁagD
+*
+\9a¡r
+,
+Regi¡\94
+
+\9aput
+,
+
+252
+DoubËRegi¡\94
+
+»suÉ
+,
+Numb\94UÁagDMode
+
+mode
+);
+
+257
+CÚd\99iÚ
+
+Em\99Ty³ofIs
+(
+Lab\96
+*
+\8cue_Ïb\96
+, Lab\96*
+çl£_Ïb\96
+,
+Regi¡\94
+
+\9aput
+,
+
+258
+HªdË
+<
+S\8c\9ag
+>
+ty³_Çme
+);
+
+263
+CÚd\99iÚ
+
+Em\99IsObjeù
+(
+Regi¡\94
+
+\9aput
+, Regi¡\94
+\8bmp1
+,
+Lab\96
+*
+is_nÙ_objeù
+,
+
+264
+Lab\96
+*
+is_objeù
+);
+
+269
+CÚd\99iÚ
+
+Em\99IsS\8c\9ag
+(
+Regi¡\94
+
+\9aput
+, Regi¡\94
+\8bmp1
+,
+Lab\96
+*
+is_nÙ_¡r\9ag
+,
+
+270
+SmiCheck
+
+check_Ãeded
+);
+
+274 \1e
+Em\99IsCÚ¡ruùC®l
+(
+Regi¡\94
+
+\8bmp1
+, Regi¡\94
+\8bmp2
+);
+
+278 \1e
+Em\99D\93pCÝy
+(
+HªdË
+<
+JSObjeù
+>
+objeù
+,
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+sourû
+,
+
+279 \12*
+off£t
+,
+AÎoÿtiÚS\99eMode
+
+mode
+);
+
+281 \1e
+Ensu»S·ûFÜLazyDeÝt
+(\12
+¥aû_Ãeded
+è
+ gOVERRIDE
+;
+
+282 \1e
+DoLßdKeyedEx\8bº®A¼ay
+(
+LLßdKeyed
+*
+\9a¡r
+);
+
+283 \1e
+DoLßdKeyedFixedDoubËA¼ay
+(
+LLßdKeyed
+*
+\9a¡r
+);
+
+284 \1e
+DoLßdKeyedFixedA¼ay
+(
+LLßdKeyed
+*
+\9a¡r
+);
+
+285 \1e
+DoStÜeKeyedEx\8bº®A¼ay
+(
+LStÜeKeyed
+*
+\9a¡r
+);
+
+286 \1e
+DoStÜeKeyedFixedDoubËA¼ay
+(
+LStÜeKeyed
+*
+\9a¡r
+);
+
+287 \1e
+DoStÜeKeyedFixedA¼ay
+(
+LStÜeKeyed
+*
+\9a¡r
+);
+
+289
+ g\8bm¶©e
+ <
+þass
+
+ gT
+>
+
+290 \1e
+Em\99VeùÜLßdICRegi¡\94s
+(
+T
+*
+\9a¡r
+);
+
+292
+ gZÚeLi¡
+<
+ gLEnv\9cÚm\92t
+*>
+ gdeÝtimiz©iÚs_
+;
+
+293
+ gZÚeLi¡
+<
+ gDeÝtimiz\94
+::
+JumpTabËEÁry
+>
+jump_\8fbË_
+;
+
+294
+ gZÚeLi¡
+<
+ gHªdË
+<
+ gObjeù
+> >
+ gdeÝtimiz©iÚ_l\99\94®s_
+;
+
+295 \12
+ g\9al\9aed_funùiÚ_couÁ_
+;
+
+296
+ScÝe
+* cڡ
+ gscÝe_
+;
+
+297
+T¿n¦©iÚBufãr
+
+ g\8cª¦©iÚs_
+;
+
+298
+ gZÚeLi¡
+<
+ gLDeã¼edCode
+*>
+ gdeã¼ed_
+;
+
+299 \12
+ go¤_pc_off£t_
+;
+
+300
+boÞ
+
+ gäame_is_bu\9et_
+;
+
+304
+Saãpo\9atTabËBu\9ed\94
+
+ g§ãpo\9ats_
+;
+
+307
+LGResÞv\94
+
+ g»sÞv\94_
+;
+
+309
+ gSaãpo\9at
+::
+K\9ad
+
+ex³ùed_§ãpo\9at_k\9ad_
+;
+
+311 þas
+ cPushSaãpo\9atRegi¡\94sScÝe
+
+FINAL
+
+ gBASE_EMBEDDED
+ {
+
+312
+ gpublic
+:
+
+313
+ex¶ic\99
+
+PushSaãpo\9atRegi¡\94sScÝe
+(
+LCodeG\92
+*
+codeg\92
+)
+
+314 :
+codeg\92_
+(
+codeg\92
+) {
+
+315
+DCHECK
+(
+codeg\92_
+->
+\9afo
+()->
+is_ÿÎ\9ag
+());
+
+316
+DCHECK
+(
+codeg\92_
+->
+ex³ùed_§ãpo\9at_k\9ad_
+ =ð
+Saãpo\9at
+::
+kSim¶e
+);
+
+317
+ gcodeg\92_
+->
+ gex³ùed_§ãpo\9at_k\9ad_
+ =
+Saãpo\9at
+::
+kW\99hRegi¡\94s
+;
+
+318
+StÜeRegi¡\94sS\8f\8bStub
+
+¡ub
+(
+codeg\92_
+->
+isީe
+());
+
+319
+ gcodeg\92_
+->
+ gmasm_
+->
+C®lStub
+(&
+¡ub
+);
+
+322 ~
+PushSaãpo\9atRegi¡\94sScÝe
+() {
+
+323
+DCHECK
+(
+codeg\92_
+->
+ex³ùed_§ãpo\9at_k\9ad_
+ =ð
+Saãpo\9at
+::
+kW\99hRegi¡\94s
+);
+
+324
+Re¡ÜeRegi¡\94sS\8f\8bStub
+
+¡ub
+(
+codeg\92_
+->
+isީe
+());
+
+325
+ gcodeg\92_
+->
+ gmasm_
+->
+C®lStub
+(&
+¡ub
+);
+
+326
+ gcodeg\92_
+->
+ gex³ùed_§ãpo\9at_k\9ad_
+ =
+Saãpo\9at
+::
+kSim¶e
+;
+
+329
+ g´iv©e
+:
+
+330
+LCodeG\92
+*
+codeg\92_
+;
+
+333
+ä\9bnd
+
+þass
+
+ gLDeã¼edCode
+;
+
+334
+ä\9bnd
+
+þass
+
+ gLEnv\9cÚm\92t
+;
+
+335
+ä\9bnd
+
+þass
+
+ gSaãpo\9atG\92\94©Ü
+;
+
+336
+DISALLOW_COPY_AND_ASSIGN
+(
+LCodeG\92
+);
+
+340 þas
+ cLDeã¼edCode
+ :
+public
+
+ZÚeObjeù
+ {
+
+341
+public
+:
+
+342
+ex¶ic\99
+
+LDeã¼edCode
+(
+LCodeG\92
+*
+codeg\92
+)
+
+343 :
+codeg\92_
+(
+codeg\92
+),
+
+344
+ex\8bº®_ex\99_
+(
+NULL
+),
+
+345
+\9a¡ruùiÚ_\9adex_
+(
+codeg\92
+->
+cu¼\92t_\9a¡ruùiÚ_
+) {
+
+346
+ gcodeg\92
+->
+AddDeã¼edCode
+(
+this
+);
+
+349
+ gv\9ctu®
+ ~
+LDeã¼edCode
+() {}
+
+350
+v\9ctu®
+ \1e
+G\92\94©e
+() = 0;
+
+351
+v\9ctu®
+
+LIn¡ruùiÚ
+*
+\9a¡r
+() = 0;
+
+353 \1e
+S\91Ex\99
+(
+Lab\96
+*
+ex\99
+è{
+ gex\8bº®_ex\99_
+ =\83xit; }
+
+354
+Lab\96
+*
+\92\8cy
+(è{ \15 &
+ g\92\8cy_
+; }
+
+355
+Lab\96
+*
+ex\99
+(è{ \15
+ gex\8bº®_ex\99_
+ !ð
+NULL
+ ?
+ex\8bº®_ex\99_
+ : &
+ex\99_
+; }
+
+356 \12
+\9a¡ruùiÚ_\9adex
+(ècÚ¡ { \15
+ g\9a¡ruùiÚ_\9adex_
+; }
+
+358
+ g´Ùeùed
+:
+
+359
+LCodeG\92
+*
+codeg\92
+(ècÚ¡ { \15
+codeg\92_
+; }
+
+360
+MaüoAs£mbËr
+*
+masm
+(ècÚ¡ { \15
+ gcodeg\92_
+->masm(); }
+
+362
+ g´iv©e
+:
+
+363
+LCodeG\92
+*
+codeg\92_
+;
+
+364
+Lab\96
+
+ g\92\8cy_
+;
+
+365
+Lab\96
+
+ gex\99_
+;
+
+366
+Lab\96
+*
+ gex\8bº®_ex\99_
+;
+
+367 \12
+ g\9a¡ruùiÚ_\9adex_
+;
+
+ @lithium-gap-resolver-ppc.cc
+
+5 \ 2
+ ~"¤c/v8.h
+"
+
+7 \ 2
+ ~"¤c/µc/l\99hium-codeg\92-µc.h
+"
+
+8 \ 2
+ ~"¤c/µc/l\99hium-g-»sÞv\94-µc.h
+"
+
+10
+Çme¥aû
+
+ gv8
+ {
+
+11
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+13 \18cڡ
+Regi¡\94
+
+ gkSavedV®ueRegi¡\94
+ = {11};
+
+15
+ gLGResÞv\94
+::
+LGResÞv\94
+(
+LCodeG\92
+*
+owÃr
+)
+
+16 :
+cg\92_
+(
+owÃr
+),
+
+17
+moves_
+(32,
+owÃr
+->
+zÚe
+()),
+
+18
+roÙ_\9adex_
+(0),
+
+19
+\9a_cyþe_
+(
+çl£
+),
+
+20
+§ved_de¡\9a©iÚ_
+(
+NULL
+) {}
+
+23 \1e
+ gLGResÞv\94
+::
+ResÞve
+(
+LP¬®ËlMove
+*
+·¿Î\96_move
+) {
+
+24
+DCHECK
+(
+moves_
+.
+is_em±y
+());
+
+26
+Bu\9edIn\99\9flMoveLi¡
+(
+·¿Î\96_move
+);
+
+28 \ f\12
+ gi
+ = 0; i <
+ gmoves_
+.
+Ëngth
+(); ++i) {
+
+29
+LMoveO³¿nds
+
+ gmove
+ =
+moves_
+[
+i
+];
+
+33 ià(!
+ gmove
+.
+IsElim\9a©ed
+(è&& !move.
+sourû
+()->
+IsCÚ¡ªtO³¿nd
+()) {
+
+34
+ groÙ_\9adex_
+ =
+i
+;
+
+35
+P\94fÜmMove
+(
+i
+);
+
+36 ià(
+ g\9a_cyþe_
+) {
+
+37
+Re¡ÜeV®ue
+();
+
+43 \ f\12
+ gi
+ = 0; i <
+ gmoves_
+.
+Ëngth
+(); ++i) {
+
+44 ià(!
+ gmoves_
+[
+i
+].
+IsElim\9a©ed
+()) {
+
+45
+DCHECK
+(
+moves_
+[
+i
+].
+sourû
+()->
+IsCÚ¡ªtO³¿nd
+());
+
+46
+Em\99Move
+(
+i
+);
+
+50
+ gmoves_
+.
+Rew\9ad
+(0);
+
+54 \1e
+ gLGResÞv\94
+::
+Bu\9edIn\99\9flMoveLi¡
+(
+LP¬®ËlMove
+*
+·¿Î\96_move
+) {
+
+59 cڡ
+ZÚeLi¡
+<
+LMoveO³¿nds
+>*
+moves
+ =
+·¿Î\96_move
+->
+move_Ý\94ªds
+();
+
+60 \ f\12
+ gi
+ = 0; i <
+ gmoves
+->
+Ëngth
+(); ++i) {
+
+61
+LMoveO³¿nds
+
+ gmove
+ =
+moves
+->
+©
+(
+i
+);
+
+62 ià(!
+ gmove
+.
+IsRedundªt
+()è
+ gmoves_
+.
+Add
+(
+move
+,
+cg\92_
+->
+zÚe
+());
+
+64
+V\94ify
+();
+
+68 \1e
+ gLGResÞv\94
+::
+P\94fÜmMove
+(\12
+\9adex
+) {
+
+83
+DCHECK
+(!
+moves_
+[
+\9adex
+].
+IsP\92d\9ag
+());
+
+84
+DCHECK
+(!
+moves_
+[
+\9adex
+].
+IsRedundªt
+());
+
+89
+DCHECK
+(
+moves_
+[
+\9adex
+].
+sourû
+(è!ð
+NULL
+);
+
+90
+LO³¿nd
+*
+ gde¡\9a©iÚ
+ =
+moves_
+[
+\9adex
+].
+de¡\9a©iÚ
+();
+
+91
+ gmoves_
+[
+\9adex
+].
+£t_de¡\9a©iÚ
+(
+NULL
+);
+
+97 \ f\12
+ gi
+ = 0; i <
+ gmoves_
+.
+Ëngth
+(); ++i) {
+
+98
+LMoveO³¿nds
+
+ gÙh\94_move
+ =
+moves_
+[
+i
+];
+
+99 ià(
+ gÙh\94_move
+.
+Blocks
+(
+de¡\9a©iÚ
+è&& !Ùh\94_move.
+IsP\92d\9ag
+()) {
+
+100
+P\94fÜmMove
+(
+i
+);
+
+109
+ gmoves_
+[
+\9adex
+].
+£t_de¡\9a©iÚ
+(
+de¡\9a©iÚ
+);
+
+114
+LMoveO³¿nds
+
+ gÙh\94_move
+ =
+moves_
+[
+roÙ_\9adex_
+];
+
+115 ià(
+ gÙh\94_move
+.
+Blocks
+(
+de¡\9a©iÚ
+)) {
+
+116
+DCHECK
+(
+Ùh\94_move
+.
+IsP\92d\9ag
+());
+
+117
+B»akCyþe
+(
+\9adex
+);
+
+122
+Em\99Move
+(
+\9adex
+);
+
+126 \1e
+ gLGResÞv\94
+::
+V\94ify
+() {
+
+127 #ifdeà
+ENABLE_SLOW_DCHECKS
+
+
+129 \ f\12
+i
+ = 0;
+ gi
+ <
+ gmoves_
+.
+Ëngth
+(); ++i) {
+
+130
+LO³¿nd
+*
+ gde¡\9a©iÚ
+ =
+moves_
+[
+i
+].
+de¡\9a©iÚ
+();
+
+131 \ f\12
+ gj
+ =
+i
+ + 1; j <
+ gmoves_
+.
+Ëngth
+(); ++j) {
+
+132
+SLOW_DCHECK
+(!
+de¡\9a©iÚ
+->
+Equ®s
+(
+moves_
+[
+j
+].destination()));
+
+138 \ 1
+ #__
+
+ `ACCESS_MASM
+(
+cg\92_
+->
+ `masm
+())
+
+ )
+
+140 \1e
+ gLGResÞv\94
+::
+B»akCyþe
+(\12
+\9adex
+) {
+
+144
+DCHECK
+(
+moves_
+[
+\9adex
+].
+de¡\9a©iÚ
+()->
+Equ®s
+(moves_[
+roÙ_\9adex_
+].
+sourû
+()));
+
+145
+DCHECK
+(!
+\9a_cyþe_
+);
+
+146
+ g\9a_cyþe_
+ =
+\8cue
+;
+
+147
+LO³¿nd
+*
+ gsourû
+ =
+moves_
+[
+\9adex
+].
+sourû
+();
+
+148
+ g§ved_de¡\9a©iÚ_
+ =
+moves_
+[
+\9adex
+].
+de¡\9a©iÚ
+();
+
+149 ià(
+ gsourû
+->
+IsRegi¡\94
+()) {
+
+150
+__
+
+mr
+(
+kSavedV®ueRegi¡\94
+,
+cg\92_
+->
+ToRegi¡\94
+(
+sourû
+));
+
+151 } \vià(
+ gsourû
+->
+IsS\8fckSlÙ
+()) {
+
+152
+__
+
+LßdP
+(
+kSavedV®ueRegi¡\94
+,
+cg\92_
+->
+ToMemO³¿nd
+(
+sourû
+));
+
+153 } \vià(
+ gsourû
+->
+IsDoubËRegi¡\94
+()) {
+
+154
+__
+
+fmr
+(
+kSü©chDoubËReg
+,
+cg\92_
+->
+ToDoubËRegi¡\94
+(
+sourû
+));
+
+155 } \vià(
+ gsourû
+->
+IsDoubËS\8fckSlÙ
+()) {
+
+156
+__
+
+lfd
+(
+kSü©chDoubËReg
+,
+cg\92_
+->
+ToMemO³¿nd
+(
+sourû
+));
+
+158
+UNREACHABLE
+();
+
+161
+ gmoves_
+[
+\9adex
+].
+Elim\9a©e
+();
+
+165 \1e
+ gLGResÞv\94
+::
+Re¡ÜeV®ue
+() {
+
+166
+DCHECK
+(
+\9a_cyþe_
+);
+
+167
+DCHECK
+(
+§ved_de¡\9a©iÚ_
+ !ð
+NULL
+);
+
+170 ià(
+ g§ved_de¡\9a©iÚ_
+->
+IsRegi¡\94
+()) {
+
+171
+__
+
+mr
+(
+cg\92_
+->
+ToRegi¡\94
+(
+§ved_de¡\9a©iÚ_
+),
+kSavedV®ueRegi¡\94
+);
+
+172 } \vià(
+ g§ved_de¡\9a©iÚ_
+->
+IsS\8fckSlÙ
+()) {
+
+173
+__
+
+StÜeP
+(
+kSavedV®ueRegi¡\94
+,
+cg\92_
+->
+ToMemO³¿nd
+(
+§ved_de¡\9a©iÚ_
+));
+
+174 } \vià(
+ g§ved_de¡\9a©iÚ_
+->
+IsDoubËRegi¡\94
+()) {
+
+175
+__
+
+fmr
+(
+cg\92_
+->
+ToDoubËRegi¡\94
+(
+§ved_de¡\9a©iÚ_
+),
+kSü©chDoubËReg
+);
+
+176 } \vià(
+ g§ved_de¡\9a©iÚ_
+->
+IsDoubËS\8fckSlÙ
+()) {
+
+177
+__
+
+¡fd
+(
+kSü©chDoubËReg
+,
+cg\92_
+->
+ToMemO³¿nd
+(
+§ved_de¡\9a©iÚ_
+));
+
+179
+UNREACHABLE
+();
+
+182
+ g\9a_cyþe_
+ =
+çl£
+;
+
+183
+ g§ved_de¡\9a©iÚ_
+ =
+NULL
+;
+
+187 \1e
+ gLGResÞv\94
+::
+Em\99Move
+(\12
+\9adex
+) {
+
+188
+LO³¿nd
+*
+sourû
+ =
+moves_
+[
+\9adex
+].source();
+
+189
+LO³¿nd
+*
+ gde¡\9a©iÚ
+ =
+moves_
+[
+\9adex
+].
+de¡\9a©iÚ
+();
+
+194 ià(
+ gsourû
+->
+IsRegi¡\94
+()) {
+
+195
+Regi¡\94
+
+ gsourû_»gi¡\94
+ =
+cg\92_
+->
+ToRegi¡\94
+(
+sourû
+);
+
+196 ià(
+ gde¡\9a©iÚ
+->
+IsRegi¡\94
+()) {
+
+197
+__
+
+mr
+(
+cg\92_
+->
+ToRegi¡\94
+(
+de¡\9a©iÚ
+),
+sourû_»gi¡\94
+);
+
+199
+DCHECK
+(
+de¡\9a©iÚ
+->
+IsS\8fckSlÙ
+());
+
+200
+__
+
+StÜeP
+(
+sourû_»gi¡\94
+,
+cg\92_
+->
+ToMemO³¿nd
+(
+de¡\9a©iÚ
+));
+
+202 } \vià(
+ gsourû
+->
+IsS\8fckSlÙ
+()) {
+
+203
+MemO³¿nd
+
+ gsourû_Ý\94ªd
+ =
+cg\92_
+->
+ToMemO³¿nd
+(
+sourû
+);
+
+204 ià(
+ gde¡\9a©iÚ
+->
+IsRegi¡\94
+()) {
+
+205
+__
+
+LßdP
+(
+cg\92_
+->
+ToRegi¡\94
+(
+de¡\9a©iÚ
+),
+sourû_Ý\94ªd
+);
+
+207
+DCHECK
+(
+de¡\9a©iÚ
+->
+IsS\8fckSlÙ
+());
+
+208
+MemO³¿nd
+
+ gde¡\9a©iÚ_Ý\94ªd
+ =
+cg\92_
+->
+ToMemO³¿nd
+(
+de¡\9a©iÚ
+);
+
+209 ià(
+ g\9a_cyþe_
+) {
+
+210
+__
+
+LßdP
+(
+\9d
+,
+sourû_Ý\94ªd
+);
+
+211
+__
+
+StÜeP
+(
+\9d
+,
+de¡\9a©iÚ_Ý\94ªd
+);
+
+213
+__
+
+LßdP
+(
+kSavedV®ueRegi¡\94
+,
+sourû_Ý\94ªd
+);
+
+214
+__
+
+StÜeP
+(
+kSavedV®ueRegi¡\94
+,
+de¡\9a©iÚ_Ý\94ªd
+);
+
+218 } \vià(
+ gsourû
+->
+IsCÚ¡ªtO³¿nd
+()) {
+
+219
+LCÚ¡ªtO³¿nd
+*
+ gcÚ¡ªt_sourû
+ = LCÚ¡ªtO³¿nd::
+ÿ¡
+(
+sourû
+);
+
+220 ià(
+ gde¡\9a©iÚ
+->
+IsRegi¡\94
+()) {
+
+221
+Regi¡\94
+
+ gd¡
+ =
+cg\92_
+->
+ToRegi¡\94
+(
+de¡\9a©iÚ
+);
+
+222 ià(
+ gcg\92_
+->
+IsIÁeg\9432
+(
+cÚ¡ªt_sourû
+)) {
+
+223
+ gcg\92_
+->
+Em\99LßdIÁeg\94CÚ¡ªt
+(
+cÚ¡ªt_sourû
+,
+d¡
+);
+
+225
+__
+
+Move
+(
+d¡
+,
+cg\92_
+->
+ToHªdË
+(
+cÚ¡ªt_sourû
+));
+
+227 } \vià(
+ gde¡\9a©iÚ
+->
+IsDoubËRegi¡\94
+()) {
+
+228
+DoubËRegi¡\94
+
+ g»suÉ
+ =
+cg\92_
+->
+ToDoubËRegi¡\94
+(
+de¡\9a©iÚ
+);
+
+229 \b
+ gv
+ =
+cg\92_
+->
+ToDoubË
+(
+cÚ¡ªt_sourû
+);
+
+230
+__
+
+LßdDoubËL\99\94®
+(
+»suÉ
+,
+v
+,
+\9d
+);
+
+232
+DCHECK
+(
+de¡\9a©iÚ
+->
+IsS\8fckSlÙ
+());
+
+233
+DCHECK
+(!
+\9a_cyþe_
+);
+
+234 ià(
+ gcg\92_
+->
+IsIÁeg\9432
+(
+cÚ¡ªt_sourû
+)) {
+
+235
+ gcg\92_
+->
+Em\99LßdIÁeg\94CÚ¡ªt
+(
+cÚ¡ªt_sourû
+,
+kSavedV®ueRegi¡\94
+);
+
+237
+__
+
+Move
+(
+kSavedV®ueRegi¡\94
+,
+cg\92_
+->
+ToHªdË
+(
+cÚ¡ªt_sourû
+));
+
+239
+__
+
+StÜeP
+(
+kSavedV®ueRegi¡\94
+,
+cg\92_
+->
+ToMemO³¿nd
+(
+de¡\9a©iÚ
+));
+
+242 } \vià(
+ gsourû
+->
+IsDoubËRegi¡\94
+()) {
+
+243
+DoubËRegi¡\94
+
+ gsourû_»gi¡\94
+ =
+cg\92_
+->
+ToDoubËRegi¡\94
+(
+sourû
+);
+
+244 ià(
+ gde¡\9a©iÚ
+->
+IsDoubËRegi¡\94
+()) {
+
+245
+__
+
+fmr
+(
+cg\92_
+->
+ToDoubËRegi¡\94
+(
+de¡\9a©iÚ
+),
+sourû_»gi¡\94
+);
+
+247
+DCHECK
+(
+de¡\9a©iÚ
+->
+IsDoubËS\8fckSlÙ
+());
+
+248
+__
+
+¡fd
+(
+sourû_»gi¡\94
+,
+cg\92_
+->
+ToMemO³¿nd
+(
+de¡\9a©iÚ
+));
+
+251 } \vià(
+ gsourû
+->
+IsDoubËS\8fckSlÙ
+()) {
+
+252
+MemO³¿nd
+
+ gsourû_Ý\94ªd
+ =
+cg\92_
+->
+ToMemO³¿nd
+(
+sourû
+);
+
+253 ià(
+ gde¡\9a©iÚ
+->
+IsDoubËRegi¡\94
+()) {
+
+254
+__
+
+lfd
+(
+cg\92_
+->
+ToDoubËRegi¡\94
+(
+de¡\9a©iÚ
+),
+sourû_Ý\94ªd
+);
+
+256
+DCHECK
+(
+de¡\9a©iÚ
+->
+IsDoubËS\8fckSlÙ
+());
+
+257
+MemO³¿nd
+
+ gde¡\9a©iÚ_Ý\94ªd
+ =
+cg\92_
+->
+ToMemO³¿nd
+(
+de¡\9a©iÚ
+);
+
+258 ià(
+ g\9a_cyþe_
+) {
+
+261 #ià
+V8_TARGET_ARCH_PPC64
+
+
+262
+__
+
+ld
+(
+kSavedV®ueRegi¡\94
+,
+sourû_Ý\94ªd
+);
+
+263
+__
+
+¡d
+(
+kSavedV®ueRegi¡\94
+,
+de¡\9a©iÚ_Ý\94ªd
+);
+
+265
+MemO³¿nd
+
+ gsourû_high_Ý\94ªd
+ =
+cg\92_
+->
+ToHighMemO³¿nd
+(
+sourû
+);
+
+266
+MemO³¿nd
+
+ gde¡\9a©iÚ_high_Ý\94ªd
+ =
+
+267
+cg\92_
+->
+ToHighMemO³¿nd
+(
+de¡\9a©iÚ
+);
+
+268
+__
+
+lwz
+(
+kSavedV®ueRegi¡\94
+,
+sourû_Ý\94ªd
+);
+
+269
+__
+
+¡w
+(
+kSavedV®ueRegi¡\94
+,
+de¡\9a©iÚ_Ý\94ªd
+);
+
+270
+__
+
+lwz
+(
+kSavedV®ueRegi¡\94
+,
+sourû_high_Ý\94ªd
+);
+
+271
+__
+
+¡w
+(
+kSavedV®ueRegi¡\94
+,
+de¡\9a©iÚ_high_Ý\94ªd
+);
+
+274
+__
+
+lfd
+(
+kSü©chDoubËReg
+,
+sourû_Ý\94ªd
+);
+
+275
+__
+
+¡fd
+(
+kSü©chDoubËReg
+,
+de¡\9a©iÚ_Ý\94ªd
+);
+
+279
+UNREACHABLE
+();
+
+282
+ gmoves_
+[
+\9adex
+].
+Elim\9a©e
+();
+
+286 #undeà
+__
+
+
+ @lithium-gap-resolver-ppc.h
+
+5 #iâdeà
+V8_PPC_LITHIUM_GAP_RESOLVER_PPC_H_
+
+
+6 \ 1
+ #V8_PPC_LITHIUM_GAP_RESOLVER_PPC_H_
+
+
+ )
+
+8 \ 2
+ ~"¤c/v8.h
+"
+
+10 \ 2
+ ~"¤c/l\99hium.h
+"
+
+12
+Çme¥aû
+
+ gv8
+ {
+
+13
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+15
+þass
+
+ gLCodeG\92
+;
+
+16
+þass
+
+ gLGResÞv\94
+;
+
+18 þas
+ cLGResÞv\94
+
+FINAL
+
+ gBASE_EMBEDDED
+ {
+
+19
+ gpublic
+:
+
+20
+ex¶ic\99
+
+LGResÞv\94
+(
+LCodeG\92
+*
+owÃr
+);
+
+23 \1e
+ResÞve
+(
+LP¬®ËlMove
+*
+·¿Î\96_move
+);
+
+25
+ g´iv©e
+:
+
+27 \1e
+Bu\9edIn\99\9flMoveLi¡
+(
+LP¬®ËlMove
+*
+·¿Î\96_move
+);
+
+31 \1e
+P\94fÜmMove
+(\12
+\9adex
+);
+
+36 \1e
+B»akCyþe
+(\12
+\9adex
+);
+
+40 \1e
+Re¡ÜeV®ue
+();
+
+43 \1e
+Em\99Move
+(\12
+\9adex
+);
+
+46 \1e
+V\94ify
+();
+
+48
+LCodeG\92
+*
+ gcg\92_
+;
+
+51
+ gZÚeLi¡
+<
+ gLMoveO³¿nds
+>
+ gmoves_
+;
+
+53 \12
+ groÙ_\9adex_
+;
+
+54
+boÞ
+
+ g\9a_cyþe_
+;
+
+55
+LO³¿nd
+*
+ g§ved_de¡\9a©iÚ_
+;
+
+ @lithium-ppc.cc
+
+5 \ 2
+ ~<s¡»am
+>
+
+7 \ 2
+ ~"¤c/v8.h
+"
+
+9 \ 2
+ ~"¤c/hydrog\92-o¤.h
+"
+
+10 \ 2
+ ~"¤c/l\99hium-\9al.h
+"
+
+11 \ 2
+ ~"¤c/µc/l\99hium-codeg\92-µc.h
+"
+
+13
+Çme¥aû
+
+ gv8
+ {
+
+14
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+16 \ 1
+ #DEFINE_COMPILE
+(
+ty³
+) \
+
+17 \1e
+L
+##
+ty³
+::
+ `Comp\9eeToN©ive
+(
+LCodeG\92
+*
+g\92\94©Ü
+) { \
+
+18
+g\92\94©Ü
+->
+Do
+##
+ `ty³
+(
+this
+); \
+
+19 }
+
+ )
+
+20
+LITHIUM_CONCRETE_INSTRUCTION_LIST
+(
+DEFINE_COMPILE
+)
+
+21 #undeà
+DEFINE_COMPILE
+
+
+23 #ifdeà
+DEBUG
+
+
+24 \1e
+ gLIn¡ruùiÚ
+::
+V\94ifyC®l
+() {
+
+29
+DCHECK
+(
+Ou\8dut
+(è=ð
+NULL
+ ||
+LUÇÎoÿ\8bd
+::
+ÿ¡
+(Ou\8dut())->
+HasFixedPÞicy
+() ||
+
+30 !
+LUÇÎoÿ\8bd
+::
+ÿ¡
+(
+Ou\8dut
+())->
+HasRegi¡\94PÞicy
+());
+
+31 \ f
+U£I\8b¿tÜ
+
+\99
+(
+this
+); !
+ g\99
+.
+DÚe
+(); it.
+Advªû
+()) {
+
+32
+LUÇÎoÿ\8bd
+*
+ gÝ\94ªd
+ = LUÇÎoÿ\8bd::
+ÿ¡
+(
+\99
+.
+Cu¼\92t
+());
+
+33
+DCHECK
+(
+Ý\94ªd
+->
+HasFixedPÞicy
+(è|| o³¿nd->
+IsU£dAtS\8f¹
+());
+
+35 \ f
+TempI\8b¿tÜ
+
+\99
+(
+this
+); !
+ g\99
+.
+DÚe
+(); it.
+Advªû
+()) {
+
+36
+LUÇÎoÿ\8bd
+*
+ gÝ\94ªd
+ = LUÇÎoÿ\8bd::
+ÿ¡
+(
+\99
+.
+Cu¼\92t
+());
+
+37
+DCHECK
+(
+Ý\94ªd
+->
+HasFixedPÞicy
+(è|| !Ý\94ªd->
+HasRegi¡\94PÞicy
+());
+
+43 \1e
+ gLIn¡ruùiÚ
+::
+Pr\9atTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+44
+¡»am
+->
+Add
+("% ",
+this
+->
+MÃmÚic
+());
+
+46
+Pr\9atOu\8dutO³¿ndTo
+(
+¡»am
+);
+
+48
+Pr\9atD©aTo
+(
+¡»am
+);
+
+50 ià(
+HasEnv\9cÚm\92t
+()) {
+
+51
+ g¡»am
+->
+Add
+(" ");
+
+52
+\92v\9cÚm\92t
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+55 ià(
+HasPo\9a\8brM
+()) {
+
+56
+ g¡»am
+->
+Add
+(" ");
+
+57
+po\9a\8br_m
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+62 \1e
+ gLIn¡ruùiÚ
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+63
+¡»am
+->
+Add
+("= ");
+
+64 \ f\12
+ gi
+ = 0; i <
+IÅutCouÁ
+(); i++) {
+
+65 ià(
+ gi
+ > 0è
+ g¡»am
+->
+Add
+(" ");
+
+66 ià(
+IÅutAt
+(
+i
+è=ð
+NULL
+) {
+
+67
+¡»am
+->
+Add
+("NULL");
+
+69
+IÅutAt
+(
+i
+)->
+Pr\9atTo
+(
+¡»am
+);
+
+75 \1e
+ gLIn¡ruùiÚ
+::
+Pr\9atOu\8dutO³¿ndTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+76 ià(
+HasResuÉ
+()è
+»suÉ
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+80 \1e
+ gLLab\96
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+81
+LG
+::
+Pr\9atD©aTo
+(
+¡»am
+);
+
+82
+LLab\96
+*
+ g»p
+ =
+»¶aûm\92t
+();
+
+83 ià(
+ g»p
+ !ð
+NULL
+) {
+
+84
+¡»am
+->
+Add
+(" D\97d block\84\95Ïûd w\99h B%d",
+»p
+->
+block_id
+());
+
+89
+boÞ
+
+ gLG
+::
+IsRedundªt
+() const {
+
+90 \ f\12
+i
+ = 0;
+ gi
+ < 4; i++) {
+
+91 ià(
+ g·¿Î\96_moves_
+[
+i
+] !ð
+NULL
+ && !
+·¿Î\96_moves_
+[i]->
+IsRedundªt
+()) {
+
+92 \15
+çl£
+;
+
+96 \15
+ g\8cue
+;
+
+100 \1e
+ gLG
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+101 \ f\12
+i
+ = 0;
+ gi
+ < 4; i++) {
+
+102
+ g¡»am
+->
+Add
+("(");
+
+103 ià(
+ g·¿Î\96_moves_
+[
+i
+] !ð
+NULL
+) {
+
+104
+·¿Î\96_moves_
+[
+i
+]->
+Pr\9atD©aTo
+(
+¡»am
+);
+
+106
+ g¡»am
+->
+Add
+(") ");
+
+111 cڡ \ 5*
+ gLAr\99hm\91icD
+::
+MÃmÚic
+() const {
+
+112 \1a
+Ý
+()) {
+
+113 \ 4
+Tok\92
+::
+ADD
+:
+
+115 \ 4
+ gTok\92
+::
+SUB
+:
+
+117 \ 4
+ gTok\92
+::
+MUL
+:
+
+119 \ 4
+ gTok\92
+::
+DIV
+:
+
+121 \ 4
+ gTok\92
+::
+MOD
+:
+
+124
+UNREACHABLE
+();
+
+125 \15
+ gNULL
+;
+
+130 cڡ \ 5*
+ gLAr\99hm\91icT
+::
+MÃmÚic
+() const {
+
+131 \1a
+Ý
+()) {
+
+132 \ 4
+Tok\92
+::
+ADD
+:
+
+134 \ 4
+ gTok\92
+::
+SUB
+:
+
+136 \ 4
+ gTok\92
+::
+MUL
+:
+
+138 \ 4
+ gTok\92
+::
+MOD
+:
+
+140 \ 4
+ gTok\92
+::
+DIV
+:
+
+142 \ 4
+ gTok\92
+::
+BIT_AND
+:
+
+144 \ 4
+ gTok\92
+::
+BIT_OR
+:
+
+146 \ 4
+ gTok\92
+::
+BIT_XOR
+:
+
+148 \ 4
+ gTok\92
+::
+ROR
+:
+
+150 \ 4
+ gTok\92
+::
+SHL
+:
+
+152 \ 4
+ gTok\92
+::
+SAR
+:
+
+154 \ 4
+ gTok\92
+::
+SHR
+:
+
+157
+UNREACHABLE
+();
+
+158 \15
+ gNULL
+;
+
+163
+boÞ
+
+ gLGÙo
+::
+HasIÁ\94e¡\9agComm\92t
+(
+LCodeG\92
+*
+g\92
+) const {
+
+164 \15 !
+g\92
+->
+IsNextEm\99\8bdBlock
+(
+block_id
+());
+
+168 \1e
+ gLGÙo
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+169
+¡»am
+->
+Add
+("B%d",
+block_id
+());
+
+173 \1e
+ gLB¿nch
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+174
+¡»am
+->
+Add
+("B%d | B%d oÀ",
+\8cue_block_id
+(),
+çl£_block_id
+());
+
+175
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+179 \1e
+ gLCom·»Num\94icAndB¿nch
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+180
+¡»am
+->
+Add
+("if ");
+
+181
+Ëá
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+182
+ g¡»am
+->
+Add
+(" % ",
+Tok\92
+::
+S\8c\9ag
+(
+Ý
+()));
+
+183
+right
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+184
+ g¡»am
+->
+Add
+("\81h\92 B%d\83l£ B%d",
+\8cue_block_id
+(),
+çl£_block_id
+());
+
+188 \1e
+ gLIsObjeùAndB¿nch
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+189
+¡»am
+->
+Add
+("if is_object(");
+
+190
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+191
+ g¡»am
+->
+Add
+("èth\92 B%d\83l£ B%d",
+\8cue_block_id
+(),
+çl£_block_id
+());
+
+195 \1e
+ gLIsS\8c\9agAndB¿nch
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+196
+¡»am
+->
+Add
+("if is_string(");
+
+197
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+198
+ g¡»am
+->
+Add
+("èth\92 B%d\83l£ B%d",
+\8cue_block_id
+(),
+çl£_block_id
+());
+
+202 \1e
+ gLIsSmiAndB¿nch
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+203
+¡»am
+->
+Add
+("if is_smi(");
+
+204
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+205
+ g¡»am
+->
+Add
+("èth\92 B%d\83l£ B%d",
+\8cue_block_id
+(),
+çl£_block_id
+());
+
+209 \1e
+ gLIsUnd\91eùabËAndB¿nch
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+210
+¡»am
+->
+Add
+("if is_undetectable(");
+
+211
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+212
+ g¡»am
+->
+Add
+("èth\92 B%d\83l£ B%d",
+\8cue_block_id
+(),
+çl£_block_id
+());
+
+216 \1e
+ gLS\8c\9agCom·»AndB¿nch
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+217
+¡»am
+->
+Add
+("if string_compare(");
+
+218
+Ëá
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+219
+right
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+220
+ g¡»am
+->
+Add
+("èth\92 B%d\83l£ B%d",
+\8cue_block_id
+(),
+çl£_block_id
+());
+
+224 \1e
+ gLHasIn¡ªûTy³AndB¿nch
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+225
+¡»am
+->
+Add
+("if has_instance_type(");
+
+226
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+227
+ g¡»am
+->
+Add
+("èth\92 B%d\83l£ B%d",
+\8cue_block_id
+(),
+çl£_block_id
+());
+
+231 \1e
+ gLHasCachedA¼ayIndexAndB¿nch
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+232
+¡»am
+->
+Add
+("if has_cached_array_index(");
+
+233
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+234
+ g¡»am
+->
+Add
+("èth\92 B%d\83l£ B%d",
+\8cue_block_id
+(),
+çl£_block_id
+());
+
+238 \1e
+ gLCÏssOfTe¡AndB¿nch
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+239
+¡»am
+->
+Add
+("if class_of_test(");
+
+240
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+241
+ g¡»am
+->
+Add
+(", \"%o\"èth\92 B%d\83l£ B%d", *
+hydrog\92
+()->
+þass_Çme
+(),
+
+242
+\8cue_block_id
+(),
+çl£_block_id
+());
+
+246 \1e
+ gLTy³ofIsAndB¿nch
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+247
+¡»am
+->
+Add
+("if\81ypeof ");
+
+248
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+249
+ g¡»am
+->
+Add
+(" == \"%s\"\81hen B%d\83lse B%d",
+
+250
+hydrog\92
+()->
+ty³_l\99\94®
+()->
+ToCS\8c\9ag
+().
+g\91
+(),
+\8cue_block_id
+(),
+
+251
+çl£_block_id
+());
+
+255 \1e
+ gLStÜeCodeEÁry
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+256
+¡»am
+->
+Add
+(" = ");
+
+257
+funùiÚ
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+258
+ g¡»am
+->
+Add
+(".code_entry = ");
+
+259
+code_objeù
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+263 \1e
+ gLIÂ\94AÎoÿ\8bdObjeù
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+264
+¡»am
+->
+Add
+(" = ");
+
+265
+ba£_objeù
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+266
+ g¡»am
+->
+Add
+(" + ");
+
+267
+off£t
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+271 \1e
+ gLC®lJSFunùiÚ
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+272
+¡»am
+->
+Add
+("= ");
+
+273
+funùiÚ
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+274
+ g¡»am
+->
+Add
+("#%d / ",
+¬\99y
+());
+
+278 \1e
+ gLC®lW\99hDesü\9dtÜ
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+279 \ f\12
+i
+ = 0;
+ gi
+ <
+IÅutCouÁ
+(); i++) {
+
+280
+IÅutAt
+(
+i
+)->
+Pr\9atTo
+(
+¡»am
+);
+
+281
+ g¡»am
+->
+Add
+(" ");
+
+283
+ g¡»am
+->
+Add
+("#%d / ",
+¬\99y
+());
+
+287 \1e
+ gLLßdCÚ\8bxtSlÙ
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+288
+cڋxt
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+289
+ g¡»am
+->
+Add
+("[%d]",
+¦Ù_\9adex
+());
+
+293 \1e
+ gLStÜeCÚ\8bxtSlÙ
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+294
+cڋxt
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+295
+ g¡»am
+->
+Add
+("[%d] <- ",
+¦Ù_\9adex
+());
+
+296
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+300 \1e
+ gLInvokeFunùiÚ
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+301
+¡»am
+->
+Add
+("= ");
+
+302
+funùiÚ
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+303
+ g¡»am
+->
+Add
+(" #%d / ",
+¬\99y
+());
+
+307 \1e
+ gLC®lNew
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+308
+¡»am
+->
+Add
+("= ");
+
+309
+cÚ¡ruùÜ
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+310
+ g¡»am
+->
+Add
+(" #%d / ",
+¬\99y
+());
+
+314 \1e
+ gLC®lNewA¼ay
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+315
+¡»am
+->
+Add
+("= ");
+
+316
+cÚ¡ruùÜ
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+317
+ g¡»am
+->
+Add
+(" #%d / ",
+¬\99y
+());
+
+318
+EËm\92tsK\9ad
+
+ gk\9ad
+ =
+hydrog\92
+()->
+\96em\92ts_k\9ad
+();
+
+319
+ g¡»am
+->
+Add
+(" (%sè",
+EËm\92tsK\9adToS\8c\9ag
+(
+k\9ad
+));
+
+323 \1e
+ gLAcûssArgum\92tsAt
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+324
+¬gum\92ts
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+325
+ g¡»am
+->
+Add
+("\86ength ");
+
+326
+Ëngth
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+327
+ g¡»am
+->
+Add
+(" index ");
+
+328
+\9adex
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+332 \1e
+ gLStÜeNamedF\9bld
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+333
+objeù
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+334
+ g¡d
+::
+o¡r\9ag¡»am
+
+os
+;
+
+335
+ gos
+ <<
+hydrog\92
+()->
+acûss
+() << " <- ";
+
+336
+ g¡»am
+->
+Add
+(
+os
+.
+¡r
+().
+c_¡r
+());
+
+337
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+341 \1e
+ gLStÜeNamedG\92\94ic
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+342
+objeù
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+343
+ g¡»am
+->
+Add
+(".");
+
+344
+ g¡»am
+->
+Add
+(
+S\8c\9ag
+::
+ÿ¡
+(*
+Çme
+())->
+ToCS\8c\9ag
+().
+g\91
+());
+
+345
+ g¡»am
+->
+Add
+(" <- ");
+
+346
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+350 \1e
+ gLLßdKeyed
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+351
+\96em\92ts
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+352
+ g¡»am
+->
+Add
+("[");
+
+353
+key
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+354 ià(
+hydrog\92
+()->
+IsDehoi¡ed
+()) {
+
+355
+ g¡»am
+->
+Add
+(" + %d]",
+ba£_off£t
+());
+
+357
+ g¡»am
+->
+Add
+("]");
+
+362 \1e
+ gLStÜeKeyed
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+363
+\96em\92ts
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+364
+ g¡»am
+->
+Add
+("[");
+
+365
+key
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+366 ià(
+hydrog\92
+()->
+IsDehoi¡ed
+()) {
+
+367
+ g¡»am
+->
+Add
+(" + %d] <-",
+ba£_off£t
+());
+
+369
+ g¡»am
+->
+Add
+("] <- ");
+
+372 ià(
+v®ue
+(è=ð
+NULL
+) {
+
+373
+DCHECK
+(
+hydrog\92
+()->
+IsCÚ¡ªtHÞeStÜe
+() &&
+
+374
+hydrog\92
+()->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+375
+ g¡»am
+->
+Add
+("<the hole(nan)>");
+
+377
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+382 \1e
+ gLStÜeKeyedG\92\94ic
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+383
+objeù
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+384
+ g¡»am
+->
+Add
+("[");
+
+385
+key
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+386
+ g¡»am
+->
+Add
+("] <- ");
+
+387
+v®ue
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+391 \1e
+ gLT¿ns\99iÚEËm\92tsK\9ad
+::
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+) {
+
+392
+objeù
+()->
+Pr\9atTo
+(
+¡»am
+);
+
+393
+ g¡»am
+->
+Add
+(" %°-> %p", *
+Üig\9a®_m
+(), *
+\8cªs\99iÚed_m
+());
+
+397 \12
+ gLPÏtfÜmChunk
+::
+G\91NextSp\9elIndex
+(
+Regi¡\94K\9ad
+
+k\9ad
+) {
+
+399 ià(
+k\9ad
+ =ð
+DOUBLE_REGISTERS
+è
+¥\9el_¦Ù_couÁ_
+++;
+
+400 \15
+ g¥\9el_¦Ù_couÁ_
+++;
+
+404
+LO³¿nd
+*
+ gLPÏtfÜmChunk
+::
+G\91NextSp\9elSlÙ
+(
+Regi¡\94K\9ad
+
+k\9ad
+) {
+
+405 \12
+\9adex
+ =
+G\91NextSp\9elIndex
+(
+k\9ad
+);
+
+406 ià(
+ gk\9ad
+ =ð
+DOUBLE_REGISTERS
+) {
+
+407 \15
+LDoubËS\8fckSlÙ
+::
+C»©e
+(
+\9adex
+,
+zÚe
+());
+
+409
+DCHECK
+(
+k\9ad
+ =ð
+GENERAL_REGISTERS
+);
+
+410 \15
+ gLS\8fckSlÙ
+::
+C»©e
+(
+\9adex
+,
+zÚe
+());
+
+415
+LPÏtfÜmChunk
+*
+ gLChunkBu\9ed\94
+::
+Bu\9ed
+() {
+
+416
+DCHECK
+(
+is_unu£d
+());
+
+417
+ gchunk_
+ =
+Ãw
+ (
+zÚe
+()è
+LPÏtfÜmChunk
+(
+\9afo
+(),
+g¿ph
+());
+
+418
+LPha£
+
+pha£
+("L_Bu\9ed\9ag chunk",
+chunk_
+);
+
+419
+ g¡©us_
+ =
+BUILDING
+;
+
+423 ià(
+g¿ph
+()->
+has_o¤
+()) {
+
+424 \ f\12
+ gi
+ =
+g¿ph
+()->
+o¤
+()->
+UnÝtimizedF¿meSlÙs
+(); i > 0; i--) {
+
+425
+ gchunk_
+->
+G\91NextSp\9elIndex
+(
+GENERAL_REGISTERS
+);
+
+429 cڡ
+ gZÚeLi¡
+<
+ gHBasicBlock
+*>*
+ gblocks
+ =
+g¿ph
+()->
+blocks
+();
+
+430 \ f\12
+ gi
+ = 0; i <
+ gblocks
+->
+Ëngth
+(); i++) {
+
+431
+HBasicBlock
+*
+ gÃxt
+ =
+NULL
+;
+
+432 ià(
+ gi
+ <
+ gblocks
+->
+Ëngth
+(è- 1è
+ gÃxt
+ =
+blocks
+->
+©
+(
+i
+ + 1);
+
+433
+DoBasicBlock
+(
+blocks
+->
+©
+(
+i
+),
+Ãxt
+);
+
+434 ià(
+is_ab܋d
+()è\15
+ gNULL
+;
+
+436
+ g¡©us_
+ =
+DONE
+;
+
+437 \15
+ gchunk_
+;
+
+441
+LUÇÎoÿ\8bd
+*
+ gLChunkBu\9ed\94
+::
+ToUÇÎoÿ\8bd
+(
+Regi¡\94
+
+»g
+) {
+
+442 \15
+Ãw
+ (
+zÚe
+()è
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+FIXED_REGISTER
+,
+
+443
+Regi¡\94
+::
+ToAÎoÿtiÚIndex
+(
+»g
+));
+
+447
+LUÇÎoÿ\8bd
+*
+ gLChunkBu\9ed\94
+::
+ToUÇÎoÿ\8bd
+(
+DoubËRegi¡\94
+
+»g
+) {
+
+448 \15
+Ãw
+ (
+zÚe
+()è
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+FIXED_DOUBLE_REGISTER
+,
+
+449
+DoubËRegi¡\94
+::
+ToAÎoÿtiÚIndex
+(
+»g
+));
+
+453
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£Fixed
+(
+HV®ue
+*
+v®ue
+,
+Regi¡\94
+
+fixed_»gi¡\94
+) {
+
+454 \15
+U£
+(
+v®ue
+,
+ToUÇÎoÿ\8bd
+(
+fixed_»gi¡\94
+));
+
+458
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£FixedDoubË
+(
+HV®ue
+*
+v®ue
+,
+DoubËRegi¡\94
+
+»g
+) {
+
+459 \15
+U£
+(
+v®ue
+,
+ToUÇÎoÿ\8bd
+(
+»g
+));
+
+463
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£Regi¡\94
+(
+HV®ue
+*
+v®ue
+) {
+
+464 \15
+U£
+(
+v®ue
+,
+
+465
+Ãw
+ (
+zÚe
+()è
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+MUST_HAVE_REGISTER
+));
+
+469
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£Regi¡\94AtS\8f¹
+(
+HV®ue
+*
+v®ue
+) {
+
+470 \15
+U£
+(
+v®ue
+,
+Ãw
+ (
+zÚe
+()è
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+MUST_HAVE_REGISTER
+,
+
+471
+LUÇÎoÿ\8bd
+::
+USED_AT_START
+));
+
+475
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£TempRegi¡\94
+(
+HV®ue
+*
+v®ue
+) {
+
+476 \15
+U£
+(
+v®ue
+,
+Ãw
+ (
+zÚe
+()è
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+WRITABLE_REGISTER
+));
+
+480
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£
+(
+HV®ue
+*
+v®ue
+) {
+
+481 \15
+U£
+(
+v®ue
+,
+Ãw
+ (
+zÚe
+()è
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+NONE
+));
+
+485
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£AtS\8f¹
+(
+HV®ue
+*
+v®ue
+) {
+
+486 \15
+U£
+(
+v®ue
+,
+Ãw
+ (
+zÚe
+())
+
+487
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+NONE
+, LUÇÎoÿ\8bd::
+USED_AT_START
+));
+
+491
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£OrCÚ¡ªt
+(
+HV®ue
+*
+v®ue
+) {
+
+492 \15
+v®ue
+->
+IsCÚ¡ªt
+()
+
+493 ?
+chunk_
+->
+Def\9aeCÚ¡ªtO³¿nd
+(
+HCÚ¡ªt
+::
+ÿ¡
+(
+v®ue
+))
+
+494 :
+U£
+(
+v®ue
+);
+
+498
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£OrCÚ¡ªtAtS\8f¹
+(
+HV®ue
+*
+v®ue
+) {
+
+499 \15
+v®ue
+->
+IsCÚ¡ªt
+()
+
+500 ?
+chunk_
+->
+Def\9aeCÚ¡ªtO³¿nd
+(
+HCÚ¡ªt
+::
+ÿ¡
+(
+v®ue
+))
+
+501 :
+U£AtS\8f¹
+(
+v®ue
+);
+
+505
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£Regi¡\94OrCÚ¡ªt
+(
+HV®ue
+*
+v®ue
+) {
+
+506 \15
+v®ue
+->
+IsCÚ¡ªt
+()
+
+507 ?
+chunk_
+->
+Def\9aeCÚ¡ªtO³¿nd
+(
+HCÚ¡ªt
+::
+ÿ¡
+(
+v®ue
+))
+
+508 :
+U£Regi¡\94
+(
+v®ue
+);
+
+512
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+HV®ue
+*
+v®ue
+) {
+
+513 \15
+v®ue
+->
+IsCÚ¡ªt
+()
+
+514 ?
+chunk_
+->
+Def\9aeCÚ¡ªtO³¿nd
+(
+HCÚ¡ªt
+::
+ÿ¡
+(
+v®ue
+))
+
+515 :
+U£Regi¡\94AtS\8f¹
+(
+v®ue
+);
+
+519
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£CÚ¡ªt
+(
+HV®ue
+*
+v®ue
+) {
+
+520 \15
+chunk_
+->
+Def\9aeCÚ¡ªtO³¿nd
+(
+HCÚ¡ªt
+::
+ÿ¡
+(
+v®ue
+));
+
+524
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£Any
+(
+HV®ue
+*
+v®ue
+) {
+
+525 \15
+v®ue
+->
+IsCÚ¡ªt
+()
+
+526 ?
+chunk_
+->
+Def\9aeCÚ¡ªtO³¿nd
+(
+HCÚ¡ªt
+::
+ÿ¡
+(
+v®ue
+))
+
+527 :
+U£
+(
+v®ue
+,
+Ãw
+ (
+zÚe
+()è
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+ANY
+));
+
+531
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+U£
+(
+HV®ue
+*
+v®ue
+,
+LUÇÎoÿ\8bd
+*
+Ý\94ªd
+) {
+
+532 ià(
+ gv®ue
+->
+Em\99AtU£s
+()) {
+
+533
+HIn¡ruùiÚ
+*
+ g\9a¡r
+ = HIn¡ruùiÚ::
+ÿ¡
+(
+v®ue
+);
+
+534
+Vis\99In¡ruùiÚ
+(
+\9a¡r
+);
+
+536
+ gÝ\94ªd
+->
+£t_v\9ctu®_»gi¡\94
+(
+v®ue
+->
+id
+());
+
+537 \15
+ gÝ\94ªd
+;
+
+541
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+Def\9ae
+(
+LTem¶©eResuÉIn¡ruùiÚ
+<1>*
+\9a¡r
+,
+
+542
+LUÇÎoÿ\8bd
+*
+»suÉ
+) {
+
+543
+ g»suÉ
+->
+£t_v\9ctu®_»gi¡\94
+(
+cu¼\92t_\9a¡ruùiÚ_
+->
+id
+());
+
+544
+ g\9a¡r
+->
+£t_»suÉ
+(
+»suÉ
+);
+
+545 \15
+ g\9a¡r
+;
+
+549
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+Def\9aeAsRegi¡\94
+(
+
+550
+LTem¶©eResuÉIn¡ruùiÚ
+<1>*
+\9a¡r
+) {
+
+551 \15
+Def\9ae
+(
+\9a¡r
+,
+
+552
+Ãw
+ (
+zÚe
+()è
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+MUST_HAVE_REGISTER
+));
+
+556
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+Def\9aeAsSp\9eËd
+(
+
+557
+LTem¶©eResuÉIn¡ruùiÚ
+<1>*
+\9a¡r
+, \12
+\9adex
+) {
+
+558 \15
+Def\9ae
+(
+\9a¡r
+,
+
+559
+Ãw
+ (
+zÚe
+()è
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+FIXED_SLOT
+,
+\9adex
+));
+
+563
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+Def\9aeSameAsF\9c¡
+(
+
+564
+LTem¶©eResuÉIn¡ruùiÚ
+<1>*
+\9a¡r
+) {
+
+565 \15
+Def\9ae
+(
+\9a¡r
+,
+
+566
+Ãw
+ (
+zÚe
+()è
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+SAME_AS_FIRST_INPUT
+));
+
+570
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+Def\9aeFixed
+(
+LTem¶©eResuÉIn¡ruùiÚ
+<1>*
+\9a¡r
+,
+
+571
+Regi¡\94
+
+»g
+) {
+
+572 \15
+Def\9ae
+(
+\9a¡r
+,
+ToUÇÎoÿ\8bd
+(
+»g
+));
+
+576
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+Def\9aeFixedDoubË
+(
+
+577
+LTem¶©eResuÉIn¡ruùiÚ
+<1>*
+\9a¡r
+,
+DoubËRegi¡\94
+
+»g
+) {
+
+578 \15
+Def\9ae
+(
+\9a¡r
+,
+ToUÇÎoÿ\8bd
+(
+»g
+));
+
+582
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+AssignEnv\9cÚm\92t
+(LIn¡ruùiÚ*
+\9a¡r
+) {
+
+583
+HEnv\9cÚm\92t
+*
+hydrog\92_\92v
+ =
+cu¼\92t_block_
+->
+Ï¡_\92v\9cÚm\92t
+();
+
+584 \12
+ g¬gum\92t_\9adex_accumuÏtÜ
+ = 0;
+
+585
+ gZÚeLi¡
+<
+ gHV®ue
+*>
+objeùs_to_m©\94\9flize
+(0,
+zÚe
+());
+
+586
+ g\9a¡r
+->
+£t_\92v\9cÚm\92t
+(
+C»©eEnv\9cÚm\92t
+(
+
+587
+hydrog\92_\92v
+, &
+¬gum\92t_\9adex_accumuÏtÜ
+, &
+objeùs_to_m©\94\9flize
+));
+
+588 \15
+ g\9a¡r
+;
+
+592
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+M¬kAsC®l
+(LIn¡ruùiÚ*
+\9a¡r
+,
+
+593
+HIn¡ruùiÚ
+*
+h\9a¡r
+,
+
+594
+CªDeÝtimize
+
+ÿn_deÝtimize
+) {
+
+595
+\9afo
+()->
+M¬kAsNÚDeã¼edC®l\9ag
+();
+
+596 #ifdeà
+DEBUG
+
+
+597
+ g\9a¡r
+->
+V\94ifyC®l
+();
+
+599
+ g\9a¡r
+->
+M¬kAsC®l
+();
+
+600
+ g\9a¡r
+ =
+AssignPo\9a\8brM
+(
+\9a¡r
+);
+
+606
+boÞ
+
+ gÃeds_\92v\9cÚm\92t
+ = (
+ÿn_deÝtimize
+ =ð
+CAN_DEOPTIMIZE_EAGERLY
+) ||
+
+607 !
+h\9a¡r
+->
+HasOb£rvabËSideEfãùs
+();
+
+608 ià(
+ gÃeds_\92v\9cÚm\92t
+ && !
+ g\9a¡r
+->
+HasEnv\9cÚm\92t
+()) {
+
+609
+ g\9a¡r
+ =
+AssignEnv\9cÚm\92t
+(
+\9a¡r
+);
+
+611
+ g\9a¡r
+->
+\92v\9cÚm\92t
+()->
+£t_has_b\93n_u£d
+();
+
+614 \15
+ g\9a¡r
+;
+
+618
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+AssignPo\9a\8brM
+(LIn¡ruùiÚ*
+\9a¡r
+) {
+
+619
+DCHECK
+(!
+\9a¡r
+->
+HasPo\9a\8brM
+());
+
+620
+ g\9a¡r
+->
+£t_po\9a\8br_m
+(
+Ãw
+ (
+zÚe
+()è
+LPo\9a\8brM
+(zone()));
+
+621 \15
+ g\9a¡r
+;
+
+625
+LUÇÎoÿ\8bd
+*
+ gLChunkBu\9ed\94
+::
+TempRegi¡\94
+() {
+
+626
+LUÇÎoÿ\8bd
+*
+Ý\94ªd
+ =
+
+627
+Ãw
+ (
+zÚe
+()è
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+MUST_HAVE_REGISTER
+);
+
+628 \12
+ gv»g
+ =
+®loÿtÜ_
+->
+G\91V\9ctu®Regi¡\94
+();
+
+629 ià(!
+ g®loÿtÜ_
+->
+AÎoÿtiÚOk
+()) {
+
+630
+AbÜt
+(
+kOutOfV\9ctu®Regi¡\94sWh\9eeTry\9agToAÎoÿ\8bTempRegi¡\94
+);
+
+631
+ gv»g
+ = 0;
+
+633
+ gÝ\94ªd
+->
+£t_v\9ctu®_»gi¡\94
+(
+v»g
+);
+
+634 \15
+ gÝ\94ªd
+;
+
+638
+LUÇÎoÿ\8bd
+*
+ gLChunkBu\9ed\94
+::
+TempDoubËRegi¡\94
+() {
+
+639
+LUÇÎoÿ\8bd
+*
+Ý\94ªd
+ =
+
+640
+Ãw
+ (
+zÚe
+()è
+LUÇÎoÿ\8bd
+(LUÇÎoÿ\8bd::
+MUST_HAVE_DOUBLE_REGISTER
+);
+
+641 \12
+ gv»g
+ =
+®loÿtÜ_
+->
+G\91V\9ctu®Regi¡\94
+();
+
+642 ià(!
+ g®loÿtÜ_
+->
+AÎoÿtiÚOk
+()) {
+
+643
+AbÜt
+(
+kOutOfV\9ctu®Regi¡\94sWh\9eeTry\9agToAÎoÿ\8bTempRegi¡\94
+);
+
+644
+ gv»g
+ = 0;
+
+646
+ gÝ\94ªd
+->
+£t_v\9ctu®_»gi¡\94
+(
+v»g
+);
+
+647 \15
+ gÝ\94ªd
+;
+
+651
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+FixedTemp
+(
+Regi¡\94
+
+»g
+) {
+
+652
+LUÇÎoÿ\8bd
+*
+Ý\94ªd
+ =
+ToUÇÎoÿ\8bd
+(
+»g
+);
+
+653
+DCHECK
+(
+Ý\94ªd
+->
+HasFixedPÞicy
+());
+
+654 \15
+ gÝ\94ªd
+;
+
+658
+LO³¿nd
+*
+ gLChunkBu\9ed\94
+::
+FixedTemp
+(
+DoubËRegi¡\94
+
+»g
+) {
+
+659
+LUÇÎoÿ\8bd
+*
+Ý\94ªd
+ =
+ToUÇÎoÿ\8bd
+(
+»g
+);
+
+660
+DCHECK
+(
+Ý\94ªd
+->
+HasFixedPÞicy
+());
+
+661 \15
+ gÝ\94ªd
+;
+
+665
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoBlockEÁry
+(
+HBlockEÁry
+*
+\9a¡r
+) {
+
+666 \15
+Ãw
+ (
+zÚe
+()è
+LLab\96
+(
+\9a¡r
+->
+block
+());
+
+670
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoDummyU£
+(
+HDummyU£
+*
+\9a¡r
+) {
+
+671 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LDummyU£
+(
+U£Any
+(
+\9a¡r
+->
+v®ue
+())));
+
+675
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoEnv\9cÚm\92tM¬k\94
+(
+HEnv\9cÚm\92tM¬k\94
+*
+\9a¡r
+) {
+
+676
+UNREACHABLE
+();
+
+677 \15
+ gNULL
+;
+
+681
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoDeÝtimize
+(
+HDeÝtimize
+*
+\9a¡r
+) {
+
+682 \15
+AssignEnv\9cÚm\92t
+(
+Ãw
+ (
+zÚe
+()è
+LDeÝtimize
+);
+
+686
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoShiá
+(
+Tok\92
+::
+V®ue
+
+Ý
+,
+
+687
+HB\99wi£B\9a¬yO³¿tiÚ
+*
+\9a¡r
+) {
+
+688 ià(
+ g\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+()) {
+
+689
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+690
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+691
+LO³¿nd
+*
+ gËá
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+Ëá
+());
+
+693
+HV®ue
+*
+ gright_v®ue
+ =
+\9a¡r
+->
+right
+();
+
+694
+LO³¿nd
+*
+ gright
+ =
+NULL
+;
+
+695 \12
+ gcÚ¡ªt_v®ue
+ = 0;
+
+696
+boÞ
+
+ gdÛs_deÝt
+ =
+çl£
+;
+
+697 ià(
+ gright_v®ue
+->
+IsCÚ¡ªt
+()) {
+
+698
+HCÚ¡ªt
+*
+ gcÚ¡ªt
+ = HCÚ¡ªt::
+ÿ¡
+(
+right_v®ue
+);
+
+699
+ gright
+ =
+chunk_
+->
+Def\9aeCÚ¡ªtO³¿nd
+(
+cÚ¡ªt
+);
+
+700
+ gcÚ¡ªt_v®ue
+ =
+cÚ¡ªt
+->
+IÁeg\9432V®ue
+() & 0x1f;
+
+703 ià(
+ g\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmi
+(è&&
+ gcÚ¡ªt_v®ue
+ > 0) {
+
+704
+ gdÛs_deÝt
+ = !
+\9a¡r
+->
+CheckU£sFÜFÏg
+(
+HV®ue
+::
+kTrunÿt\9agToSmi
+);
+
+707
+ gright
+ =
+U£Regi¡\94AtS\8f¹
+(
+right_v®ue
+);
+
+712 ià(
+ gÝ
+ =ð
+Tok\92
+::
+SHR
+ &&
+cÚ¡ªt_v®ue
+ == 0) {
+
+713
+dÛs_deÝt
+ = !
+\9a¡r
+->
+CheckFÏg
+(
+HIn¡ruùiÚ
+::
+kU\9at32
+);
+
+716
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+717
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LShiáI
+(
+Ý
+,
+Ëá
+,
+right
+,
+dÛs_deÝt
+));
+
+718 \15
+ gdÛs_deÝt
+ ?
+AssignEnv\9cÚm\92t
+(
+»suÉ
+) :\84esult;
+
+720 \15
+DoAr\99hm\91icT
+(
+Ý
+,
+\9a¡r
+);
+
+725
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoAr\99hm\91icD
+(
+Tok\92
+::
+V®ue
+
+Ý
+,
+
+726
+HAr\99hm\91icB\9a¬yO³¿tiÚ
+*
+\9a¡r
+) {
+
+727
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+728
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+729
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+730 ià(
+ gÝ
+ =ð
+Tok\92
+::
+MOD
+) {
+
+731
+LO³¿nd
+*
+Ëá
+ =
+U£FixedDoubË
+(
+\9a¡r
+->Ëá(),
+d1
+);
+
+732
+LO³¿nd
+*
+ gright
+ =
+U£FixedDoubË
+(
+\9a¡r
+->
+right
+(),
+d2
+);
+
+733
+LAr\99hm\91icD
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLAr\99hm\91icD(
+Ý
+,
+Ëá
+,
+right
+);
+
+737 \15
+M¬kAsC®l
+(
+Def\9aeFixedDoubË
+(
+»suÉ
+,
+d1
+),
+\9a¡r
+);
+
+739
+LO³¿nd
+*
+ gËá
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+Ëá
+());
+
+740
+LO³¿nd
+*
+ gright
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+right
+());
+
+741
+LAr\99hm\91icD
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLAr\99hm\91icD(
+Ý
+,
+Ëá
+,
+right
+);
+
+742 \15
+Def\9aeAsRegi¡\94
+(
+»suÉ
+);
+
+747
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoAr\99hm\91icT
+(
+Tok\92
+::
+V®ue
+
+Ý
+,
+
+748
+HB\9a¬yO³¿tiÚ
+*
+\9a¡r
+) {
+
+749
+HV®ue
+*
+ gËá
+ =
+\9a¡r
+->
+Ëá
+();
+
+750
+HV®ue
+*
+ gright
+ =
+\9a¡r
+->
+right
+();
+
+751
+DCHECK
+(
+Ëá
+->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+752
+DCHECK
+(
+right
+->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+753
+LO³¿nd
+*
+ gcڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->
+cڋxt
+(),
+ý
+);
+
+754
+LO³¿nd
+*
+ gËá_Ý\94ªd
+ =
+U£Fixed
+(
+Ëá
+,
+r4
+);
+
+755
+LO³¿nd
+*
+ gright_Ý\94ªd
+ =
+U£Fixed
+(
+right
+,
+r3
+);
+
+756
+LAr\99hm\91icT
+*
+ g»suÉ
+ =
+
+757
+Ãw
+ (
+zÚe
+()è
+LAr\99hm\91icT
+(
+Ý
+,
+cڋxt
+,
+Ëá_Ý\94ªd
+,
+right_Ý\94ªd
+);
+
+758 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+);
+
+762 \1e
+ gLChunkBu\9ed\94
+::
+DoBasicBlock
+(
+HBasicBlock
+*
+block
+, HBasicBlock*
+Ãxt_block
+) {
+
+763
+DCHECK
+(
+is_bu\9ed\9ag
+());
+
+764
+ gcu¼\92t_block_
+ =
+block
+;
+
+765
+ gÃxt_block_
+ =
+Ãxt_block
+;
+
+766 ià(
+ gblock
+->
+IsS\8f¹Block
+()) {
+
+767
+ gblock
+->
+Upd©eEnv\9cÚm\92t
+(
+g¿ph_
+->
+¡¬t_\92v\9cÚm\92t
+());
+
+768
+ g¬gum\92t_couÁ_
+ = 0;
+
+769 } \vià(
+ gblock
+->
+´edeûssÜs
+()->
+Ëngth
+() == 1) {
+
+772
+DCHECK
+(
+block
+->
+phis
+()->
+Ëngth
+() == 0);
+
+773
+HBasicBlock
+*
+ g´ed
+ =
+block
+->
+´edeûssÜs
+()->
+©
+(0);
+
+774
+HEnv\9cÚm\92t
+*
+ gÏ¡_\92v\9cÚm\92t
+ =
+´ed
+->
+Ï¡_\92v\9cÚm\92t
+();
+
+775
+DCHECK
+(
+Ï¡_\92v\9cÚm\92t
+ !ð
+NULL
+);
+
+777 ià(
+ g´ed
+->
+\92d
+()->
+SecÚdSucûssÜ
+(è=ð
+NULL
+) {
+
+778
+DCHECK
+(
+´ed
+->
+\92d
+()->
+F\9c¡SucûssÜ
+(è=ð
+block
+);
+
+780 ià(
+ g´ed
+->
+\92d
+()->
+F\9c¡SucûssÜ
+()->
+block_id
+(è>
+ gblock
+->block_id() ||
+
+781
+ g´ed
+->
+\92d
+()->
+SecÚdSucûssÜ
+()->
+block_id
+(è>
+ gblock
+->block_id()) {
+
+782
+ gÏ¡_\92v\9cÚm\92t
+ =
+Ï¡_\92v\9cÚm\92t
+->
+CÝy
+();
+
+785
+ gblock
+->
+Upd©eEnv\9cÚm\92t
+(
+Ï¡_\92v\9cÚm\92t
+);
+
+786
+DCHECK
+(
+´ed
+->
+¬gum\92t_couÁ
+() >= 0);
+
+787
+ g¬gum\92t_couÁ_
+ =
+´ed
+->
+¬gum\92t_couÁ
+();
+
+790
+HBasicBlock
+*
+ g´ed
+ =
+block
+->
+´edeûssÜs
+()->
+©
+(0);
+
+792
+HEnv\9cÚm\92t
+*
+ gÏ¡_\92v\9cÚm\92t
+ =
+´ed
+->
+Ï¡_\92v\9cÚm\92t
+();
+
+793 \ f\12
+ gi
+ = 0; i <
+ gblock
+->
+phis
+()->
+Ëngth
+(); ++i) {
+
+794
+HPhi
+*
+ gphi
+ =
+block
+->
+phis
+()->
+©
+(
+i
+);
+
+795 ià(
+ gphi
+->
+HasM\94gedIndex
+()) {
+
+796
+ gÏ¡_\92v\9cÚm\92t
+->
+S\91V®ueAt
+(
+phi
+->
+m\94ged_\9adex
+(),\85hi);
+
+799 \ f\12
+ gi
+ = 0; i <
+ gblock
+->
+d\96\91ed_phis
+()->
+Ëngth
+(); ++i) {
+
+800 ià(
+ gblock
+->
+d\96\91ed_phis
+()->
+©
+(
+i
+è<
+ gÏ¡_\92v\9cÚm\92t
+->
+Ëngth
+()) {
+
+801
+ gÏ¡_\92v\9cÚm\92t
+->
+S\91V®ueAt
+(
+block
+->
+d\96\91ed_phis
+()->
+©
+(
+i
+),
+
+802
+g¿ph_
+->
+G\91CÚ¡ªtUndef\9aed
+());
+
+805
+ gblock
+->
+Upd©eEnv\9cÚm\92t
+(
+Ï¡_\92v\9cÚm\92t
+);
+
+807
+ g¬gum\92t_couÁ_
+ =
+´ed
+->
+¬gum\92t_couÁ
+();
+
+809
+HIn¡ruùiÚ
+*
+ gcu¼\92t
+ =
+block
+->
+f\9c¡
+();
+
+810 \12
+ g¡¬t
+ =
+chunk_
+->
+\9a¡ruùiÚs
+()->
+Ëngth
+();
+
+811 \1f
+ gcu¼\92t
+ !ð
+NULL
+ && !
+is_ab܋d
+()) {
+
+813 ià(!
+cu¼\92t
+->
+Em\99AtU£s
+()) {
+
+814
+Vis\99In¡ruùiÚ
+(
+cu¼\92t
+);
+
+816
+ gcu¼\92t
+ =
+cu¼\92t
+->
+Ãxt
+();
+
+818 \12
+ g\92d
+ =
+chunk_
+->
+\9a¡ruùiÚs
+()->
+Ëngth
+() - 1;
+
+819 ià(
+ g\92d
+ >ð
+¡¬t
+) {
+
+820
+block
+->
+£t_f\9c¡_\9a¡ruùiÚ_\9adex
+(
+¡¬t
+);
+
+821
+ gblock
+->
+£t_Ï¡_\9a¡ruùiÚ_\9adex
+(
+\92d
+);
+
+823
+ gblock
+->
+£t_¬gum\92t_couÁ
+(
+¬gum\92t_couÁ_
+);
+
+824
+ gÃxt_block_
+ =
+NULL
+;
+
+825
+ gcu¼\92t_block_
+ =
+NULL
+;
+
+829 \1e
+ gLChunkBu\9ed\94
+::
+Vis\99In¡ruùiÚ
+(
+HIn¡ruùiÚ
+*
+cu¼\92t
+) {
+
+830
+HIn¡ruùiÚ
+*
+Þd_cu¼\92t
+ =
+cu¼\92t_\9a¡ruùiÚ_
+;
+
+831
+ gcu¼\92t_\9a¡ruùiÚ_
+ =
+cu¼\92t
+;
+
+833
+LIn¡ruùiÚ
+*
+ g\9a¡r
+ =
+NULL
+;
+
+834 ià(
+ gcu¼\92t
+->
+CªR\95ÏûW\99hDummyU£s
+()) {
+
+835 ià(
+ gcu¼\92t
+->
+O³¿ndCouÁ
+() == 0) {
+
+836
+\9a¡r
+ =
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LDummy
+());
+
+838
+DCHECK
+(!
+cu¼\92t
+->
+O³¿ndAt
+(0)->
+IsCÚ\8cÞIn¡ruùiÚ
+());
+
+839
+ g\9a¡r
+ =
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+())
+
+840
+LDummyU£
+(
+U£Any
+(
+cu¼\92t
+->
+O³¿ndAt
+(0))));
+
+842 \ f\12
+ gi
+ = 1; i <
+ gcu¼\92t
+->
+O³¿ndCouÁ
+(); ++i) {
+
+843 ià(
+ gcu¼\92t
+->
+O³¿ndAt
+(
+i
+)->
+IsCÚ\8cÞIn¡ruùiÚ
+()) \ 6;
+
+844
+LIn¡ruùiÚ
+*
+ gdummy
+ =
+
+845
+Ãw
+ (
+zÚe
+()è
+LDummyU£
+(
+U£Any
+(
+cu¼\92t
+->
+O³¿ndAt
+(
+i
+)));
+
+846
+ gdummy
+->
+£t_hydrog\92_v®ue
+(
+cu¼\92t
+);
+
+847
+ gchunk_
+->
+AddIn¡ruùiÚ
+(
+dummy
+,
+cu¼\92t_block_
+);
+
+850
+HBasicBlock
+*
+ gsucûssÜ
+;
+
+851 ià(
+ gcu¼\92t
+->
+IsCÚ\8cÞIn¡ruùiÚ
+() &&
+
+852
+ gHCÚ\8cÞIn¡ruùiÚ
+::
+ÿ¡
+(
+cu¼\92t
+)->
+KnownSucûssÜBlock
+(&
+sucûssÜ
+) &&
+
+853
+sucûssÜ
+ !ð
+NULL
+) {
+
+854
+\9a¡r
+ =
+Ãw
+ (
+zÚe
+()è
+LGÙo
+(
+sucûssÜ
+);
+
+856
+ g\9a¡r
+ =
+cu¼\92t
+->
+Comp\9eeToL\99hium
+(
+this
+);
+
+860
+ g¬gum\92t_couÁ_
+ +ð
+cu¼\92t
+->
+¬gum\92t_d\96\8f
+();
+
+861
+DCHECK
+(
+¬gum\92t_couÁ_
+ >= 0);
+
+863 ià(
+ g\9a¡r
+ !ð
+NULL
+) {
+
+864
+AddIn¡ruùiÚ
+(
+\9a¡r
+,
+cu¼\92t
+);
+
+867
+ gcu¼\92t_\9a¡ruùiÚ_
+ =
+Þd_cu¼\92t
+;
+
+871 \1e
+ gLChunkBu\9ed\94
+::
+AddIn¡ruùiÚ
+(
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+
+872
+HIn¡ruùiÚ
+*
+hydrog\92_v®
+) {
+
+875
+ g\9a¡r
+->
+£t_hydrog\92_v®ue
+(
+hydrog\92_v®
+);
+
+877 #ià
+DEBUG
+
+
+888 ià(!(
+ g\9a¡r
+->
+Clobb\94sRegi¡\94s
+() &&
+
+889
+ g\9a¡r
+->
+Clobb\94sDoubËRegi¡\94s
+(
+isީe
+()))) {
+
+890 \12
+ gfixed
+ = 0;
+
+891 \12
+ gu£d_©_¡¬t
+ = 0;
+
+892 \ f
+U£I\8b¿tÜ
+
+\99
+(
+\9a¡r
+); !
+ g\99
+.
+DÚe
+(); it.
+Advªû
+()) {
+
+893
+LUÇÎoÿ\8bd
+*
+ gÝ\94ªd
+ = LUÇÎoÿ\8bd::
+ÿ¡
+(
+\99
+.
+Cu¼\92t
+());
+
+894 ià(
+ gÝ\94ªd
+->
+IsU£dAtS\8f¹
+()è++
+ gu£d_©_¡¬t
+;
+
+896 ià(
+ g\9a¡r
+->
+Ou\8dut
+(è!ð
+NULL
+) {
+
+897 ià(
+LUÇÎoÿ\8bd
+::
+ÿ¡
+(
+\9a¡r
+->
+Ou\8dut
+())->
+HasFixedPÞicy
+()è++
+fixed
+;
+
+899 \ f
+TempI\8b¿tÜ
+
+\99
+(
+\9a¡r
+); !
+ g\99
+.
+DÚe
+(); it.
+Advªû
+()) {
+
+900
+LUÇÎoÿ\8bd
+*
+ gÝ\94ªd
+ = LUÇÎoÿ\8bd::
+ÿ¡
+(
+\99
+.
+Cu¼\92t
+());
+
+901 ià(
+ gÝ\94ªd
+->
+HasFixedPÞicy
+()è++
+ gfixed
+;
+
+903
+DCHECK
+(
+fixed
+ =ð0 ||
+u£d_©_¡¬t
+ == 0);
+
+907 ià(
+ gFLAG_¡»ss_po\9a\8br_ms
+ && !
+ g\9a¡r
+->
+HasPo\9a\8brM
+()) {
+
+908
+ g\9a¡r
+ =
+AssignPo\9a\8brM
+(
+\9a¡r
+);
+
+910 ià(
+ gFLAG_¡»ss_\92v\9cÚm\92ts
+ && !
+ g\9a¡r
+->
+HasEnv\9cÚm\92t
+()) {
+
+911
+ g\9a¡r
+ =
+AssignEnv\9cÚm\92t
+(
+\9a¡r
+);
+
+913
+ gchunk_
+->
+AddIn¡ruùiÚ
+(
+\9a¡r
+,
+cu¼\92t_block_
+);
+
+915 ià(
+ g\9a¡r
+->
+IsC®l
+()) {
+
+916
+HV®ue
+*
+ ghydrog\92_v®ue_fÜ_Ïzy_ba\9eout
+ =
+hydrog\92_v®
+;
+
+917
+LIn¡ruùiÚ
+*
+ g\9a¡ruùiÚ_Ãed\9ag_\92v\9cÚm\92t
+ =
+NULL
+;
+
+918 ià(
+ ghydrog\92_v®
+->
+HasOb£rvabËSideEfãùs
+()) {
+
+919
+HSimuϋ
+*
+ gsim
+ = HSimuϋ::
+ÿ¡
+(
+hydrog\92_v®
+->
+Ãxt
+());
+
+920
+ g\9a¡ruùiÚ_Ãed\9ag_\92v\9cÚm\92t
+ =
+\9a¡r
+;
+
+921
+ gsim
+->
+R\95ÏyEnv\9cÚm\92t
+(
+cu¼\92t_block_
+->
+Ï¡_\92v\9cÚm\92t
+());
+
+922
+ ghydrog\92_v®ue_fÜ_Ïzy_ba\9eout
+ =
+sim
+;
+
+924
+LIn¡ruùiÚ
+*
+ gba\9eout
+ =
+AssignEnv\9cÚm\92t
+(
+Ãw
+ (
+zÚe
+()è
+LLazyBa\9eout
+());
+
+925
+ gba\9eout
+->
+£t_hydrog\92_v®ue
+(
+hydrog\92_v®ue_fÜ_Ïzy_ba\9eout
+);
+
+926
+ gchunk_
+->
+AddIn¡ruùiÚ
+(
+ba\9eout
+,
+cu¼\92t_block_
+);
+
+927 ià(
+ g\9a¡ruùiÚ_Ãed\9ag_\92v\9cÚm\92t
+ !ð
+NULL
+) {
+
+930
+\9a¡ruùiÚ_Ãed\9ag_\92v\9cÚm\92t
+->
+S\91Deã¼edLazyDeÝtimiz©iÚEnv\9cÚm\92t
+(
+
+931
+ba\9eout
+->
+\92v\9cÚm\92t
+());
+
+937
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoGÙo
+(
+HGÙo
+*
+\9a¡r
+) {
+
+938 \15
+Ãw
+ (
+zÚe
+()è
+LGÙo
+(
+\9a¡r
+->
+F\9c¡SucûssÜ
+());
+
+942
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoB¿nch
+(
+HB¿nch
+*
+\9a¡r
+) {
+
+943
+HV®ue
+*
+v®ue
+ =
+\9a¡r
+->value();
+
+944
+R\95»£Á©iÚ
+
+ gr
+ =
+v®ue
+->
+»´e£Á©iÚ
+();
+
+945
+HTy³
+
+ gty³
+ =
+v®ue
+->
+ty³
+();
+
+946
+ gToBoޗnStub
+::
+Ty³s
+
+ex³ùed
+ =
+\9a¡r
+->
+ex³ùed_\9aput_ty³s
+();
+
+947 ià(
+ gex³ùed
+.
+IsEm±y
+()èex³ùed =
+ToBoޗnStub
+::
+Ty³s
+::
+G\92\94ic
+();
+
+949
+boÞ
+
+ g\97sy_ÿ£
+ = !
+r
+.
+IsTagged
+(è||
+ty³
+.
+IsBoޗn
+(è||\81y³.
+IsSmi
+() ||
+
+950
+ty³
+.
+IsJSA¼ay
+(è||\81y³.
+IsH\97pNumb\94
+(è||\81y³.
+IsS\8c\9ag
+();
+
+951
+LIn¡ruùiÚ
+*
+ gb¿nch
+ =
+Ãw
+ (
+zÚe
+()è
+LB¿nch
+(
+U£Regi¡\94
+(
+v®ue
+));
+
+952 ià(!
+ g\97sy_ÿ£
+ &&
+
+953 ((!
+ gex³ùed
+.
+CÚ\8f\9as
+(
+ToBoޗnStub
+::
+SMI
+è&&
+ex³ùed
+.
+N\93dsM
+()) ||
+
+954 !
+ex³ùed
+.
+IsG\92\94ic
+())) {
+
+955
+b¿nch
+ =
+AssignEnv\9cÚm\92t
+(branch);
+
+957 \15
+ gb¿nch
+;
+
+961
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoDebugB»ak
+(
+HDebugB»ak
+*
+\9a¡r
+) {
+
+962 \15
+Ãw
+ (
+zÚe
+()è
+LDebugB»ak
+();
+
+966
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCom·»M
+(
+HCom·»M
+*
+\9a¡r
+) {
+
+967
+DCHECK
+(
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+968
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+969
+LO³¿nd
+*
+ g\8bmp
+ =
+TempRegi¡\94
+();
+
+970 \15
+Ãw
+ (
+zÚe
+()è
+LCmpMAndB¿nch
+(
+v®ue
+,
+\8bmp
+);
+
+974
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoArgum\92tsL\92gth
+(
+HArgum\92tsL\92gth
+*
+\9a¡r
+) {
+
+975
+\9afo
+()->
+M¬kAsRequ\9cesF¿me
+();
+
+976
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+977 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LArgum\92tsL\92gth
+(
+v®ue
+));
+
+981
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoArgum\92tsEËm\92ts
+(
+HArgum\92tsEËm\92ts
+*
+\96ems
+) {
+
+982
+\9afo
+()->
+M¬kAsRequ\9cesF¿me
+();
+
+983 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LArgum\92tsEËm\92ts
+);
+
+987
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoIn¡ªûOf
+(
+HIn¡ªûOf
+*
+\9a¡r
+) {
+
+988
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+989
+LIn¡ªûOf
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()) LInstanceOf(
+
+990
+cڋxt
+,
+U£Fixed
+(
+\9a¡r
+->
+Ëá
+(),
+r3
+), U£Fixed(\9a¡r->
+right
+(),
+r4
+));
+
+991 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+);
+
+995
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoIn¡ªûOfKnownGlob®
+(
+
+996
+HIn¡ªûOfKnownGlob®
+*
+\9a¡r
+) {
+
+997
+LIn¡ªûOfKnownGlob®
+*
+»suÉ
+ =
+Ãw
+ (
+zÚe
+())
+
+998
+LIn¡ªûOfKnownGlob®
+(
+U£Fixed
+(
+\9a¡r
+->
+cڋxt
+(),
+ý
+),
+
+999
+U£Fixed
+(
+\9a¡r
+->
+Ëá
+(),
+r3
+),
+FixedTemp
+(
+r7
+));
+
+1000 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+);
+
+1004
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoW¿pReûiv\94
+(
+HW¿pReûiv\94
+*
+\9a¡r
+) {
+
+1005
+LO³¿nd
+*
+»ûiv\94
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->receiver());
+
+1006
+LO³¿nd
+*
+ gfunùiÚ
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+funùiÚ
+());
+
+1007
+LW¿pReûiv\94
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLW¿pReûiv\94(
+»ûiv\94
+,
+funùiÚ
+);
+
+1008 \15
+AssignEnv\9cÚm\92t
+(
+Def\9aeAsRegi¡\94
+(
+»suÉ
+));
+
+1012
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoAµlyArgum\92ts
+(
+HAµlyArgum\92ts
+*
+\9a¡r
+) {
+
+1013
+LO³¿nd
+*
+funùiÚ
+ =
+U£Fixed
+(
+\9a¡r
+->funùiÚ(),
+r4
+);
+
+1014
+LO³¿nd
+*
+ g»ûiv\94
+ =
+U£Fixed
+(
+\9a¡r
+->
+»ûiv\94
+(),
+r3
+);
+
+1015
+LO³¿nd
+*
+ gËngth
+ =
+U£Fixed
+(
+\9a¡r
+->
+Ëngth
+(),
+r5
+);
+
+1016
+LO³¿nd
+*
+ g\96em\92ts
+ =
+U£Fixed
+(
+\9a¡r
+->
+\96em\92ts
+(),
+r6
+);
+
+1017
+LAµlyArgum\92ts
+*
+ g»suÉ
+ =
+
+1018
+Ãw
+ (
+zÚe
+()è
+LAµlyArgum\92ts
+(
+funùiÚ
+,
+»ûiv\94
+,
+Ëngth
+,
+\96em\92ts
+);
+
+1019 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+,
+CAN_DEOPTIMIZE_EAGERLY
+);
+
+1023
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoPushArgum\92ts
+(
+HPushArgum\92ts
+*
+\9a¡r
+) {
+
+1024 \12
+¬gc
+ =
+\9a¡r
+->
+O³¿ndCouÁ
+();
+
+1025 \ f\12
+ gi
+ = 0; i <
+ g¬gc
+; ++i) {
+
+1026
+LO³¿nd
+*
+ g¬gum\92t
+ =
+U£
+(
+\9a¡r
+->
+¬gum\92t
+(
+i
+));
+
+1027
+AddIn¡ruùiÚ
+(
+Ãw
+ (
+zÚe
+()è
+LPushArgum\92t
+(
+¬gum\92t
+),
+\9a¡r
+);
+
+1029 \15
+ gNULL
+;
+
+1033
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoStÜeCodeEÁry
+(
+
+1034
+HStÜeCodeEÁry
+*
+¡Üe_code_\92\8cy
+) {
+
+1035
+LO³¿nd
+*
+funùiÚ
+ =
+U£Regi¡\94
+(
+¡Üe_code_\92\8cy
+->function());
+
+1036
+LO³¿nd
+*
+ gcode_objeù
+ =
+U£TempRegi¡\94
+(
+¡Üe_code_\92\8cy
+->
+code_objeù
+());
+
+1037 \15
+Ãw
+ (
+zÚe
+()è
+LStÜeCodeEÁry
+(
+funùiÚ
+,
+code_objeù
+);
+
+1041
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoIÂ\94AÎoÿ\8bdObjeù
+(
+
+1042
+HIÂ\94AÎoÿ\8bdObjeù
+*
+\9a¡r
+) {
+
+1043
+LO³¿nd
+*
+ba£_objeù
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->base_object());
+
+1044
+LO³¿nd
+*
+ goff£t
+ =
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+off£t
+());
+
+1045 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+())
+
+1046
+LIÂ\94AÎoÿ\8bdObjeù
+(
+ba£_objeù
+,
+off£t
+));
+
+1050
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoThisFunùiÚ
+(
+HThisFunùiÚ
+*
+\9a¡r
+) {
+
+1051 \15
+\9a¡r
+->
+HasNoU£s
+(è?
+NULL
+
+
+1052 :
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LThisFunùiÚ
+);
+
+1056
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCڋxt
+(
+HCڋxt
+*
+\9a¡r
+) {
+
+1057 ià(
+\9a¡r
+->
+HasNoU£s
+()è\15
+NULL
+;
+
+1059 ià(
+\9afo
+()->
+IsStub
+()) {
+
+1060 \15
+Def\9aeFixed
+(
+Ãw
+ (
+zÚe
+()è
+LCڋxt
+,
+ý
+);
+
+1063 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LCڋxt
+);
+
+1067
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoDeþ¬eGlob®s
+(
+HDeþ¬eGlob®s
+*
+\9a¡r
+) {
+
+1068
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+1069 \15
+M¬kAsC®l
+(
+Ãw
+ (
+zÚe
+()è
+LDeþ¬eGlob®s
+(
+cڋxt
+),
+\9a¡r
+);
+
+1073
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoC®lJSFunùiÚ
+(
+HC®lJSFunùiÚ
+*
+\9a¡r
+) {
+
+1074
+LO³¿nd
+*
+funùiÚ
+ =
+U£Fixed
+(
+\9a¡r
+->funùiÚ(),
+r4
+);
+
+1076
+LC®lJSFunùiÚ
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLC®lJSFunùiÚ(
+funùiÚ
+);
+
+1078 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+);
+
+1082
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoC®lW\99hDesü\9dtÜ
+(
+HC®lW\99hDesü\9dtÜ
+*
+\9a¡r
+) {
+
+1083
+C®lIÁ\94çûDesü\9dtÜ
+
+desü\9dtÜ
+ =
+\9a¡r
+->descriptor();
+
+1085
+LO³¿nd
+*
+ g\8frg\91
+ =
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+\8frg\91
+());
+
+1086
+ gZÚeLi¡
+<
+ gLO³¿nd
+*>
+Ýs
+(
+\9a¡r
+->
+O³¿ndCouÁ
+(),
+zÚe
+());
+
+1087
+ gÝs
+.
+Add
+(
+\8frg\91
+,
+zÚe
+());
+
+1088 \ f\12
+ gi
+ = 1; i <
+ g\9a¡r
+->
+O³¿ndCouÁ
+(); i++) {
+
+1089
+LO³¿nd
+*
+ gÝ
+ =
+
+1090
+U£Fixed
+(
+\9a¡r
+->
+O³¿ndAt
+(
+i
+),
+desü\9dtÜ
+.
+G\91P¬am\91\94Regi¡\94
+(i - 1));
+
+1091
+ gÝs
+.
+Add
+(
+Ý
+,
+zÚe
+());
+
+1094
+LC®lW\99hDesü\9dtÜ
+*
+ g»suÉ
+ =
+
+1095
+Ãw
+ (
+zÚe
+()è
+LC®lW\99hDesü\9dtÜ
+(
+desü\9dtÜ
+,
+Ýs
+, zone());
+
+1096 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+);
+
+1100
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoTa\9eC®lThroughMegamÜphicCache
+(
+
+1101
+HTa\9eC®lThroughMegamÜphicCache
+*
+\9a¡r
+) {
+
+1102
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+1103
+LO³¿nd
+*
+ g»ûiv\94_»gi¡\94
+ =
+
+1104
+U£Fixed
+(
+\9a¡r
+->
+»ûiv\94
+(),
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+());
+
+1105
+LO³¿nd
+*
+ gÇme_»gi¡\94
+ =
+
+1106
+U£Fixed
+(
+\9a¡r
+->
+Çme
+(),
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+());
+
+1108 \15
+Ãw
+ (
+zÚe
+()è
+LTa\9eC®lThroughMegamÜphicCache
+(
+
+1109
+cڋxt
+,
+»ûiv\94_»gi¡\94
+,
+Çme_»gi¡\94
+);
+
+1113
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoInvokeFunùiÚ
+(
+HInvokeFunùiÚ
+*
+\9a¡r
+) {
+
+1114
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+1115
+LO³¿nd
+*
+ gfunùiÚ
+ =
+U£Fixed
+(
+\9a¡r
+->
+funùiÚ
+(),
+r4
+);
+
+1116
+LInvokeFunùiÚ
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLInvokeFunùiÚ(
+cڋxt
+,
+funùiÚ
+);
+
+1117 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+,
+CANNOT_DEOPTIMIZE_EAGERLY
+);
+
+1121
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoUÇryM©hO³¿tiÚ
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+) {
+
+1122 \1a
+\9a¡r
+->
+Ý
+()) {
+
+1123 \ 4
+kM©hFloÜ
+:
+
+1124 \15
+DoM©hFloÜ
+(
+\9a¡r
+);
+
+1125 \ 4
+ gkM©hRound
+:
+
+1126 \15
+DoM©hRound
+(
+\9a¡r
+);
+
+1127 \ 4
+ gkM©hFround
+:
+
+1128 \15
+DoM©hFround
+(
+\9a¡r
+);
+
+1129 \ 4
+ gkM©hAbs
+:
+
+1130 \15
+DoM©hAbs
+(
+\9a¡r
+);
+
+1131 \ 4
+ gkM©hLog
+:
+
+1132 \15
+DoM©hLog
+(
+\9a¡r
+);
+
+1133 \ 4
+ gkM©hExp
+:
+
+1134 \15
+DoM©hExp
+(
+\9a¡r
+);
+
+1135 \ 4
+ gkM©hSq¹
+:
+
+1136 \15
+DoM©hSq¹
+(
+\9a¡r
+);
+
+1137 \ 4
+ gkM©hPowH®f
+:
+
+1138 \15
+DoM©hPowH®f
+(
+\9a¡r
+);
+
+1139 \ 4
+ gkM©hClz32
+:
+
+1140 \15
+DoM©hClz32
+(
+\9a¡r
+);
+
+1142
+UNREACHABLE
+();
+
+1143 \15
+ gNULL
+;
+
+1148
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoM©hFloÜ
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+) {
+
+1149
+LO³¿nd
+*
+\9aput
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+1150
+LM©hFloÜ
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLM©hFloÜ(
+\9aput
+);
+
+1151 \15
+AssignEnv\9cÚm\92t
+(
+AssignPo\9a\8brM
+(
+Def\9aeAsRegi¡\94
+(
+»suÉ
+)));
+
+1155
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoM©hRound
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+) {
+
+1156
+LO³¿nd
+*
+\9aput
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+1157
+LO³¿nd
+*
+ g\8bmp
+ =
+TempDoubËRegi¡\94
+();
+
+1158
+LM©hRound
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLM©hRound(
+\9aput
+,
+\8bmp
+);
+
+1159 \15
+AssignEnv\9cÚm\92t
+(
+Def\9aeAsRegi¡\94
+(
+»suÉ
+));
+
+1163
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoM©hFround
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+) {
+
+1164
+LO³¿nd
+*
+\9aput
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+1165
+LM©hFround
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLM©hFround(
+\9aput
+);
+
+1166 \15
+Def\9aeAsRegi¡\94
+(
+»suÉ
+);
+
+1170
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoM©hAbs
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+) {
+
+1171
+R\95»£Á©iÚ
+
+r
+ =
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+();
+
+1172
+LO³¿nd
+*
+ gcڋxt
+ = (
+r
+.
+IsDoubË
+(è||\84.
+IsSmiOrIÁeg\9432
+())
+
+1173 ?
+NULL
+
+
+1174 :
+U£Fixed
+(
+\9a¡r
+->
+cڋxt
+(),
+ý
+);
+
+1175
+LO³¿nd
+*
+ g\9aput
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+1176
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+1177
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LM©hAbs
+(
+cڋxt
+,
+\9aput
+));
+
+1178 ià(!
+ gr
+.
+IsDoubË
+(è&& !r.
+IsSmiOrIÁeg\9432
+()è
+ g»suÉ
+ =
+AssignPo\9a\8brM
+(
+»suÉ
+);
+
+1179 ià(!
+ gr
+.
+IsDoubË
+()è
+ g»suÉ
+ =
+AssignEnv\9cÚm\92t
+(
+»suÉ
+);
+
+1180 \15
+ g»suÉ
+;
+
+1184
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoM©hLog
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+) {
+
+1185
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+1186
+DCHECK
+(
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+1187
+LO³¿nd
+*
+ g\9aput
+ =
+U£FixedDoubË
+(
+\9a¡r
+->
+v®ue
+(),
+d1
+);
+
+1188 \15
+M¬kAsC®l
+(
+Def\9aeFixedDoubË
+(
+Ãw
+ (
+zÚe
+()è
+LM©hLog
+(
+\9aput
+),
+d1
+),
+\9a¡r
+);
+
+1192
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoM©hClz32
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+) {
+
+1193
+LO³¿nd
+*
+\9aput
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+1194
+LM©hClz32
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLM©hClz32(
+\9aput
+);
+
+1195 \15
+Def\9aeAsRegi¡\94
+(
+»suÉ
+);
+
+1199
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoM©hExp
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+) {
+
+1200
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+1201
+DCHECK
+(
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+1202
+LO³¿nd
+*
+ g\9aput
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+1203
+LO³¿nd
+*
+ g\8bmp1
+ =
+TempRegi¡\94
+();
+
+1204
+LO³¿nd
+*
+ g\8bmp2
+ =
+TempRegi¡\94
+();
+
+1205
+LO³¿nd
+*
+ gdoubË_\8bmp
+ =
+TempDoubËRegi¡\94
+();
+
+1206
+LM©hExp
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLM©hExp(
+\9aput
+,
+doubË_\8bmp
+,
+\8bmp1
+,
+\8bmp2
+);
+
+1207 \15
+Def\9aeAsRegi¡\94
+(
+»suÉ
+);
+
+1211
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoM©hSq¹
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+) {
+
+1212
+LO³¿nd
+*
+\9aput
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+1213
+LM©hSq¹
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLM©hSq¹(
+\9aput
+);
+
+1214 \15
+Def\9aeAsRegi¡\94
+(
+»suÉ
+);
+
+1218
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoM©hPowH®f
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+) {
+
+1219
+LO³¿nd
+*
+\9aput
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+1220
+LM©hPowH®f
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLM©hPowH®f(
+\9aput
+);
+
+1221 \15
+Def\9aeAsRegi¡\94
+(
+»suÉ
+);
+
+1225
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoC®lNew
+(
+HC®lNew
+*
+\9a¡r
+) {
+
+1226
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+1227
+LO³¿nd
+*
+ gcÚ¡ruùÜ
+ =
+U£Fixed
+(
+\9a¡r
+->
+cÚ¡ruùÜ
+(),
+r4
+);
+
+1228
+LC®lNew
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLC®lNew(
+cڋxt
+,
+cÚ¡ruùÜ
+);
+
+1229 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+);
+
+1233
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoC®lNewA¼ay
+(
+HC®lNewA¼ay
+*
+\9a¡r
+) {
+
+1234
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+1235
+LO³¿nd
+*
+ gcÚ¡ruùÜ
+ =
+U£Fixed
+(
+\9a¡r
+->
+cÚ¡ruùÜ
+(),
+r4
+);
+
+1236
+LC®lNewA¼ay
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLC®lNewA¼ay(
+cڋxt
+,
+cÚ¡ruùÜ
+);
+
+1237 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+);
+
+1241
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoC®lFunùiÚ
+(
+HC®lFunùiÚ
+*
+\9a¡r
+) {
+
+1242
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+1243
+LO³¿nd
+*
+ gfunùiÚ
+ =
+U£Fixed
+(
+\9a¡r
+->
+funùiÚ
+(),
+r4
+);
+
+1244
+LC®lFunùiÚ
+*
+ gÿÎ
+ =
+Ãw
+ (
+zÚe
+()èLC®lFunùiÚ(
+cڋxt
+,
+funùiÚ
+);
+
+1245 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+ÿÎ
+,
+r3
+),
+\9a¡r
+);
+
+1249
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoC®lRuÁime
+(
+HC®lRuÁime
+*
+\9a¡r
+) {
+
+1250
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+1251 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+Ãw
+ (
+zÚe
+()è
+LC®lRuÁime
+(
+cڋxt
+),
+r3
+),
+\9a¡r
+);
+
+1255
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoRÜ
+(
+HRÜ
+*
+\9a¡r
+) {
+
+1256 \15
+DoShiá
+(
+Tok\92
+::
+ROR
+,
+\9a¡r
+);
+
+1260
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoShr
+(
+HShr
+*
+\9a¡r
+) {
+
+1261 \15
+DoShiá
+(
+Tok\92
+::
+SHR
+,
+\9a¡r
+);
+
+1265
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoS¬
+(
+HS¬
+*
+\9a¡r
+) {
+
+1266 \15
+DoShiá
+(
+Tok\92
+::
+SAR
+,
+\9a¡r
+);
+
+1270
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoShl
+(
+HShl
+*
+\9a¡r
+) {
+
+1271 \15
+DoShiá
+(
+Tok\92
+::
+SHL
+,
+\9a¡r
+);
+
+1275
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoB\99wi£
+(
+HB\99wi£
+*
+\9a¡r
+) {
+
+1276 ià(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+()) {
+
+1277
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1278
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1279
+DCHECK
+(
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kTrunÿt\9agToIÁ32
+));
+
+1281
+LO³¿nd
+*
+ gËá
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+B\91\8brLeáO³¿nd
+());
+
+1282
+LO³¿nd
+*
+ gright
+ =
+U£OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+B\91\8brRightO³¿nd
+());
+
+1283 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LB\99I
+(
+Ëá
+,
+right
+));
+
+1285 \15
+DoAr\99hm\91icT
+(
+\9a¡r
+->
+Ý
+(), instr);
+
+1290
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoDivByPow\94Of2I
+(
+HDiv
+*
+\9a¡r
+) {
+
+1291
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+());
+
+1292
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1293
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1294
+LO³¿nd
+*
+ gdivid\92d
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+Ëá
+());
+
+1295
+\9at32_t
+
+ gdivisÜ
+ =
+\9a¡r
+->
+right
+()->
+G\91IÁeg\9432CÚ¡ªt
+();
+
+1296
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+1297
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LDivByPow\94Of2I
+(
+divid\92d
+,
+divisÜ
+));
+
+1298 ià((
+ g\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+è&&
+divisÜ
+ < 0) ||
+
+1299 (
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+è&&
+divisÜ
+ == -1) ||
+
+1300 (!
+\9a¡r
+->
+CheckFÏg
+(
+HIn¡ruùiÚ
+::
+kAÎU£sTrunÿt\9agToIÁ32
+) &&
+
+1301
+divisÜ
+ != 1 && divisor != -1)) {
+
+1302
+»suÉ
+ =
+AssignEnv\9cÚm\92t
+(result);
+
+1304 \15
+ g»suÉ
+;
+
+1308
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoDivByCڡI
+(
+HDiv
+*
+\9a¡r
+) {
+
+1309
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsIÁeg\9432
+());
+
+1310
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1311
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1312
+LO³¿nd
+*
+ gdivid\92d
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+Ëá
+());
+
+1313
+\9at32_t
+
+ gdivisÜ
+ =
+\9a¡r
+->
+right
+()->
+G\91IÁeg\9432CÚ¡ªt
+();
+
+1314
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+1315
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LDivByCڡI
+(
+divid\92d
+,
+divisÜ
+));
+
+1316 ià(
+ gdivisÜ
+ == 0 ||
+
+1317 (
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+è&&
+divisÜ
+ < 0) ||
+
+1318 !
+\9a¡r
+->
+CheckFÏg
+(
+HIn¡ruùiÚ
+::
+kAÎU£sTrunÿt\9agToIÁ32
+)) {
+
+1319
+»suÉ
+ =
+AssignEnv\9cÚm\92t
+(result);
+
+1321 \15
+ g»suÉ
+;
+
+1325
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoDivI
+(
+HDiv
+*
+\9a¡r
+) {
+
+1326
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+());
+
+1327
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1328
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1329
+LO³¿nd
+*
+ gdivid\92d
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+Ëá
+());
+
+1330
+LO³¿nd
+*
+ gdivisÜ
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+right
+());
+
+1331
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+1332
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LDivI
+(
+divid\92d
+,
+divisÜ
+));
+
+1333 ià(
+ g\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªBeDivByZ\94o
+) ||
+
+1334
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+) ||
+
+1335 (
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+) &&
+
+1336 !
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kAÎU£sTrunÿt\9agToIÁ32
+)) ||
+
+1337 (!
+\9a¡r
+->
+IsM©hFloÜOfDiv
+() &&
+
+1338 !
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kAÎU£sTrunÿt\9agToIÁ32
+))) {
+
+1339
+»suÉ
+ =
+AssignEnv\9cÚm\92t
+(result);
+
+1341 \15
+ g»suÉ
+;
+
+1345
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoDiv
+(
+HDiv
+*
+\9a¡r
+) {
+
+1346 ià(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+()) {
+
+1347 ià(
+\9a¡r
+->
+RightIsPow\94Of2
+()) {
+
+1348 \15
+DoDivByPow\94Of2I
+(
+\9a¡r
+);
+
+1349 } \vià(
+ g\9a¡r
+->
+right
+()->
+IsCÚ¡ªt
+()) {
+
+1350 \15
+DoDivByCڡI
+(
+\9a¡r
+);
+
+1352 \15
+DoDivI
+(
+\9a¡r
+);
+
+1354 } \vià(
+ g\9a¡r
+->
+»´e£Á©iÚ
+().
+IsDoubË
+()) {
+
+1355 \15
+DoAr\99hm\91icD
+(
+Tok\92
+::
+DIV
+,
+\9a¡r
+);
+
+1357 \15
+DoAr\99hm\91icT
+(
+Tok\92
+::
+DIV
+,
+\9a¡r
+);
+
+1362
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoFloÜ\9agDivByPow\94Of2I
+(
+HM©hFloÜOfDiv
+*
+\9a¡r
+) {
+
+1363
+LO³¿nd
+*
+divid\92d
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+Ëá
+());
+
+1364
+\9at32_t
+
+ gdivisÜ
+ =
+\9a¡r
+->
+right
+()->
+G\91IÁeg\9432CÚ¡ªt
+();
+
+1365
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+1366
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LFloÜ\9agDivByPow\94Of2I
+(
+divid\92d
+,
+divisÜ
+));
+
+1367 ià((
+ g\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+è&&
+divisÜ
+ < 0) ||
+
+1368 (
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kLeáCªBeM\9aIÁ
+è&&
+divisÜ
+ == -1)) {
+
+1369
+»suÉ
+ =
+AssignEnv\9cÚm\92t
+(result);
+
+1371 \15
+ g»suÉ
+;
+
+1375
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoFloܚgDivByCڡI
+(
+HM©hFloÜOfDiv
+*
+\9a¡r
+) {
+
+1376
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsIÁeg\9432
+());
+
+1377
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1378
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1379
+LO³¿nd
+*
+ gdivid\92d
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+Ëá
+());
+
+1380
+\9at32_t
+
+ gdivisÜ
+ =
+\9a¡r
+->
+right
+()->
+G\91IÁeg\9432CÚ¡ªt
+();
+
+1381
+LO³¿nd
+*
+ g\8bmp
+ =
+
+1382 ((
+divisÜ
+ > 0 && !
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kLeáCªBeNeg©ive
+)) ||
+
+1383 (
+divisÜ
+ < 0 && !
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kLeáCªBePos\99ive
+)))
+
+1384 ?
+NULL
+
+
+1385 :
+TempRegi¡\94
+();
+
+1386
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Def\9aeAsRegi¡\94
+(
+
+1387
+Ãw
+ (
+zÚe
+()è
+LFloܚgDivByCڡI
+(
+divid\92d
+,
+divisÜ
+,
+\8bmp
+));
+
+1388 ià(
+ gdivisÜ
+ == 0 ||
+
+1389 (
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+è&&
+divisÜ
+ < 0)) {
+
+1390
+»suÉ
+ =
+AssignEnv\9cÚm\92t
+(result);
+
+1392 \15
+ g»suÉ
+;
+
+1396
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoFloܚgDivI
+(
+HM©hFloÜOfDiv
+*
+\9a¡r
+) {
+
+1397
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+());
+
+1398
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1399
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1400
+LO³¿nd
+*
+ gdivid\92d
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+Ëá
+());
+
+1401
+LO³¿nd
+*
+ gdivisÜ
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+right
+());
+
+1402
+LFloܚgDivI
+*
+ gdiv
+ =
+Ãw
+ (
+zÚe
+()èLFloÜ\9agDivI(
+divid\92d
+,
+divisÜ
+);
+
+1403 \15
+AssignEnv\9cÚm\92t
+(
+Def\9aeAsRegi¡\94
+(
+div
+));
+
+1407
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoM©hFloÜOfDiv
+(
+HM©hFloÜOfDiv
+*
+\9a¡r
+) {
+
+1408 ià(
+\9a¡r
+->
+RightIsPow\94Of2
+()) {
+
+1409 \15
+DoFloÜ\9agDivByPow\94Of2I
+(
+\9a¡r
+);
+
+1410 } \vià(
+ g\9a¡r
+->
+right
+()->
+IsCÚ¡ªt
+()) {
+
+1411 \15
+DoFloܚgDivByCڡI
+(
+\9a¡r
+);
+
+1413 \15
+DoFloܚgDivI
+(
+\9a¡r
+);
+
+1418
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoModByPow\94Of2I
+(
+HMod
+*
+\9a¡r
+) {
+
+1419
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+());
+
+1420
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1421
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1422
+LO³¿nd
+*
+ gdivid\92d
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+Ëá
+());
+
+1423
+\9at32_t
+
+ gdivisÜ
+ =
+\9a¡r
+->
+right
+()->
+G\91IÁeg\9432CÚ¡ªt
+();
+
+1424
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+1425
+Def\9aeSameAsF\9c¡
+(
+Ãw
+ (
+zÚe
+()è
+LModByPow\94Of2I
+(
+divid\92d
+,
+divisÜ
+));
+
+1426 ià(
+ g\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kLeáCªBeNeg©ive
+) &&
+
+1427
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+1428
+»suÉ
+ =
+AssignEnv\9cÚm\92t
+(result);
+
+1430 \15
+ g»suÉ
+;
+
+1434
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoModByCڡI
+(
+HMod
+*
+\9a¡r
+) {
+
+1435
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+());
+
+1436
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1437
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1438
+LO³¿nd
+*
+ gdivid\92d
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+Ëá
+());
+
+1439
+\9at32_t
+
+ gdivisÜ
+ =
+\9a¡r
+->
+right
+()->
+G\91IÁeg\9432CÚ¡ªt
+();
+
+1440
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+1441
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LModByCڡI
+(
+divid\92d
+,
+divisÜ
+));
+
+1442 ià(
+ gdivisÜ
+ =ð0 ||
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+1443
+»suÉ
+ =
+AssignEnv\9cÚm\92t
+(result);
+
+1445 \15
+ g»suÉ
+;
+
+1449
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoModI
+(
+HMod
+*
+\9a¡r
+) {
+
+1450
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+());
+
+1451
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1452
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1453
+LO³¿nd
+*
+ gdivid\92d
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+Ëá
+());
+
+1454
+LO³¿nd
+*
+ gdivisÜ
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+right
+());
+
+1455
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+1456
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LModI
+(
+divid\92d
+,
+divisÜ
+));
+
+1457 ià(
+ g\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªBeDivByZ\94o
+) ||
+
+1458
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+)) {
+
+1459
+»suÉ
+ =
+AssignEnv\9cÚm\92t
+(result);
+
+1461 \15
+ g»suÉ
+;
+
+1465
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoMod
+(
+HMod
+*
+\9a¡r
+) {
+
+1466 ià(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+()) {
+
+1467 ià(
+\9a¡r
+->
+RightIsPow\94Of2
+()) {
+
+1468 \15
+DoModByPow\94Of2I
+(
+\9a¡r
+);
+
+1469 } \vià(
+ g\9a¡r
+->
+right
+()->
+IsCÚ¡ªt
+()) {
+
+1470 \15
+DoModByCڡI
+(
+\9a¡r
+);
+
+1472 \15
+DoModI
+(
+\9a¡r
+);
+
+1474 } \vià(
+ g\9a¡r
+->
+»´e£Á©iÚ
+().
+IsDoubË
+()) {
+
+1475 \15
+DoAr\99hm\91icD
+(
+Tok\92
+::
+MOD
+,
+\9a¡r
+);
+
+1477 \15
+DoAr\99hm\91icT
+(
+Tok\92
+::
+MOD
+,
+\9a¡r
+);
+
+1482
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoMul
+(
+HMul
+*
+\9a¡r
+) {
+
+1483 ià(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+()) {
+
+1484
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1485
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1486
+HV®ue
+*
+ gËá
+ =
+\9a¡r
+->
+B\91\8brLeáO³¿nd
+();
+
+1487
+HV®ue
+*
+ gright
+ =
+\9a¡r
+->
+B\91\8brRightO³¿nd
+();
+
+1488
+LO³¿nd
+*
+ gËá_Ý
+;
+
+1489
+LO³¿nd
+*
+ gright_Ý
+;
+
+1490
+boÞ
+
+ gÿn_ov\94æow
+ =
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+);
+
+1491
+boÞ
+
+ gba\9eout_Ú_m\9aus_z\94o
+ =
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kBa\9eoutOnM\9ausZ\94o
+);
+
+1493 ià(
+ gright
+->
+IsCÚ¡ªt
+()) {
+
+1494
+HCÚ¡ªt
+*
+ gcÚ¡ªt
+ = HCÚ¡ªt::
+ÿ¡
+(
+right
+);
+
+1495
+\9at32_t
+
+ gcÚ¡ªt_v®ue
+ =
+cÚ¡ªt
+->
+IÁeg\9432V®ue
+();
+
+1498 ià(!
+ gÿn_ov\94æow
+ || ((
+ gcÚ¡ªt_v®ue
+ >ð-1è&& (
+cÚ¡ªt_v®ue
+ <= 1))) {
+
+1499
+Ëá_Ý
+ =
+U£Regi¡\94AtS\8f¹
+(
+Ëá
+);
+
+1500
+ gright_Ý
+ =
+U£CÚ¡ªt
+(
+right
+);
+
+1502 ià(
+ gba\9eout_Ú_m\9aus_z\94o
+) {
+
+1503
+ gËá_Ý
+ =
+U£Regi¡\94
+(
+Ëá
+);
+
+1505
+ gËá_Ý
+ =
+U£Regi¡\94AtS\8f¹
+(
+Ëá
+);
+
+1507
+ gright_Ý
+ =
+U£Regi¡\94
+(
+right
+);
+
+1510 ià(
+ gba\9eout_Ú_m\9aus_z\94o
+) {
+
+1511
+ gËá_Ý
+ =
+U£Regi¡\94
+(
+Ëá
+);
+
+1513
+ gËá_Ý
+ =
+U£Regi¡\94AtS\8f¹
+(
+Ëá
+);
+
+1515
+ gright_Ý
+ =
+U£Regi¡\94
+(
+right
+);
+
+1517
+LMulI
+*
+ gmul
+ =
+Ãw
+ (
+zÚe
+()èLMulI(
+Ëá_Ý
+,
+right_Ý
+);
+
+1518 ià(
+ gÿn_ov\94æow
+ ||
+ gba\9eout_Ú_m\9aus_z\94o
+) {
+
+1519
+AssignEnv\9cÚm\92t
+(
+mul
+);
+
+1521 \15
+Def\9aeAsRegi¡\94
+(
+mul
+);
+
+1523 } \vià(
+ g\9a¡r
+->
+»´e£Á©iÚ
+().
+IsDoubË
+()) {
+
+1524 ià(
+ g\9a¡r
+->
+HasOÃU£
+() &&
+
+1525 (
+ g\9a¡r
+->
+u£s
+().
+v®ue
+()->
+IsAdd
+(è|| in¡r->u£s().v®ue()->
+IsSub
+())) {
+
+1526
+HB\9a¬yO³¿tiÚ
+*
+ gu£
+ = HB\9a¬yO³¿tiÚ::
+ÿ¡
+(
+\9a¡r
+->
+u£s
+().
+v®ue
+());
+
+1528 ià(
+ gu£
+->
+IsAdd
+(è&&
+ g\9a¡r
+ =ð
+u£
+->
+Ëá
+()) {
+
+1531 \15
+NULL
+;
+
+1533 ià(
+ g\9a¡r
+ =ð
+u£
+->
+right
+(è&& u£->
+IsAdd
+() &&
+
+1534 !(
+u£
+->
+Ëá
+()->
+IsMul
+(è&& u£->Ëá()->
+HasOÃU£
+())) {
+
+1537 \15
+NULL
+;
+
+1539 ià(
+ g\9a¡r
+ =ð
+u£
+->
+Ëá
+(è&& u£->
+IsSub
+()) {
+
+1542 \15
+NULL
+;
+
+1546 \15
+DoAr\99hm\91icD
+(
+Tok\92
+::
+MUL
+,
+\9a¡r
+);
+
+1548 \15
+DoAr\99hm\91icT
+(
+Tok\92
+::
+MUL
+,
+\9a¡r
+);
+
+1553
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoSub
+(
+HSub
+*
+\9a¡r
+) {
+
+1554 ià(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+()) {
+
+1555
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1556
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1558 ià(
+ g\9a¡r
+->
+Ëá
+()->
+IsCÚ¡ªt
+() &&
+
+1559 !
+ g\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+)) {
+
+1561 \15
+DoRSub
+(
+\9a¡r
+);
+
+1564
+LO³¿nd
+*
+ gËá
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+Ëá
+());
+
+1565
+LO³¿nd
+*
+ gright
+ =
+U£OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+right
+());
+
+1566
+LSubI
+*
+ gsub
+ =
+Ãw
+ (
+zÚe
+()èLSubI(
+Ëá
+,
+right
+);
+
+1567
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Def\9aeAsRegi¡\94
+(
+sub
+);
+
+1568 ià(
+ g\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+)) {
+
+1569
+»suÉ
+ =
+AssignEnv\9cÚm\92t
+(result);
+
+1571 \15
+ g»suÉ
+;
+
+1572 } \vià(
+ g\9a¡r
+->
+»´e£Á©iÚ
+().
+IsDoubË
+()) {
+
+1573 ià(
+ g\9a¡r
+->
+Ëá
+()->
+IsMul
+(è&& in¡r->Ëá()->
+HasOÃU£
+()) {
+
+1574 \15
+DoMuɝlySub
+(
+\9a¡r
+->
+right
+(),
+HMul
+::
+ÿ¡
+(\9a¡r->
+Ëá
+()));
+
+1577 \15
+DoAr\99hm\91icD
+(
+Tok\92
+::
+SUB
+,
+\9a¡r
+);
+
+1579 \15
+DoAr\99hm\91icT
+(
+Tok\92
+::
+SUB
+,
+\9a¡r
+);
+
+1584
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoRSub
+(
+HSub
+*
+\9a¡r
+) {
+
+1585
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+());
+
+1586
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1587
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1588
+DCHECK
+(!
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+));
+
+1592
+LO³¿nd
+*
+ gËá
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+right
+());
+
+1593
+LO³¿nd
+*
+ gright
+ =
+U£OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+Ëá
+());
+
+1594
+LRSubI
+*
+ grsb
+ =
+Ãw
+ (
+zÚe
+()èLRSubI(
+Ëá
+,
+right
+);
+
+1595
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Def\9aeAsRegi¡\94
+(
+rsb
+);
+
+1596 \15
+ g»suÉ
+;
+
+1600
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoMuɝlyAdd
+(
+HMul
+*
+mul
+,
+HV®ue
+*
+add\92d
+) {
+
+1601
+LO³¿nd
+*
+ gmuÉ\9dl\9br_Ý
+ =
+U£Regi¡\94AtS\8f¹
+(
+mul
+->
+Ëá
+());
+
+1602
+LO³¿nd
+*
+ gmuÉ\9dliÿnd_Ý
+ =
+U£Regi¡\94AtS\8f¹
+(
+mul
+->
+right
+());
+
+1603
+LO³¿nd
+*
+ gadd\92d_Ý
+ =
+U£Regi¡\94AtS\8f¹
+(
+add\92d
+);
+
+1604 \15
+Def\9aeSameAsF\9c¡
+(
+
+1605
+Ãw
+ (
+zÚe
+()è
+LMuɝlyAddD
+(
+add\92d_Ý
+,
+muÉ\9dl\9br_Ý
+,
+muÉ\9dliÿnd_Ý
+));
+
+1609
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoMuɝlySub
+(
+HV®ue
+*
+m\9au\92d
+,
+HMul
+*
+mul
+) {
+
+1610
+LO³¿nd
+*
+ gm\9au\92d_Ý
+ =
+U£Regi¡\94AtS\8f¹
+(
+m\9au\92d
+);
+
+1611
+LO³¿nd
+*
+ gmuÉ\9dl\9br_Ý
+ =
+U£Regi¡\94AtS\8f¹
+(
+mul
+->
+Ëá
+());
+
+1612
+LO³¿nd
+*
+ gmuÉ\9dliÿnd_Ý
+ =
+U£Regi¡\94AtS\8f¹
+(
+mul
+->
+right
+());
+
+1614 \15
+Def\9aeSameAsF\9c¡
+(
+
+1615
+Ãw
+ (
+zÚe
+()è
+LMuɝlySubD
+(
+m\9au\92d_Ý
+,
+muÉ\9dl\9br_Ý
+,
+muÉ\9dliÿnd_Ý
+));
+
+1619
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoAdd
+(
+HAdd
+*
+\9a¡r
+) {
+
+1620 ià(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+()) {
+
+1621
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1622
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1623
+LO³¿nd
+*
+ gËá
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+B\91\8brLeáO³¿nd
+());
+
+1624
+LO³¿nd
+*
+ gright
+ =
+U£OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+B\91\8brRightO³¿nd
+());
+
+1625
+LAddI
+*
+ gadd
+ =
+Ãw
+ (
+zÚe
+()èLAddI(
+Ëá
+,
+right
+);
+
+1626
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Def\9aeAsRegi¡\94
+(
+add
+);
+
+1627 ià(
+ g\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+)) {
+
+1628
+»suÉ
+ =
+AssignEnv\9cÚm\92t
+(result);
+
+1630 \15
+ g»suÉ
+;
+
+1631 } \vià(
+ g\9a¡r
+->
+»´e£Á©iÚ
+().
+IsEx\8bº®
+()) {
+
+1632
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+IsEx\8bº®
+());
+
+1633
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+IsIÁeg\9432
+());
+
+1634
+DCHECK
+(!
+\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+));
+
+1635
+LO³¿nd
+*
+ gËá
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+Ëá
+());
+
+1636
+LO³¿nd
+*
+ gright
+ =
+U£OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+right
+());
+
+1637
+LAddI
+*
+ gadd
+ =
+Ãw
+ (
+zÚe
+()èLAddI(
+Ëá
+,
+right
+);
+
+1638
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Def\9aeAsRegi¡\94
+(
+add
+);
+
+1639 \15
+ g»suÉ
+;
+
+1640 } \vià(
+ g\9a¡r
+->
+»´e£Á©iÚ
+().
+IsDoubË
+()) {
+
+1641 ià(
+ g\9a¡r
+->
+Ëá
+()->
+IsMul
+(è&& in¡r->Ëá()->
+HasOÃU£
+()) {
+
+1642 \15
+DoMuɝlyAdd
+(
+HMul
+::
+ÿ¡
+(
+\9a¡r
+->
+Ëá
+()), in¡r->
+right
+());
+
+1645 ià(
+ g\9a¡r
+->
+right
+()->
+IsMul
+(è&& in¡r->right()->
+HasOÃU£
+()) {
+
+1646
+DCHECK
+(!
+\9a¡r
+->
+Ëá
+()->
+IsMul
+(è|| !\9a¡r->Ëá()->
+HasOÃU£
+());
+
+1647 \15
+DoMuɝlyAdd
+(
+HMul
+::
+ÿ¡
+(
+\9a¡r
+->
+right
+()), in¡r->
+Ëá
+());
+
+1650 \15
+DoAr\99hm\91icD
+(
+Tok\92
+::
+ADD
+,
+\9a¡r
+);
+
+1652 \15
+DoAr\99hm\91icT
+(
+Tok\92
+::
+ADD
+,
+\9a¡r
+);
+
+1657
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoM©hM\9aMax
+(
+HM©hM\9aMax
+*
+\9a¡r
+) {
+
+1658
+LO³¿nd
+*
+Ëá
+ =
+NULL
+;
+
+1659
+LO³¿nd
+*
+ gright
+ =
+NULL
+;
+
+1660 ià(
+ g\9a¡r
+->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+()) {
+
+1661
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1662
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(instr->representation()));
+
+1663
+ gËá
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+B\91\8brLeáO³¿nd
+());
+
+1664
+ gright
+ =
+U£OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+B\91\8brRightO³¿nd
+());
+
+1666
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+1667
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+1668
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+1669
+ gËá
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+Ëá
+());
+
+1670
+ gright
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+right
+());
+
+1672 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LM©hM\9aMax
+(
+Ëá
+,
+right
+));
+
+1676
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoPow\94
+(
+HPow\94
+*
+\9a¡r
+) {
+
+1677
+DCHECK
+(
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+1680
+R\95»£Á©iÚ
+
+ gexpÚ\92t_ty³
+ =
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+();
+
+1681
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+1682
+LO³¿nd
+*
+ gËá
+ =
+U£FixedDoubË
+(
+\9a¡r
+->
+Ëá
+(),
+d1
+);
+
+1683
+LO³¿nd
+*
+ gright
+ =
+
+1684
+expÚ\92t_ty³
+.
+IsDoubË
+()
+
+1685 ?
+U£FixedDoubË
+(
+\9a¡r
+->
+right
+(),
+d2
+)
+
+1686 :
+U£Fixed
+(
+\9a¡r
+->
+right
+(),
+M©hPowTaggedDesü\9dtÜ
+::
+expڒt
+());
+
+1687
+LPow\94
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLPow\94(
+Ëá
+,
+right
+);
+
+1688 \15
+M¬kAsC®l
+(
+Def\9aeFixedDoubË
+(
+»suÉ
+,
+d3
+),
+\9a¡r
+,
+
+1689
+CAN_DEOPTIMIZE_EAGERLY
+);
+
+1693
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCom·»G\92\94ic
+(
+HCom·»G\92\94ic
+*
+\9a¡r
+) {
+
+1694
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+1695
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+1696
+LO³¿nd
+*
+ gcڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->
+cڋxt
+(),
+ý
+);
+
+1697
+LO³¿nd
+*
+ gËá
+ =
+U£Fixed
+(
+\9a¡r
+->
+Ëá
+(),
+r4
+);
+
+1698
+LO³¿nd
+*
+ gright
+ =
+U£Fixed
+(
+\9a¡r
+->
+right
+(),
+r3
+);
+
+1699
+LCmpT
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLCmpT(
+cڋxt
+,
+Ëá
+,
+right
+);
+
+1700 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+);
+
+1704
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCom·»Num\94icAndB¿nch
+(
+
+1705
+HCom·»Num\94icAndB¿nch
+*
+\9a¡r
+) {
+
+1706
+R\95»£Á©iÚ
+
+r
+ =
+\9a¡r
+->
+»´e£Á©iÚ
+();
+
+1707 ià(
+ gr
+.
+IsSmiOrIÁeg\9432
+()) {
+
+1708
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(
+r
+));
+
+1709
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+Equ®s
+(
+r
+));
+
+1710
+LO³¿nd
+*
+ gËá
+ =
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+Ëá
+());
+
+1711
+LO³¿nd
+*
+ gright
+ =
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+right
+());
+
+1712 \15
+Ãw
+ (
+zÚe
+()è
+LCom·»Num\94icAndB¿nch
+(
+Ëá
+,
+right
+);
+
+1714
+DCHECK
+(
+r
+.
+IsDoubË
+());
+
+1715
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+1716
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+1717
+LO³¿nd
+*
+ gËá
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+Ëá
+());
+
+1718
+LO³¿nd
+*
+ gright
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+right
+());
+
+1719 \15
+Ãw
+ (
+zÚe
+()è
+LCom·»Num\94icAndB¿nch
+(
+Ëá
+,
+right
+);
+
+1724
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCom·»ObjeùEqAndB¿nch
+(
+
+1725
+HCom·»ObjeùEqAndB¿nch
+*
+\9a¡r
+) {
+
+1726
+LO³¿nd
+*
+Ëá
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->left());
+
+1727
+LO³¿nd
+*
+ gright
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+right
+());
+
+1728 \15
+Ãw
+ (
+zÚe
+()è
+LCmpObjeùEqAndB¿nch
+(
+Ëá
+,
+right
+);
+
+1732
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCom·»HÞeAndB¿nch
+(
+
+1733
+HCom·»HÞeAndB¿nch
+*
+\9a¡r
+) {
+
+1734
+LO³¿nd
+*
+v®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->value());
+
+1735 \15
+Ãw
+ (
+zÚe
+()è
+LCmpHÞeAndB¿nch
+(
+v®ue
+);
+
+1739
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCom·»M\9ausZ\94oAndB¿nch
+(
+
+1740
+HCom·»M\9ausZ\94oAndB¿nch
+*
+\9a¡r
+) {
+
+1741
+LO³¿nd
+*
+v®ue
+ =
+U£Regi¡\94
+(
+\9a¡r
+->value());
+
+1742
+LO³¿nd
+*
+ gsü©ch
+ =
+TempRegi¡\94
+();
+
+1743 \15
+Ãw
+ (
+zÚe
+()è
+LCom·»M\9ausZ\94oAndB¿nch
+(
+v®ue
+,
+sü©ch
+);
+
+1747
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoIsObjeùAndB¿nch
+(
+HIsObjeùAndB¿nch
+*
+\9a¡r
+) {
+
+1748
+DCHECK
+(
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+1749
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+1750
+LO³¿nd
+*
+ g\8bmp
+ =
+TempRegi¡\94
+();
+
+1751 \15
+Ãw
+ (
+zÚe
+()è
+LIsObjeùAndB¿nch
+(
+v®ue
+,
+\8bmp
+);
+
+1755
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoIsS\8c\9agAndB¿nch
+(
+HIsS\8c\9agAndB¿nch
+*
+\9a¡r
+) {
+
+1756
+DCHECK
+(
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+1757
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+1758
+LO³¿nd
+*
+ g\8bmp
+ =
+TempRegi¡\94
+();
+
+1759 \15
+Ãw
+ (
+zÚe
+()è
+LIsS\8c\9agAndB¿nch
+(
+v®ue
+,
+\8bmp
+);
+
+1763
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoIsSmiAndB¿nch
+(
+HIsSmiAndB¿nch
+*
+\9a¡r
+) {
+
+1764
+DCHECK
+(
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+1765 \15
+Ãw
+ (
+zÚe
+()è
+LIsSmiAndB¿nch
+(
+U£
+(
+\9a¡r
+->
+v®ue
+()));
+
+1769
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoIsUnd\91eùabËAndB¿nch
+(
+
+1770
+HIsUnd\91eùabËAndB¿nch
+*
+\9a¡r
+) {
+
+1771
+DCHECK
+(
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+1772
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+1773 \15
+Ãw
+ (
+zÚe
+()è
+LIsUnd\91eùabËAndB¿nch
+(
+v®ue
+,
+TempRegi¡\94
+());
+
+1777
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoS\8c\9agCom·»AndB¿nch
+(
+
+1778
+HS\8c\9agCom·»AndB¿nch
+*
+\9a¡r
+) {
+
+1779
+DCHECK
+(
+\9a¡r
+->
+Ëá
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+1780
+DCHECK
+(
+\9a¡r
+->
+right
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+1781
+LO³¿nd
+*
+ gcڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->
+cڋxt
+(),
+ý
+);
+
+1782
+LO³¿nd
+*
+ gËá
+ =
+U£Fixed
+(
+\9a¡r
+->
+Ëá
+(),
+r4
+);
+
+1783
+LO³¿nd
+*
+ gright
+ =
+U£Fixed
+(
+\9a¡r
+->
+right
+(),
+r3
+);
+
+1784
+LS\8c\9agCom·»AndB¿nch
+*
+ g»suÉ
+ =
+
+1785
+Ãw
+ (
+zÚe
+()è
+LS\8c\9agCom·»AndB¿nch
+(
+cڋxt
+,
+Ëá
+,
+right
+);
+
+1786 \15
+M¬kAsC®l
+(
+»suÉ
+,
+\9a¡r
+);
+
+1790
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoHasIn¡ªûTy³AndB¿nch
+(
+
+1791
+HHasIn¡ªûTy³AndB¿nch
+*
+\9a¡r
+) {
+
+1792
+DCHECK
+(
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+1793
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+1794 \15
+Ãw
+ (
+zÚe
+()è
+LHasIn¡ªûTy³AndB¿nch
+(
+v®ue
+);
+
+1798
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoG\91CachedA¼ayIndex
+(
+
+1799
+HG\91CachedA¼ayIndex
+*
+\9a¡r
+) {
+
+1800
+DCHECK
+(
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+1801
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+1803 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LG\91CachedA¼ayIndex
+(
+v®ue
+));
+
+1807
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoHasCachedA¼ayIndexAndB¿nch
+(
+
+1808
+HHasCachedA¼ayIndexAndB¿nch
+*
+\9a¡r
+) {
+
+1809
+DCHECK
+(
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+1810 \15
+Ãw
+ (
+zÚe
+())
+
+1811
+LHasCachedA¼ayIndexAndB¿nch
+(
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+()));
+
+1815
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCÏssOfTe¡AndB¿nch
+(
+
+1816
+HCÏssOfTe¡AndB¿nch
+*
+\9a¡r
+) {
+
+1817
+DCHECK
+(
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+1818
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+1819 \15
+Ãw
+ (
+zÚe
+()è
+LCÏssOfTe¡AndB¿nch
+(
+v®ue
+,
+TempRegi¡\94
+());
+
+1823
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoMEnumL\92gth
+(
+HMEnumL\92gth
+*
+\9a¡r
+) {
+
+1824
+LO³¿nd
+*
+m
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+1825 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LMEnumL\92gth
+(
+m
+));
+
+1829
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoD©eF\9bld
+(
+HD©eF\9bld
+*
+\9a¡r
+) {
+
+1830
+LO³¿nd
+*
+objeù
+ =
+U£Fixed
+(
+\9a¡r
+->
+v®ue
+(),
+r3
+);
+
+1831
+LD©eF\9bld
+*
+ g»suÉ
+ =
+
+1832
+Ãw
+ (
+zÚe
+()è
+LD©eF\9bld
+(
+objeù
+,
+FixedTemp
+(
+r4
+),
+\9a¡r
+->
+\9adex
+());
+
+1833 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+,
+CAN_DEOPTIMIZE_EAGERLY
+);
+
+1837
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoSeqS\8c\9agG\91Ch¬
+(
+HSeqS\8c\9agG\91Ch¬
+*
+\9a¡r
+) {
+
+1838
+LO³¿nd
+*
+¡r\9ag
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->string());
+
+1839
+LO³¿nd
+*
+ g\9adex
+ =
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+\9adex
+());
+
+1840 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LSeqS\8c\9agG\91Ch¬
+(
+¡r\9ag
+,
+\9adex
+));
+
+1844
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoSeqS\8c\9agS\91Ch¬
+(
+HSeqS\8c\9agS\91Ch¬
+*
+\9a¡r
+) {
+
+1845
+LO³¿nd
+*
+¡r\9ag
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->string());
+
+1846
+LO³¿nd
+*
+ g\9adex
+ =
+FLAG_debug_code
+
+
+1847 ?
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+\9adex
+())
+
+1848 :
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+\9adex
+());
+
+1849
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+1850
+LO³¿nd
+*
+ gcڋxt
+ =
+FLAG_debug_code
+ ?
+U£Fixed
+(
+\9a¡r
+->
+cڋxt
+(),
+ý
+è:
+NULL
+;
+
+1851 \15
+Ãw
+ (
+zÚe
+()è
+LSeqS\8c\9agS\91Ch¬
+(
+cڋxt
+,
+¡r\9ag
+,
+\9adex
+,
+v®ue
+);
+
+1855
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoBoundsCheck
+(
+HBoundsCheck
+*
+\9a¡r
+) {
+
+1856 ià(!
+FLAG_debug_code
+ &&
+\9a¡r
+->
+sk\9d_check
+()è\15
+NULL
+;
+
+1857
+LO³¿nd
+*
+ g\9adex
+ =
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+\9adex
+());
+
+1858
+LO³¿nd
+*
+ gËngth
+ = !
+\9adex
+->
+IsCÚ¡ªtO³¿nd
+()
+
+1859 ?
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+Ëngth
+())
+
+1860 :
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+Ëngth
+());
+
+1861
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()è
+LBoundsCheck
+(
+\9adex
+,
+Ëngth
+);
+
+1862 ià(!
+ gFLAG_debug_code
+ || !
+ g\9a¡r
+->
+sk\9d_check
+()) {
+
+1863
+ g»suÉ
+ =
+AssignEnv\9cÚm\92t
+(
+»suÉ
+);
+
+1865 \15
+ g»suÉ
+;
+
+1869
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoBoundsCheckBa£IndexInfÜm©iÚ
+(
+
+1870
+HBoundsCheckBa£IndexInfÜm©iÚ
+*
+\9a¡r
+) {
+
+1871
+UNREACHABLE
+();
+
+1872 \15
+ gNULL
+;
+
+1876
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoAbnÜm®Ex\99
+(
+HAbnÜm®Ex\99
+*
+\9a¡r
+) {
+
+1879 \15
+NULL
+;
+
+1883
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoU£CÚ¡
+(
+HU£CÚ¡
+*
+\9a¡r
+è{ \15
+NULL
+; }
+
+1886
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoFÜûR\95»£Á©iÚ
+(
+HFÜûR\95»£Á©iÚ
+*
+bad
+) {
+
+1889
+UNREACHABLE
+();
+
+1890 \15
+ gNULL
+;
+
+1894
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoChªge
+(
+HChªge
+*
+\9a¡r
+) {
+
+1895
+R\95»£Á©iÚ
+
+äom
+ =
+\9a¡r
+->from();
+
+1896
+R\95»£Á©iÚ
+
+ gto
+ =
+\9a¡r
+->
+to
+();
+
+1897
+HV®ue
+*
+ gv®
+ =
+\9a¡r
+->
+v®ue
+();
+
+1898 ià(
+ gäom
+.
+IsSmi
+()) {
+
+1899 ià(
+ gto
+.
+IsTagged
+()) {
+
+1900
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94
+(
+v®
+);
+
+1901 \15
+Def\9aeSameAsF\9c¡
+(
+Ãw
+ (
+zÚe
+()è
+LDummyU£
+(
+v®ue
+));
+
+1903
+ gäom
+ =
+R\95»£Á©iÚ
+::
+Tagged
+();
+
+1905 ià(
+ gäom
+.
+IsTagged
+()) {
+
+1906 ià(
+ gto
+.
+IsDoubË
+()) {
+
+1907
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94
+(
+v®
+);
+
+1908
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+1909
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LNumb\94UÁagD
+(
+v®ue
+));
+
+1910 ià(!
+ gv®
+->
+»´e£Á©iÚ
+().
+IsSmi
+()è
+ g»suÉ
+ =
+AssignEnv\9cÚm\92t
+(
+»suÉ
+);
+
+1911 \15
+ g»suÉ
+;
+
+1912 } \vià(
+ gto
+.
+IsSmi
+()) {
+
+1913
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94
+(
+v®
+);
+
+1914 ià(
+ gv®
+->
+ty³
+().
+IsSmi
+()) {
+
+1915 \15
+Def\9aeSameAsF\9c¡
+(
+Ãw
+ (
+zÚe
+()è
+LDummyU£
+(
+v®ue
+));
+
+1917 \15
+AssignEnv\9cÚm\92t
+(
+
+1918
+Def\9aeSameAsF\9c¡
+(
+Ãw
+ (
+zÚe
+()è
+LCheckSmi
+(
+v®ue
+)));
+
+1920
+DCHECK
+(
+to
+.
+IsIÁeg\9432
+());
+
+1921 ià(
+ gv®
+->
+ty³
+().
+IsSmi
+(è|| v®->
+»´e£Á©iÚ
+().IsSmi()) {
+
+1922
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+v®
+);
+
+1923 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LSmiUÁag
+(
+v®ue
+,
+çl£
+));
+
+1925
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94
+(
+v®
+);
+
+1926
+LO³¿nd
+*
+ g\8bmp1
+ =
+TempRegi¡\94
+();
+
+1927
+LO³¿nd
+*
+ g\8bmp2
+ =
+TempDoubËRegi¡\94
+();
+
+1928
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+1929
+Def\9aeSameAsF\9c¡
+(
+Ãw
+ (
+zÚe
+()è
+LTaggedToI
+(
+v®ue
+,
+\8bmp1
+,
+\8bmp2
+));
+
+1930 ià(!
+ gv®
+->
+»´e£Á©iÚ
+().
+IsSmi
+()è
+ g»suÉ
+ =
+AssignEnv\9cÚm\92t
+(
+»suÉ
+);
+
+1931 \15
+ g»suÉ
+;
+
+1934 } \vià(
+ gäom
+.
+IsDoubË
+()) {
+
+1935 ià(
+ gto
+.
+IsTagged
+()) {
+
+1936
+\9afo
+()->
+M¬kAsDeã¼edC®l\9ag
+();
+
+1937
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94
+(
+v®
+);
+
+1938
+LO³¿nd
+*
+ g\8bmp1
+ =
+TempRegi¡\94
+();
+
+1939
+LO³¿nd
+*
+ g\8bmp2
+ =
+TempRegi¡\94
+();
+
+1940
+LUÇÎoÿ\8bd
+*
+ g»suÉ_\8bmp
+ =
+TempRegi¡\94
+();
+
+1941
+LNumb\94TagD
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLNumb\94TagD(
+v®ue
+,
+\8bmp1
+,
+\8bmp2
+);
+
+1942 \15
+AssignPo\9a\8brM
+(
+Def\9ae
+(
+»suÉ
+,
+»suÉ_\8bmp
+));
+
+1943 } \vià(
+ gto
+.
+IsSmi
+()) {
+
+1944
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94
+(
+v®
+);
+
+1945 \15
+AssignEnv\9cÚm\92t
+(
+
+1946
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LDoubËToSmi
+(
+v®ue
+)));
+
+1948
+DCHECK
+(
+to
+.
+IsIÁeg\9432
+());
+
+1949
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94
+(
+v®
+);
+
+1950
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LDoubËToI
+(
+v®ue
+));
+
+1951 ià(!
+ g\9a¡r
+->
+CªTrunÿ\8bToIÁ32
+()è
+ g»suÉ
+ =
+AssignEnv\9cÚm\92t
+(
+»suÉ
+);
+
+1952 \15
+ g»suÉ
+;
+
+1954 } \vià(
+ gäom
+.
+IsIÁeg\9432
+()) {
+
+1955
+\9afo
+()->
+M¬kAsDeã¼edC®l\9ag
+();
+
+1956 ià(
+ gto
+.
+IsTagged
+()) {
+
+1957 ià(!
+ g\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+)) {
+
+1958
+LO³¿nd
+*
+v®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+v®
+);
+
+1959 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LSmiTag
+(
+v®ue
+));
+
+1960 } \vià(
+ gv®
+->
+CheckFÏg
+(
+HIn¡ruùiÚ
+::
+kU\9at32
+)) {
+
+1961
+LO³¿nd
+*
+v®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+v®
+);
+
+1962
+LO³¿nd
+*
+ g\8bmp1
+ =
+TempRegi¡\94
+();
+
+1963
+LO³¿nd
+*
+ g\8bmp2
+ =
+TempRegi¡\94
+();
+
+1964
+LNumb\94TagU
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLNumb\94TagU(
+v®ue
+,
+\8bmp1
+,
+\8bmp2
+);
+
+1965 \15
+AssignPo\9a\8brM
+(
+Def\9aeAsRegi¡\94
+(
+»suÉ
+));
+
+1967
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+v®
+);
+
+1968
+LO³¿nd
+*
+ g\8bmp1
+ =
+TempRegi¡\94
+();
+
+1969
+LO³¿nd
+*
+ g\8bmp2
+ =
+TempRegi¡\94
+();
+
+1970
+LNumb\94TagI
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLNumb\94TagI(
+v®ue
+,
+\8bmp1
+,
+\8bmp2
+);
+
+1971 \15
+AssignPo\9a\8brM
+(
+Def\9aeAsRegi¡\94
+(
+»suÉ
+));
+
+1973 } \vià(
+ gto
+.
+IsSmi
+()) {
+
+1974
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94
+(
+v®
+);
+
+1975
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LSmiTag
+(
+v®ue
+));
+
+1976 ià(
+ g\9a¡r
+->
+CheckFÏg
+(
+HV®ue
+::
+kCªOv\94æow
+)) {
+
+1977
+»suÉ
+ =
+AssignEnv\9cÚm\92t
+(result);
+
+1979 \15
+ g»suÉ
+;
+
+1981
+DCHECK
+(
+to
+.
+IsDoubË
+());
+
+1982 ià(
+ gv®
+->
+CheckFÏg
+(
+HIn¡ruùiÚ
+::
+kU\9at32
+)) {
+
+1983 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LU\9at32ToDoubË
+(
+U£Regi¡\94
+(
+v®
+)));
+
+1985 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LIÁeg\9432ToDoubË
+(
+U£
+(
+v®
+)));
+
+1989
+UNREACHABLE
+();
+
+1990 \15
+ gNULL
+;
+
+1994
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCheckH\97pObjeù
+(
+HCheckH\97pObjeù
+*
+\9a¡r
+) {
+
+1995
+LO³¿nd
+*
+v®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->value());
+
+1996
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()è
+LCheckNÚSmi
+(
+v®ue
+);
+
+1997 ià(!
+ g\9a¡r
+->
+v®ue
+()->
+ty³
+().
+IsH\97pObjeù
+()) {
+
+1998
+ g»suÉ
+ =
+AssignEnv\9cÚm\92t
+(
+»suÉ
+);
+
+2000 \15
+ g»suÉ
+;
+
+2004
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCheckSmi
+(
+HCheckSmi
+*
+\9a¡r
+) {
+
+2005
+LO³¿nd
+*
+v®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->value());
+
+2006 \15
+AssignEnv\9cÚm\92t
+(
+Ãw
+ (
+zÚe
+()è
+LCheckSmi
+(
+v®ue
+));
+
+2010
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCheckIn¡ªûTy³
+(
+HCheckIn¡ªûTy³
+*
+\9a¡r
+) {
+
+2011
+LO³¿nd
+*
+v®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->value());
+
+2012
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()è
+LCheckIn¡ªûTy³
+(
+v®ue
+);
+
+2013 \15
+AssignEnv\9cÚm\92t
+(
+»suÉ
+);
+
+2017
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCheckV®ue
+(
+HCheckV®ue
+*
+\9a¡r
+) {
+
+2018
+LO³¿nd
+*
+v®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->value());
+
+2019 \15
+AssignEnv\9cÚm\92t
+(
+Ãw
+ (
+zÚe
+()è
+LCheckV®ue
+(
+v®ue
+));
+
+2023
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCheckMs
+(
+HCheckMs
+*
+\9a¡r
+) {
+
+2024 ià(
+\9a¡r
+->
+IsS\8fb\9e\99yCheck
+()è\15
+Ãw
+ (
+zÚe
+()è
+LCheckMs
+;
+
+2025
+LO³¿nd
+*
+ gv®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+2026
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+AssignEnv\9cÚm\92t
+(
+Ãw
+ (
+zÚe
+()è
+LCheckMs
+(
+v®ue
+));
+
+2027 ià(
+ g\9a¡r
+->
+HasMig¿tiÚT¬g\91
+()) {
+
+2028
+\9afo
+()->
+M¬kAsDeã¼edC®l\9ag
+();
+
+2029
+ g»suÉ
+ =
+AssignPo\9a\8brM
+(
+»suÉ
+);
+
+2031 \15
+ g»suÉ
+;
+
+2035
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCÏmpToU\9at8
+(
+HCÏmpToU\9at8
+*
+\9a¡r
+) {
+
+2036
+HV®ue
+*
+v®ue
+ =
+\9a¡r
+->value();
+
+2037
+R\95»£Á©iÚ
+
+ g\9aput_»p
+ =
+v®ue
+->
+»´e£Á©iÚ
+();
+
+2038
+LO³¿nd
+*
+ g»g
+ =
+U£Regi¡\94
+(
+v®ue
+);
+
+2039 ià(
+ g\9aput_»p
+.
+IsDoubË
+()) {
+
+2040 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LCÏmpDToU\9at8
+(
+»g
+));
+
+2041 } \vià(
+ g\9aput_»p
+.
+IsIÁeg\9432
+()) {
+
+2042 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LCÏmpIToU\9at8
+(
+»g
+));
+
+2044
+DCHECK
+(
+\9aput_»p
+.
+IsSmiOrTagged
+());
+
+2045
+LCÏmpTToU\9at8
+*
+ g»suÉ
+ =
+
+2046
+Ãw
+ (
+zÚe
+()è
+LCÏmpTToU\9at8
+(
+»g
+,
+TempDoubËRegi¡\94
+());
+
+2047 \15
+AssignEnv\9cÚm\92t
+(
+Def\9aeAsRegi¡\94
+(
+»suÉ
+));
+
+2052
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoDoubËB\99s
+(
+HDoubËB\99s
+*
+\9a¡r
+) {
+
+2053
+HV®ue
+*
+v®ue
+ =
+\9a¡r
+->value();
+
+2054
+DCHECK
+(
+v®ue
+->
+»´e£Á©iÚ
+().
+IsDoubË
+());
+
+2055 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LDoubËB\99s
+(
+U£Regi¡\94
+(
+v®ue
+)));
+
+2059
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCÚ¡ruùDoubË
+(
+HCÚ¡ruùDoubË
+*
+\9a¡r
+) {
+
+2060
+LO³¿nd
+*
+lo
+ =
+U£Regi¡\94
+(
+\9a¡r
+->lo());
+
+2061
+LO³¿nd
+*
+ ghi
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+hi
+());
+
+2062 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LCÚ¡ruùDoubË
+(
+hi
+,
+lo
+));
+
+2066
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoR\91uº
+(
+HR\91uº
+*
+\9a¡r
+) {
+
+2067
+LO³¿nd
+*
+cڋxt
+ =
+\9afo
+()->
+IsStub
+(è?
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+è:
+NULL
+;
+
+2068
+LO³¿nd
+*
+ g·¿m\91\94_couÁ
+ =
+U£Regi¡\94OrCÚ¡ªt
+(
+\9a¡r
+->
+·¿m\91\94_couÁ
+());
+
+2069 \15
+Ãw
+ (
+zÚe
+())
+
+2070
+LR\91uº
+(
+U£Fixed
+(
+\9a¡r
+->
+v®ue
+(),
+r3
+),
+cڋxt
+,
+·¿m\91\94_couÁ
+);
+
+2074
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCÚ¡ªt
+(
+HCÚ¡ªt
+*
+\9a¡r
+) {
+
+2075
+R\95»£Á©iÚ
+
+r
+ =
+\9a¡r
+->
+»´e£Á©iÚ
+();
+
+2076 ià(
+ gr
+.
+IsSmi
+()) {
+
+2077 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LCÚ¡ªtS
+);
+
+2078 } \vià(
+ gr
+.
+IsIÁeg\9432
+()) {
+
+2079 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LCÚ¡ªtI
+);
+
+2080 } \vià(
+ gr
+.
+IsDoubË
+()) {
+
+2081 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LCÚ¡ªtD
+);
+
+2082 } \vià(
+ gr
+.
+IsEx\8bº®
+()) {
+
+2083 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LCÚ¡ªtE
+);
+
+2084 } \vià(
+ gr
+.
+IsTagged
+()) {
+
+2085 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LCÚ¡ªtT
+);
+
+2087
+UNREACHABLE
+();
+
+2088 \15
+ gNULL
+;
+
+2093
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoLßdGlob®C\96l
+(
+HLßdGlob®C\96l
+*
+\9a¡r
+) {
+
+2094
+LLßdGlob®C\96l
+*
+»suÉ
+ =
+Ãw
+ (
+zÚe
+()) LLoadGlobalCell;
+
+2095 \15
+ g\9a¡r
+->
+Requ\9cesHÞeCheck
+()
+
+2096 ?
+AssignEnv\9cÚm\92t
+(
+Def\9aeAsRegi¡\94
+(
+»suÉ
+))
+
+2097 :
+Def\9aeAsRegi¡\94
+(
+»suÉ
+);
+
+2101
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoLßdGlob®G\92\94ic
+(
+HLßdGlob®G\92\94ic
+*
+\9a¡r
+) {
+
+2102
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2103
+LO³¿nd
+*
+ gglob®_objeù
+ =
+
+2104
+U£Fixed
+(
+\9a¡r
+->
+glob®_objeù
+(),
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+());
+
+2105
+LO³¿nd
+*
+ gveùÜ
+ =
+NULL
+;
+
+2106 ià(
+ gFLAG_veùÜ_ics
+) {
+
+2107
+ gveùÜ
+ =
+FixedTemp
+(
+VeùÜLßdICDesü\9dtÜ
+::
+VeùÜRegi¡\94
+());
+
+2109
+LLßdGlob®G\92\94ic
+*
+ g»suÉ
+ =
+
+2110
+Ãw
+ (
+zÚe
+()è
+LLßdGlob®G\92\94ic
+(
+cڋxt
+,
+glob®_objeù
+,
+veùÜ
+);
+
+2111 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+);
+
+2115
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoStÜeGlob®C\96l
+(
+HStÜeGlob®C\96l
+*
+\9a¡r
+) {
+
+2116
+LO³¿nd
+*
+v®ue
+ =
+U£Regi¡\94
+(
+\9a¡r
+->value());
+
+2119 \15
+ g\9a¡r
+->
+Requ\9cesHÞeCheck
+()
+
+2120 ?
+AssignEnv\9cÚm\92t
+(
+Ãw
+ (
+zÚe
+())
+
+2121
+LStÜeGlob®C\96l
+(
+v®ue
+,
+TempRegi¡\94
+()))
+
+2122 :
+Ãw
+ (
+zÚe
+()è
+LStÜeGlob®C\96l
+(
+v®ue
+,
+NULL
+);
+
+2126
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoLßdCÚ\8bxtSlÙ
+(
+HLßdCÚ\8bxtSlÙ
+*
+\9a¡r
+) {
+
+2127
+LO³¿nd
+*
+cڋxt
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+2128
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+2129
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LLßdCÚ\8bxtSlÙ
+(
+cڋxt
+));
+
+2130 ià(
+ g\9a¡r
+->
+Requ\9cesHÞeCheck
+(è&& in¡r->
+DeÝtimizesOnHÞe
+()) {
+
+2131
+ g»suÉ
+ =
+AssignEnv\9cÚm\92t
+(
+»suÉ
+);
+
+2133 \15
+ g»suÉ
+;
+
+2137
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoStÜeCÚ\8bxtSlÙ
+(
+HStÜeCÚ\8bxtSlÙ
+*
+\9a¡r
+) {
+
+2138
+LO³¿nd
+*
+cڋxt
+;
+
+2139
+LO³¿nd
+*
+ gv®ue
+;
+
+2140 ià(
+ g\9a¡r
+->
+N\93dsWr\99eB¬r\9br
+()) {
+
+2141
+ gcڋxt
+ =
+U£TempRegi¡\94
+(
+\9a¡r
+->
+cڋxt
+());
+
+2142
+ gv®ue
+ =
+U£TempRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2144
+ gcڋxt
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+cڋxt
+());
+
+2145
+ gv®ue
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2147
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()è
+LStÜeCÚ\8bxtSlÙ
+(
+cڋxt
+,
+v®ue
+);
+
+2148 ià(
+ g\9a¡r
+->
+Requ\9cesHÞeCheck
+(è&& in¡r->
+DeÝtimizesOnHÞe
+()) {
+
+2149
+ g»suÉ
+ =
+AssignEnv\9cÚm\92t
+(
+»suÉ
+);
+
+2151 \15
+ g»suÉ
+;
+
+2155
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoLßdNamedF\9bld
+(
+HLßdNamedF\9bld
+*
+\9a¡r
+) {
+
+2156
+LO³¿nd
+*
+obj
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+objeù
+());
+
+2157 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LLßdNamedF\9bld
+(
+obj
+));
+
+2161
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoLßdNamedG\92\94ic
+(
+HLßdNamedG\92\94ic
+*
+\9a¡r
+) {
+
+2162
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2163
+LO³¿nd
+*
+ gobjeù
+ =
+
+2164
+U£Fixed
+(
+\9a¡r
+->
+objeù
+(),
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+());
+
+2165
+LO³¿nd
+*
+ gveùÜ
+ =
+NULL
+;
+
+2166 ià(
+ gFLAG_veùÜ_ics
+) {
+
+2167
+ gveùÜ
+ =
+FixedTemp
+(
+VeùÜLßdICDesü\9dtÜ
+::
+VeùÜRegi¡\94
+());
+
+2170
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+
+2171
+Def\9aeFixed
+(
+Ãw
+ (
+zÚe
+()è
+LLßdNamedG\92\94ic
+(
+cڋxt
+,
+objeù
+,
+veùÜ
+),
+r3
+);
+
+2172 \15
+M¬kAsC®l
+(
+»suÉ
+,
+\9a¡r
+);
+
+2176
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoLßdFunùiÚPrÙÙy³
+(
+
+2177
+HLßdFunùiÚPrÙÙy³
+*
+\9a¡r
+) {
+
+2178 \15
+AssignEnv\9cÚm\92t
+(
+Def\9aeAsRegi¡\94
+(
+
+2179
+Ãw
+ (
+zÚe
+()è
+LLßdFunùiÚPrÙÙy³
+(
+U£Regi¡\94
+(
+\9a¡r
+->
+funùiÚ
+()))));
+
+2183
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoLßdRoÙ
+(
+HLßdRoÙ
+*
+\9a¡r
+) {
+
+2184 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LLßdRoÙ
+);
+
+2188
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoLßdKeyed
+(
+HLßdKeyed
+*
+\9a¡r
+) {
+
+2189
+DCHECK
+(
+\9a¡r
+->
+key
+()->
+»´e£Á©iÚ
+().
+IsSmiOrIÁeg\9432
+());
+
+2190
+EËm\92tsK\9ad
+
+ g\96em\92ts_k\9ad
+ =
+\9a¡r
+->
+\96em\92ts_k\9ad
+();
+
+2191
+LO³¿nd
+*
+ gkey
+ =
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+key
+());
+
+2192
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+NULL
+;
+
+2194 ià(!
+ g\9a¡r
+->
+is_ty³d_\96em\92ts
+()) {
+
+2195
+LO³¿nd
+*
+ gobj
+ =
+NULL
+;
+
+2196 ià(
+ g\9a¡r
+->
+»´e£Á©iÚ
+().
+IsDoubË
+()) {
+
+2197
+ gobj
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+2199
+ gobj
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+2201
+ g»suÉ
+ =
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LLßdKeyed
+(
+obj
+,
+key
+));
+
+2203
+DCHECK
+((
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsIÁeg\9432
+() &&
+
+2204 !
+IsDoubËOrFlßtEËm\92tsK\9ad
+(
+\96em\92ts_k\9ad
+)) ||
+
+2205 (
+\9a¡r
+->
+»´e£Á©iÚ
+().
+IsDoubË
+() &&
+
+2206
+IsDoubËOrFlßtEËm\92tsK\9ad
+(
+\96em\92ts_k\9ad
+)));
+
+2207
+LO³¿nd
+*
+ gback\9ag_¡Üe
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+2208
+ g»suÉ
+ =
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LLßdKeyed
+(
+back\9ag_¡Üe
+,
+key
+));
+
+2211 ià((
+ g\9a¡r
+->
+is_ex\8bº®
+(è|| in¡r->
+is_fixed_ty³d_¬¿y
+())
+
+2214 ((
+ g\96em\92ts_k\9ad
+ =ð
+EXTERNAL_UINT32_ELEMENTS
+ ||
+
+2215
+\96em\92ts_k\9ad
+ =ð
+UINT32_ELEMENTS
+) &&
+
+2216 !
+\9a¡r
+->
+CheckFÏg
+(
+HIn¡ruùiÚ
+::
+kU\9at32
+))
+
+2220
+\9a¡r
+->
+Requ\9cesHÞeCheck
+()) {
+
+2221
+»suÉ
+ =
+AssignEnv\9cÚm\92t
+(result);
+
+2223 \15
+ g»suÉ
+;
+
+2227
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoLßdKeyedG\92\94ic
+(
+HLßdKeyedG\92\94ic
+*
+\9a¡r
+) {
+
+2228
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2229
+LO³¿nd
+*
+ gobjeù
+ =
+
+2230
+U£Fixed
+(
+\9a¡r
+->
+objeù
+(),
+LßdDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+());
+
+2231
+LO³¿nd
+*
+ gkey
+ =
+U£Fixed
+(
+\9a¡r
+->
+key
+(),
+LßdDesü\9dtÜ
+::
+NameRegi¡\94
+());
+
+2232
+LO³¿nd
+*
+ gveùÜ
+ =
+NULL
+;
+
+2233 ià(
+ gFLAG_veùÜ_ics
+) {
+
+2234
+ gveùÜ
+ =
+FixedTemp
+(
+VeùÜLßdICDesü\9dtÜ
+::
+VeùÜRegi¡\94
+());
+
+2237
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Def\9aeFixed
+(
+
+2238
+Ãw
+ (
+zÚe
+()è
+LLßdKeyedG\92\94ic
+(
+cڋxt
+,
+objeù
+,
+key
+,
+veùÜ
+),
+r3
+);
+
+2239 \15
+M¬kAsC®l
+(
+»suÉ
+,
+\9a¡r
+);
+
+2243
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoStÜeKeyed
+(
+HStÜeKeyed
+*
+\9a¡r
+) {
+
+2244 ià(!
+\9a¡r
+->
+is_ty³d_\96em\92ts
+()) {
+
+2245
+DCHECK
+(
+\9a¡r
+->
+\96em\92ts
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+2246
+boÞ
+
+ gÃeds_wr\99e_b¬r\9br
+ =
+\9a¡r
+->
+N\93dsWr\99eB¬r\9br
+();
+
+2247
+LO³¿nd
+*
+ gobjeù
+ =
+NULL
+;
+
+2248
+LO³¿nd
+*
+ gkey
+ =
+NULL
+;
+
+2249
+LO³¿nd
+*
+ gv®
+ =
+NULL
+;
+
+2251 ià(
+ g\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+()) {
+
+2252
+ gobjeù
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+2253
+ gv®
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2254
+ gkey
+ =
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+key
+());
+
+2256 ià(
+ gÃeds_wr\99e_b¬r\9br
+) {
+
+2257
+ gobjeù
+ =
+U£TempRegi¡\94
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+2258
+ gv®
+ =
+U£TempRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2259
+ gkey
+ =
+U£TempRegi¡\94
+(
+\9a¡r
+->
+key
+());
+
+2261
+ gobjeù
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+2262
+ gv®
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+2263
+ gkey
+ =
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+key
+());
+
+2267 \15
+Ãw
+ (
+zÚe
+()è
+LStÜeKeyed
+(
+objeù
+,
+key
+,
+v®
+);
+
+2270
+DCHECK
+((
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsIÁeg\9432
+() &&
+
+2271 !
+IsDoubËOrFlßtEËm\92tsK\9ad
+(
+\9a¡r
+->
+\96em\92ts_k\9ad
+())) ||
+
+2272 (
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+() &&
+
+2273
+IsDoubËOrFlßtEËm\92tsK\9ad
+(
+\9a¡r
+->
+\96em\92ts_k\9ad
+())));
+
+2274
+DCHECK
+((
+\9a¡r
+->
+is_fixed_ty³d_¬¿y
+() &&
+
+2275
+\9a¡r
+->
+\96em\92ts
+()->
+»´e£Á©iÚ
+().
+IsTagged
+()) ||
+
+2276 (
+\9a¡r
+->
+is_ex\8bº®
+() &&
+
+2277
+\9a¡r
+->
+\96em\92ts
+()->
+»´e£Á©iÚ
+().
+IsEx\8bº®
+()));
+
+2278
+LO³¿nd
+*
+ gv®
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2279
+LO³¿nd
+*
+ gkey
+ =
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+key
+());
+
+2280
+LO³¿nd
+*
+ gback\9ag_¡Üe
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+\96em\92ts
+());
+
+2281 \15
+Ãw
+ (
+zÚe
+()è
+LStÜeKeyed
+(
+back\9ag_¡Üe
+,
+key
+,
+v®
+);
+
+2285
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoStÜeKeyedG\92\94ic
+(
+HStÜeKeyedG\92\94ic
+*
+\9a¡r
+) {
+
+2286
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2287
+LO³¿nd
+*
+ gobj
+ =
+
+2288
+U£Fixed
+(
+\9a¡r
+->
+objeù
+(),
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+());
+
+2289
+LO³¿nd
+*
+ gkey
+ =
+U£Fixed
+(
+\9a¡r
+->
+key
+(),
+StÜeDesü\9dtÜ
+::
+NameRegi¡\94
+());
+
+2290
+LO³¿nd
+*
+ gv®
+ =
+U£Fixed
+(
+\9a¡r
+->
+v®ue
+(),
+StÜeDesü\9dtÜ
+::
+V®ueRegi¡\94
+());
+
+2292
+DCHECK
+(
+\9a¡r
+->
+objeù
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+2293
+DCHECK
+(
+\9a¡r
+->
+key
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+2294
+DCHECK
+(
+\9a¡r
+->
+v®ue
+()->
+»´e£Á©iÚ
+().
+IsTagged
+());
+
+2296 \15
+M¬kAsC®l
+(
+Ãw
+ (
+zÚe
+()è
+LStÜeKeyedG\92\94ic
+(
+cڋxt
+,
+obj
+,
+key
+,
+v®
+),
+
+2297
+\9a¡r
+);
+
+2301
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoT¿ns\99iÚEËm\92tsK\9ad
+(
+
+2302
+HT¿ns\99iÚEËm\92tsK\9ad
+*
+\9a¡r
+) {
+
+2303 ià(
+IsSim¶eMChªgeT¿ns\99iÚ
+(
+\9a¡r
+->
+äom_k\9ad
+(), in¡r->
+to_k\9ad
+())) {
+
+2304
+LO³¿nd
+*
+ gobjeù
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+objeù
+());
+
+2305
+LO³¿nd
+*
+ gÃw_m_»g
+ =
+TempRegi¡\94
+();
+
+2306
+LT¿ns\99iÚEËm\92tsK\9ad
+*
+ g»suÉ
+ =
+
+2307
+Ãw
+ (
+zÚe
+()è
+LT¿ns\99iÚEËm\92tsK\9ad
+(
+objeù
+,
+NULL
+,
+Ãw_m_»g
+);
+
+2308 \15
+ g»suÉ
+;
+
+2310
+LO³¿nd
+*
+ gobjeù
+ =
+U£Fixed
+(
+\9a¡r
+->
+objeù
+(),
+r3
+);
+
+2311
+LO³¿nd
+*
+ gcڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->
+cڋxt
+(),
+ý
+);
+
+2312
+LT¿ns\99iÚEËm\92tsK\9ad
+*
+ g»suÉ
+ =
+
+2313
+Ãw
+ (
+zÚe
+()è
+LT¿ns\99iÚEËm\92tsK\9ad
+(
+objeù
+,
+cڋxt
+,
+NULL
+);
+
+2314 \15
+M¬kAsC®l
+(
+»suÉ
+,
+\9a¡r
+);
+
+2319
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoT¿pAÎoÿtiÚMem\92to
+(
+
+2320
+HT¿pAÎoÿtiÚMem\92to
+*
+\9a¡r
+) {
+
+2321
+LO³¿nd
+*
+objeù
+ =
+U£Regi¡\94
+(
+\9a¡r
+->object());
+
+2322
+LO³¿nd
+*
+ g\8bmp
+ =
+TempRegi¡\94
+();
+
+2323
+LT¿pAÎoÿtiÚMem\92to
+*
+ g»suÉ
+ =
+
+2324
+Ãw
+ (
+zÚe
+()è
+LT¿pAÎoÿtiÚMem\92to
+(
+objeù
+,
+\8bmp
+);
+
+2325 \15
+AssignEnv\9cÚm\92t
+(
+»suÉ
+);
+
+2329
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoStÜeNamedF\9bld
+(
+HStÜeNamedF\9bld
+*
+\9a¡r
+) {
+
+2330
+boÞ
+
+is_\9a_objeù
+ =
+\9a¡r
+->
+acûss
+().
+IsInobjeù
+();
+
+2331
+boÞ
+
+ gÃeds_wr\99e_b¬r\9br
+ =
+\9a¡r
+->
+N\93dsWr\99eB¬r\9br
+();
+
+2332
+boÞ
+
+ gÃeds_wr\99e_b¬r\9br_fÜ_m
+ =
+
+2333
+\9a¡r
+->
+has_\8cªs\99iÚ
+(è&& in¡r->
+N\93dsWr\99eB¬r\9brFÜM
+();
+
+2335
+LO³¿nd
+*
+ gobj
+;
+
+2336 ià(
+ gÃeds_wr\99e_b¬r\9br
+) {
+
+2337
+ gobj
+ =
+is_\9a_objeù
+ ?
+U£Regi¡\94
+(
+\9a¡r
+->
+objeù
+())
+
+2338 :
+U£TempRegi¡\94
+(
+\9a¡r
+->
+objeù
+());
+
+2340
+ gobj
+ =
+Ãeds_wr\99e_b¬r\9br_fÜ_m
+ ?
+U£Regi¡\94
+(
+\9a¡r
+->
+objeù
+())
+
+2341 :
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+objeù
+());
+
+2344
+LO³¿nd
+*
+ gv®
+;
+
+2345 ià(
+ gÃeds_wr\99e_b¬r\9br
+) {
+
+2346
+ gv®
+ =
+U£TempRegi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2347 } \vià(
+ g\9a¡r
+->
+f\9bld_»´e£Á©iÚ
+().
+IsDoubË
+()) {
+
+2348
+ gv®
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+v®ue
+());
+
+2350
+ gv®
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2354
+LO³¿nd
+*
+ g\8bmp
+ =
+Ãeds_wr\99e_b¬r\9br_fÜ_m
+ ?
+TempRegi¡\94
+(è:
+NULL
+;
+
+2356 \15
+Ãw
+ (
+zÚe
+()è
+LStÜeNamedF\9bld
+(
+obj
+,
+v®
+,
+\8bmp
+);
+
+2360
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoStÜeNamedG\92\94ic
+(
+HStÜeNamedG\92\94ic
+*
+\9a¡r
+) {
+
+2361
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2362
+LO³¿nd
+*
+ gobj
+ =
+
+2363
+U£Fixed
+(
+\9a¡r
+->
+objeù
+(),
+StÜeDesü\9dtÜ
+::
+Reûiv\94Regi¡\94
+());
+
+2364
+LO³¿nd
+*
+ gv®
+ =
+U£Fixed
+(
+\9a¡r
+->
+v®ue
+(),
+StÜeDesü\9dtÜ
+::
+V®ueRegi¡\94
+());
+
+2366
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()è
+LStÜeNamedG\92\94ic
+(
+cڋxt
+,
+obj
+,
+v®
+);
+
+2367 \15
+M¬kAsC®l
+(
+»suÉ
+,
+\9a¡r
+);
+
+2371
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoS\8c\9agAdd
+(
+HS\8c\9agAdd
+*
+\9a¡r
+) {
+
+2372
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2373
+LO³¿nd
+*
+ gËá
+ =
+U£Fixed
+(
+\9a¡r
+->
+Ëá
+(),
+r4
+);
+
+2374
+LO³¿nd
+*
+ gright
+ =
+U£Fixed
+(
+\9a¡r
+->
+right
+(),
+r3
+);
+
+2375 \15
+M¬kAsC®l
+(
+
+2376
+Def\9aeFixed
+(
+Ãw
+ (
+zÚe
+()è
+LS\8c\9agAdd
+(
+cڋxt
+,
+Ëá
+,
+right
+),
+r3
+),
+\9a¡r
+);
+
+2380
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoS\8c\9agCh¬CodeAt
+(
+HS\8c\9agCh¬CodeAt
+*
+\9a¡r
+) {
+
+2381
+LO³¿nd
+*
+¡r\9ag
+ =
+U£TempRegi¡\94
+(
+\9a¡r
+->string());
+
+2382
+LO³¿nd
+*
+ g\9adex
+ =
+U£TempRegi¡\94
+(
+\9a¡r
+->
+\9adex
+());
+
+2383
+LO³¿nd
+*
+ gcڋxt
+ =
+U£Any
+(
+\9a¡r
+->
+cڋxt
+());
+
+2384
+LS\8c\9agCh¬CodeAt
+*
+ g»suÉ
+ =
+
+2385
+Ãw
+ (
+zÚe
+()è
+LS\8c\9agCh¬CodeAt
+(
+cڋxt
+,
+¡r\9ag
+,
+\9adex
+);
+
+2386 \15
+AssignPo\9a\8brM
+(
+Def\9aeAsRegi¡\94
+(
+»suÉ
+));
+
+2390
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoS\8c\9agCh¬FromCode
+(
+HS\8c\9agCh¬FromCode
+*
+\9a¡r
+) {
+
+2391
+LO³¿nd
+*
+ch¬_code
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+());
+
+2392
+LO³¿nd
+*
+ gcڋxt
+ =
+U£Any
+(
+\9a¡r
+->
+cڋxt
+());
+
+2393
+LS\8c\9agCh¬FromCode
+*
+ g»suÉ
+ =
+
+2394
+Ãw
+ (
+zÚe
+()è
+LS\8c\9agCh¬FromCode
+(
+cڋxt
+,
+ch¬_code
+);
+
+2395 \15
+AssignPo\9a\8brM
+(
+Def\9aeAsRegi¡\94
+(
+»suÉ
+));
+
+2399
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoAÎoÿ\8b
+(
+HAÎoÿ\8b
+*
+\9a¡r
+) {
+
+2400
+\9afo
+()->
+M¬kAsDeã¼edC®l\9ag
+();
+
+2401
+LO³¿nd
+*
+ gcڋxt
+ =
+U£Any
+(
+\9a¡r
+->
+cڋxt
+());
+
+2402
+LO³¿nd
+*
+ gsize
+ =
+U£Regi¡\94OrCÚ¡ªt
+(
+\9a¡r
+->
+size
+());
+
+2403
+LO³¿nd
+*
+ g\8bmp1
+ =
+TempRegi¡\94
+();
+
+2404
+LO³¿nd
+*
+ g\8bmp2
+ =
+TempRegi¡\94
+();
+
+2405
+LAÎoÿ\8b
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLAÎoÿ\8b(
+cڋxt
+,
+size
+,
+\8bmp1
+,
+\8bmp2
+);
+
+2406 \15
+AssignPo\9a\8brM
+(
+Def\9aeAsRegi¡\94
+(
+»suÉ
+));
+
+2410
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoRegExpL\99\94®
+(
+HRegExpL\99\94®
+*
+\9a¡r
+) {
+
+2411
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2412 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+Ãw
+ (
+zÚe
+()è
+LRegExpL\99\94®
+(
+cڋxt
+),
+r3
+),
+
+2413
+\9a¡r
+);
+
+2417
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoFunùiÚL\99\94®
+(
+HFunùiÚL\99\94®
+*
+\9a¡r
+) {
+
+2418
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2419 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+Ãw
+ (
+zÚe
+()è
+LFunùiÚL\99\94®
+(
+cڋxt
+),
+r3
+),
+
+2420
+\9a¡r
+);
+
+2424
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoO¤EÁry
+(
+HO¤EÁry
+*
+\9a¡r
+) {
+
+2425
+DCHECK
+(
+¬gum\92t_couÁ_
+ == 0);
+
+2426
+ g®loÿtÜ_
+->
+M¬kAsO¤EÁry
+();
+
+2427
+ gcu¼\92t_block_
+->
+Ï¡_\92v\9cÚm\92t
+()->
+£t_a¡_id
+(
+\9a¡r
+->
+a¡_id
+());
+
+2428 \15
+AssignEnv\9cÚm\92t
+(
+Ãw
+ (
+zÚe
+()è
+LO¤EÁry
+);
+
+2432
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoP¬am\91\94
+(
+HP¬am\91\94
+*
+\9a¡r
+) {
+
+2433
+LP¬am\91\94
+*
+»suÉ
+ =
+Ãw
+ (
+zÚe
+()) LParameter;
+
+2434 ià(
+ g\9a¡r
+->
+k\9ad
+(è=ð
+HP¬am\91\94
+::
+STACK_PARAMETER
+) {
+
+2435 \12
+¥\9el_\9adex
+ =
+chunk
+()->
+G\91P¬am\91\94S\8fckSlÙ
+(
+\9a¡r
+->
+\9adex
+());
+
+2436 \15
+Def\9aeAsSp\9eËd
+(
+»suÉ
+,
+¥\9el_\9adex
+);
+
+2438
+DCHECK
+(
+\9afo
+()->
+IsStub
+());
+
+2439
+C®lIÁ\94çûDesü\9dtÜ
+
+ gdesü\9dtÜ
+ =
+
+2440
+\9afo
+()->
+code_¡ub
+()->
+G\91C®lIÁ\94çûDesü\9dtÜ
+();
+
+2441 \12
+ g\9adex
+ =
+¡©ic_ÿ¡
+<\12>(
+\9a¡r
+->
+\9adex
+());
+
+2442
+Regi¡\94
+
+ g»g
+ =
+desü\9dtÜ
+.
+G\91Env\9cÚm\92tP¬am\91\94Regi¡\94
+(
+\9adex
+);
+
+2443 \15
+Def\9aeFixed
+(
+»suÉ
+,
+»g
+);
+
+2448
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoUnknownOSRV®ue
+(
+HUnknownOSRV®ue
+*
+\9a¡r
+) {
+
+2451 \12
+\92v_\9adex
+ =
+\9a¡r
+->
+\9adex
+();
+
+2452 \12
+ g¥\9el_\9adex
+ = 0;
+
+2453 ià(
+ g\9a¡r
+->
+\92v\9cÚm\92t
+()->
+is_·¿m\91\94_\9adex
+(
+\92v_\9adex
+)) {
+
+2454
+ g¥\9el_\9adex
+ =
+chunk
+()->
+G\91P¬am\91\94S\8fckSlÙ
+(
+\92v_\9adex
+);
+
+2456
+ g¥\9el_\9adex
+ =
+\92v_\9adex
+ -
+\9a¡r
+->
+\92v\9cÚm\92t
+()->
+f\9c¡_loÿl_\9adex
+();
+
+2457 ià(
+ g¥\9el_\9adex
+ >
+ gLUÇÎoÿ\8bd
+::
+kMaxFixedSlÙIndex
+) {
+
+2458
+R\91ry
+(
+kTooMªySp\9elSlÙsN\93dedFÜOSR
+);
+
+2459
+ g¥\9el_\9adex
+ = 0;
+
+2462 \15
+Def\9aeAsSp\9eËd
+(
+Ãw
+ (
+zÚe
+()è
+LUnknownOSRV®ue
+,
+¥\9el_\9adex
+);
+
+2466
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoC®lStub
+(
+HC®lStub
+*
+\9a¡r
+) {
+
+2467
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2468 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+Ãw
+ (
+zÚe
+()è
+LC®lStub
+(
+cڋxt
+),
+r3
+),
+\9a¡r
+);
+
+2472
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoArgum\92tsObjeù
+(
+HArgum\92tsObjeù
+*
+\9a¡r
+) {
+
+2477 \15
+NULL
+;
+
+2481
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCtu»dObjeù
+(
+HCtu»dObjeù
+*
+\9a¡r
+) {
+
+2482
+\9a¡r
+->
+R\95ÏyEnv\9cÚm\92t
+(
+cu¼\92t_block_
+->
+Ï¡_\92v\9cÚm\92t
+());
+
+2485 \15
+ gNULL
+;
+
+2489
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoAcûssArgum\92tsAt
+(
+HAcûssArgum\92tsAt
+*
+\9a¡r
+) {
+
+2490
+\9afo
+()->
+M¬kAsRequ\9cesF¿me
+();
+
+2491
+LO³¿nd
+*
+ g¬gs
+ =
+U£Regi¡\94
+(
+\9a¡r
+->
+¬gum\92ts
+());
+
+2492
+LO³¿nd
+*
+ gËngth
+ =
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+Ëngth
+());
+
+2493
+LO³¿nd
+*
+ g\9adex
+ =
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+\9a¡r
+->
+\9adex
+());
+
+2494 \15
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LAcûssArgum\92tsAt
+(
+¬gs
+,
+Ëngth
+,
+\9adex
+));
+
+2498
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoToFa¡PrÝ\94t\9bs
+(
+HToFa¡PrÝ\94t\9bs
+*
+\9a¡r
+) {
+
+2499
+LO³¿nd
+*
+objeù
+ =
+U£Fixed
+(
+\9a¡r
+->
+v®ue
+(),
+r3
+);
+
+2500
+LToFa¡PrÝ\94t\9bs
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLToFa¡PrÝ\94t\9bs(
+objeù
+);
+
+2501 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+);
+
+2505
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoTy³of
+(
+HTy³of
+*
+\9a¡r
+) {
+
+2506
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2507
+LTy³of
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLTy³of(
+cڋxt
+,
+U£Fixed
+(
+\9a¡r
+->
+v®ue
+(),
+r3
+));
+
+2508 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+);
+
+2512
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoTy³ofIsAndB¿nch
+(
+HTy³ofIsAndB¿nch
+*
+\9a¡r
+) {
+
+2513 \15
+Ãw
+ (
+zÚe
+()è
+LTy³ofIsAndB¿nch
+(
+U£Regi¡\94
+(
+\9a¡r
+->
+v®ue
+()));
+
+2517
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoIsCÚ¡ruùC®lAndB¿nch
+(
+
+2518
+HIsCÚ¡ruùC®lAndB¿nch
+*
+\9a¡r
+) {
+
+2519 \15
+Ãw
+ (
+zÚe
+()è
+LIsCÚ¡ruùC®lAndB¿nch
+(
+TempRegi¡\94
+());
+
+2523
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoSimuϋ
+(
+HSimuϋ
+*
+\9a¡r
+) {
+
+2524
+\9a¡r
+->
+R\95ÏyEnv\9cÚm\92t
+(
+cu¼\92t_block_
+->
+Ï¡_\92v\9cÚm\92t
+());
+
+2525 \15
+ gNULL
+;
+
+2529
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoS\8fckCheck
+(
+HS\8fckCheck
+*
+\9a¡r
+) {
+
+2530 ià(
+\9a¡r
+->
+is_funùiÚ_\92\8cy
+()) {
+
+2531
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2532 \15
+M¬kAsC®l
+(
+Ãw
+ (
+zÚe
+()è
+LS\8fckCheck
+(
+cڋxt
+),
+\9a¡r
+);
+
+2534
+DCHECK
+(
+\9a¡r
+->
+is_backw¬ds_b¿nch
+());
+
+2535
+LO³¿nd
+*
+ gcڋxt
+ =
+U£Any
+(
+\9a¡r
+->
+cڋxt
+());
+
+2536 \15
+AssignEnv\9cÚm\92t
+(
+
+2537
+AssignPo\9a\8brM
+(
+Ãw
+ (
+zÚe
+()è
+LS\8fckCheck
+(
+cڋxt
+)));
+
+2542
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoEÁ\94IÆ\9aed
+(
+HEÁ\94IÆ\9aed
+*
+\9a¡r
+) {
+
+2543
+HEnv\9cÚm\92t
+*
+ou\8br
+ =
+cu¼\92t_block_
+->
+Ï¡_\92v\9cÚm\92t
+();
+
+2544
+ gou\8br
+->
+£t_a¡_id
+(
+\9a¡r
+->
+R\91uºId
+());
+
+2545
+HCÚ¡ªt
+*
+ gundef\9aed
+ =
+g¿ph
+()->
+G\91CÚ¡ªtUndef\9aed
+();
+
+2546
+HEnv\9cÚm\92t
+*
+ g\9aÃr
+ =
+ou\8br
+->
+CÝyFÜIÆ\9a\9ag
+(
+
+2547
+\9a¡r
+->
+þosu»
+(), in¡r->
+¬gum\92ts_couÁ
+(), in¡r->
+funùiÚ
+(),
+undef\9aed
+,
+
+2548
+\9a¡r
+->
+\9al\9a\9ag_k\9ad
+());
+
+2550 ià(
+ g\9a¡r
+->
+¬gum\92ts_v¬
+(è!ð
+NULL
+ &&
+\9a¡r
+->
+¬gum\92ts_objeù
+()->
+IsL\9aked
+()) {
+
+2551
+\9aÃr
+->
+B\9ad
+(
+\9a¡r
+->
+¬gum\92ts_v¬
+(), in¡r->
+¬gum\92ts_objeù
+());
+
+2553
+ g\9aÃr
+->
+B\9adCÚ\8bxt
+(
+\9a¡r
+->
+þosu»_cÚ\8bxt
+());
+
+2554
+ g\9aÃr
+->
+£t_\92\8cy
+(
+\9a¡r
+);
+
+2555
+ gcu¼\92t_block_
+->
+Upd©eEnv\9cÚm\92t
+(
+\9aÃr
+);
+
+2556
+ gchunk_
+->
+AddIÆ\9aedClosu»
+(
+\9a¡r
+->
+þosu»
+());
+
+2557 \15
+ gNULL
+;
+
+2561
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoL\97veIÆ\9aed
+(
+HL\97veIÆ\9aed
+*
+\9a¡r
+) {
+
+2562
+LIn¡ruùiÚ
+*
+pÝ
+ =
+NULL
+;
+
+2564
+HEnv\9cÚm\92t
+*
+ g\92v
+ =
+cu¼\92t_block_
+->
+Ï¡_\92v\9cÚm\92t
+();
+
+2566 ià(
+ g\92v
+->
+\92\8cy
+()->
+¬gum\92ts_pushed
+()) {
+
+2567 \12
+ g¬gum\92t_couÁ
+ =
+\92v
+->
+¬gum\92ts_\92v\9cÚm\92t
+()->
+·¿m\91\94_couÁ
+();
+
+2568
+ gpÝ
+ =
+Ãw
+ (
+zÚe
+()è
+LDrÝ
+(
+¬gum\92t_couÁ
+);
+
+2569
+DCHECK
+(
+\9a¡r
+->
+¬gum\92t_d\96\8f
+(è=ð-
+¬gum\92t_couÁ
+);
+
+2572
+HEnv\9cÚm\92t
+*
+ gou\8br
+ =
+
+2573
+cu¼\92t_block_
+->
+Ï¡_\92v\9cÚm\92t
+()->
+DisÿrdIÆ\9aed
+(
+çl£
+);
+
+2574
+ gcu¼\92t_block_
+->
+Upd©eEnv\9cÚm\92t
+(
+ou\8br
+);
+
+2576 \15
+ gpÝ
+;
+
+2580
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoFÜInP»·»M
+(
+HFÜInP»·»M
+*
+\9a¡r
+) {
+
+2581
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2582
+LO³¿nd
+*
+ gobjeù
+ =
+U£Fixed
+(
+\9a¡r
+->
+\92um\94abË
+(),
+r3
+);
+
+2583
+LFÜInP»·»M
+*
+ g»suÉ
+ =
+Ãw
+ (
+zÚe
+()èLFÜInP»·»M(
+cڋxt
+,
+objeù
+);
+
+2584 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+r3
+),
+\9a¡r
+,
+CAN_DEOPTIMIZE_EAGERLY
+);
+
+2588
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoFÜInCacheA¼ay
+(
+HFÜInCacheA¼ay
+*
+\9a¡r
+) {
+
+2589
+LO³¿nd
+*
+m
+ =
+U£Regi¡\94
+(
+\9a¡r
+->map());
+
+2590 \15
+AssignEnv\9cÚm\92t
+(
+
+2591
+Def\9aeAsRegi¡\94
+(
+Ãw
+ (
+zÚe
+()è
+LFÜInCacheA¼ay
+(
+m
+)));
+
+2595
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoCheckMV®ue
+(
+HCheckMV®ue
+*
+\9a¡r
+) {
+
+2596
+LO³¿nd
+*
+v®ue
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->value());
+
+2597
+LO³¿nd
+*
+ gm
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+m
+());
+
+2598 \15
+AssignEnv\9cÚm\92t
+(
+Ãw
+ (
+zÚe
+()è
+LCheckMV®ue
+(
+v®ue
+,
+m
+));
+
+2602
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoLßdF\9bldByIndex
+(
+HLßdF\9bldByIndex
+*
+\9a¡r
+) {
+
+2603
+LO³¿nd
+*
+objeù
+ =
+U£Regi¡\94
+(
+\9a¡r
+->object());
+
+2604
+LO³¿nd
+*
+ g\9adex
+ =
+U£TempRegi¡\94
+(
+\9a¡r
+->
+\9adex
+());
+
+2605
+LLßdF\9bldByIndex
+*
+ glßd
+ =
+Ãw
+ (
+zÚe
+()èLLßdF\9bldByIndex(
+objeù
+,
+\9adex
+);
+
+2606
+LIn¡ruùiÚ
+*
+ g»suÉ
+ =
+Def\9aeSameAsF\9c¡
+(
+lßd
+);
+
+2607 \15
+AssignPo\9a\8brM
+(
+»suÉ
+);
+
+2611
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoStÜeF¿meCÚ\8bxt
+(
+HStÜeF¿meCÚ\8bxt
+*
+\9a¡r
+) {
+
+2612
+LO³¿nd
+*
+cڋxt
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->context());
+
+2613 \15
+Ãw
+ (
+zÚe
+()è
+LStÜeF¿meCÚ\8bxt
+(
+cڋxt
+);
+
+2617
+LIn¡ruùiÚ
+*
+ gLChunkBu\9ed\94
+::
+DoAÎoÿ\8bBlockCÚ\8bxt
+(
+
+2618
+HAÎoÿ\8bBlockCÚ\8bxt
+*
+\9a¡r
+) {
+
+2619
+LO³¿nd
+*
+cڋxt
+ =
+U£Fixed
+(
+\9a¡r
+->cڋxt(),
+ý
+);
+
+2620
+LO³¿nd
+*
+ gfunùiÚ
+ =
+U£Regi¡\94AtS\8f¹
+(
+\9a¡r
+->
+funùiÚ
+());
+
+2621
+LAÎoÿ\8bBlockCÚ\8bxt
+*
+ g»suÉ
+ =
+
+2622
+Ãw
+ (
+zÚe
+()è
+LAÎoÿ\8bBlockCÚ\8bxt
+(
+cڋxt
+,
+funùiÚ
+);
+
+2623 \15
+M¬kAsC®l
+(
+Def\9aeFixed
+(
+»suÉ
+,
+ý
+),
+\9a¡r
+);
+
+ @lithium-ppc.h
+
+5 #iâdeà
+V8_PPC_LITHIUM_PPC_H_
+
+
+6 \ 1
+ #V8_PPC_LITHIUM_PPC_H_
+
+
+ )
+
+8 \ 2
+ ~"¤c/hydrog\92.h
+"
+
+9 \ 2
+ ~"¤c/l\99hium.h
+"
+
+10 \ 2
+ ~"¤c/l\99hium-®loÿtÜ.h
+"
+
+11 \ 2
+ ~"¤c/§ãpo\9at-\8fbË.h
+"
+
+12 \ 2
+ ~"¤c/ut\9es.h
+"
+
+14
+Çme¥aû
+
+ gv8
+ {
+
+15
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+18
+þass
+
+ gLCodeG\92
+;
+
+20 \ 1
+ #LITHIUM_CONCRETE_INSTRUCTION_LIST
+(
+V
+) \
+
+21
+ `V
+(
+AcûssArgum\92tsAt
+) \
+
+22
+ `V
+(
+AddI
+) \
+
+23
+ `V
+(
+AÎoÿ\8b
+) \
+
+24
+ `V
+(
+AÎoÿ\8bBlockCÚ\8bxt
+) \
+
+25
+ `V
+(
+AµlyArgum\92ts
+) \
+
+26
+ `V
+(
+Argum\92tsEËm\92ts
+) \
+
+27
+ `V
+(
+Argum\92tsL\92gth
+) \
+
+28
+ `V
+(
+Ar\99hm\91icD
+) \
+
+29
+ `V
+(
+Ar\99hm\91icT
+) \
+
+30
+ `V
+(
+B\99I
+) \
+
+31
+ `V
+(
+BoundsCheck
+) \
+
+32
+ `V
+(
+B¿nch
+) \
+
+33
+ `V
+(
+C®lJSFunùiÚ
+) \
+
+34
+ `V
+(
+C®lW\99hDesü\9dtÜ
+) \
+
+35
+ `V
+(
+C®lFunùiÚ
+) \
+
+36
+ `V
+(
+C®lNew
+) \
+
+37
+ `V
+(
+C®lNewA¼ay
+) \
+
+38
+ `V
+(
+C®lRuÁime
+) \
+
+39
+ `V
+(
+C®lStub
+) \
+
+40
+ `V
+(
+CheckIn¡ªûTy³
+) \
+
+41
+ `V
+(
+CheckNÚSmi
+) \
+
+42
+ `V
+(
+CheckMs
+) \
+
+43
+ `V
+(
+CheckMV®ue
+) \
+
+44
+ `V
+(
+CheckSmi
+) \
+
+45
+ `V
+(
+CheckV®ue
+) \
+
+46
+ `V
+(
+CÏmpDToU\9at8
+) \
+
+47
+ `V
+(
+CÏmpIToU\9at8
+) \
+
+48
+ `V
+(
+CÏmpTToU\9at8
+) \
+
+49
+ `V
+(
+CÏssOfTe¡AndB¿nch
+) \
+
+50
+ `V
+(
+Com·»M\9ausZ\94oAndB¿nch
+) \
+
+51
+ `V
+(
+Com·»Num\94icAndB¿nch
+) \
+
+52
+ `V
+(
+CmpObjeùEqAndB¿nch
+) \
+
+53
+ `V
+(
+CmpHÞeAndB¿nch
+) \
+
+54
+ `V
+(
+CmpMAndB¿nch
+) \
+
+55
+ `V
+(
+CmpT
+) \
+
+56
+ `V
+(
+CÚ¡ªtD
+) \
+
+57
+ `V
+(
+CÚ¡ªtE
+) \
+
+58
+ `V
+(
+CÚ¡ªtI
+) \
+
+59
+ `V
+(
+CÚ¡ªtS
+) \
+
+60
+ `V
+(
+CÚ¡ªtT
+) \
+
+61
+ `V
+(
+CÚ¡ruùDoubË
+) \
+
+62
+ `V
+(
+Cڋxt
+) \
+
+63
+ `V
+(
+D©eF\9bld
+) \
+
+64
+ `V
+(
+DebugB»ak
+) \
+
+65
+ `V
+(
+Deþ¬eGlob®s
+) \
+
+66
+ `V
+(
+DeÝtimize
+) \
+
+67
+ `V
+(
+DivByCڡI
+) \
+
+68
+ `V
+(
+DivByPow\94Of2I
+) \
+
+69
+ `V
+(
+DivI
+) \
+
+70
+ `V
+(
+DoubËB\99s
+) \
+
+71
+ `V
+(
+DoubËToI
+) \
+
+72
+ `V
+(
+DoubËToSmi
+) \
+
+73
+ `V
+(
+DrÝ
+) \
+
+74
+ `V
+(
+Dummy
+) \
+
+75
+ `V
+(
+DummyU£
+) \
+
+76
+ `V
+(
+FloܚgDivByCڡI
+) \
+
+77
+ `V
+(
+FloÜ\9agDivByPow\94Of2I
+) \
+
+78
+ `V
+(
+FloܚgDivI
+) \
+
+79
+ `V
+(
+FÜInCacheA¼ay
+) \
+
+80
+ `V
+(
+FÜInP»·»M
+) \
+
+81
+ `V
+(
+FunùiÚL\99\94®
+) \
+
+82
+ `V
+(
+G\91CachedA¼ayIndex
+) \
+
+83
+ `V
+(
+GÙo
+) \
+
+84
+ `V
+(
+HasCachedA¼ayIndexAndB¿nch
+) \
+
+85
+ `V
+(
+HasIn¡ªûTy³AndB¿nch
+) \
+
+86
+ `V
+(
+IÂ\94AÎoÿ\8bdObjeù
+) \
+
+87
+ `V
+(
+In¡ªûOf
+) \
+
+88
+ `V
+(
+In¡ªûOfKnownGlob®
+) \
+
+89
+ `V
+(
+In¡ruùiÚG
+) \
+
+90
+ `V
+(
+IÁeg\9432ToDoubË
+) \
+
+91
+ `V
+(
+InvokeFunùiÚ
+) \
+
+92
+ `V
+(
+IsCÚ¡ruùC®lAndB¿nch
+) \
+
+93
+ `V
+(
+IsObjeùAndB¿nch
+) \
+
+94
+ `V
+(
+IsS\8c\9agAndB¿nch
+) \
+
+95
+ `V
+(
+IsSmiAndB¿nch
+) \
+
+96
+ `V
+(
+IsUnd\91eùabËAndB¿nch
+) \
+
+97
+ `V
+(
+Lab\96
+) \
+
+98
+ `V
+(
+LazyBa\9eout
+) \
+
+99
+ `V
+(
+LßdCÚ\8bxtSlÙ
+) \
+
+100
+ `V
+(
+LßdRoÙ
+) \
+
+101
+ `V
+(
+LßdF\9bldByIndex
+) \
+
+102
+ `V
+(
+LßdFunùiÚPrÙÙy³
+) \
+
+103
+ `V
+(
+LßdGlob®C\96l
+) \
+
+104
+ `V
+(
+LßdGlob®G\92\94ic
+) \
+
+105
+ `V
+(
+LßdKeyed
+) \
+
+106
+ `V
+(
+LßdKeyedG\92\94ic
+) \
+
+107
+ `V
+(
+LßdNamedF\9bld
+) \
+
+108
+ `V
+(
+LßdNamedG\92\94ic
+) \
+
+109
+ `V
+(
+MEnumL\92gth
+) \
+
+110
+ `V
+(
+M©hAbs
+) \
+
+111
+ `V
+(
+M©hClz32
+) \
+
+112
+ `V
+(
+M©hExp
+) \
+
+113
+ `V
+(
+M©hFloÜ
+) \
+
+114
+ `V
+(
+M©hFround
+) \
+
+115
+ `V
+(
+M©hLog
+) \
+
+116
+ `V
+(
+M©hM\9aMax
+) \
+
+117
+ `V
+(
+M©hPowH®f
+) \
+
+118
+ `V
+(
+M©hRound
+) \
+
+119
+ `V
+(
+M©hSq¹
+) \
+
+120
+ `V
+(
+ModByCڡI
+) \
+
+121
+ `V
+(
+ModByPow\94Of2I
+) \
+
+122
+ `V
+(
+ModI
+) \
+
+123
+ `V
+(
+MulI
+) \
+
+124
+ `V
+(
+MuɝlyAddD
+) \
+
+125
+ `V
+(
+MuɝlySubD
+) \
+
+126
+ `V
+(
+Numb\94TagD
+) \
+
+127
+ `V
+(
+Numb\94TagI
+) \
+
+128
+ `V
+(
+Numb\94TagU
+) \
+
+129
+ `V
+(
+Numb\94UÁagD
+) \
+
+130
+ `V
+(
+O¤EÁry
+) \
+
+131
+ `V
+(
+P¬am\91\94
+) \
+
+132
+ `V
+(
+Pow\94
+) \
+
+133
+ `V
+(
+PushArgum\92t
+) \
+
+134
+ `V
+(
+RegExpL\99\94®
+) \
+
+135
+ `V
+(
+R\91uº
+) \
+
+136
+ `V
+(
+SeqS\8c\9agG\91Ch¬
+) \
+
+137
+ `V
+(
+SeqS\8c\9agS\91Ch¬
+) \
+
+138
+ `V
+(
+ShiáI
+) \
+
+139
+ `V
+(
+SmiTag
+) \
+
+140
+ `V
+(
+SmiUÁag
+) \
+
+141
+ `V
+(
+S\8fckCheck
+) \
+
+142
+ `V
+(
+StÜeCodeEÁry
+) \
+
+143
+ `V
+(
+StÜeCÚ\8bxtSlÙ
+) \
+
+144
+ `V
+(
+StÜeF¿meCÚ\8bxt
+) \
+
+145
+ `V
+(
+StÜeGlob®C\96l
+) \
+
+146
+ `V
+(
+StÜeKeyed
+) \
+
+147
+ `V
+(
+StÜeKeyedG\92\94ic
+) \
+
+148
+ `V
+(
+StÜeNamedF\9bld
+) \
+
+149
+ `V
+(
+StÜeNamedG\92\94ic
+) \
+
+150
+ `V
+(
+S\8c\9agAdd
+) \
+
+151
+ `V
+(
+S\8c\9agCh¬CodeAt
+) \
+
+152
+ `V
+(
+S\8c\9agCh¬FromCode
+) \
+
+153
+ `V
+(
+S\8c\9agCom·»AndB¿nch
+) \
+
+154
+ `V
+(
+SubI
+) \
+
+155
+ `V
+(
+RSubI
+) \
+
+156
+ `V
+(
+TaggedToI
+) \
+
+157
+ `V
+(
+Ta\9eC®lThroughMegamÜphicCache
+) \
+
+158
+ `V
+(
+ThisFunùiÚ
+) \
+
+159
+ `V
+(
+ToFa¡PrÝ\94t\9bs
+) \
+
+160
+ `V
+(
+T¿ns\99iÚEËm\92tsK\9ad
+) \
+
+161
+ `V
+(
+T¿pAÎoÿtiÚMem\92to
+) \
+
+162
+ `V
+(
+Ty³of
+) \
+
+163
+ `V
+(
+Ty³ofIsAndB¿nch
+) \
+
+164
+ `V
+(
+U\9at32ToDoubË
+) \
+
+165
+ `V
+(
+UnknownOSRV®ue
+) \
+
+166
+ `V
+(
+W¿pReûiv\94
+)
+
+ )
+
+169 \ 1
+ #DECLARE_CONCRETE_INSTRUCTION
+(
+ty³
+,
+mÃmÚic
+) \
+
+170
+v\9ctu®
+
+Opcode
+
+ `Ýcode
+(ècÚ¡
+FINAL
+
+OVERRIDE
+ { \
+
+171 \15
+LIn¡ruùiÚ
+::
+k
+##
+ty³
+; \
+
+173
+v\9ctu®
+ \1e
+ `Comp\9eeToN©ive
+(
+LCodeG\92
+*
+g\92\94©Ü
+è
+FINAL
+
+OVERRIDE
+; \
+
+174
+v\9ctu®
+ cڡ \ 5*
+ `MÃmÚic
+(ècÚ¡
+FINAL
+
+OVERRIDE
+ { \15
+mÃmÚic
+; } \
+
+175 \18
+L
+##
+ty³
+*
+ `ÿ¡
+(
+LIn¡ruùiÚ
+*
+\9a¡r
+) { \
+
+176
+ `DCHECK
+(
+\9a¡r
+->
+Is
+##
+ `ty³
+()); \
+
+177 \15
+»\9a\8b½»t_ÿ¡
+<
+L
+##
+ty³
+*>(
+\9a¡r
+); \
+
+178 }
+
+ )
+
+181 \ 1
+ #DECLARE_HYDROGEN_ACCESSOR
+(
+ty³
+) \
+
+182
+H
+##
+ty³
+*
+ `hydrog\92
+(ècÚ¡ { \15 H##ty³::
+ `ÿ¡
+(
+ `hydrog\92_v®ue
+()); }
+
+ )
+
+185 þas
+ cLIn¡ruùiÚ
+ :
+public
+
+ZÚeObjeù
+ {
+
+186
+public
+:
+
+187
+LIn¡ruùiÚ
+()
+
+188 :
+\92v\9cÚm\92t_
+(
+NULL
+),
+
+189
+hydrog\92_v®ue_
+(
+NULL
+),
+
+190
+b\99_f\9bld_
+(
+IsC®lB\99s
+::
+\92code
+(
+çl£
+)) {}
+
+192
+v\9ctu®
+ ~
+LIn¡ruùiÚ
+() {}
+
+194
+v\9ctu®
+ \1e
+Comp\9eeToN©ive
+(
+LCodeG\92
+*
+g\92\94©Ü
+) = 0;
+
+195
+v\9ctu®
+ cڡ \ 5*
+MÃmÚic
+() const = 0;
+
+196
+v\9ctu®
+ \1e
+Pr\9atTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+);
+
+197
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+);
+
+198
+v\9ctu®
+ \1e
+Pr\9atOu\8dutO³¿ndTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+);
+
+200 \f
+ eOpcode
+ {
+
+202 \ 1
+ #DECLARE_OPCODE
+(
+ty³
+è
+k
+##ty³,
+
+ )
+
+203
+LITHIUM_CONCRETE_INSTRUCTION_LIST
+(
+DECLARE_OPCODE
+è
+ gkNumb\94OfIn¡ruùiÚs
+
+
+204 #undeà
+DECLARE_OPCODE
+
+
+207
+v\9ctu®
+
+Opcode
+
+Ýcode
+() const = 0;
+
+210 \ 1
+ #DECLARE_PREDICATE
+(
+ty³
+) \
+
+211
+boÞ
+
+Is
+##
+ `ty³
+(ècÚ¡ { \15
+ `Ýcode
+(è=ð
+k
+##
+ty³
+; }
+
+ )
+
+212
+LITHIUM_CONCRETE_INSTRUCTION_LIST
+(
+DECLARE_PREDICATE
+)
+
+213 #undeà
+DECLARE_PREDICATE
+
+
+217
+v\9ctu®
+
+boÞ
+
+IsG
+(ècÚ¡ { \15
+ gçl£
+; }
+
+219
+v\9ctu®
+
+boÞ
+
+IsCÚ\8cÞ
+(ècÚ¡ { \15
+ gçl£
+; }
+
+222
+v\9ctu®
+
+boÞ
+
+TryD\96\91e
+(è{ \15
+ gçl£
+; }
+
+224 \1e
+£t_\92v\9cÚm\92t
+(
+LEnv\9cÚm\92t
+*
+\92v
+è{
+ g\92v\9cÚm\92t_
+ =\83nv; }
+
+225
+LEnv\9cÚm\92t
+*
+\92v\9cÚm\92t
+(ècÚ¡ { \15
+ g\92v\9cÚm\92t_
+; }
+
+226
+boÞ
+
+HasEnv\9cÚm\92t
+(ècÚ¡ { \15
+ g\92v\9cÚm\92t_
+ !ð
+NULL
+; }
+
+228 \1e
+£t_po\9a\8br_m
+(
+LPo\9a\8brM
+*
+p
+è{
+ gpo\9a\8br_m_
+.
+£t
+(p); }
+
+229
+LPo\9a\8brM
+*
+po\9a\8br_m
+(ècÚ¡ { \15
+ gpo\9a\8br_m_
+.
+g\91
+(); }
+
+230
+boÞ
+
+HasPo\9a\8brM
+(ècÚ¡ { \15
+ gpo\9a\8br_m_
+.
+is_£t
+(); }
+
+232 \1e
+£t_hydrog\92_v®ue
+(
+HV®ue
+*
+v®ue
+è{
+ ghydrog\92_v®ue_
+ = value; }
+
+233
+HV®ue
+*
+hydrog\92_v®ue
+(ècÚ¡ { \15
+ ghydrog\92_v®ue_
+; }
+
+235
+v\9ctu®
+ \1e
+S\91Deã¼edLazyDeÝtimiz©iÚEnv\9cÚm\92t
+(
+LEnv\9cÚm\92t
+*
+\92v
+) {}
+
+237 \1e
+M¬kAsC®l
+(è{
+ gb\99_f\9bld_
+ =
+IsC®lB\99s
+::
+upd©e
+(
+b\99_f\9bld_
+,
+\8cue
+); }
+
+238
+boÞ
+
+IsC®l
+(ècÚ¡ { \15
+ gIsC®lB\99s
+::
+decode
+(
+b\99_f\9bld_
+); }
+
+241
+boÞ
+
+Clobb\94sTemps
+(ècÚ¡ { \15
+IsC®l
+(); }
+
+242
+boÞ
+
+Clobb\94sRegi¡\94s
+(ècÚ¡ { \15
+IsC®l
+(); }
+
+243
+v\9ctu®
+
+boÞ
+
+Clobb\94sDoubËRegi¡\94s
+(
+Isީe
+*
+isީe
+) const {
+
+244 \15
+IsC®l
+();
+
+248
+boÞ
+
+IsM¬kedAsC®l
+(ècÚ¡ { \15
+IsC®l
+(); }
+
+250
+v\9ctu®
+
+boÞ
+
+HasResuÉ
+() const = 0;
+
+251
+v\9ctu®
+
+LO³¿nd
+*
+»suÉ
+() const = 0;
+
+253
+LO³¿nd
+*
+F\9c¡IÅut
+(è{ \15
+IÅutAt
+(0); }
+
+254
+LO³¿nd
+*
+Ou\8dut
+(è{ \15
+HasResuÉ
+(è?
+»suÉ
+(è:
+NULL
+; }
+
+256
+v\9ctu®
+
+boÞ
+
+HasIÁ\94e¡\9agComm\92t
+(
+LCodeG\92
+*
+g\92
+ècÚ¡ { \15
+ g\8cue
+; }
+
+258 #ifdeà
+DEBUG
+
+
+259 \1e
+V\94ifyC®l
+();
+
+262
+v\9ctu®
+ \12
+IÅutCouÁ
+() = 0;
+
+263
+v\9ctu®
+
+LO³¿nd
+*
+IÅutAt
+(\12
+i
+) = 0;
+
+265
+ g´iv©e
+:
+
+267
+ä\9bnd
+
+þass
+
+IÅutI\8b¿tÜ
+;
+
+269
+ä\9bnd
+
+þass
+
+ gTempI\8b¿tÜ
+;
+
+270
+v\9ctu®
+ \12
+TempCouÁ
+() = 0;
+
+271
+v\9ctu®
+
+LO³¿nd
+*
+TempAt
+(\12
+i
+) = 0;
+
+273
+þass
+
+ gIsC®lB\99s
+ :
+public
+
+B\99F\9bld
+<
+boÞ
+, 0, 1> {};
+
+275
+LEnv\9cÚm\92t
+*
+ g\92v\9cÚm\92t_
+;
+
+276
+ gS\91OnûPo\9a\8br
+<
+ gLPo\9a\8brM
+>
+ gpo\9a\8br_m_
+;
+
+277
+HV®ue
+*
+ ghydrog\92_v®ue_
+;
+
+278 \12
+ gb\99_f\9bld_
+;
+
+283
+ g\8bm¶©e
+ <\12
+ gR
+>
+
+284 þas
+ cLTem¶©eResuÉIn¡ruùiÚ
+ :
+public
+
+LIn¡ruùiÚ
+ {
+
+285
+public
+:
+
+287
+STATIC_ASSERT
+(
+R
+ == 0 || R == 1);
+
+288
+v\9ctu®
+
+boÞ
+
+HasResuÉ
+(ècÚ¡
+FINAL
+
+ gOVERRIDE
+ {
+
+289 \15
+ gR
+ !ð0 &&
+»suÉ
+(è!ð
+NULL
+;
+
+291 \1e
+£t_»suÉ
+(
+LO³¿nd
+*
+Ý\94ªd
+è{
+ g»suÉs_
+[0] = operand; }
+
+292
+LO³¿nd
+*
+»suÉ
+(ècÚ¡ { \15
+ g»suÉs_
+[0]; }
+
+294
+ g´Ùeùed
+:
+
+295
+EmbeddedCÚ\8f\9a\94
+<
+LO³¿nd
+*,
+ gR
+>
+ g»suÉs_
+;
+
+302
+ g\8bm¶©e
+ <\12
+ gR
+, \12
+ gI
+, \12
+ gT
+>
+
+303
+þass
+
+ gLTem¶©eIn¡ruùiÚ
+ :
+public
+
+LTem¶©eResuÉIn¡ruùiÚ
+<
+R
+> {
+
+304
+´Ùeùed
+:
+
+305
+EmbeddedCÚ\8f\9a\94
+<
+LO³¿nd
+*,
+ gI
+>
+ g\9aputs_
+;
+
+306
+ gEmbeddedCÚ\8f\9a\94
+<
+ gLO³¿nd
+*,
+ gT
+>
+ g\8bmps_
+;
+
+308
+ g´iv©e
+:
+
+310
+v\9ctu®
+ \12
+IÅutCouÁ
+(è
+FINAL
+
+OVERRIDE
+ { \15
+I
+; }
+
+311
+v\9ctu®
+
+LO³¿nd
+*
+IÅutAt
+(\12
+i
+è
+FINAL
+
+ gOVERRIDE
+ { \15
+ g\9aputs_
+[i]; }
+
+313
+v\9ctu®
+ \12
+TempCouÁ
+(è
+FINAL
+
+ gOVERRIDE
+ { \15
+ gT
+; }
+
+314
+v\9ctu®
+
+LO³¿nd
+*
+TempAt
+(\12
+i
+è
+FINAL
+
+ gOVERRIDE
+ { \15
+ g\8bmps_
+[i]; }
+
+318
+þass
+
+ gLG
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 0, 0> {
+
+319
+ gpublic
+:
+
+320
+ex¶ic\99
+
+LG
+(
+HBasicBlock
+*
+block
+è:
+block_
+(block) {
+
+321
+·¿Î\96_moves_
+[
+BEFORE
+] =
+NULL
+;
+
+322
+ g·¿Î\96_moves_
+[
+START
+] =
+NULL
+;
+
+323
+ g·¿Î\96_moves_
+[
+END
+] =
+NULL
+;
+
+324
+ g·¿Î\96_moves_
+[
+AFTER
+] =
+NULL
+;
+
+328
+v\9ctu®
+
+boÞ
+
+IsG
+(ècÚ¡
+ gOVERRIDE
+ { \15
+ g\8cue
+; }
+
+329
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+330 \18
+LG
+*
+ÿ¡
+(
+LIn¡ruùiÚ
+*
+\9a¡r
+) {
+
+331
+DCHECK
+(
+\9a¡r
+->
+IsG
+());
+
+332 \15
+ g»\9a\8b½»t_ÿ¡
+<
+ gLG
+*>(
+ g\9a¡r
+);
+
+335
+boÞ
+
+IsRedundªt
+() const;
+
+337
+HBasicBlock
+*
+block
+(ècÚ¡ { \15
+ gblock_
+; }
+
+339 \f
+ eIÂ\94Pos\99iÚ
+ {
+
+340
+ gBEFORE
+,
+
+341
+ gSTART
+,
+
+342
+ gEND
+,
+
+343
+ gAFTER
+,
+
+344
+ gFIRST_INNER_POSITION
+ =
+BEFORE
+,
+
+345
+ gLAST_INNER_POSITION
+ =
+AFTER
+
+
+348
+LP¬®ËlMove
+*
+G\91OrC»©eP¬®ËlMove
+(
+IÂ\94Pos\99iÚ
+
+pos
+,
+ZÚe
+*
+zÚe
+) {
+
+349 ià(
+ g·¿Î\96_moves_
+[
+pos
+] =ð
+NULL
+) {
+
+350
+·¿Î\96_moves_
+[
+pos
+] =
+Ãw
+ (
+zÚe
+è
+LP¬®ËlMove
+(zone);
+
+352 \15
+ g·¿Î\96_moves_
+[
+pos
+];
+
+355
+LP¬®ËlMove
+*
+G\91P¬®ËlMove
+(
+IÂ\94Pos\99iÚ
+
+pos
+) {
+
+356 \15
+ g·¿Î\96_moves_
+[
+pos
+];
+
+359
+ g´iv©e
+:
+
+360
+LP¬®ËlMove
+*
+·¿Î\96_moves_
+[
+LAST_INNER_POSITION
+ + 1];
+
+361
+HBasicBlock
+*
+ gblock_
+;
+
+365 þas
+ cLIn¡ruùiÚG
+
+ gFINAL
+ :
+public
+
+LG
+ {
+
+366
+public
+:
+
+367
+ex¶ic\99
+
+LIn¡ruùiÚG
+(
+HBasicBlock
+*
+block
+è:
+LG
+(block) {}
+
+369
+v\9ctu®
+
+boÞ
+
+HasIÁ\94e¡\9agComm\92t
+(
+LCodeG\92
+*
+g\92
+ècÚ¡
+OVERRIDE
+ {
+
+370 \15 !
+IsRedundªt
+();
+
+373
+DECLARE_CONCRETE_INSTRUCTION
+(
+In¡ruùiÚG
+, "gap")
+
+377
+þass
+
+LGÙo
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 0, 0> {
+
+378
+ gpublic
+:
+
+379
+ex¶ic\99
+
+LGÙo
+(
+HBasicBlock
+*
+block
+è:
+block_
+(block) {}
+
+381
+v\9ctu®
+
+boÞ
+
+HasIÁ\94e¡\9agComm\92t
+(
+LCodeG\92
+*
+g\92
+ècÚ¡
+OVERRIDE
+;
+
+382
+DECLARE_CONCRETE_INSTRUCTION
+(
+GÙo
+, "goto")
+
+383
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+384
+v\9ctu®
+
+boÞ
+
+IsCÚ\8cÞ
+(ècÚ¡
+ gOVERRIDE
+ { \15
+ g\8cue
+; }
+
+386 \12
+block_id
+(ècÚ¡ { \15
+ gblock_
+->block_id(); }
+
+388
+ g´iv©e
+:
+
+389
+HBasicBlock
+*
+block_
+;
+
+393
+þass
+
+LLazyBa\9eout
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 0, 0> {
+
+394
+ gpublic
+:
+
+395
+LLazyBa\9eout
+(è:
+g_\9a¡ruùiÚs_size_
+(0) {}
+
+397
+DECLARE_CONCRETE_INSTRUCTION
+(
+LazyBa\9eout
+, "lazy-bailout")
+
+399 \1e
+£t_g_\9a¡ruùiÚs_size
+(\12
+g_\9a¡ruùiÚs_size
+) {
+
+400
+ gg_\9a¡ruùiÚs_size_
+ =
+g_\9a¡ruùiÚs_size
+;
+
+402 \12
+g_\9a¡ruùiÚs_size
+(è{ \15
+ gg_\9a¡ruùiÚs_size_
+; }
+
+404
+ g´iv©e
+:
+
+405 \12
+g_\9a¡ruùiÚs_size_
+;
+
+409
+þass
+
+LDummy
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+410
+ gpublic
+:
+
+411
+LDummy
+() {}
+
+412
+DECLARE_CONCRETE_INSTRUCTION
+(
+Dummy
+, "dummy")
+
+416
+þass
+
+LDummyU£
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+417
+ gpublic
+:
+
+418
+ex¶ic\99
+
+LDummyU£
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+419
+DECLARE_CONCRETE_INSTRUCTION
+(
+DummyU£
+, "dummy-use")
+
+423
+þass
+
+LDeÝtimize
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 0, 0> {
+
+424
+ gpublic
+:
+
+425
+v\9ctu®
+
+boÞ
+
+IsCÚ\8cÞ
+(ècÚ¡
+OVERRIDE
+ { \15
+\8cue
+; }
+
+426
+DECLARE_CONCRETE_INSTRUCTION
+(
+DeÝtimize
+, "deoptimize")
+
+427
+DECLARE_HYDROGEN_ACCESSOR
+(
+DeÝtimize
+)
+
+431 þas
+ cLLab\96
+
+ gFINAL
+ :
+public
+
+LG
+ {
+
+432
+public
+:
+
+433
+ex¶ic\99
+
+LLab\96
+(
+HBasicBlock
+*
+block
+è:
+LG
+(block),
+»¶aûm\92t_
+(
+NULL
+) {}
+
+435
+v\9ctu®
+
+boÞ
+
+HasIÁ\94e¡\9agComm\92t
+(
+LCodeG\92
+*
+g\92
+ècÚ¡
+ gOVERRIDE
+ {
+
+436 \15
+ gçl£
+;
+
+438
+DECLARE_CONCRETE_INSTRUCTION
+(
+Lab\96
+, "label")
+
+440
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+442 \12
+block_id
+(ècÚ¡ { \15
+block
+()->block_id(); }
+
+443
+boÞ
+
+is_loÝ_h\97d\94
+(ècÚ¡ { \15
+block
+()->
+IsLoÝH\97d\94
+(); }
+
+444
+boÞ
+
+is_o¤_\92\8cy
+(ècÚ¡ { \15
+block
+()->is_osr_entry(); }
+
+445
+Lab\96
+*
+Ïb\96
+(è{ \15 &
+ gÏb\96_
+; }
+
+446
+LLab\96
+*
+»¶aûm\92t
+(ècÚ¡ { \15
+ g»¶aûm\92t_
+; }
+
+447 \1e
+£t_»¶aûm\92t
+(
+LLab\96
+*
+Ïb\96
+è{
+ g»¶aûm\92t_
+ =\86abel; }
+
+448
+boÞ
+
+HasR\95Ïûm\92t
+(ècÚ¡ { \15
+ g»¶aûm\92t_
+ !ð
+NULL
+; }
+
+450
+ g´iv©e
+:
+
+451
+Lab\96
+
+Ïb\96_
+;
+
+452
+LLab\96
+*
+ g»¶aûm\92t_
+;
+
+456
+þass
+
+LP¬am\91\94
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+457
+ gpublic
+:
+
+458
+v\9ctu®
+
+boÞ
+
+HasIÁ\94e¡\9agComm\92t
+(
+LCodeG\92
+*
+g\92
+ècÚ¡ { \15
+çl£
+; }
+
+459
+DECLARE_CONCRETE_INSTRUCTION
+(
+P¬am\91\94
+, "parameter")
+
+463
+þass
+
+LC®lStub
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+464
+ gpublic
+:
+
+465
+ex¶ic\99
+
+LC®lStub
+(
+LO³¿nd
+*
+cڋxt
+è{
+\9aputs_
+[0] = context; }
+
+467
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+469
+DECLARE_CONCRETE_INSTRUCTION
+(
+C®lStub
+, "call-stub")
+
+470
+DECLARE_HYDROGEN_ACCESSOR
+(
+C®lStub
+)
+
+474
+þass
+
+LTa\9eC®lThroughMegamÜphicCache
+
+ gFINAL
+
+
+475 :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 3, 0> {
+
+476
+ gpublic
+:
+
+477
+ex¶ic\99
+
+LTa\9eC®lThroughMegamÜphicCache
+(
+LO³¿nd
+*
+cڋxt
+,
+
+478
+LO³¿nd
+*
+»ûiv\94
+,
+
+479
+LO³¿nd
+*
+Çme
+) {
+
+480
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+481
+ g\9aputs_
+[1] =
+»ûiv\94
+;
+
+482
+ g\9aputs_
+[2] =
+Çme
+;
+
+485
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+486
+LO³¿nd
+*
+»ûiv\94
+(è{ \15
+ g\9aputs_
+[1]; }
+
+487
+LO³¿nd
+*
+Çme
+(è{ \15
+ g\9aputs_
+[2]; }
+
+489
+DECLARE_CONCRETE_INSTRUCTION
+(
+Ta\9eC®lThroughMegamÜphicCache
+,
+
+491
+DECLARE_HYDROGEN_ACCESSOR
+(
+Ta\9eC®lThroughMegamÜphicCache
+)
+
+494
+þass
+
+LUnknownOSRV®ue
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+495
+ gpublic
+:
+
+496
+v\9ctu®
+
+boÞ
+
+HasIÁ\94e¡\9agComm\92t
+(
+LCodeG\92
+*
+g\92
+ècÚ¡
+OVERRIDE
+ {
+
+497 \15
+çl£
+;
+
+499
+DECLARE_CONCRETE_INSTRUCTION
+(
+UnknownOSRV®ue
+, "unknown-osr-value")
+
+503
+ g\8bm¶©e
+ <\12
+ gI
+, \12
+ gT
+>
+
+504
+þass
+
+ gLCÚ\8cÞIn¡ruùiÚ
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0,
+ gI
+,
+ gT
+> {
+
+505
+ gpublic
+:
+
+506
+LCÚ\8cÞIn¡ruùiÚ
+(è:
+çl£_Ïb\96_
+(
+NULL
+),
+\8cue_Ïb\96_
+(NULL) {}
+
+508
+v\9ctu®
+
+boÞ
+
+IsCÚ\8cÞ
+(ècÚ¡
+FINAL
+
+ gOVERRIDE
+ { \15
+ g\8cue
+; }
+
+510 \12
+SucûssÜCouÁ
+(è{ \15
+hydrog\92
+()->SuccessorCount(); }
+
+511
+HBasicBlock
+*
+SucûssÜAt
+(\12
+i
+è{ \15
+hydrog\92
+()->SuccessorAt(i); }
+
+513 \12
+TrueDe¡\9a©iÚ
+(
+LChunk
+*
+chunk
+) {
+
+514 \15
+ gchunk
+->
+LookupDe¡\9a©iÚ
+(
+\8cue_block_id
+());
+
+516 \12
+F®£De¡\9a©iÚ
+(
+LChunk
+*
+chunk
+) {
+
+517 \15
+ gchunk
+->
+LookupDe¡\9a©iÚ
+(
+çl£_block_id
+());
+
+520
+Lab\96
+*
+TrueLab\96
+(
+LChunk
+*
+chunk
+) {
+
+521 ià(
+ g\8cue_Ïb\96_
+ =ð
+NULL
+) {
+
+522
+\8cue_Ïb\96_
+ =
+chunk
+->
+G\91As£mblyLab\96
+(
+TrueDe¡\9a©iÚ
+(chunk));
+
+524 \15
+ g\8cue_Ïb\96_
+;
+
+526
+Lab\96
+*
+F®£Lab\96
+(
+LChunk
+*
+chunk
+) {
+
+527 ià(
+ gçl£_Ïb\96_
+ =ð
+NULL
+) {
+
+528
+çl£_Ïb\96_
+ =
+chunk
+->
+G\91As£mblyLab\96
+(
+F®£De¡\9a©iÚ
+(chunk));
+
+530 \15
+ gçl£_Ïb\96_
+;
+
+533
+ g´Ùeùed
+:
+
+534 \12
+\8cue_block_id
+(è{ \15
+SucûssÜAt
+(0)->
+block_id
+(); }
+
+535 \12
+çl£_block_id
+(è{ \15
+SucûssÜAt
+(1)->
+block_id
+(); }
+
+537
+ g´iv©e
+:
+
+538
+HCÚ\8cÞIn¡ruùiÚ
+*
+hydrog\92
+() {
+
+539 \15
+HCÚ\8cÞIn¡ruùiÚ
+::
+ÿ¡
+(
+this
+->
+hydrog\92_v®ue
+());
+
+542
+Lab\96
+*
+ gçl£_Ïb\96_
+;
+
+543
+Lab\96
+*
+ g\8cue_Ïb\96_
+;
+
+547
+þass
+
+LW¿pReûiv\94
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+548
+ gpublic
+:
+
+549
+LW¿pReûiv\94
+(
+LO³¿nd
+*
+»ûiv\94
+, LO³¿nd*
+funùiÚ
+) {
+
+550
+ g\9aputs_
+[0] =
+»ûiv\94
+;
+
+551
+ g\9aputs_
+[1] =
+funùiÚ
+;
+
+554
+DECLARE_CONCRETE_INSTRUCTION
+(
+W¿pReûiv\94
+, "wrap-receiver")
+
+555
+DECLARE_HYDROGEN_ACCESSOR
+(
+W¿pReûiv\94
+)
+
+557
+LO³¿nd
+*
+»ûiv\94
+(è{ \15
+ g\9aputs_
+[0]; }
+
+558
+LO³¿nd
+*
+funùiÚ
+(è{ \15
+ g\9aputs_
+[1]; }
+
+562
+þass
+
+LAµlyArgum\92ts
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 4, 0> {
+
+563
+ gpublic
+:
+
+564
+LAµlyArgum\92ts
+(
+LO³¿nd
+*
+funùiÚ
+, LO³¿nd*
+»ûiv\94
+, LO³¿nd*
+Ëngth
+,
+
+565
+LO³¿nd
+*
+\96em\92ts
+) {
+
+566
+ g\9aputs_
+[0] =
+funùiÚ
+;
+
+567
+ g\9aputs_
+[1] =
+»ûiv\94
+;
+
+568
+ g\9aputs_
+[2] =
+Ëngth
+;
+
+569
+ g\9aputs_
+[3] =
+\96em\92ts
+;
+
+572
+DECLARE_CONCRETE_INSTRUCTION
+(
+AµlyArgum\92ts
+, "apply-arguments")
+
+574
+LO³¿nd
+*
+funùiÚ
+(è{ \15
+ g\9aputs_
+[0]; }
+
+575
+LO³¿nd
+*
+»ûiv\94
+(è{ \15
+ g\9aputs_
+[1]; }
+
+576
+LO³¿nd
+*
+Ëngth
+(è{ \15
+ g\9aputs_
+[2]; }
+
+577
+LO³¿nd
+*
+\96em\92ts
+(è{ \15
+ g\9aputs_
+[3]; }
+
+581
+þass
+
+LAcûssArgum\92tsAt
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 3, 0> {
+
+582
+ gpublic
+:
+
+583
+LAcûssArgum\92tsAt
+(
+LO³¿nd
+*
+¬gum\92ts
+, LO³¿nd*
+Ëngth
+, LO³¿nd*
+\9adex
+) {
+
+584
+ g\9aputs_
+[0] =
+¬gum\92ts
+;
+
+585
+ g\9aputs_
+[1] =
+Ëngth
+;
+
+586
+ g\9aputs_
+[2] =
+\9adex
+;
+
+589
+DECLARE_CONCRETE_INSTRUCTION
+(
+AcûssArgum\92tsAt
+, "access-arguments-at")
+
+591
+LO³¿nd
+*
+¬gum\92ts
+(è{ \15
+ g\9aputs_
+[0]; }
+
+592
+LO³¿nd
+*
+Ëngth
+(è{ \15
+ g\9aputs_
+[1]; }
+
+593
+LO³¿nd
+*
+\9adex
+(è{ \15
+ g\9aputs_
+[2]; }
+
+595
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+599
+þass
+
+LArgum\92tsL\92gth
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+600
+ gpublic
+:
+
+601
+ex¶ic\99
+
+LArgum\92tsL\92gth
+(
+LO³¿nd
+*
+\96em\92ts
+è{
+\9aputs_
+[0] =\83lements; }
+
+603
+LO³¿nd
+*
+\96em\92ts
+(è{ \15
+ g\9aputs_
+[0]; }
+
+605
+DECLARE_CONCRETE_INSTRUCTION
+(
+Argum\92tsL\92gth
+, "arguments-length")
+
+609
+þass
+
+LArgum\92tsEËm\92ts
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+610
+ gpublic
+:
+
+611
+DECLARE_CONCRETE_INSTRUCTION
+(
+Argum\92tsEËm\92ts
+, "arguments-elements")
+
+612
+DECLARE_HYDROGEN_ACCESSOR
+(
+Argum\92tsEËm\92ts
+)
+
+616
+þass
+
+LModByPow\94Of2I
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+617
+ gpublic
+:
+
+618
+LModByPow\94Of2I
+(
+LO³¿nd
+*
+divid\92d
+,
+\9at32_t
+
+divisÜ
+) {
+
+619
+ g\9aputs_
+[0] =
+divid\92d
+;
+
+620
+ gdivisÜ_
+ =
+divisÜ
+;
+
+623
+LO³¿nd
+*
+divid\92d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+624
+\9at32_t
+
+divisÜ
+(ècÚ¡ { \15
+ gdivisÜ_
+; }
+
+626
+DECLARE_CONCRETE_INSTRUCTION
+(
+ModByPow\94Of2I
+, "mod-by-power-of-2-i")
+
+627
+DECLARE_HYDROGEN_ACCESSOR
+(
+Mod
+)
+
+629
+ g´iv©e
+:
+
+630
+\9at32_t
+
+divisÜ_
+;
+
+634
+þass
+
+LModByCڡI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+635
+ gpublic
+:
+
+636
+LModByCڡI
+(
+LO³¿nd
+*
+divid\92d
+,
+\9at32_t
+
+divisÜ
+) {
+
+637
+ g\9aputs_
+[0] =
+divid\92d
+;
+
+638
+ gdivisÜ_
+ =
+divisÜ
+;
+
+641
+LO³¿nd
+*
+divid\92d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+642
+\9at32_t
+
+divisÜ
+(ècÚ¡ { \15
+ gdivisÜ_
+; }
+
+644
+DECLARE_CONCRETE_INSTRUCTION
+(
+ModByCڡI
+, "mod-by-const-i")
+
+645
+DECLARE_HYDROGEN_ACCESSOR
+(
+Mod
+)
+
+647
+ g´iv©e
+:
+
+648
+\9at32_t
+
+divisÜ_
+;
+
+652
+þass
+
+LModI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+653
+ gpublic
+:
+
+654
+LModI
+(
+LO³¿nd
+*
+Ëá
+, LO³¿nd*
+right
+) {
+
+655
+ g\9aputs_
+[0] =
+Ëá
+;
+
+656
+ g\9aputs_
+[1] =
+right
+;
+
+659
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[0]; }
+
+660
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[1]; }
+
+662
+DECLARE_CONCRETE_INSTRUCTION
+(
+ModI
+, "mod-i")
+
+663
+DECLARE_HYDROGEN_ACCESSOR
+(
+Mod
+)
+
+667
+þass
+
+LDivByPow\94Of2I
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+668
+ gpublic
+:
+
+669
+LDivByPow\94Of2I
+(
+LO³¿nd
+*
+divid\92d
+,
+\9at32_t
+
+divisÜ
+) {
+
+670
+ g\9aputs_
+[0] =
+divid\92d
+;
+
+671
+ gdivisÜ_
+ =
+divisÜ
+;
+
+674
+LO³¿nd
+*
+divid\92d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+675
+\9at32_t
+
+divisÜ
+(ècÚ¡ { \15
+ gdivisÜ_
+; }
+
+677
+DECLARE_CONCRETE_INSTRUCTION
+(
+DivByPow\94Of2I
+, "div-by-power-of-2-i")
+
+678
+DECLARE_HYDROGEN_ACCESSOR
+(
+Div
+)
+
+680
+ g´iv©e
+:
+
+681
+\9at32_t
+
+divisÜ_
+;
+
+685
+þass
+
+LDivByCڡI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+686
+ gpublic
+:
+
+687
+LDivByCڡI
+(
+LO³¿nd
+*
+divid\92d
+,
+\9at32_t
+
+divisÜ
+) {
+
+688
+ g\9aputs_
+[0] =
+divid\92d
+;
+
+689
+ gdivisÜ_
+ =
+divisÜ
+;
+
+692
+LO³¿nd
+*
+divid\92d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+693
+\9at32_t
+
+divisÜ
+(ècÚ¡ { \15
+ gdivisÜ_
+; }
+
+695
+DECLARE_CONCRETE_INSTRUCTION
+(
+DivByCڡI
+, "div-by-const-i")
+
+696
+DECLARE_HYDROGEN_ACCESSOR
+(
+Div
+)
+
+698
+ g´iv©e
+:
+
+699
+\9at32_t
+
+divisÜ_
+;
+
+703
+þass
+
+LDivI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+704
+ gpublic
+:
+
+705
+LDivI
+(
+LO³¿nd
+*
+divid\92d
+, LO³¿nd*
+divisÜ
+) {
+
+706
+ g\9aputs_
+[0] =
+divid\92d
+;
+
+707
+ g\9aputs_
+[1] =
+divisÜ
+;
+
+710
+LO³¿nd
+*
+divid\92d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+711
+LO³¿nd
+*
+divisÜ
+(è{ \15
+ g\9aputs_
+[1]; }
+
+713
+DECLARE_CONCRETE_INSTRUCTION
+(
+DivI
+, "div-i")
+
+714
+DECLARE_HYDROGEN_ACCESSOR
+(
+B\9a¬yO³¿tiÚ
+)
+
+718
+þass
+
+LFloÜ\9agDivByPow\94Of2I
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+719
+ gpublic
+:
+
+720
+LFloÜ\9agDivByPow\94Of2I
+(
+LO³¿nd
+*
+divid\92d
+,
+\9at32_t
+
+divisÜ
+) {
+
+721
+ g\9aputs_
+[0] =
+divid\92d
+;
+
+722
+ gdivisÜ_
+ =
+divisÜ
+;
+
+725
+LO³¿nd
+*
+divid\92d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+726
+\9at32_t
+
+divisÜ
+(è{ \15
+ gdivisÜ_
+; }
+
+728
+DECLARE_CONCRETE_INSTRUCTION
+(
+FloÜ\9agDivByPow\94Of2I
+,
+
+730
+DECLARE_HYDROGEN_ACCESSOR
+(
+M©hFloÜOfDiv
+)
+
+732
+ g´iv©e
+:
+
+733
+\9at32_t
+
+divisÜ_
+;
+
+737
+þass
+
+LFloܚgDivByCڡI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 1> {
+
+738
+ gpublic
+:
+
+739
+LFloܚgDivByCڡI
+(
+LO³¿nd
+*
+divid\92d
+,
+\9at32_t
+
+divisÜ
+, LO³¿nd*
+\8bmp
+) {
+
+740
+ g\9aputs_
+[0] =
+divid\92d
+;
+
+741
+ gdivisÜ_
+ =
+divisÜ
+;
+
+742
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+745
+LO³¿nd
+*
+divid\92d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+746
+\9at32_t
+
+divisÜ
+(ècÚ¡ { \15
+ gdivisÜ_
+; }
+
+747
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+749
+DECLARE_CONCRETE_INSTRUCTION
+(
+FloܚgDivByCڡI
+, "flooring-div-by-const-i")
+
+750
+DECLARE_HYDROGEN_ACCESSOR
+(
+M©hFloÜOfDiv
+)
+
+752
+ g´iv©e
+:
+
+753
+\9at32_t
+
+divisÜ_
+;
+
+757
+þass
+
+LFloܚgDivI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+758
+ gpublic
+:
+
+759
+LFloܚgDivI
+(
+LO³¿nd
+*
+divid\92d
+, LO³¿nd*
+divisÜ
+) {
+
+760
+ g\9aputs_
+[0] =
+divid\92d
+;
+
+761
+ g\9aputs_
+[1] =
+divisÜ
+;
+
+764
+LO³¿nd
+*
+divid\92d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+765
+LO³¿nd
+*
+divisÜ
+(è{ \15
+ g\9aputs_
+[1]; }
+
+767
+DECLARE_CONCRETE_INSTRUCTION
+(
+FloܚgDivI
+, "flooring-div-i")
+
+768
+DECLARE_HYDROGEN_ACCESSOR
+(
+M©hFloÜOfDiv
+)
+
+772
+þass
+
+LMulI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+773
+ gpublic
+:
+
+774
+LMulI
+(
+LO³¿nd
+*
+Ëá
+, LO³¿nd*
+right
+) {
+
+775
+ g\9aputs_
+[0] =
+Ëá
+;
+
+776
+ g\9aputs_
+[1] =
+right
+;
+
+779
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[0]; }
+
+780
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[1]; }
+
+782
+DECLARE_CONCRETE_INSTRUCTION
+(
+MulI
+, "mul-i")
+
+783
+DECLARE_HYDROGEN_ACCESSOR
+(
+Mul
+)
+
+788
+þass
+
+LMuɝlyAddD
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 3, 0> {
+
+789
+ gpublic
+:
+
+790
+LMuɝlyAddD
+(
+LO³¿nd
+*
+add\92d
+, LO³¿nd*
+muÉ\9dl\9br
+,
+
+791
+LO³¿nd
+*
+muÉ\9dliÿnd
+) {
+
+792
+ g\9aputs_
+[0] =
+add\92d
+;
+
+793
+ g\9aputs_
+[1] =
+muÉ\9dl\9br
+;
+
+794
+ g\9aputs_
+[2] =
+muÉ\9dliÿnd
+;
+
+797
+LO³¿nd
+*
+add\92d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+798
+LO³¿nd
+*
+muÉ\9dl\9br
+(è{ \15
+ g\9aputs_
+[1]; }
+
+799
+LO³¿nd
+*
+muÉ\9dliÿnd
+(è{ \15
+ g\9aputs_
+[2]; }
+
+801
+DECLARE_CONCRETE_INSTRUCTION
+(
+MuɝlyAddD
+, "multiply-add-d")
+
+806
+þass
+
+LMuɝlySubD
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 3, 0> {
+
+807
+ gpublic
+:
+
+808
+LMuɝlySubD
+(
+LO³¿nd
+*
+m\9au\92d
+, LO³¿nd*
+muÉ\9dl\9br
+,
+
+809
+LO³¿nd
+*
+muÉ\9dliÿnd
+) {
+
+810
+ g\9aputs_
+[0] =
+m\9au\92d
+;
+
+811
+ g\9aputs_
+[1] =
+muÉ\9dl\9br
+;
+
+812
+ g\9aputs_
+[2] =
+muÉ\9dliÿnd
+;
+
+815
+LO³¿nd
+*
+m\9au\92d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+816
+LO³¿nd
+*
+muÉ\9dl\9br
+(è{ \15
+ g\9aputs_
+[1]; }
+
+817
+LO³¿nd
+*
+muÉ\9dliÿnd
+(è{ \15
+ g\9aputs_
+[2]; }
+
+819
+DECLARE_CONCRETE_INSTRUCTION
+(
+MuɝlySubD
+, "multiply-sub-d")
+
+823
+þass
+
+LDebugB»ak
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 0, 0> {
+
+824
+ gpublic
+:
+
+825
+DECLARE_CONCRETE_INSTRUCTION
+(
+DebugB»ak
+, "break")
+
+829
+þass
+
+LCom·»Num\94icAndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<2, 0> {
+
+830
+ gpublic
+:
+
+831
+LCom·»Num\94icAndB¿nch
+(
+LO³¿nd
+*
+Ëá
+, LO³¿nd*
+right
+) {
+
+832
+ g\9aputs_
+[0] =
+Ëá
+;
+
+833
+ g\9aputs_
+[1] =
+right
+;
+
+836
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[0]; }
+
+837
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[1]; }
+
+839
+DECLARE_CONCRETE_INSTRUCTION
+(
+Com·»Num\94icAndB¿nch
+,
+
+841
+DECLARE_HYDROGEN_ACCESSOR
+(
+Com·»Num\94icAndB¿nch
+)
+
+843
+ gTok\92
+::
+V®ue
+
+Ý
+(ècÚ¡ { \15
+hydrog\92
+()->
+tok\92
+(); }
+
+844
+boÞ
+
+is_doubË
+(ècÚ¡ { \15
+hydrog\92
+()->
+»´e£Á©iÚ
+().
+IsDoubË
+(); }
+
+846
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+850
+þass
+
+LM©hFloÜ
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+851
+ gpublic
+:
+
+852
+ex¶ic\99
+
+LM©hFloÜ
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+854
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+856
+DECLARE_CONCRETE_INSTRUCTION
+(
+M©hFloÜ
+, "math-floor")
+
+857
+DECLARE_HYDROGEN_ACCESSOR
+(
+UÇryM©hO³¿tiÚ
+)
+
+861
+þass
+
+LM©hRound
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 1> {
+
+862
+ gpublic
+:
+
+863
+LM©hRound
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+\8bmp
+) {
+
+864
+ g\9aputs_
+[0] =
+v®ue
+;
+
+865
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+868
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+869
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+871
+DECLARE_CONCRETE_INSTRUCTION
+(
+M©hRound
+, "math-round")
+
+872
+DECLARE_HYDROGEN_ACCESSOR
+(
+UÇryM©hO³¿tiÚ
+)
+
+876
+þass
+
+LM©hFround
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+877
+ gpublic
+:
+
+878
+ex¶ic\99
+
+LM©hFround
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+880
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+882
+DECLARE_CONCRETE_INSTRUCTION
+(
+M©hFround
+, "math-fround")
+
+886
+þass
+
+LM©hAbs
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+887
+ gpublic
+:
+
+888
+LM©hAbs
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+v®ue
+) {
+
+889
+ g\9aputs_
+[1] =
+cڋxt
+;
+
+890
+ g\9aputs_
+[0] =
+v®ue
+;
+
+893
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[1]; }
+
+894
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+896
+DECLARE_CONCRETE_INSTRUCTION
+(
+M©hAbs
+, "math-abs")
+
+897
+DECLARE_HYDROGEN_ACCESSOR
+(
+UÇryM©hO³¿tiÚ
+)
+
+901
+þass
+
+LM©hLog
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+902
+ gpublic
+:
+
+903
+ex¶ic\99
+
+LM©hLog
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+905
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+907
+DECLARE_CONCRETE_INSTRUCTION
+(
+M©hLog
+, "math-log")
+
+911
+þass
+
+LM©hClz32
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+912
+ gpublic
+:
+
+913
+ex¶ic\99
+
+LM©hClz32
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+915
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+917
+DECLARE_CONCRETE_INSTRUCTION
+(
+M©hClz32
+, "math-clz32")
+
+921
+þass
+
+LM©hExp
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 3> {
+
+922
+ gpublic
+:
+
+923
+LM©hExp
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+doubË_\8bmp
+, LO³¿nd*
+\8bmp1
+,
+
+924
+LO³¿nd
+*
+\8bmp2
+) {
+
+925
+ g\9aputs_
+[0] =
+v®ue
+;
+
+926
+ g\8bmps_
+[0] =
+\8bmp1
+;
+
+927
+ g\8bmps_
+[1] =
+\8bmp2
+;
+
+928
+ g\8bmps_
+[2] =
+doubË_\8bmp
+;
+
+929
+ gEx\8bº®Reã»nû
+::
+In\99\9flizeM©hExpD©a
+();
+
+932
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+933
+LO³¿nd
+*
+\8bmp1
+(è{ \15
+ g\8bmps_
+[0]; }
+
+934
+LO³¿nd
+*
+\8bmp2
+(è{ \15
+ g\8bmps_
+[1]; }
+
+935
+LO³¿nd
+*
+doubË_\8bmp
+(è{ \15
+ g\8bmps_
+[2]; }
+
+937
+DECLARE_CONCRETE_INSTRUCTION
+(
+M©hExp
+, "math-exp")
+
+941
+þass
+
+LM©hSq¹
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+942
+ gpublic
+:
+
+943
+ex¶ic\99
+
+LM©hSq¹
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+945
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+947
+DECLARE_CONCRETE_INSTRUCTION
+(
+M©hSq¹
+, "math-sqrt")
+
+951
+þass
+
+LM©hPowH®f
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+952
+ gpublic
+:
+
+953
+ex¶ic\99
+
+LM©hPowH®f
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+955
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+957
+DECLARE_CONCRETE_INSTRUCTION
+(
+M©hPowH®f
+, "math-pow-half")
+
+961
+þass
+
+LCmpObjeùEqAndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<2, 0> {
+
+962
+ gpublic
+:
+
+963
+LCmpObjeùEqAndB¿nch
+(
+LO³¿nd
+*
+Ëá
+, LO³¿nd*
+right
+) {
+
+964
+ g\9aputs_
+[0] =
+Ëá
+;
+
+965
+ g\9aputs_
+[1] =
+right
+;
+
+968
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[0]; }
+
+969
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[1]; }
+
+971
+DECLARE_CONCRETE_INSTRUCTION
+(
+CmpObjeùEqAndB¿nch
+, "cmp-object-eq-and-branch")
+
+972
+DECLARE_HYDROGEN_ACCESSOR
+(
+Com·»ObjeùEqAndB¿nch
+)
+
+976
+þass
+
+LCmpHÞeAndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<1, 0> {
+
+977
+ gpublic
+:
+
+978
+ex¶ic\99
+
+LCmpHÞeAndB¿nch
+(
+LO³¿nd
+*
+objeù
+è{
+\9aputs_
+[0] = object; }
+
+980
+LO³¿nd
+*
+objeù
+(è{ \15
+ g\9aputs_
+[0]; }
+
+982
+DECLARE_CONCRETE_INSTRUCTION
+(
+CmpHÞeAndB¿nch
+, "cmp-hole-and-branch")
+
+983
+DECLARE_HYDROGEN_ACCESSOR
+(
+Com·»HÞeAndB¿nch
+)
+
+987
+þass
+
+LCom·»M\9ausZ\94oAndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<1, 1> {
+
+988
+ gpublic
+:
+
+989
+LCom·»M\9ausZ\94oAndB¿nch
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+\8bmp
+) {
+
+990
+ g\9aputs_
+[0] =
+v®ue
+;
+
+991
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+994
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+995
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+997
+DECLARE_CONCRETE_INSTRUCTION
+(
+Com·»M\9ausZ\94oAndB¿nch
+,
+
+999
+DECLARE_HYDROGEN_ACCESSOR
+(
+Com·»M\9ausZ\94oAndB¿nch
+)
+
+1003
+þass
+
+LIsObjeùAndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<1, 1> {
+
+1004
+ gpublic
+:
+
+1005
+LIsObjeùAndB¿nch
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+\8bmp
+) {
+
+1006
+ g\9aputs_
+[0] =
+v®ue
+;
+
+1007
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+1010
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1011
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1013
+DECLARE_CONCRETE_INSTRUCTION
+(
+IsObjeùAndB¿nch
+, "is-object-and-branch")
+
+1014
+DECLARE_HYDROGEN_ACCESSOR
+(
+IsObjeùAndB¿nch
+)
+
+1016
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1020
+þass
+
+LIsS\8c\9agAndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<1, 1> {
+
+1021
+ gpublic
+:
+
+1022
+LIsS\8c\9agAndB¿nch
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+\8bmp
+) {
+
+1023
+ g\9aputs_
+[0] =
+v®ue
+;
+
+1024
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+1027
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1028
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1030
+DECLARE_CONCRETE_INSTRUCTION
+(
+IsS\8c\9agAndB¿nch
+, "is-string-and-branch")
+
+1031
+DECLARE_HYDROGEN_ACCESSOR
+(
+IsS\8c\9agAndB¿nch
+)
+
+1033
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1037
+þass
+
+LIsSmiAndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<1, 0> {
+
+1038
+ gpublic
+:
+
+1039
+ex¶ic\99
+
+LIsSmiAndB¿nch
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+1041
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1043
+DECLARE_CONCRETE_INSTRUCTION
+(
+IsSmiAndB¿nch
+, "is-smi-and-branch")
+
+1044
+DECLARE_HYDROGEN_ACCESSOR
+(
+IsSmiAndB¿nch
+)
+
+1046
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1050
+þass
+
+LIsUnd\91eùabËAndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<1, 1> {
+
+1051
+ gpublic
+:
+
+1052
+ex¶ic\99
+
+LIsUnd\91eùabËAndB¿nch
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+\8bmp
+) {
+
+1053
+ g\9aputs_
+[0] =
+v®ue
+;
+
+1054
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+1057
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1058
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1060
+DECLARE_CONCRETE_INSTRUCTION
+(
+IsUnd\91eùabËAndB¿nch
+,
+
+1062
+DECLARE_HYDROGEN_ACCESSOR
+(
+IsUnd\91eùabËAndB¿nch
+)
+
+1064
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1068
+þass
+
+LS\8c\9agCom·»AndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<3, 0> {
+
+1069
+ gpublic
+:
+
+1070
+LS\8c\9agCom·»AndB¿nch
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+Ëá
+, LO³¿nd*
+right
+) {
+
+1071
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1072
+ g\9aputs_
+[1] =
+Ëá
+;
+
+1073
+ g\9aputs_
+[2] =
+right
+;
+
+1076
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1077
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1078
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[2]; }
+
+1080
+DECLARE_CONCRETE_INSTRUCTION
+(
+S\8c\9agCom·»AndB¿nch
+,
+
+1082
+DECLARE_HYDROGEN_ACCESSOR
+(
+S\8c\9agCom·»AndB¿nch
+)
+
+1084
+ gTok\92
+::
+V®ue
+
+Ý
+(ècÚ¡ { \15
+hydrog\92
+()->
+tok\92
+(); }
+
+1086
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1090
+þass
+
+LHasIn¡ªûTy³AndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<1, 0> {
+
+1091
+ gpublic
+:
+
+1092
+ex¶ic\99
+
+LHasIn¡ªûTy³AndB¿nch
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+1094
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1096
+DECLARE_CONCRETE_INSTRUCTION
+(
+HasIn¡ªûTy³AndB¿nch
+,
+
+1098
+DECLARE_HYDROGEN_ACCESSOR
+(
+HasIn¡ªûTy³AndB¿nch
+)
+
+1100
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1104
+þass
+
+LG\91CachedA¼ayIndex
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+1105
+ gpublic
+:
+
+1106
+ex¶ic\99
+
+LG\91CachedA¼ayIndex
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+1108
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1110
+DECLARE_CONCRETE_INSTRUCTION
+(
+G\91CachedA¼ayIndex
+, "get-cached-array-index")
+
+1111
+DECLARE_HYDROGEN_ACCESSOR
+(
+G\91CachedA¼ayIndex
+)
+
+1115
+þass
+
+LHasCachedA¼ayIndexAndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<1, 0> {
+
+1116
+ gpublic
+:
+
+1117
+ex¶ic\99
+
+LHasCachedA¼ayIndexAndB¿nch
+(
+LO³¿nd
+*
+v®ue
+) {
+
+1118
+\9aputs_
+[0] =
+v®ue
+;
+
+1121
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1123
+DECLARE_CONCRETE_INSTRUCTION
+(
+HasCachedA¼ayIndexAndB¿nch
+,
+
+1125
+DECLARE_HYDROGEN_ACCESSOR
+(
+HasCachedA¼ayIndexAndB¿nch
+)
+
+1127
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1131
+þass
+
+LCÏssOfTe¡AndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<1, 1> {
+
+1132
+ gpublic
+:
+
+1133
+LCÏssOfTe¡AndB¿nch
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+\8bmp
+) {
+
+1134
+ g\9aputs_
+[0] =
+v®ue
+;
+
+1135
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+1138
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1139
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1141
+DECLARE_CONCRETE_INSTRUCTION
+(
+CÏssOfTe¡AndB¿nch
+, "class-of-test-and-branch")
+
+1142
+DECLARE_HYDROGEN_ACCESSOR
+(
+CÏssOfTe¡AndB¿nch
+)
+
+1144
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1148
+þass
+
+LCmpT
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 3, 0> {
+
+1149
+ gpublic
+:
+
+1150
+LCmpT
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+Ëá
+, LO³¿nd*
+right
+) {
+
+1151
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1152
+ g\9aputs_
+[1] =
+Ëá
+;
+
+1153
+ g\9aputs_
+[2] =
+right
+;
+
+1156
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1157
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1158
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[2]; }
+
+1160
+DECLARE_CONCRETE_INSTRUCTION
+(
+CmpT
+, "cmp-t")
+
+1161
+DECLARE_HYDROGEN_ACCESSOR
+(
+Com·»G\92\94ic
+)
+
+1163
+ gTok\92
+::
+V®ue
+
+Ý
+(ècÚ¡ { \15
+hydrog\92
+()->
+tok\92
+(); }
+
+1167
+þass
+
+LIn¡ªûOf
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 3, 0> {
+
+1168
+ gpublic
+:
+
+1169
+LIn¡ªûOf
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+Ëá
+, LO³¿nd*
+right
+) {
+
+1170
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1171
+ g\9aputs_
+[1] =
+Ëá
+;
+
+1172
+ g\9aputs_
+[2] =
+right
+;
+
+1175
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1176
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1177
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[2]; }
+
+1179
+DECLARE_CONCRETE_INSTRUCTION
+(
+In¡ªûOf
+, "instance-of")
+
+1183
+þass
+
+LIn¡ªûOfKnownGlob®
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 1> {
+
+1184
+ gpublic
+:
+
+1185
+LIn¡ªûOfKnownGlob®
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+v®ue
+, LO³¿nd*
+\8bmp
+) {
+
+1186
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1187
+ g\9aputs_
+[1] =
+v®ue
+;
+
+1188
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+1191
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1192
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1193
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1195
+DECLARE_CONCRETE_INSTRUCTION
+(
+In¡ªûOfKnownGlob®
+,
+
+1197
+DECLARE_HYDROGEN_ACCESSOR
+(
+In¡ªûOfKnownGlob®
+)
+
+1199
+ gHªdË
+<
+ gJSFunùiÚ
+>
+funùiÚ
+(ècÚ¡ { \15
+hydrog\92
+()->function(); }
+
+1200
+LEnv\9cÚm\92t
+*
+G\91Deã¼edLazyDeÝtimiz©iÚEnv\9cÚm\92t
+() {
+
+1201 \15
+ gÏzy_deÝt_\92v_
+;
+
+1203
+v\9ctu®
+ \1e
+S\91Deã¼edLazyDeÝtimiz©iÚEnv\9cÚm\92t
+(
+
+1204
+LEnv\9cÚm\92t
+*
+\92v
+è
+ gOVERRIDE
+ {
+
+1205
+ gÏzy_deÝt_\92v_
+ =
+\92v
+;
+
+1208
+ g´iv©e
+:
+
+1209
+LEnv\9cÚm\92t
+*
+Ïzy_deÝt_\92v_
+;
+
+1213
+þass
+
+LBoundsCheck
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 2, 0> {
+
+1214
+ gpublic
+:
+
+1215
+LBoundsCheck
+(
+LO³¿nd
+*
+\9adex
+, LO³¿nd*
+Ëngth
+) {
+
+1216
+ g\9aputs_
+[0] =
+\9adex
+;
+
+1217
+ g\9aputs_
+[1] =
+Ëngth
+;
+
+1220
+LO³¿nd
+*
+\9adex
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1221
+LO³¿nd
+*
+Ëngth
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1223
+DECLARE_CONCRETE_INSTRUCTION
+(
+BoundsCheck
+, "bounds-check")
+
+1224
+DECLARE_HYDROGEN_ACCESSOR
+(
+BoundsCheck
+)
+
+1228
+þass
+
+LB\99I
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1229
+ gpublic
+:
+
+1230
+LB\99I
+(
+LO³¿nd
+*
+Ëá
+, LO³¿nd*
+right
+) {
+
+1231
+ g\9aputs_
+[0] =
+Ëá
+;
+
+1232
+ g\9aputs_
+[1] =
+right
+;
+
+1235
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1236
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1238
+ gTok\92
+::
+V®ue
+
+Ý
+(ècÚ¡ { \15
+hydrog\92
+()->op(); }
+
+1240
+DECLARE_CONCRETE_INSTRUCTION
+(
+B\99I
+, "bit-i")
+
+1241
+DECLARE_HYDROGEN_ACCESSOR
+(
+B\99wi£
+)
+
+1245
+þass
+
+LShiáI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1246
+ gpublic
+:
+
+1247
+LShiáI
+(
+Tok\92
+::
+V®ue
+
+Ý
+,
+LO³¿nd
+*
+Ëá
+, LO³¿nd*
+right
+,
+boÞ
+
+ÿn_deÝt
+)
+
+1248 :
+Ý_
+(
+Ý
+),
+ÿn_deÝt_
+(
+ÿn_deÝt
+) {
+
+1249
+ g\9aputs_
+[0] =
+Ëá
+;
+
+1250
+ g\9aputs_
+[1] =
+right
+;
+
+1253
+ gTok\92
+::
+V®ue
+
+Ý
+(ècÚ¡ { \15
+Ý_
+; }
+
+1254
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1255
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1256
+boÞ
+
+ÿn_deÝt
+(ècÚ¡ { \15
+ gÿn_deÝt_
+; }
+
+1258
+DECLARE_CONCRETE_INSTRUCTION
+(
+ShiáI
+, "shift-i")
+
+1260
+ g´iv©e
+:
+
+1261
+Tok\92
+::
+V®ue
+
+Ý_
+;
+
+1262
+boÞ
+
+ gÿn_deÝt_
+;
+
+1266
+þass
+
+LSubI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1267
+ gpublic
+:
+
+1268
+LSubI
+(
+LO³¿nd
+*
+Ëá
+, LO³¿nd*
+right
+) {
+
+1269
+ g\9aputs_
+[0] =
+Ëá
+;
+
+1270
+ g\9aputs_
+[1] =
+right
+;
+
+1273
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1274
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1276
+DECLARE_CONCRETE_INSTRUCTION
+(
+SubI
+, "sub-i")
+
+1277
+DECLARE_HYDROGEN_ACCESSOR
+(
+Sub
+)
+
+1281
+þass
+
+LRSubI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1282
+ gpublic
+:
+
+1283
+LRSubI
+(
+LO³¿nd
+*
+Ëá
+, LO³¿nd*
+right
+) {
+
+1284
+ g\9aputs_
+[0] =
+Ëá
+;
+
+1285
+ g\9aputs_
+[1] =
+right
+;
+
+1288
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1289
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1291
+DECLARE_CONCRETE_INSTRUCTION
+(
+RSubI
+, "rsub-i")
+
+1292
+DECLARE_HYDROGEN_ACCESSOR
+(
+Sub
+)
+
+1296
+þass
+
+LCÚ¡ªtI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+1297
+ gpublic
+:
+
+1298
+DECLARE_CONCRETE_INSTRUCTION
+(
+CÚ¡ªtI
+, "constant-i")
+
+1299
+DECLARE_HYDROGEN_ACCESSOR
+(
+CÚ¡ªt
+)
+
+1301
+\9at32_t
+
+v®ue
+(ècÚ¡ { \15
+hydrog\92
+()->
+IÁeg\9432V®ue
+(); }
+
+1305
+þass
+
+LCÚ¡ªtS
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+1306
+ gpublic
+:
+
+1307
+DECLARE_CONCRETE_INSTRUCTION
+(
+CÚ¡ªtS
+, "constant-s")
+
+1308
+DECLARE_HYDROGEN_ACCESSOR
+(
+CÚ¡ªt
+)
+
+1310
+Smi
+*
+v®ue
+(ècÚ¡ { \15
+ gSmi
+::
+FromIÁ
+(
+hydrog\92
+()->
+IÁeg\9432V®ue
+()); }
+
+1314
+þass
+
+LCÚ¡ªtD
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+1315
+ gpublic
+:
+
+1316
+DECLARE_CONCRETE_INSTRUCTION
+(
+CÚ¡ªtD
+, "constant-d")
+
+1317
+DECLARE_HYDROGEN_ACCESSOR
+(
+CÚ¡ªt
+)
+
+1319 \b
+v®ue
+(ècÚ¡ { \15
+hydrog\92
+()->
+DoubËV®ue
+(); }
+
+1323
+þass
+
+LCÚ¡ªtE
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+1324
+ gpublic
+:
+
+1325
+DECLARE_CONCRETE_INSTRUCTION
+(
+CÚ¡ªtE
+, "constant-e")
+
+1326
+DECLARE_HYDROGEN_ACCESSOR
+(
+CÚ¡ªt
+)
+
+1328
+Ex\8bº®Reã»nû
+
+v®ue
+() const {
+
+1329 \15
+hydrog\92
+()->
+Ex\8bº®Reã»nûV®ue
+();
+
+1334
+þass
+
+LCÚ¡ªtT
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+1335
+ gpublic
+:
+
+1336
+DECLARE_CONCRETE_INSTRUCTION
+(
+CÚ¡ªtT
+, "constant-t")
+
+1337
+DECLARE_HYDROGEN_ACCESSOR
+(
+CÚ¡ªt
+)
+
+1339
+ gHªdË
+<
+ gObjeù
+>
+v®ue
+(
+Isީe
+*
+isީe
+) const {
+
+1340 \15
+hydrog\92
+()->
+hªdË
+(
+isީe
+);
+
+1345
+þass
+
+LB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<1, 0> {
+
+1346
+ gpublic
+:
+
+1347
+ex¶ic\99
+
+LB¿nch
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+1349
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1351
+DECLARE_CONCRETE_INSTRUCTION
+(
+B¿nch
+, "branch")
+
+1352
+DECLARE_HYDROGEN_ACCESSOR
+(
+B¿nch
+)
+
+1354
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1358
+þass
+
+LCmpMAndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<1, 1> {
+
+1359
+ gpublic
+:
+
+1360
+LCmpMAndB¿nch
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+\8bmp
+) {
+
+1361
+ g\9aputs_
+[0] =
+v®ue
+;
+
+1362
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+1365
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1366
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1368
+DECLARE_CONCRETE_INSTRUCTION
+(
+CmpMAndB¿nch
+, "cmp-map-and-branch")
+
+1369
+DECLARE_HYDROGEN_ACCESSOR
+(
+Com·»M
+)
+
+1371
+ gHªdË
+<
+ gM
+>
+m
+(ècÚ¡ { \15
+hydrog\92
+()->m().
+hªdË
+(); }
+
+1375
+þass
+
+LMEnumL\92gth
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+1376
+ gpublic
+:
+
+1377
+ex¶ic\99
+
+LMEnumL\92gth
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+1379
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1381
+DECLARE_CONCRETE_INSTRUCTION
+(
+MEnumL\92gth
+, "map-enum-length")
+
+1385
+þass
+
+LD©eF\9bld
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 1> {
+
+1386
+ gpublic
+:
+
+1387
+LD©eF\9bld
+(
+LO³¿nd
+*
+d©e
+, LO³¿nd*
+\8bmp
+,
+Smi
+*
+\9adex
+è:
+\9adex_
+(index) {
+
+1388
+\9aputs_
+[0] =
+d©e
+;
+
+1389
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+1392
+LO³¿nd
+*
+d©e
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1393
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1394
+Smi
+*
+\9adex
+(ècÚ¡ { \15
+ g\9adex_
+; }
+
+1396
+DECLARE_CONCRETE_INSTRUCTION
+(
+D©eF\9bld
+, "date-field")
+
+1397
+DECLARE_HYDROGEN_ACCESSOR
+(
+D©eF\9bld
+)
+
+1399
+ g´iv©e
+:
+
+1400
+Smi
+*
+\9adex_
+;
+
+1404
+þass
+
+LSeqS\8c\9agG\91Ch¬
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1405
+ gpublic
+:
+
+1406
+LSeqS\8c\9agG\91Ch¬
+(
+LO³¿nd
+*
+¡r\9ag
+, LO³¿nd*
+\9adex
+) {
+
+1407
+ g\9aputs_
+[0] =
+¡r\9ag
+;
+
+1408
+ g\9aputs_
+[1] =
+\9adex
+;
+
+1411
+LO³¿nd
+*
+¡r\9ag
+(ècÚ¡ { \15
+ g\9aputs_
+[0]; }
+
+1412
+LO³¿nd
+*
+\9adex
+(ècÚ¡ { \15
+ g\9aputs_
+[1]; }
+
+1414
+DECLARE_CONCRETE_INSTRUCTION
+(
+SeqS\8c\9agG\91Ch¬
+, "seq-string-get-char")
+
+1415
+DECLARE_HYDROGEN_ACCESSOR
+(
+SeqS\8c\9agG\91Ch¬
+)
+
+1419
+þass
+
+LSeqS\8c\9agS\91Ch¬
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 4, 0> {
+
+1420
+ gpublic
+:
+
+1421
+LSeqS\8c\9agS\91Ch¬
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+¡r\9ag
+, LO³¿nd*
+\9adex
+,
+
+1422
+LO³¿nd
+*
+v®ue
+) {
+
+1423
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1424
+ g\9aputs_
+[1] =
+¡r\9ag
+;
+
+1425
+ g\9aputs_
+[2] =
+\9adex
+;
+
+1426
+ g\9aputs_
+[3] =
+v®ue
+;
+
+1429
+LO³¿nd
+*
+¡r\9ag
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1430
+LO³¿nd
+*
+\9adex
+(è{ \15
+ g\9aputs_
+[2]; }
+
+1431
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[3]; }
+
+1433
+DECLARE_CONCRETE_INSTRUCTION
+(
+SeqS\8c\9agS\91Ch¬
+, "seq-string-set-char")
+
+1434
+DECLARE_HYDROGEN_ACCESSOR
+(
+SeqS\8c\9agS\91Ch¬
+)
+
+1438
+þass
+
+LAddI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1439
+ gpublic
+:
+
+1440
+LAddI
+(
+LO³¿nd
+*
+Ëá
+, LO³¿nd*
+right
+) {
+
+1441
+ g\9aputs_
+[0] =
+Ëá
+;
+
+1442
+ g\9aputs_
+[1] =
+right
+;
+
+1445
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1446
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1448
+DECLARE_CONCRETE_INSTRUCTION
+(
+AddI
+, "add-i")
+
+1449
+DECLARE_HYDROGEN_ACCESSOR
+(
+Add
+)
+
+1453
+þass
+
+LM©hM\9aMax
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1454
+ gpublic
+:
+
+1455
+LM©hM\9aMax
+(
+LO³¿nd
+*
+Ëá
+, LO³¿nd*
+right
+) {
+
+1456
+ g\9aputs_
+[0] =
+Ëá
+;
+
+1457
+ g\9aputs_
+[1] =
+right
+;
+
+1460
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1461
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1463
+DECLARE_CONCRETE_INSTRUCTION
+(
+M©hM\9aMax
+, "math-min-max")
+
+1464
+DECLARE_HYDROGEN_ACCESSOR
+(
+M©hM\9aMax
+)
+
+1468
+þass
+
+LPow\94
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1469
+ gpublic
+:
+
+1470
+LPow\94
+(
+LO³¿nd
+*
+Ëá
+, LO³¿nd*
+right
+) {
+
+1471
+ g\9aputs_
+[0] =
+Ëá
+;
+
+1472
+ g\9aputs_
+[1] =
+right
+;
+
+1475
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1476
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1478
+DECLARE_CONCRETE_INSTRUCTION
+(
+Pow\94
+, "power")
+
+1479
+DECLARE_HYDROGEN_ACCESSOR
+(
+Pow\94
+)
+
+1483
+þass
+
+LAr\99hm\91icD
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1484
+ gpublic
+:
+
+1485
+LAr\99hm\91icD
+(
+Tok\92
+::
+V®ue
+
+Ý
+,
+LO³¿nd
+*
+Ëá
+, LO³¿nd*
+right
+è:
+Ý_
+(op) {
+
+1486
+\9aputs_
+[0] =
+Ëá
+;
+
+1487
+ g\9aputs_
+[1] =
+right
+;
+
+1490
+ gTok\92
+::
+V®ue
+
+Ý
+(ècÚ¡ { \15
+Ý_
+; }
+
+1491
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1492
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1494
+v\9ctu®
+
+Opcode
+
+Ýcode
+(ècÚ¡
+ gOVERRIDE
+ { \15
+ gLIn¡ruùiÚ
+::
+kAr\99hm\91icD
+; }
+
+1495
+v\9ctu®
+ \1e
+Comp\9eeToN©ive
+(
+LCodeG\92
+*
+g\92\94©Ü
+è
+ gOVERRIDE
+;
+
+1496
+v\9ctu®
+ cڡ \ 5*
+MÃmÚic
+(ècÚ¡
+ gOVERRIDE
+;
+
+1498
+ g´iv©e
+:
+
+1499
+Tok\92
+::
+V®ue
+
+Ý_
+;
+
+1503
+þass
+
+LAr\99hm\91icT
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 3, 0> {
+
+1504
+ gpublic
+:
+
+1505
+LAr\99hm\91icT
+(
+Tok\92
+::
+V®ue
+
+Ý
+,
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+Ëá
+,
+
+1506
+LO³¿nd
+*
+right
+)
+
+1507 :
+Ý_
+(
+Ý
+) {
+
+1508
+\9aputs_
+[0] =
+cڋxt
+;
+
+1509
+ g\9aputs_
+[1] =
+Ëá
+;
+
+1510
+ g\9aputs_
+[2] =
+right
+;
+
+1513
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1514
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1515
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[2]; }
+
+1516
+ gTok\92
+::
+V®ue
+
+Ý
+(ècÚ¡ { \15
+Ý_
+; }
+
+1518
+v\9ctu®
+
+Opcode
+
+Ýcode
+(ècÚ¡
+ gOVERRIDE
+ { \15
+ gLIn¡ruùiÚ
+::
+kAr\99hm\91icT
+; }
+
+1519
+v\9ctu®
+ \1e
+Comp\9eeToN©ive
+(
+LCodeG\92
+*
+g\92\94©Ü
+è
+ gOVERRIDE
+;
+
+1520
+v\9ctu®
+ cڡ \ 5*
+MÃmÚic
+(ècÚ¡
+ gOVERRIDE
+;
+
+1522
+ g´iv©e
+:
+
+1523
+Tok\92
+::
+V®ue
+
+Ý_
+;
+
+1527
+þass
+
+LR\91uº
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 3, 0> {
+
+1528
+ gpublic
+:
+
+1529
+LR\91uº
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+cڋxt
+, LO³¿nd*
+·¿m\91\94_couÁ
+) {
+
+1530
+ g\9aputs_
+[0] =
+v®ue
+;
+
+1531
+ g\9aputs_
+[1] =
+cڋxt
+;
+
+1532
+ g\9aputs_
+[2] =
+·¿m\91\94_couÁ
+;
+
+1535
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1537
+boÞ
+
+has_cÚ¡ªt_·¿m\91\94_couÁ
+() {
+
+1538 \15
+·¿m\91\94_couÁ
+()->
+IsCÚ¡ªtO³¿nd
+();
+
+1540
+LCÚ¡ªtO³¿nd
+*
+cÚ¡ªt_·¿m\91\94_couÁ
+() {
+
+1541
+DCHECK
+(
+has_cÚ¡ªt_·¿m\91\94_couÁ
+());
+
+1542 \15
+ gLCÚ¡ªtO³¿nd
+::
+ÿ¡
+(
+·¿m\91\94_couÁ
+());
+
+1544
+LO³¿nd
+*
+·¿m\91\94_couÁ
+(è{ \15
+ g\9aputs_
+[2]; }
+
+1546
+DECLARE_CONCRETE_INSTRUCTION
+(
+R\91uº
+, "return")
+
+1550
+þass
+
+LLßdNamedF\9bld
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+1551
+ gpublic
+:
+
+1552
+ex¶ic\99
+
+LLßdNamedF\9bld
+(
+LO³¿nd
+*
+objeù
+è{
+\9aputs_
+[0] = object; }
+
+1554
+LO³¿nd
+*
+objeù
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1556
+DECLARE_CONCRETE_INSTRUCTION
+(
+LßdNamedF\9bld
+, "load-named-field")
+
+1557
+DECLARE_HYDROGEN_ACCESSOR
+(
+LßdNamedF\9bld
+)
+
+1561
+þass
+
+LLßdNamedG\92\94ic
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 1> {
+
+1562
+ gpublic
+:
+
+1563
+LLßdNamedG\92\94ic
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+objeù
+, LO³¿nd*
+veùÜ
+) {
+
+1564
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1565
+ g\9aputs_
+[1] =
+objeù
+;
+
+1566
+ g\8bmps_
+[0] =
+veùÜ
+;
+
+1569
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1570
+LO³¿nd
+*
+objeù
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1571
+LO³¿nd
+*
+\8bmp_veùÜ
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1573
+DECLARE_CONCRETE_INSTRUCTION
+(
+LßdNamedG\92\94ic
+, "load-named-generic")
+
+1574
+DECLARE_HYDROGEN_ACCESSOR
+(
+LßdNamedG\92\94ic
+)
+
+1576
+ gHªdË
+<
+ gObjeù
+>
+Çme
+(ècÚ¡ { \15
+hydrog\92
+()->name(); }
+
+1580
+þass
+
+LLßdFunùiÚPrÙÙy³
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+1581
+ gpublic
+:
+
+1582
+ex¶ic\99
+
+LLßdFunùiÚPrÙÙy³
+(
+LO³¿nd
+*
+funùiÚ
+è{
+\9aputs_
+[0] = function; }
+
+1584
+LO³¿nd
+*
+funùiÚ
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1586
+DECLARE_CONCRETE_INSTRUCTION
+(
+LßdFunùiÚPrÙÙy³
+, "load-function-prototype")
+
+1587
+DECLARE_HYDROGEN_ACCESSOR
+(
+LßdFunùiÚPrÙÙy³
+)
+
+1591
+þass
+
+LLßdRoÙ
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+1592
+ gpublic
+:
+
+1593
+DECLARE_CONCRETE_INSTRUCTION
+(
+LßdRoÙ
+, "load-root")
+
+1594
+DECLARE_HYDROGEN_ACCESSOR
+(
+LßdRoÙ
+)
+
+1596
+ gH\97p
+::
+RoÙLi¡Index
+
+\9adex
+(ècÚ¡ { \15
+hydrog\92
+()->index(); }
+
+1600
+þass
+
+LLßdKeyed
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1601
+ gpublic
+:
+
+1602
+LLßdKeyed
+(
+LO³¿nd
+*
+\96em\92ts
+, LO³¿nd*
+key
+) {
+
+1603
+ g\9aputs_
+[0] =
+\96em\92ts
+;
+
+1604
+ g\9aputs_
+[1] =
+key
+;
+
+1607
+LO³¿nd
+*
+\96em\92ts
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1608
+LO³¿nd
+*
+key
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1609
+EËm\92tsK\9ad
+
+\96em\92ts_k\9ad
+(ècÚ¡ { \15
+hydrog\92
+()->elements_kind(); }
+
+1610
+boÞ
+
+is_ex\8bº®
+(ècÚ¡ { \15
+hydrog\92
+()->is_external(); }
+
+1611
+boÞ
+
+is_fixed_ty³d_¬¿y
+() const {
+
+1612 \15
+hydrog\92
+()->
+is_fixed_ty³d_¬¿y
+();
+
+1614
+boÞ
+
+is_ty³d_\96em\92ts
+() const {
+
+1615 \15
+is_ex\8bº®
+(è||
+is_fixed_ty³d_¬¿y
+();
+
+1618
+DECLARE_CONCRETE_INSTRUCTION
+(
+LßdKeyed
+, "load-keyed")
+
+1619
+DECLARE_HYDROGEN_ACCESSOR
+(
+LßdKeyed
+)
+
+1621
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1622
+u\9at32_t
+
+ba£_off£t
+(ècÚ¡ { \15
+hydrog\92
+()->base_offset(); }
+
+1626
+þass
+
+LLßdKeyedG\92\94ic
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 3, 1> {
+
+1627
+ gpublic
+:
+
+1628
+LLßdKeyedG\92\94ic
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+objeù
+, LO³¿nd*
+key
+,
+
+1629
+LO³¿nd
+*
+veùÜ
+) {
+
+1630
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1631
+ g\9aputs_
+[1] =
+objeù
+;
+
+1632
+ g\9aputs_
+[2] =
+key
+;
+
+1633
+ g\8bmps_
+[0] =
+veùÜ
+;
+
+1636
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1637
+LO³¿nd
+*
+objeù
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1638
+LO³¿nd
+*
+key
+(è{ \15
+ g\9aputs_
+[2]; }
+
+1639
+LO³¿nd
+*
+\8bmp_veùÜ
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1641
+DECLARE_CONCRETE_INSTRUCTION
+(
+LßdKeyedG\92\94ic
+, "load-keyed-generic")
+
+1642
+DECLARE_HYDROGEN_ACCESSOR
+(
+LßdKeyedG\92\94ic
+)
+
+1646
+þass
+
+LLßdGlob®C\96l
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+1647
+ gpublic
+:
+
+1648
+DECLARE_CONCRETE_INSTRUCTION
+(
+LßdGlob®C\96l
+, "load-global-cell")
+
+1649
+DECLARE_HYDROGEN_ACCESSOR
+(
+LßdGlob®C\96l
+)
+
+1653
+þass
+
+LLßdGlob®G\92\94ic
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 1> {
+
+1654
+ gpublic
+:
+
+1655
+LLßdGlob®G\92\94ic
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+glob®_objeù
+,
+
+1656
+LO³¿nd
+*
+veùÜ
+) {
+
+1657
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1658
+ g\9aputs_
+[1] =
+glob®_objeù
+;
+
+1659
+ g\8bmps_
+[0] =
+veùÜ
+;
+
+1662
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1663
+LO³¿nd
+*
+glob®_objeù
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1664
+LO³¿nd
+*
+\8bmp_veùÜ
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1666
+DECLARE_CONCRETE_INSTRUCTION
+(
+LßdGlob®G\92\94ic
+, "load-global-generic")
+
+1667
+DECLARE_HYDROGEN_ACCESSOR
+(
+LßdGlob®G\92\94ic
+)
+
+1669
+ gHªdË
+<
+ gObjeù
+>
+Çme
+(ècÚ¡ { \15
+hydrog\92
+()->name(); }
+
+1670
+boÞ
+
+fÜ_ty³of
+(ècÚ¡ { \15
+hydrog\92
+()->for_typeof(); }
+
+1674
+þass
+
+LStÜeGlob®C\96l
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 1, 1> {
+
+1675
+ gpublic
+:
+
+1676
+LStÜeGlob®C\96l
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+\8bmp
+) {
+
+1677
+ g\9aputs_
+[0] =
+v®ue
+;
+
+1678
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+1681
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1682
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1684
+DECLARE_CONCRETE_INSTRUCTION
+(
+StÜeGlob®C\96l
+, "store-global-cell")
+
+1685
+DECLARE_HYDROGEN_ACCESSOR
+(
+StÜeGlob®C\96l
+)
+
+1689
+þass
+
+LLßdCÚ\8bxtSlÙ
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+1690
+ gpublic
+:
+
+1691
+ex¶ic\99
+
+LLßdCÚ\8bxtSlÙ
+(
+LO³¿nd
+*
+cڋxt
+è{
+\9aputs_
+[0] = context; }
+
+1693
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1695
+DECLARE_CONCRETE_INSTRUCTION
+(
+LßdCÚ\8bxtSlÙ
+, "load-context-slot")
+
+1696
+DECLARE_HYDROGEN_ACCESSOR
+(
+LßdCÚ\8bxtSlÙ
+)
+
+1698 \12
+¦Ù_\9adex
+(è{ \15
+hydrog\92
+()->slot_index(); }
+
+1700
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1704
+þass
+
+LStÜeCÚ\8bxtSlÙ
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 2, 0> {
+
+1705
+ gpublic
+:
+
+1706
+LStÜeCÚ\8bxtSlÙ
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+v®ue
+) {
+
+1707
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1708
+ g\9aputs_
+[1] =
+v®ue
+;
+
+1711
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1712
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1714
+DECLARE_CONCRETE_INSTRUCTION
+(
+StÜeCÚ\8bxtSlÙ
+, "store-context-slot")
+
+1715
+DECLARE_HYDROGEN_ACCESSOR
+(
+StÜeCÚ\8bxtSlÙ
+)
+
+1717 \12
+¦Ù_\9adex
+(è{ \15
+hydrog\92
+()->slot_index(); }
+
+1719
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1723
+þass
+
+LPushArgum\92t
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 1, 0> {
+
+1724
+ gpublic
+:
+
+1725
+ex¶ic\99
+
+LPushArgum\92t
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+1727
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1729
+DECLARE_CONCRETE_INSTRUCTION
+(
+PushArgum\92t
+, "push-argument")
+
+1733
+þass
+
+LDrÝ
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 0, 0> {
+
+1734
+ gpublic
+:
+
+1735
+ex¶ic\99
+
+LDrÝ
+(\12
+couÁ
+è:
+couÁ_
+(count) {}
+
+1737 \12
+couÁ
+(ècÚ¡ { \15
+couÁ_
+; }
+
+1739
+DECLARE_CONCRETE_INSTRUCTION
+(
+DrÝ
+, "drop")
+
+1741
+ g´iv©e
+:
+
+1742 \12
+couÁ_
+;
+
+1746
+þass
+
+LStÜeCodeEÁry
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 2, 0> {
+
+1747
+ gpublic
+:
+
+1748
+LStÜeCodeEÁry
+(
+LO³¿nd
+*
+funùiÚ
+, LO³¿nd*
+code_objeù
+) {
+
+1749
+ g\9aputs_
+[0] =
+funùiÚ
+;
+
+1750
+ g\9aputs_
+[1] =
+code_objeù
+;
+
+1753
+LO³¿nd
+*
+funùiÚ
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1754
+LO³¿nd
+*
+code_objeù
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1756
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+);
+
+1758
+DECLARE_CONCRETE_INSTRUCTION
+(
+StÜeCodeEÁry
+, "store-code-entry")
+
+1759
+DECLARE_HYDROGEN_ACCESSOR
+(
+StÜeCodeEÁry
+)
+
+1763
+þass
+
+LIÂ\94AÎoÿ\8bdObjeù
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1764
+ gpublic
+:
+
+1765
+LIÂ\94AÎoÿ\8bdObjeù
+(
+LO³¿nd
+*
+ba£_objeù
+, LO³¿nd*
+off£t
+) {
+
+1766
+ g\9aputs_
+[0] =
+ba£_objeù
+;
+
+1767
+ g\9aputs_
+[1] =
+off£t
+;
+
+1770
+LO³¿nd
+*
+ba£_objeù
+(ècÚ¡ { \15
+ g\9aputs_
+[0]; }
+
+1771
+LO³¿nd
+*
+off£t
+(ècÚ¡ { \15
+ g\9aputs_
+[1]; }
+
+1773
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1775
+DECLARE_CONCRETE_INSTRUCTION
+(
+IÂ\94AÎoÿ\8bdObjeù
+, "inner-allocated-object")
+
+1779
+þass
+
+LThisFunùiÚ
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+1780
+ gpublic
+:
+
+1781
+DECLARE_CONCRETE_INSTRUCTION
+(
+ThisFunùiÚ
+, "this-function")
+
+1782
+DECLARE_HYDROGEN_ACCESSOR
+(
+ThisFunùiÚ
+)
+
+1786
+þass
+
+LCڋxt
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 0, 0> {
+
+1787
+ gpublic
+:
+
+1788
+DECLARE_CONCRETE_INSTRUCTION
+(
+Cڋxt
+, "context")
+
+1789
+DECLARE_HYDROGEN_ACCESSOR
+(
+Cڋxt
+)
+
+1793
+þass
+
+LDeþ¬eGlob®s
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 1, 0> {
+
+1794
+ gpublic
+:
+
+1795
+ex¶ic\99
+
+LDeþ¬eGlob®s
+(
+LO³¿nd
+*
+cڋxt
+è{
+\9aputs_
+[0] = context; }
+
+1797
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1799
+DECLARE_CONCRETE_INSTRUCTION
+(
+Deþ¬eGlob®s
+, "declare-globals")
+
+1800
+DECLARE_HYDROGEN_ACCESSOR
+(
+Deþ¬eGlob®s
+)
+
+1804
+þass
+
+LC®lJSFunùiÚ
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+1805
+ gpublic
+:
+
+1806
+ex¶ic\99
+
+LC®lJSFunùiÚ
+(
+LO³¿nd
+*
+funùiÚ
+è{
+\9aputs_
+[0] = function; }
+
+1808
+LO³¿nd
+*
+funùiÚ
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1810
+DECLARE_CONCRETE_INSTRUCTION
+(
+C®lJSFunùiÚ
+, "call-js-function")
+
+1811
+DECLARE_HYDROGEN_ACCESSOR
+(
+C®lJSFunùiÚ
+)
+
+1813
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1815 \12
+¬\99y
+(ècÚ¡ { \15
+hydrog\92
+()->
+¬gum\92t_couÁ
+() - 1; }
+
+1819
+þass
+
+LC®lW\99hDesü\9dtÜ
+
+ gFINAL
+ :
+public
+
+LTem¶©eResuÉIn¡ruùiÚ
+<1> {
+
+1820
+public
+:
+
+1821
+LC®lW\99hDesü\9dtÜ
+(
+C®lIÁ\94çûDesü\9dtÜ
+
+desü\9dtÜ
+,
+
+1822 cڡ
+ZÚeLi¡
+<
+LO³¿nd
+*>&
+Ý\94ªds
+,
+ZÚe
+*
+zÚe
+)
+
+1823 :
+desü\9dtÜ_
+(
+desü\9dtÜ
+),
+
+1824
+\9aputs_
+(
+desü\9dtÜ
+.
+G\91Regi¡\94P¬am\91\94CouÁ
+(è+ 1,
+zÚe
+) {
+
+1825
+DCHECK
+(
+desü\9dtÜ
+.
+G\91Regi¡\94P¬am\91\94CouÁ
+(è+ 1 =ð
+Ý\94ªds
+.
+Ëngth
+());
+
+1826
+ g\9aputs_
+.
+AddAÎ
+(
+Ý\94ªds
+,
+zÚe
+);
+
+1829
+LO³¿nd
+*
+\8frg\91
+(ècÚ¡ { \15
+ g\9aputs_
+[0]; }
+
+1831 cڡ
+C®lIÁ\94çûDesü\9dtÜ
+
+desü\9dtÜ
+(è{ \15
+ gdesü\9dtÜ_
+; }
+
+1833
+ g´iv©e
+:
+
+1834
+DECLARE_CONCRETE_INSTRUCTION
+(
+C®lW\99hDesü\9dtÜ
+, "call-with-descriptor")
+
+1835
+DECLARE_HYDROGEN_ACCESSOR
+(
+C®lW\99hDesü\9dtÜ
+)
+
+1837
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1839 \12
+¬\99y
+(ècÚ¡ { \15
+hydrog\92
+()->
+¬gum\92t_couÁ
+() - 1; }
+
+1841
+C®lIÁ\94çûDesü\9dtÜ
+
+ gdesü\9dtÜ_
+;
+
+1842
+ gZÚeLi¡
+<
+ gLO³¿nd
+*>
+ g\9aputs_
+;
+
+1845
+v\9ctu®
+ \12
+IÅutCouÁ
+(è
+FINAL
+
+ gOVERRIDE
+ { \15
+ g\9aputs_
+.
+Ëngth
+(); }
+
+1846
+v\9ctu®
+
+LO³¿nd
+*
+IÅutAt
+(\12
+i
+è
+FINAL
+
+ gOVERRIDE
+ { \15
+ g\9aputs_
+[i]; }
+
+1848
+v\9ctu®
+ \12
+TempCouÁ
+(è
+FINAL
+
+ gOVERRIDE
+ { \15 0; }
+
+1849
+v\9ctu®
+
+LO³¿nd
+*
+TempAt
+(\12
+i
+è
+FINAL
+
+ gOVERRIDE
+ { \15
+ gNULL
+; }
+
+1853
+þass
+
+LInvokeFunùiÚ
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1854
+ gpublic
+:
+
+1855
+LInvokeFunùiÚ
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+funùiÚ
+) {
+
+1856
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1857
+ g\9aputs_
+[1] =
+funùiÚ
+;
+
+1860
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1861
+LO³¿nd
+*
+funùiÚ
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1863
+DECLARE_CONCRETE_INSTRUCTION
+(
+InvokeFunùiÚ
+, "invoke-function")
+
+1864
+DECLARE_HYDROGEN_ACCESSOR
+(
+InvokeFunùiÚ
+)
+
+1866
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1868 \12
+¬\99y
+(ècÚ¡ { \15
+hydrog\92
+()->
+¬gum\92t_couÁ
+() - 1; }
+
+1872
+þass
+
+LC®lFunùiÚ
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1873
+ gpublic
+:
+
+1874
+LC®lFunùiÚ
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+funùiÚ
+) {
+
+1875
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1876
+ g\9aputs_
+[1] =
+funùiÚ
+;
+
+1879
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1880
+LO³¿nd
+*
+funùiÚ
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1882
+DECLARE_CONCRETE_INSTRUCTION
+(
+C®lFunùiÚ
+, "call-function")
+
+1883
+DECLARE_HYDROGEN_ACCESSOR
+(
+C®lFunùiÚ
+)
+
+1885 \12
+¬\99y
+(ècÚ¡ { \15
+hydrog\92
+()->
+¬gum\92t_couÁ
+() - 1; }
+
+1889
+þass
+
+LC®lNew
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1890
+ gpublic
+:
+
+1891
+LC®lNew
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+cÚ¡ruùÜ
+) {
+
+1892
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1893
+ g\9aputs_
+[1] =
+cÚ¡ruùÜ
+;
+
+1896
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1897
+LO³¿nd
+*
+cÚ¡ruùÜ
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1899
+DECLARE_CONCRETE_INSTRUCTION
+(
+C®lNew
+, "call-new")
+
+1900
+DECLARE_HYDROGEN_ACCESSOR
+(
+C®lNew
+)
+
+1902
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1904 \12
+¬\99y
+(ècÚ¡ { \15
+hydrog\92
+()->
+¬gum\92t_couÁ
+() - 1; }
+
+1908
+þass
+
+LC®lNewA¼ay
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+1909
+ gpublic
+:
+
+1910
+LC®lNewA¼ay
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+cÚ¡ruùÜ
+) {
+
+1911
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+1912
+ g\9aputs_
+[1] =
+cÚ¡ruùÜ
+;
+
+1915
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1916
+LO³¿nd
+*
+cÚ¡ruùÜ
+(è{ \15
+ g\9aputs_
+[1]; }
+
+1918
+DECLARE_CONCRETE_INSTRUCTION
+(
+C®lNewA¼ay
+, "call-new-array")
+
+1919
+DECLARE_HYDROGEN_ACCESSOR
+(
+C®lNewA¼ay
+)
+
+1921
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+1923 \12
+¬\99y
+(ècÚ¡ { \15
+hydrog\92
+()->
+¬gum\92t_couÁ
+() - 1; }
+
+1927
+þass
+
+LC®lRuÁime
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+1928
+ gpublic
+:
+
+1929
+ex¶ic\99
+
+LC®lRuÁime
+(
+LO³¿nd
+*
+cڋxt
+è{
+\9aputs_
+[0] = context; }
+
+1931
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1933
+DECLARE_CONCRETE_INSTRUCTION
+(
+C®lRuÁime
+, "call-runtime")
+
+1934
+DECLARE_HYDROGEN_ACCESSOR
+(
+C®lRuÁime
+)
+
+1936
+v\9ctu®
+
+boÞ
+
+Clobb\94sDoubËRegi¡\94s
+(
+Isީe
+*
+isީe
+ècÚ¡
+ gOVERRIDE
+ {
+
+1937 \15
+§ve_doubËs
+(è=ð
+kDÚtSaveFPRegs
+;
+
+1940 cڡ
+ gRuÁime
+::
+FunùiÚ
+*
+funùiÚ
+(ècÚ¡ { \15
+hydrog\92
+()->function(); }
+
+1941 \12
+¬\99y
+(ècÚ¡ { \15
+hydrog\92
+()->
+¬gum\92t_couÁ
+(); }
+
+1942
+SaveFPRegsMode
+
+§ve_doubËs
+(ècÚ¡ { \15
+hydrog\92
+()->save_doubles(); }
+
+1946
+þass
+
+LIÁeg\9432ToDoubË
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+1947
+ gpublic
+:
+
+1948
+ex¶ic\99
+
+LIÁeg\9432ToDoubË
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+1950
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1952
+DECLARE_CONCRETE_INSTRUCTION
+(
+IÁeg\9432ToDoubË
+, "int32-to-double")
+
+1956
+þass
+
+LU\9at32ToDoubË
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+1957
+ gpublic
+:
+
+1958
+ex¶ic\99
+
+LU\9at32ToDoubË
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+1960
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1962
+DECLARE_CONCRETE_INSTRUCTION
+(
+U\9at32ToDoubË
+, "uint32-to-double")
+
+1966
+þass
+
+LNumb\94TagI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 2> {
+
+1967
+ gpublic
+:
+
+1968
+LNumb\94TagI
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+\8bmp1
+, LO³¿nd*
+\8bmp2
+) {
+
+1969
+ g\9aputs_
+[0] =
+v®ue
+;
+
+1970
+ g\8bmps_
+[0] =
+\8bmp1
+;
+
+1971
+ g\8bmps_
+[1] =
+\8bmp2
+;
+
+1974
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1975
+LO³¿nd
+*
+\8bmp1
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1976
+LO³¿nd
+*
+\8bmp2
+(è{ \15
+ g\8bmps_
+[1]; }
+
+1978
+DECLARE_CONCRETE_INSTRUCTION
+(
+Numb\94TagI
+, "number-tag-i")
+
+1982
+þass
+
+LNumb\94TagU
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 2> {
+
+1983
+ gpublic
+:
+
+1984
+LNumb\94TagU
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+\8bmp1
+, LO³¿nd*
+\8bmp2
+) {
+
+1985
+ g\9aputs_
+[0] =
+v®ue
+;
+
+1986
+ g\8bmps_
+[0] =
+\8bmp1
+;
+
+1987
+ g\8bmps_
+[1] =
+\8bmp2
+;
+
+1990
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+1991
+LO³¿nd
+*
+\8bmp1
+(è{ \15
+ g\8bmps_
+[0]; }
+
+1992
+LO³¿nd
+*
+\8bmp2
+(è{ \15
+ g\8bmps_
+[1]; }
+
+1994
+DECLARE_CONCRETE_INSTRUCTION
+(
+Numb\94TagU
+, "number-tag-u")
+
+1998
+þass
+
+LNumb\94TagD
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 2> {
+
+1999
+ gpublic
+:
+
+2000
+LNumb\94TagD
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+\8bmp
+, LO³¿nd*
+\8bmp2
+) {
+
+2001
+ g\9aputs_
+[0] =
+v®ue
+;
+
+2002
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+2003
+ g\8bmps_
+[1] =
+\8bmp2
+;
+
+2006
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2007
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+2008
+LO³¿nd
+*
+\8bmp2
+(è{ \15
+ g\8bmps_
+[1]; }
+
+2010
+DECLARE_CONCRETE_INSTRUCTION
+(
+Numb\94TagD
+, "number-tag-d")
+
+2011
+DECLARE_HYDROGEN_ACCESSOR
+(
+Chªge
+)
+
+2015
+þass
+
+LDoubËToSmi
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2016
+ gpublic
+:
+
+2017
+ex¶ic\99
+
+LDoubËToSmi
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+2019
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2021
+DECLARE_CONCRETE_INSTRUCTION
+(
+DoubËToSmi
+, "double-to-smi")
+
+2022
+DECLARE_HYDROGEN_ACCESSOR
+(
+UÇryO³¿tiÚ
+)
+
+2024
+boÞ
+
+\8cunÿt\9ag
+(è{ \15
+hydrog\92
+()->
+CªTrunÿ\8bToIÁ32
+(); }
+
+2029
+þass
+
+LDoubËToI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2030
+ gpublic
+:
+
+2031
+ex¶ic\99
+
+LDoubËToI
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+2033
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2035
+DECLARE_CONCRETE_INSTRUCTION
+(
+DoubËToI
+, "double-to-i")
+
+2036
+DECLARE_HYDROGEN_ACCESSOR
+(
+UÇryO³¿tiÚ
+)
+
+2038
+boÞ
+
+\8cunÿt\9ag
+(è{ \15
+hydrog\92
+()->
+CªTrunÿ\8bToIÁ32
+(); }
+
+2043
+þass
+
+LTaggedToI
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 2> {
+
+2044
+ gpublic
+:
+
+2045
+LTaggedToI
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+\8bmp
+, LO³¿nd*
+\8bmp2
+) {
+
+2046
+ g\9aputs_
+[0] =
+v®ue
+;
+
+2047
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+2048
+ g\8bmps_
+[1] =
+\8bmp2
+;
+
+2051
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2052
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+2053
+LO³¿nd
+*
+\8bmp2
+(è{ \15
+ g\8bmps_
+[1]; }
+
+2055
+DECLARE_CONCRETE_INSTRUCTION
+(
+TaggedToI
+, "tagged-to-i")
+
+2056
+DECLARE_HYDROGEN_ACCESSOR
+(
+Chªge
+)
+
+2058
+boÞ
+
+\8cunÿt\9ag
+(è{ \15
+hydrog\92
+()->
+CªTrunÿ\8bToIÁ32
+(); }
+
+2062
+þass
+
+LSmiTag
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2063
+ gpublic
+:
+
+2064
+ex¶ic\99
+
+LSmiTag
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+2066
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2068
+DECLARE_CONCRETE_INSTRUCTION
+(
+SmiTag
+, "smi-tag")
+
+2069
+DECLARE_HYDROGEN_ACCESSOR
+(
+Chªge
+)
+
+2073
+þass
+
+LNumb\94UÁagD
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2074
+ gpublic
+:
+
+2075
+ex¶ic\99
+
+LNumb\94UÁagD
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+2077
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2079
+DECLARE_CONCRETE_INSTRUCTION
+(
+Numb\94UÁagD
+, "double-untag")
+
+2080
+DECLARE_HYDROGEN_ACCESSOR
+(
+Chªge
+)
+
+2084
+þass
+
+LSmiUÁag
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2085
+ gpublic
+:
+
+2086
+LSmiUÁag
+(
+LO³¿nd
+*
+v®ue
+,
+boÞ
+
+Ãeds_check
+è:
+Ãeds_check_
+(needs_check) {
+
+2087
+\9aputs_
+[0] =
+v®ue
+;
+
+2090
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2091
+boÞ
+
+Ãeds_check
+(ècÚ¡ { \15
+ gÃeds_check_
+; }
+
+2093
+DECLARE_CONCRETE_INSTRUCTION
+(
+SmiUÁag
+, "smi-untag")
+
+2095
+ g´iv©e
+:
+
+2096
+boÞ
+
+Ãeds_check_
+;
+
+2100
+þass
+
+LStÜeNamedF\9bld
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 2, 1> {
+
+2101
+ gpublic
+:
+
+2102
+LStÜeNamedF\9bld
+(
+LO³¿nd
+*
+objeù
+, LO³¿nd*
+v®ue
+, LO³¿nd*
+\8bmp
+) {
+
+2103
+ g\9aputs_
+[0] =
+objeù
+;
+
+2104
+ g\9aputs_
+[1] =
+v®ue
+;
+
+2105
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+2108
+LO³¿nd
+*
+objeù
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2109
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2110
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+2112
+DECLARE_CONCRETE_INSTRUCTION
+(
+StÜeNamedF\9bld
+, "store-named-field")
+
+2113
+DECLARE_HYDROGEN_ACCESSOR
+(
+StÜeNamedF\9bld
+)
+
+2115
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+2117
+R\95»£Á©iÚ
+
+»´e£Á©iÚ
+() const {
+
+2118 \15
+hydrog\92
+()->
+f\9bld_»´e£Á©iÚ
+();
+
+2123
+þass
+
+LStÜeNamedG\92\94ic
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 3, 0> {
+
+2124
+ gpublic
+:
+
+2125
+LStÜeNamedG\92\94ic
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+objeù
+, LO³¿nd*
+v®ue
+) {
+
+2126
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+2127
+ g\9aputs_
+[1] =
+objeù
+;
+
+2128
+ g\9aputs_
+[2] =
+v®ue
+;
+
+2131
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2132
+LO³¿nd
+*
+objeù
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2133
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[2]; }
+
+2135
+DECLARE_CONCRETE_INSTRUCTION
+(
+StÜeNamedG\92\94ic
+, "store-named-generic")
+
+2136
+DECLARE_HYDROGEN_ACCESSOR
+(
+StÜeNamedG\92\94ic
+)
+
+2138
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+2140
+ gHªdË
+<
+ gObjeù
+>
+Çme
+(ècÚ¡ { \15
+hydrog\92
+()->name(); }
+
+2141
+S\8ciùMode
+
+¡riù_mode
+(è{ \15
+hydrog\92
+()->strict_mode(); }
+
+2145
+þass
+
+LStÜeKeyed
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 3, 0> {
+
+2146
+ gpublic
+:
+
+2147
+LStÜeKeyed
+(
+LO³¿nd
+*
+objeù
+, LO³¿nd*
+key
+, LO³¿nd*
+v®ue
+) {
+
+2148
+ g\9aputs_
+[0] =
+objeù
+;
+
+2149
+ g\9aputs_
+[1] =
+key
+;
+
+2150
+ g\9aputs_
+[2] =
+v®ue
+;
+
+2153
+boÞ
+
+is_ex\8bº®
+(ècÚ¡ { \15
+hydrog\92
+()->is_external(); }
+
+2154
+boÞ
+
+is_fixed_ty³d_¬¿y
+() const {
+
+2155 \15
+hydrog\92
+()->
+is_fixed_ty³d_¬¿y
+();
+
+2157
+boÞ
+
+is_ty³d_\96em\92ts
+() const {
+
+2158 \15
+is_ex\8bº®
+(è||
+is_fixed_ty³d_¬¿y
+();
+
+2160
+LO³¿nd
+*
+\96em\92ts
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2161
+LO³¿nd
+*
+key
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2162
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[2]; }
+
+2163
+EËm\92tsK\9ad
+
+\96em\92ts_k\9ad
+(ècÚ¡ { \15
+hydrog\92
+()->elements_kind(); }
+
+2165
+DECLARE_CONCRETE_INSTRUCTION
+(
+StÜeKeyed
+, "store-keyed")
+
+2166
+DECLARE_HYDROGEN_ACCESSOR
+(
+StÜeKeyed
+)
+
+2168
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+2169
+boÞ
+
+N\93dsCªÚiÿliz©iÚ
+() {
+
+2170 ià(
+hydrog\92
+()->
+v®ue
+()->
+IsAdd
+(è|| hydrog\92()->v®ue()->
+IsSub
+() ||
+
+2171
+hydrog\92
+()->
+v®ue
+()->
+IsMul
+(è|| hydrog\92()->v®ue()->
+IsDiv
+()) {
+
+2172 \15
+ gçl£
+;
+
+2174 \15
+hydrog\92
+()->
+N\93dsCªÚiÿliz©iÚ
+();
+
+2176
+u\9at32_t
+
+ba£_off£t
+(ècÚ¡ { \15
+hydrog\92
+()->base_offset(); }
+
+2180
+þass
+
+LStÜeKeyedG\92\94ic
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 4, 0> {
+
+2181
+ gpublic
+:
+
+2182
+LStÜeKeyedG\92\94ic
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+obj
+, LO³¿nd*
+key
+,
+
+2183
+LO³¿nd
+*
+v®ue
+) {
+
+2184
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+2185
+ g\9aputs_
+[1] =
+obj
+;
+
+2186
+ g\9aputs_
+[2] =
+key
+;
+
+2187
+ g\9aputs_
+[3] =
+v®ue
+;
+
+2190
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2191
+LO³¿nd
+*
+objeù
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2192
+LO³¿nd
+*
+key
+(è{ \15
+ g\9aputs_
+[2]; }
+
+2193
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[3]; }
+
+2195
+DECLARE_CONCRETE_INSTRUCTION
+(
+StÜeKeyedG\92\94ic
+, "store-keyed-generic")
+
+2196
+DECLARE_HYDROGEN_ACCESSOR
+(
+StÜeKeyedG\92\94ic
+)
+
+2198
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+2200
+S\8ciùMode
+
+¡riù_mode
+(è{ \15
+hydrog\92
+()->strict_mode(); }
+
+2204
+þass
+
+LT¿ns\99iÚEËm\92tsK\9ad
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 2, 1> {
+
+2205
+ gpublic
+:
+
+2206
+LT¿ns\99iÚEËm\92tsK\9ad
+(
+LO³¿nd
+*
+objeù
+, LO³¿nd*
+cڋxt
+,
+
+2207
+LO³¿nd
+*
+Ãw_m_\8bmp
+) {
+
+2208
+ g\9aputs_
+[0] =
+objeù
+;
+
+2209
+ g\9aputs_
+[1] =
+cڋxt
+;
+
+2210
+ g\8bmps_
+[0] =
+Ãw_m_\8bmp
+;
+
+2213
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2214
+LO³¿nd
+*
+objeù
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2215
+LO³¿nd
+*
+Ãw_m_\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+2217
+DECLARE_CONCRETE_INSTRUCTION
+(
+T¿ns\99iÚEËm\92tsK\9ad
+,
+
+2219
+DECLARE_HYDROGEN_ACCESSOR
+(
+T¿ns\99iÚEËm\92tsK\9ad
+)
+
+2221
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+2223
+ gHªdË
+<
+ gM
+>
+Üig\9a®_m
+(è{ \15
+hydrog\92
+()->Üig\9a®_m().
+hªdË
+(); }
+
+2224
+ gHªdË
+<
+ gM
+>
+\8cªs\99iÚed_m
+() {
+
+2225 \15
+hydrog\92
+()->
+\8cªs\99iÚed_m
+().
+hªdË
+();
+
+2227
+EËm\92tsK\9ad
+
+äom_k\9ad
+(è{ \15
+hydrog\92
+()->from_kind(); }
+
+2228
+EËm\92tsK\9ad
+
+to_k\9ad
+(è{ \15
+hydrog\92
+()->to_kind(); }
+
+2232
+þass
+
+LT¿pAÎoÿtiÚMem\92to
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 1, 1> {
+
+2233
+ gpublic
+:
+
+2234
+LT¿pAÎoÿtiÚMem\92to
+(
+LO³¿nd
+*
+objeù
+, LO³¿nd*
+\8bmp
+) {
+
+2235
+ g\9aputs_
+[0] =
+objeù
+;
+
+2236
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+2239
+LO³¿nd
+*
+objeù
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2240
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+2242
+DECLARE_CONCRETE_INSTRUCTION
+(
+T¿pAÎoÿtiÚMem\92to
+, "trap-allocation-memento")
+
+2246
+þass
+
+LS\8c\9agAdd
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 3, 0> {
+
+2247
+ gpublic
+:
+
+2248
+LS\8c\9agAdd
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+Ëá
+, LO³¿nd*
+right
+) {
+
+2249
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+2250
+ g\9aputs_
+[1] =
+Ëá
+;
+
+2251
+ g\9aputs_
+[2] =
+right
+;
+
+2254
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2255
+LO³¿nd
+*
+Ëá
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2256
+LO³¿nd
+*
+right
+(è{ \15
+ g\9aputs_
+[2]; }
+
+2258
+DECLARE_CONCRETE_INSTRUCTION
+(
+S\8c\9agAdd
+, "string-add")
+
+2259
+DECLARE_HYDROGEN_ACCESSOR
+(
+S\8c\9agAdd
+)
+
+2263
+þass
+
+LS\8c\9agCh¬CodeAt
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 3, 0> {
+
+2264
+ gpublic
+:
+
+2265
+LS\8c\9agCh¬CodeAt
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+¡r\9ag
+, LO³¿nd*
+\9adex
+) {
+
+2266
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+2267
+ g\9aputs_
+[1] =
+¡r\9ag
+;
+
+2268
+ g\9aputs_
+[2] =
+\9adex
+;
+
+2271
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2272
+LO³¿nd
+*
+¡r\9ag
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2273
+LO³¿nd
+*
+\9adex
+(è{ \15
+ g\9aputs_
+[2]; }
+
+2275
+DECLARE_CONCRETE_INSTRUCTION
+(
+S\8c\9agCh¬CodeAt
+, "string-char-code-at")
+
+2276
+DECLARE_HYDROGEN_ACCESSOR
+(
+S\8c\9agCh¬CodeAt
+)
+
+2280
+þass
+
+LS\8c\9agCh¬FromCode
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+2281
+ gpublic
+:
+
+2282
+ex¶ic\99
+
+LS\8c\9agCh¬FromCode
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+ch¬_code
+) {
+
+2283
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+2284
+ g\9aputs_
+[1] =
+ch¬_code
+;
+
+2287
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2288
+LO³¿nd
+*
+ch¬_code
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2290
+DECLARE_CONCRETE_INSTRUCTION
+(
+S\8c\9agCh¬FromCode
+, "string-char-from-code")
+
+2291
+DECLARE_HYDROGEN_ACCESSOR
+(
+S\8c\9agCh¬FromCode
+)
+
+2295
+þass
+
+LCheckV®ue
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 1, 0> {
+
+2296
+ gpublic
+:
+
+2297
+ex¶ic\99
+
+LCheckV®ue
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+2299
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2301
+DECLARE_CONCRETE_INSTRUCTION
+(
+CheckV®ue
+, "check-value")
+
+2302
+DECLARE_HYDROGEN_ACCESSOR
+(
+CheckV®ue
+)
+
+2306
+þass
+
+LCheckIn¡ªûTy³
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 1, 0> {
+
+2307
+ gpublic
+:
+
+2308
+ex¶ic\99
+
+LCheckIn¡ªûTy³
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+2310
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2312
+DECLARE_CONCRETE_INSTRUCTION
+(
+CheckIn¡ªûTy³
+, "check-instance-type")
+
+2313
+DECLARE_HYDROGEN_ACCESSOR
+(
+CheckIn¡ªûTy³
+)
+
+2317
+þass
+
+LCheckMs
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 1, 0> {
+
+2318
+ gpublic
+:
+
+2319
+ex¶ic\99
+
+LCheckMs
+(
+LO³¿nd
+*
+v®ue
+ =
+NULL
+è{
+\9aputs_
+[0] = value; }
+
+2321
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2323
+DECLARE_CONCRETE_INSTRUCTION
+(
+CheckMs
+, "check-maps")
+
+2324
+DECLARE_HYDROGEN_ACCESSOR
+(
+CheckMs
+)
+
+2328
+þass
+
+LCheckSmi
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2329
+ gpublic
+:
+
+2330
+ex¶ic\99
+
+LCheckSmi
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+2332
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2334
+DECLARE_CONCRETE_INSTRUCTION
+(
+CheckSmi
+, "check-smi")
+
+2338
+þass
+
+LCheckNÚSmi
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 1, 0> {
+
+2339
+ gpublic
+:
+
+2340
+ex¶ic\99
+
+LCheckNÚSmi
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+2342
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2344
+DECLARE_CONCRETE_INSTRUCTION
+(
+CheckNÚSmi
+, "check-non-smi")
+
+2345
+DECLARE_HYDROGEN_ACCESSOR
+(
+CheckH\97pObjeù
+)
+
+2349
+þass
+
+LCÏmpDToU\9at8
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2350
+ gpublic
+:
+
+2351
+ex¶ic\99
+
+LCÏmpDToU\9at8
+(
+LO³¿nd
+*
+unþam³d
+è{
+\9aputs_
+[0] = unclamped; }
+
+2353
+LO³¿nd
+*
+unþam³d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2355
+DECLARE_CONCRETE_INSTRUCTION
+(
+CÏmpDToU\9at8
+, "clamp-d-to-uint8")
+
+2359
+þass
+
+LCÏmpIToU\9at8
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2360
+ gpublic
+:
+
+2361
+ex¶ic\99
+
+LCÏmpIToU\9at8
+(
+LO³¿nd
+*
+unþam³d
+è{
+\9aputs_
+[0] = unclamped; }
+
+2363
+LO³¿nd
+*
+unþam³d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2365
+DECLARE_CONCRETE_INSTRUCTION
+(
+CÏmpIToU\9at8
+, "clamp-i-to-uint8")
+
+2369
+þass
+
+LCÏmpTToU\9at8
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 1> {
+
+2370
+ gpublic
+:
+
+2371
+LCÏmpTToU\9at8
+(
+LO³¿nd
+*
+unþam³d
+, LO³¿nd*
+\8bmp
+) {
+
+2372
+ g\9aputs_
+[0] =
+unþam³d
+;
+
+2373
+ g\8bmps_
+[0] =
+\8bmp
+;
+
+2376
+LO³¿nd
+*
+unþam³d
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2377
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+2379
+DECLARE_CONCRETE_INSTRUCTION
+(
+CÏmpTToU\9at8
+, "clamp-t-to-uint8")
+
+2383
+þass
+
+LDoubËB\99s
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2384
+ gpublic
+:
+
+2385
+ex¶ic\99
+
+LDoubËB\99s
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+2387
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2389
+DECLARE_CONCRETE_INSTRUCTION
+(
+DoubËB\99s
+, "double-bits")
+
+2390
+DECLARE_HYDROGEN_ACCESSOR
+(
+DoubËB\99s
+)
+
+2394
+þass
+
+LCÚ¡ruùDoubË
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+2395
+ gpublic
+:
+
+2396
+LCÚ¡ruùDoubË
+(
+LO³¿nd
+*
+hi
+, LO³¿nd*
+lo
+) {
+
+2397
+ g\9aputs_
+[0] =
+hi
+;
+
+2398
+ g\9aputs_
+[1] =
+lo
+;
+
+2401
+LO³¿nd
+*
+hi
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2402
+LO³¿nd
+*
+lo
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2404
+DECLARE_CONCRETE_INSTRUCTION
+(
+CÚ¡ruùDoubË
+, "construct-double")
+
+2408
+þass
+
+LAÎoÿ\8b
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 2> {
+
+2409
+ gpublic
+:
+
+2410
+LAÎoÿ\8b
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+size
+, LO³¿nd*
+\8bmp1
+,
+
+2411
+LO³¿nd
+*
+\8bmp2
+) {
+
+2412
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+2413
+ g\9aputs_
+[1] =
+size
+;
+
+2414
+ g\8bmps_
+[0] =
+\8bmp1
+;
+
+2415
+ g\8bmps_
+[1] =
+\8bmp2
+;
+
+2418
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2419
+LO³¿nd
+*
+size
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2420
+LO³¿nd
+*
+\8bmp1
+(è{ \15
+ g\8bmps_
+[0]; }
+
+2421
+LO³¿nd
+*
+\8bmp2
+(è{ \15
+ g\8bmps_
+[1]; }
+
+2423
+DECLARE_CONCRETE_INSTRUCTION
+(
+AÎoÿ\8b
+, "allocate")
+
+2424
+DECLARE_HYDROGEN_ACCESSOR
+(
+AÎoÿ\8b
+)
+
+2428
+þass
+
+LRegExpL\99\94®
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2429
+ gpublic
+:
+
+2430
+ex¶ic\99
+
+LRegExpL\99\94®
+(
+LO³¿nd
+*
+cڋxt
+è{
+\9aputs_
+[0] = context; }
+
+2432
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2434
+DECLARE_CONCRETE_INSTRUCTION
+(
+RegExpL\99\94®
+, "regexp-literal")
+
+2435
+DECLARE_HYDROGEN_ACCESSOR
+(
+RegExpL\99\94®
+)
+
+2439
+þass
+
+LFunùiÚL\99\94®
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2440
+ gpublic
+:
+
+2441
+ex¶ic\99
+
+LFunùiÚL\99\94®
+(
+LO³¿nd
+*
+cڋxt
+è{
+\9aputs_
+[0] = context; }
+
+2443
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2445
+DECLARE_CONCRETE_INSTRUCTION
+(
+FunùiÚL\99\94®
+, "function-literal")
+
+2446
+DECLARE_HYDROGEN_ACCESSOR
+(
+FunùiÚL\99\94®
+)
+
+2450
+þass
+
+LToFa¡PrÝ\94t\9bs
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2451
+ gpublic
+:
+
+2452
+ex¶ic\99
+
+LToFa¡PrÝ\94t\9bs
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+2454
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2456
+DECLARE_CONCRETE_INSTRUCTION
+(
+ToFa¡PrÝ\94t\9bs
+, "to-fast-properties")
+
+2457
+DECLARE_HYDROGEN_ACCESSOR
+(
+ToFa¡PrÝ\94t\9bs
+)
+
+2461
+þass
+
+LTy³of
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+2462
+ gpublic
+:
+
+2463
+LTy³of
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+v®ue
+) {
+
+2464
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+2465
+ g\9aputs_
+[1] =
+v®ue
+;
+
+2468
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2469
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2471
+DECLARE_CONCRETE_INSTRUCTION
+(
+Ty³of
+, "typeof")
+
+2475
+þass
+
+LTy³ofIsAndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<1, 0> {
+
+2476
+ gpublic
+:
+
+2477
+ex¶ic\99
+
+LTy³ofIsAndB¿nch
+(
+LO³¿nd
+*
+v®ue
+è{
+\9aputs_
+[0] = value; }
+
+2479
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2481
+DECLARE_CONCRETE_INSTRUCTION
+(
+Ty³ofIsAndB¿nch
+, "typeof-is-and-branch")
+
+2482
+DECLARE_HYDROGEN_ACCESSOR
+(
+Ty³ofIsAndB¿nch
+)
+
+2484
+ gHªdË
+<
+ gS\8c\9ag
+>
+ty³_l\99\94®
+(è{ \15
+hydrog\92
+()->type_literal(); }
+
+2486
+v\9ctu®
+ \1e
+Pr\9atD©aTo
+(
+S\8c\9agS\8c\97m
+*
+¡»am
+è
+ gOVERRIDE
+;
+
+2490
+þass
+
+LIsCÚ¡ruùC®lAndB¿nch
+
+ gFINAL
+ :
+public
+
+LCÚ\8cÞIn¡ruùiÚ
+<0, 1> {
+
+2491
+ gpublic
+:
+
+2492
+ex¶ic\99
+
+LIsCÚ¡ruùC®lAndB¿nch
+(
+LO³¿nd
+*
+\8bmp
+è{
+\8bmps_
+[0] =\81emp; }
+
+2494
+LO³¿nd
+*
+\8bmp
+(è{ \15
+ g\8bmps_
+[0]; }
+
+2496
+DECLARE_CONCRETE_INSTRUCTION
+(
+IsCÚ¡ruùC®lAndB¿nch
+,
+
+2501
+þass
+
+LO¤EÁry
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 0, 0> {
+
+2502
+ gpublic
+:
+
+2503
+LO¤EÁry
+() {}
+
+2505
+v\9ctu®
+
+boÞ
+
+HasIÁ\94e¡\9agComm\92t
+(
+LCodeG\92
+*
+g\92
+ècÚ¡
+OVERRIDE
+ {
+
+2506 \15
+çl£
+;
+
+2508
+DECLARE_CONCRETE_INSTRUCTION
+(
+O¤EÁry
+, "osr-entry")
+
+2512
+þass
+
+LS\8fckCheck
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 1, 0> {
+
+2513
+ gpublic
+:
+
+2514
+ex¶ic\99
+
+LS\8fckCheck
+(
+LO³¿nd
+*
+cڋxt
+è{
+\9aputs_
+[0] = context; }
+
+2516
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2518
+DECLARE_CONCRETE_INSTRUCTION
+(
+S\8fckCheck
+, "stack-check")
+
+2519
+DECLARE_HYDROGEN_ACCESSOR
+(
+S\8fckCheck
+)
+
+2521
+Lab\96
+*
+dÚe_Ïb\96
+(è{ \15 &
+ gdÚe_Ïb\96_
+; }
+
+2523
+ g´iv©e
+:
+
+2524
+Lab\96
+
+dÚe_Ïb\96_
+;
+
+2528
+þass
+
+LFÜInP»·»M
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+2529
+ gpublic
+:
+
+2530
+LFÜInP»·»M
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+objeù
+) {
+
+2531
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+2532
+ g\9aputs_
+[1] =
+objeù
+;
+
+2535
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2536
+LO³¿nd
+*
+objeù
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2538
+DECLARE_CONCRETE_INSTRUCTION
+(
+FÜInP»·»M
+, "for-in-prepare-map")
+
+2542
+þass
+
+LFÜInCacheA¼ay
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 1, 0> {
+
+2543
+ gpublic
+:
+
+2544
+ex¶ic\99
+
+LFÜInCacheA¼ay
+(
+LO³¿nd
+*
+m
+è{
+\9aputs_
+[0] = map; }
+
+2546
+LO³¿nd
+*
+m
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2548
+DECLARE_CONCRETE_INSTRUCTION
+(
+FÜInCacheA¼ay
+, "for-in-cache-array")
+
+2550 \12
+idx
+(è{ \15
+ gHFÜInCacheA¼ay
+::
+ÿ¡
+(
+this
+->
+hydrog\92_v®ue
+())->idx(); }
+
+2554
+þass
+
+LCheckMV®ue
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 2, 0> {
+
+2555
+ gpublic
+:
+
+2556
+LCheckMV®ue
+(
+LO³¿nd
+*
+v®ue
+, LO³¿nd*
+m
+) {
+
+2557
+ g\9aputs_
+[0] =
+v®ue
+;
+
+2558
+ g\9aputs_
+[1] =
+m
+;
+
+2561
+LO³¿nd
+*
+v®ue
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2562
+LO³¿nd
+*
+m
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2564
+DECLARE_CONCRETE_INSTRUCTION
+(
+CheckMV®ue
+, "check-map-value")
+
+2568
+þass
+
+LLßdF\9bldByIndex
+
+ gFINAL
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+2569
+ gpublic
+:
+
+2570
+LLßdF\9bldByIndex
+(
+LO³¿nd
+*
+objeù
+, LO³¿nd*
+\9adex
+) {
+
+2571
+ g\9aputs_
+[0] =
+objeù
+;
+
+2572
+ g\9aputs_
+[1] =
+\9adex
+;
+
+2575
+LO³¿nd
+*
+objeù
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2576
+LO³¿nd
+*
+\9adex
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2578
+DECLARE_CONCRETE_INSTRUCTION
+(
+LßdF\9bldByIndex
+, "load-field-by-index")
+
+2582
+þass
+
+ gLStÜeF¿meCÚ\8bxt
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<0, 1, 0> {
+
+2583
+ gpublic
+:
+
+2584
+ex¶ic\99
+
+LStÜeF¿meCÚ\8bxt
+(
+LO³¿nd
+*
+cڋxt
+è{
+\9aputs_
+[0] = context; }
+
+2586
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2588
+DECLARE_CONCRETE_INSTRUCTION
+(
+StÜeF¿meCÚ\8bxt
+, "store-frame-context")
+
+2592
+þass
+
+ gLAÎoÿ\8bBlockCÚ\8bxt
+ :
+public
+
+LTem¶©eIn¡ruùiÚ
+<1, 2, 0> {
+
+2593
+ gpublic
+:
+
+2594
+LAÎoÿ\8bBlockCÚ\8bxt
+(
+LO³¿nd
+*
+cڋxt
+, LO³¿nd*
+funùiÚ
+) {
+
+2595
+ g\9aputs_
+[0] =
+cڋxt
+;
+
+2596
+ g\9aputs_
+[1] =
+funùiÚ
+;
+
+2599
+LO³¿nd
+*
+cڋxt
+(è{ \15
+ g\9aputs_
+[0]; }
+
+2600
+LO³¿nd
+*
+funùiÚ
+(è{ \15
+ g\9aputs_
+[1]; }
+
+2602
+ gHªdË
+<
+ gScÝeInfo
+>
+scÝe_\9afo
+(è{ \15
+hydrog\92
+()->scope_info(); }
+
+2604
+DECLARE_CONCRETE_INSTRUCTION
+(
+AÎoÿ\8bBlockCÚ\8bxt
+, "allocate-block-context")
+
+2605
+DECLARE_HYDROGEN_ACCESSOR
+(
+AÎoÿ\8bBlockCÚ\8bxt
+)
+
+2609
+þass
+
+ gLChunkBu\9ed\94
+;
+
+2610 þas
+ cLPÏtfÜmChunk
+
+ gFINAL
+ :
+public
+
+LChunk
+ {
+
+2611
+public
+:
+
+2612
+LPÏtfÜmChunk
+(
+Comp\9e©iÚInfo
+*
+\9afo
+,
+HG¿ph
+*
+g¿ph
+è:
+LChunk
+(info, graph) {}
+
+2614 \12
+G\91NextSp\9elIndex
+(
+Regi¡\94K\9ad
+
+k\9ad
+);
+
+2615
+LO³¿nd
+*
+G\91NextSp\9elSlÙ
+(
+Regi¡\94K\9ad
+
+k\9ad
+);
+
+2619 þas
+ cLChunkBu\9ed\94
+
+ gFINAL
+ :
+public
+
+LChunkBu\9ed\94Ba£
+ {
+
+2620
+public
+:
+
+2621
+LChunkBu\9ed\94
+(
+Comp\9e©iÚInfo
+*
+\9afo
+,
+HG¿ph
+*
+g¿ph
+,
+LAÎoÿtÜ
+*
+®loÿtÜ
+)
+
+2622 :
+LChunkBu\9ed\94Ba£
+(
+\9afo
+,
+g¿ph
+),
+
+2623
+cu¼\92t_\9a¡ruùiÚ_
+(
+NULL
+),
+
+2624
+cu¼\92t_block_
+(
+NULL
+),
+
+2625
+Ãxt_block_
+(
+NULL
+),
+
+2626
+®loÿtÜ_
+(
+®loÿtÜ
+) {}
+
+2629
+LPÏtfÜmChunk
+*
+Bu\9ed
+();
+
+2632 \ 1
+ #DECLARE_DO
+(
+ty³
+è
+LIn¡ruùiÚ
+*
+Do
+##
+ `ty³
+(
+H
+##ty³*
+node
+);
+
+ )
+
+2633
+HYDROGEN_CONCRETE_INSTRUCTION_LIST
+(
+DECLARE_DO
+)
+
+2634 #undeà
+DECLARE_DO
+
+
+2636
+LIn¡ruùiÚ
+*
+DoMuɝlyAdd
+(
+HMul
+*
+mul
+,
+HV®ue
+*
+add\92d
+);
+
+2637
+LIn¡ruùiÚ
+*
+DoMuɝlySub
+(
+HV®ue
+*
+m\9au\92d
+,
+HMul
+*
+mul
+);
+
+2638
+LIn¡ruùiÚ
+*
+DoRSub
+(
+HSub
+*
+\9a¡r
+);
+
+2640 \18
+boÞ
+
+HasMagicNumb\94FÜDivisÜ
+(
+\9at32_t
+
+divisÜ
+);
+
+2642
+LIn¡ruùiÚ
+*
+DoM©hFloÜ
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+);
+
+2643
+LIn¡ruùiÚ
+*
+DoM©hRound
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+);
+
+2644
+LIn¡ruùiÚ
+*
+DoM©hFround
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+);
+
+2645
+LIn¡ruùiÚ
+*
+DoM©hAbs
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+);
+
+2646
+LIn¡ruùiÚ
+*
+DoM©hLog
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+);
+
+2647
+LIn¡ruùiÚ
+*
+DoM©hExp
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+);
+
+2648
+LIn¡ruùiÚ
+*
+DoM©hSq¹
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+);
+
+2649
+LIn¡ruùiÚ
+*
+DoM©hPowH®f
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+);
+
+2650
+LIn¡ruùiÚ
+*
+DoM©hClz32
+(
+HUÇryM©hO³¿tiÚ
+*
+\9a¡r
+);
+
+2651
+LIn¡ruùiÚ
+*
+DoDivByPow\94Of2I
+(
+HDiv
+*
+\9a¡r
+);
+
+2652
+LIn¡ruùiÚ
+*
+DoDivByCڡI
+(
+HDiv
+*
+\9a¡r
+);
+
+2653
+LIn¡ruùiÚ
+*
+DoDivI
+(
+HDiv
+*
+\9a¡r
+);
+
+2654
+LIn¡ruùiÚ
+*
+DoModByPow\94Of2I
+(
+HMod
+*
+\9a¡r
+);
+
+2655
+LIn¡ruùiÚ
+*
+DoModByCڡI
+(
+HMod
+*
+\9a¡r
+);
+
+2656
+LIn¡ruùiÚ
+*
+DoModI
+(
+HMod
+*
+\9a¡r
+);
+
+2657
+LIn¡ruùiÚ
+*
+DoFloÜ\9agDivByPow\94Of2I
+(
+HM©hFloÜOfDiv
+*
+\9a¡r
+);
+
+2658
+LIn¡ruùiÚ
+*
+DoFloܚgDivByCڡI
+(
+HM©hFloÜOfDiv
+*
+\9a¡r
+);
+
+2659
+LIn¡ruùiÚ
+*
+DoFloܚgDivI
+(
+HM©hFloÜOfDiv
+*
+\9a¡r
+);
+
+2661
+ g´iv©e
+:
+
+2663
+LUÇÎoÿ\8bd
+*
+ToUÇÎoÿ\8bd
+(
+Regi¡\94
+
+»g
+);
+
+2664
+LUÇÎoÿ\8bd
+*
+ToUÇÎoÿ\8bd
+(
+DoubËRegi¡\94
+
+»g
+);
+
+2667
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£
+(
+HV®ue
+*
+v®ue
+,
+LUÇÎoÿ\8bd
+*
+Ý\94ªd
+);
+
+2668
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£Fixed
+(
+HV®ue
+*
+v®ue
+,
+Regi¡\94
+
+fixed_»gi¡\94
+);
+
+2669
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£FixedDoubË
+(
+HV®ue
+*
+v®ue
+,
+
+2670
+DoubËRegi¡\94
+
+fixed_»gi¡\94
+);
+
+2680
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£Regi¡\94
+(
+HV®ue
+*
+v®ue
+);
+
+2681
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£Regi¡\94AtS\8f¹
+(
+HV®ue
+*
+v®ue
+);
+
+2684
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£TempRegi¡\94
+(
+HV®ue
+*
+v®ue
+);
+
+2687
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£
+(
+HV®ue
+*
+v®ue
+);
+
+2688
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£AtS\8f¹
+(
+HV®ue
+*
+v®ue
+);
+
+2691
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£OrCÚ¡ªt
+(
+HV®ue
+*
+v®ue
+);
+
+2692
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£OrCÚ¡ªtAtS\8f¹
+(
+HV®ue
+*
+v®ue
+);
+
+2695
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£Regi¡\94OrCÚ¡ªt
+(
+HV®ue
+*
+v®ue
+);
+
+2696
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£Regi¡\94OrCÚ¡ªtAtS\8f¹
+(
+HV®ue
+*
+v®ue
+);
+
+2699
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£CÚ¡ªt
+(
+HV®ue
+*
+v®ue
+);
+
+2703
+v\9ctu®
+
+MUST_USE_RESULT
+
+LO³¿nd
+*
+U£Any
+(
+HV®ue
+*
+v®ue
+è
+ gOVERRIDE
+;
+
+2706
+MUST_USE_RESULT
+
+LUÇÎoÿ\8bd
+*
+TempRegi¡\94
+();
+
+2707
+MUST_USE_RESULT
+
+LUÇÎoÿ\8bd
+*
+TempDoubËRegi¡\94
+();
+
+2708
+MUST_USE_RESULT
+
+LO³¿nd
+*
+FixedTemp
+(
+Regi¡\94
+
+»g
+);
+
+2709
+MUST_USE_RESULT
+
+LO³¿nd
+*
+FixedTemp
+(
+DoubËRegi¡\94
+
+»g
+);
+
+2713
+LIn¡ruùiÚ
+*
+Def\9ae
+(
+LTem¶©eResuÉIn¡ruùiÚ
+<1>*
+\9a¡r
+,
+
+2714
+LUÇÎoÿ\8bd
+*
+»suÉ
+);
+
+2715
+LIn¡ruùiÚ
+*
+Def\9aeAsRegi¡\94
+(
+LTem¶©eResuÉIn¡ruùiÚ
+<1>*
+\9a¡r
+);
+
+2716
+LIn¡ruùiÚ
+*
+Def\9aeAsSp\9eËd
+(
+LTem¶©eResuÉIn¡ruùiÚ
+<1>*
+\9a¡r
+,
+
+2717 \12
+\9adex
+);
+
+2718
+LIn¡ruùiÚ
+*
+Def\9aeSameAsF\9c¡
+(
+LTem¶©eResuÉIn¡ruùiÚ
+<1>*
+\9a¡r
+);
+
+2719
+LIn¡ruùiÚ
+*
+Def\9aeFixed
+(
+LTem¶©eResuÉIn¡ruùiÚ
+<1>*
+\9a¡r
+,
+Regi¡\94
+
+»g
+);
+
+2720
+LIn¡ruùiÚ
+*
+Def\9aeFixedDoubË
+(
+LTem¶©eResuÉIn¡ruùiÚ
+<1>*
+\9a¡r
+,
+
+2721
+DoubËRegi¡\94
+
+»g
+);
+
+2722
+LIn¡ruùiÚ
+*
+AssignEnv\9cÚm\92t
+(LIn¡ruùiÚ*
+\9a¡r
+);
+
+2723
+LIn¡ruùiÚ
+*
+AssignPo\9a\8brM
+(LIn¡ruùiÚ*
+\9a¡r
+);
+
+2725 \f
+ eCªDeÝtimize
+ {
+ gCAN_DEOPTIMIZE_EAGERLY
+,
+ gCANNOT_DEOPTIMIZE_EAGERLY
+ };
+
+2730
+LIn¡ruùiÚ
+*
+M¬kAsC®l
+(
+
+2731
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+HIn¡ruùiÚ
+*
+h\9a¡r
+,
+
+2732
+CªDeÝtimize
+
+ÿn_deÝtimize
+ =
+CANNOT_DEOPTIMIZE_EAGERLY
+);
+
+2734 \1e
+Vis\99In¡ruùiÚ
+(
+HIn¡ruùiÚ
+*
+cu¼\92t
+);
+
+2735 \1e
+AddIn¡ruùiÚ
+(
+LIn¡ruùiÚ
+*
+\9a¡r
+,
+HIn¡ruùiÚ
+*
+cu¼\92t
+);
+
+2737 \1e
+DoBasicBlock
+(
+HBasicBlock
+*
+block
+, HBasicBlock*
+Ãxt_block
+);
+
+2738
+LIn¡ruùiÚ
+*
+DoShiá
+(
+Tok\92
+::
+V®ue
+
+Ý
+,
+HB\99wi£B\9a¬yO³¿tiÚ
+*
+\9a¡r
+);
+
+2739
+LIn¡ruùiÚ
+*
+DoAr\99hm\91icD
+(
+Tok\92
+::
+V®ue
+
+Ý
+,
+
+2740
+HAr\99hm\91icB\9a¬yO³¿tiÚ
+*
+\9a¡r
+);
+
+2741
+LIn¡ruùiÚ
+*
+DoAr\99hm\91icT
+(
+Tok\92
+::
+V®ue
+
+Ý
+,
+HB\9a¬yO³¿tiÚ
+*
+\9a¡r
+);
+
+2743
+HIn¡ruùiÚ
+*
+ gcu¼\92t_\9a¡ruùiÚ_
+;
+
+2744
+HBasicBlock
+*
+ gcu¼\92t_block_
+;
+
+2745
+HBasicBlock
+*
+ gÃxt_block_
+;
+
+2746
+LAÎoÿtÜ
+*
+ g®loÿtÜ_
+;
+
+2748
+DISALLOW_COPY_AND_ASSIGN
+(
+LChunkBu\9ed\94
+);
+
+2751 #undeà
+DECLARE_HYDROGEN_ACCESSOR
+
+
+2752 #undeà
+DECLARE_CONCRETE_INSTRUCTION
+
+
+ @macro-assembler-ppc.cc
+
+5 \ 2
+ ~<as£¹.h
+>
+
+6 \ 2
+ ~<lim\99s.h
+>
+
+8 \ 2
+ ~"¤c/v8.h
+"
+
+10 #ià
+V8_TARGET_ARCH_PPC
+
+
+12 \ 2
+ ~"¤c/ba£/b\99s.h
+"
+
+13 \ 2
+ ~"¤c/ba£/divisiÚ-by-cÚ¡ªt.h
+"
+
+14 \ 2
+ ~"¤c/boÙ¡¿µ\94.h
+"
+
+15 \ 2
+ ~"¤c/codeg\92.h
+"
+
+16 \ 2
+ ~"¤c/ýu-´of\9e\94.h
+"
+
+17 \ 2
+ ~"¤c/debug.h
+"
+
+18 \ 2
+ ~"¤c/isÞ©e-\9al.h
+"
+
+19 \ 2
+ ~"¤c/ruÁime/ruÁime.h
+"
+
+21
+Çme¥aû
+
+ gv8
+ {
+
+22
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+24
+ gMaüoAs£mbËr
+::
+MaüoAs£mbËr
+(
+Isީe
+*
+¬g_isÞ©e
+, \1e*
+bufãr
+, \12
+size
+)
+
+25 :
+As£mbËr
+(
+¬g_isÞ©e
+,
+bufãr
+,
+size
+),
+
+26
+g\92\94©\9ag_¡ub_
+(
+çl£
+),
+
+27
+has_äame_
+(
+çl£
+) {
+
+28 ià(
+isީe
+(è!ð
+NULL
+) {
+
+29
+code_objeù_
+ =
+
+30
+HªdË
+<
+Objeù
+>(
+isީe
+()->
+h\97p
+()->
+undef\9aed_v®ue
+(), isolate());
+
+35 \1e
+ gMaüoAs£mbËr
+::
+Jump
+(
+Regi¡\94
+
+\8frg\91
+) {
+
+36
+mtùr
+(
+\8frg\91
+);
+
+37
+bùr
+();
+
+41 \1e
+ gMaüoAs£mbËr
+::
+JumpToJSEÁry
+(
+Regi¡\94
+
+\8frg\91
+) {
+
+42
+Move
+(
+\9d
+,
+\8frg\91
+);
+
+43
+Jump
+(
+\9d
+);
+
+47 \1e
+ gMaüoAs£mbËr
+::
+Jump
+(
+\9a\8d\8c_t
+
+\8frg\91
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+
+48
+CÚd\99iÚ
+
+cÚd
+,
+CRegi¡\94
+
+ü
+) {
+
+49
+Lab\96
+
+ gsk\9d
+;
+
+51 ià(
+ gcÚd
+ !ð
+®
+è
+b
+(
+Neg©eCÚd\99iÚ
+(
+cÚd
+), &
+sk\9d
+,
+ü
+);
+
+53
+DCHECK
+(
+rmode
+ =ð
+R\96ocInfo
+::
+CODE_TARGET
+ ||\84mod\90=ðR\96ocInfo::
+RUNTIME_ENTRY
+);
+
+55
+mov
+(
+\9d
+,
+O³¿nd
+(
+\8frg\91
+,
+rmode
+));
+
+56
+mtùr
+(
+\9d
+);
+
+57
+bùr
+();
+
+59
+b\9ad
+(&
+sk\9d
+);
+
+63 \1e
+ gMaüoAs£mbËr
+::
+Jump
+(
+Add»ss
+
+\8frg\91
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+CÚd\99iÚ
+
+cÚd
+,
+
+64
+CRegi¡\94
+
+ü
+) {
+
+65
+DCHECK
+(!
+R\96ocInfo
+::
+IsCodeT¬g\91
+(
+rmode
+));
+
+66
+Jump
+(
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+\8frg\91
+),
+rmode
+,
+cÚd
+,
+ü
+);
+
+70 \1e
+ gMaüoAs£mbËr
+::
+Jump
+(
+HªdË
+<
+Code
+>
+code
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+
+71
+CÚd\99iÚ
+
+cÚd
+) {
+
+72
+DCHECK
+(
+R\96ocInfo
+::
+IsCodeT¬g\91
+(
+rmode
+));
+
+74
+AÎowDeã¼edHªdËD\94eã»nû
+
+ gembedd\9ag_¿w_add»ss
+;
+
+75
+Jump
+(
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+code
+.
+loÿtiÚ
+()),
+rmode
+,
+cÚd
+);
+
+79 \12
+ gMaüoAs£mbËr
+::
+C®lSize
+(
+Regi¡\94
+
+\8frg\91
+è{ \15 2 *
+kIn¡rSize
+; }
+
+82 \1e
+ gMaüoAs£mbËr
+::
+C®l
+(
+Regi¡\94
+
+\8frg\91
+) {
+
+83
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+this
+);
+
+84
+Lab\96
+
+ g¡¬t
+;
+
+85
+b\9ad
+(&
+¡¬t
+);
+
+89
+pos\99iÚs_»cÜd\94
+()->
+Wr\99eRecÜdedPos\99iÚs
+();
+
+92
+mtùr
+(
+\8frg\91
+);
+
+93
+bù¾
+();
+
+95
+DCHECK_EQ
+(
+C®lSize
+(
+\8frg\91
+),
+SizeOfCodeG\92\94©edS\9aû
+(&
+¡¬t
+));
+
+99 \1e
+ gMaüoAs£mbËr
+::
+C®lJSEÁry
+(
+Regi¡\94
+
+\8frg\91
+) {
+
+100
+DCHECK
+(
+\8frg\91
+.
+is
+(
+\9d
+));
+
+101
+C®l
+(
+\8frg\91
+);
+
+105 \12
+ gMaüoAs£mbËr
+::
+C®lSize
+(
+Add»ss
+
+\8frg\91
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+
+106
+CÚd\99iÚ
+
+cÚd
+) {
+
+107
+O³¿nd
+
+ gmov_Ý\94ªd
+ = O³¿nd(
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+\8frg\91
+),
+rmode
+);
+
+108 \15 (2 +
+\9a¡ruùiÚs_»qu\9ced_fÜ_mov
+(
+mov_Ý\94ªd
+)è*
+ gkIn¡rSize
+;
+
+112 \12
+ gMaüoAs£mbËr
+::
+C®lSizeNÙP»diùabËCodeSize
+(
+Add»ss
+
+\8frg\91
+,
+
+113
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+
+114
+CÚd\99iÚ
+
+cÚd
+) {
+
+115 \15 (2 +
+ gkMovIn¡ruùiÚsNoCÚ¡ªtPoÞ
+è*
+ gkIn¡rSize
+;
+
+119 \1e
+ gMaüoAs£mbËr
+::
+C®l
+(
+Add»ss
+
+\8frg\91
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+
+120
+CÚd\99iÚ
+
+cÚd
+) {
+
+121
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+this
+);
+
+122
+DCHECK
+(
+cÚd
+ =ð
+®
+);
+
+124 #ifdeà
+DEBUG
+
+
+127 \12
+ gex³ùed_size
+ =
+C®lSize
+(
+\8frg\91
+,
+rmode
+,
+cÚd
+);
+
+128
+Lab\96
+
+ g¡¬t
+;
+
+129
+b\9ad
+(&
+¡¬t
+);
+
+134
+pos\99iÚs_»cÜd\94
+()->
+Wr\99eRecÜdedPos\99iÚs
+();
+
+142
+mov
+(
+\9d
+,
+O³¿nd
+(
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+\8frg\91
+),
+rmode
+));
+
+143
+mtùr
+(
+\9d
+);
+
+144
+bù¾
+();
+
+146
+DCHECK_EQ
+(
+ex³ùed_size
+,
+SizeOfCodeG\92\94©edS\9aû
+(&
+¡¬t
+));
+
+150 \12
+ gMaüoAs£mbËr
+::
+C®lSize
+(
+HªdË
+<
+Code
+>
+code
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+
+151
+Ty³F\93dbackId
+
+a¡_id
+,
+CÚd\99iÚ
+
+cÚd
+) {
+
+152
+AÎowDeã¼edHªdËD\94eã»nû
+
+ gus\9ag_¿w_add»ss
+;
+
+153 \15
+C®lSize
+(
+»\9a\8b½»t_ÿ¡
+<
+Add»ss
+>(
+code
+.
+loÿtiÚ
+()),
+rmode
+,
+cÚd
+);
+
+157 \1e
+ gMaüoAs£mbËr
+::
+C®l
+(
+HªdË
+<
+Code
+>
+code
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+
+158
+Ty³F\93dbackId
+
+a¡_id
+,
+CÚd\99iÚ
+
+cÚd
+) {
+
+159
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+this
+);
+
+160
+DCHECK
+(
+R\96ocInfo
+::
+IsCodeT¬g\91
+(
+rmode
+));
+
+162 #ifdeà
+DEBUG
+
+
+165 \12
+ gex³ùed_size
+ =
+C®lSize
+(
+code
+,
+rmode
+,
+a¡_id
+,
+cÚd
+);
+
+166
+Lab\96
+
+ g¡¬t
+;
+
+167
+b\9ad
+(&
+¡¬t
+);
+
+170 ià(
+ grmode
+ =ð
+R\96ocInfo
+::
+CODE_TARGET
+ && !
+a¡_id
+.
+IsNÚe
+()) {
+
+171
+S\91RecÜdedA¡Id
+(
+a¡_id
+);
+
+172
+ grmode
+ =
+R\96ocInfo
+::
+CODE_TARGET_WITH_ID
+;
+
+174
+AÎowDeã¼edHªdËD\94eã»nû
+
+ gus\9ag_¿w_add»ss
+;
+
+175
+C®l
+(
+»\9a\8b½»t_ÿ¡
+<
+Add»ss
+>(
+code
+.
+loÿtiÚ
+()),
+rmode
+,
+cÚd
+);
+
+176
+DCHECK_EQ
+(
+ex³ùed_size
+,
+SizeOfCodeG\92\94©edS\9aû
+(&
+¡¬t
+));
+
+180 \1e
+ gMaüoAs£mbËr
+::
+R\91
+(
+CÚd\99iÚ
+
+cÚd
+) {
+
+181
+DCHECK
+(
+cÚd
+ =ð
+®
+);
+
+182
+bÌ
+();
+
+186 \1e
+ gMaüoAs£mbËr
+::
+DrÝ
+(\12
+couÁ
+,
+CÚd\99iÚ
+
+cÚd
+) {
+
+187
+DCHECK
+(
+cÚd
+ =ð
+®
+);
+
+188 ià(
+ gcouÁ
+ > 0) {
+
+189
+Add
+(
+¥
+, sp,
+couÁ
+ *
+kPo\9a\8brSize
+,
+r0
+);
+
+194 \1e
+ gMaüoAs£mbËr
+::
+R\91
+(\12
+drÝ
+,
+CÚd\99iÚ
+
+cÚd
+) {
+
+195
+DrÝ
+(
+drÝ
+,
+cÚd
+);
+
+196
+R\91
+(
+cÚd
+);
+
+200 \1e
+ gMaüoAs£mbËr
+::
+C®l
+(
+Lab\96
+*
+\8frg\91
+è{
+b
+Ѭg\91,
+S\91LK
+); }
+
+203 \1e
+ gMaüoAs£mbËr
+::
+Push
+(
+HªdË
+<
+Objeù
+>
+hªdË
+) {
+
+204
+mov
+(
+r0
+,
+O³¿nd
+(
+hªdË
+));
+
+205
+push
+(
+r0
+);
+
+209 \1e
+ gMaüoAs£mbËr
+::
+Move
+(
+Regi¡\94
+
+d¡
+,
+HªdË
+<
+Objeù
+>
+v®ue
+) {
+
+210
+AÎowDeã¼edHªdËD\94eã»nû
+
+ gsmi_check
+;
+
+211 ià(
+ gv®ue
+->
+IsSmi
+()) {
+
+212
+LßdSmiL\99\94®
+(
+d¡
+,
+»\9a\8b½»t_ÿ¡
+<
+Smi
+*>(*
+v®ue
+));
+
+214
+DCHECK
+(
+v®ue
+->
+IsH\97pObjeù
+());
+
+215 ià(
+isީe
+()->
+h\97p
+()->
+InNewS·û
+(*
+v®ue
+)) {
+
+216
+ gHªdË
+<
+ gC\96l
+>
+ gûÎ
+ =
+isީe
+()->
+çùÜy
+()->
+NewC\96l
+(
+v®ue
+);
+
+217
+mov
+(
+d¡
+,
+O³¿nd
+(
+ûÎ
+));
+
+218
+LßdP
+(
+d¡
+,
+F\9bldMemO³¿nd
+(d¡,
+C\96l
+::
+kV®ueOff£t
+));
+
+220
+mov
+(
+d¡
+,
+O³¿nd
+(
+v®ue
+));
+
+226 \1e
+ gMaüoAs£mbËr
+::
+Move
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+CÚd\99iÚ
+
+cÚd
+) {
+
+227
+DCHECK
+(
+cÚd
+ =ð
+®
+);
+
+228 ià(!
+ gd¡
+.
+is
+(
+¤c
+)) {
+
+229
+mr
+(
+d¡
+,
+¤c
+);
+
+234 \1e
+ gMaüoAs£mbËr
+::
+Move
+(
+DoubËRegi¡\94
+
+d¡
+, DoubËRegi¡\94
+¤c
+) {
+
+235 ià(!
+ gd¡
+.
+is
+(
+¤c
+)) {
+
+236
+fmr
+(
+d¡
+,
+¤c
+);
+
+241 \1e
+ gMaüoAs£mbËr
+::
+MuÉiPush
+(
+RegLi¡
+
+»gs
+) {
+
+242
+\9at16_t
+
+num_to_push
+ =
+Numb\94OfB\99sS\91
+(
+»gs
+);
+
+243
+\9at16_t
+
+ g¡ack_off£t
+ =
+num_to_push
+ *
+kPo\9a\8brSize
+;
+
+245
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+¡ack_off£t
+));
+
+246 \ f
+\9at16_t
+
+ gi
+ =
+kNumRegi¡\94s
+ - 1; i >= 0; i--) {
+
+247 ià((
+ g»gs
+ & (1 <<
+ gi
+)) != 0) {
+
+248
+¡ack_off£t
+ -ð
+kPo\9a\8brSize
+;
+
+249
+StÜeP
+(
+ToRegi¡\94
+(
+i
+),
+MemO³¿nd
+(
+¥
+,
+¡ack_off£t
+));
+
+255 \1e
+ gMaüoAs£mbËr
+::
+MuÉiPÝ
+(
+RegLi¡
+
+»gs
+) {
+
+256
+\9at16_t
+
+¡ack_off£t
+ = 0;
+
+258 \ f
+\9at16_t
+
+ gi
+ = 0; i <
+ gkNumRegi¡\94s
+; i++) {
+
+259 ià((
+ g»gs
+ & (1 <<
+ gi
+)) != 0) {
+
+260
+LßdP
+(
+ToRegi¡\94
+(
+i
+),
+MemO³¿nd
+(
+¥
+,
+¡ack_off£t
+));
+
+261
+ g¡ack_off£t
+ +ð
+kPo\9a\8brSize
+;
+
+264
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+¡ack_off£t
+));
+
+268 \1e
+ gMaüoAs£mbËr
+::
+LßdRoÙ
+(
+Regi¡\94
+
+de¡\9a©iÚ
+,
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+,
+
+269
+CÚd\99iÚ
+
+cÚd
+) {
+
+270
+DCHECK
+(
+cÚd
+ =ð
+®
+);
+
+271
+LßdP
+(
+de¡\9a©iÚ
+,
+MemO³¿nd
+(
+kRoÙRegi¡\94
+,
+\9adex
+ <<
+kPo\9a\8brSizeLog2
+),
+r0
+);
+
+275 \1e
+ gMaüoAs£mbËr
+::
+StÜeRoÙ
+(
+Regi¡\94
+
+sourû
+,
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+,
+
+276
+CÚd\99iÚ
+
+cÚd
+) {
+
+277
+DCHECK
+(
+cÚd
+ =ð
+®
+);
+
+278
+StÜeP
+(
+sourû
+,
+MemO³¿nd
+(
+kRoÙRegi¡\94
+,
+\9adex
+ <<
+kPo\9a\8brSizeLog2
+),
+r0
+);
+
+282 \1e
+ gMaüoAs£mbËr
+::
+InNewS·û
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch
+,
+
+283
+CÚd\99iÚ
+
+cÚd
+,
+Lab\96
+*
+b¿nch
+) {
+
+285
+DCHECK
+(
+cÚd
+ =ð
+eq
+ || cÚd =ð
+Ã
+);
+
+286
+mov
+(
+r0
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+Ãw_¥aû_mask
+(
+isީe
+())));
+
+287
+ªd_
+(
+sü©ch
+,
+objeù
+,
+r0
+);
+
+288
+mov
+(
+r0
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+Ãw_¥aû_¡¬t
+(
+isީe
+())));
+
+289
+cmp
+(
+sü©ch
+,
+r0
+);
+
+290
+b
+(
+cÚd
+,
+b¿nch
+);
+
+294 \1e
+ gMaüoAs£mbËr
+::
+RecÜdWr\99eF\9bld
+(
+
+295
+Regi¡\94
+
+objeù
+, \12
+off£t
+, Regi¡\94
+v®ue
+, Regi¡\94
+d¡
+,
+
+296
+L\9akRegi¡\94S\8ftus
+
+Ì_¡©us
+,
+SaveFPRegsMode
+
+§ve_å
+,
+
+297
+Rememb\94edS\91AùiÚ
+
+»memb\94ed_£t_aùiÚ
+,
+SmiCheck
+
+smi_check
+,
+
+298
+Po\9a\8brsToH\94eCheck
+
+po\9a\8brs_to_h\94e_check_fÜ_v®ue
+) {
+
+301
+Lab\96
+
+ gdÚe
+;
+
+304 ià(
+ gsmi_check
+ =ð
+INLINE_SMI_CHECK
+) {
+
+305
+JumpIfSmi
+(
+v®ue
+, &
+dÚe
+);
+
+310
+DCHECK
+(
+IsAligÃd
+(
+off£t
+,
+kPo\9a\8brSize
+));
+
+312
+Add
+(
+d¡
+,
+objeù
+,
+off£t
+ -
+kH\97pObjeùTag
+,
+r0
+);
+
+313 ià(
+em\99_debug_code
+()) {
+
+314
+Lab\96
+
+ gok
+;
+
+315
+ªdi
+(
+r0
+,
+d¡
+,
+O³¿nd
+((1 <<
+kPo\9a\8brSizeLog2
+) - 1));
+
+316
+beq
+(&
+ok
+,
+ü0
+);
+
+317
+¡Ý
+("Unaligned cell in write barrier");
+
+318
+b\9ad
+(&
+ok
+);
+
+321
+RecÜdWr\99e
+(
+objeù
+,
+d¡
+,
+v®ue
+,
+Ì_¡©us
+,
+§ve_å
+,
+»memb\94ed_£t_aùiÚ
+,
+
+322
+OMIT_SMI_CHECK
+,
+po\9a\8brs_to_h\94e_check_fÜ_v®ue
+);
+
+324
+b\9ad
+(&
+dÚe
+);
+
+328 ià(
+em\99_debug_code
+()) {
+
+329
+mov
+(
+v®ue
+,
+O³¿nd
+(
+b\99_ÿ¡
+<
+\9a\8d\8c_t
+>(
+kZV®ue
+ + 4)));
+
+330
+mov
+(
+d¡
+,
+O³¿nd
+(
+b\99_ÿ¡
+<
+\9a\8d\8c_t
+>(
+kZV®ue
+ + 8)));
+
+337 \1e
+ gMaüoAs£mbËr
+::
+RecÜdWr\99eFÜM
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+m
+,
+
+338
+Regi¡\94
+
+d¡
+,
+
+339
+L\9akRegi¡\94S\8ftus
+
+Ì_¡©us
+,
+
+340
+SaveFPRegsMode
+
+å_mode
+) {
+
+341 ià(
+em\99_debug_code
+()) {
+
+342
+LßdP
+(
+d¡
+,
+F\9bldMemO³¿nd
+(
+m
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+343
+Cmpi
+(
+d¡
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+m\91a_m
+()),
+r0
+);
+
+344
+Check
+(
+eq
+,
+kWrÚgAdd»ssOrV®uePas£dToRecÜdWr\99e
+);
+
+347 ià(!
+ gFLAG_\9aüem\92\8fl_m¬k\9ag
+) {
+
+351 ià(
+em\99_debug_code
+()) {
+
+352
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+353
+cmp
+(
+\9d
+,
+m
+);
+
+354
+Check
+(
+eq
+,
+kWrÚgAdd»ssOrV®uePas£dToRecÜdWr\99e
+);
+
+357
+Lab\96
+
+ gdÚe
+;
+
+363
+CheckPageFÏg
+(
+m
+,
+
+364
+m
+,
+
+365
+MemÜyChunk
+::
+kPo\9a\8brsToH\94eA»IÁ\94e¡\9agMask
+,
+eq
+, &
+dÚe
+);
+
+367
+addi
+(
+d¡
+,
+objeù
+,
+O³¿nd
+(
+H\97pObjeù
+::
+kMOff£t
+ -
+kH\97pObjeùTag
+));
+
+368 ià(
+em\99_debug_code
+()) {
+
+369
+Lab\96
+
+ gok
+;
+
+370
+ªdi
+(
+r0
+,
+d¡
+,
+O³¿nd
+((1 <<
+kPo\9a\8brSizeLog2
+) - 1));
+
+371
+beq
+(&
+ok
+,
+ü0
+);
+
+372
+¡Ý
+("Unaligned cell in write barrier");
+
+373
+b\9ad
+(&
+ok
+);
+
+377 ià(
+ gÌ_¡©us
+ =ð
+kLRHasNÙB\93nSaved
+) {
+
+378
+mær
+(
+r0
+);
+
+379
+push
+(
+r0
+);
+
+381
+RecÜdWr\99eStub
+
+¡ub
+(
+isީe
+(),
+objeù
+,
+m
+,
+d¡
+,
+OMIT_REMEMBERED_SET
+,
+
+382
+å_mode
+);
+
+383
+C®lStub
+(&
+¡ub
+);
+
+384 ià(
+ gÌ_¡©us
+ =ð
+kLRHasNÙB\93nSaved
+) {
+
+385
+pÝ
+(
+r0
+);
+
+386
+m\8er
+(
+r0
+);
+
+389
+b\9ad
+(&
+dÚe
+);
+
+392
+isީe
+()->
+couÁ\94s
+()->
+wr\99e_b¬r\9brs_¡©ic
+()->
+Inüem\92t
+();
+
+393
+Inüem\92tCouÁ\94
+(
+isީe
+()->
+couÁ\94s
+()->
+wr\99e_b¬r\9brs_dyÇmic
+(), 1,
+\9d
+,
+d¡
+);
+
+397 ià(
+em\99_debug_code
+()) {
+
+398
+mov
+(
+d¡
+,
+O³¿nd
+(
+b\99_ÿ¡
+<
+\9a\8d\8c_t
+>(
+kZV®ue
+ + 12)));
+
+399
+mov
+(
+m
+,
+O³¿nd
+(
+b\99_ÿ¡
+<
+\9a\8d\8c_t
+>(
+kZV®ue
+ + 16)));
+
+407 \1e
+ gMaüoAs£mbËr
+::
+RecÜdWr\99e
+(
+
+408
+Regi¡\94
+
+objeù
+, Regi¡\94
+add»ss
+, Regi¡\94
+v®ue
+,
+
+409
+L\9akRegi¡\94S\8ftus
+
+Ì_¡©us
+,
+SaveFPRegsMode
+
+å_mode
+,
+
+410
+Rememb\94edS\91AùiÚ
+
+»memb\94ed_£t_aùiÚ
+,
+SmiCheck
+
+smi_check
+,
+
+411
+Po\9a\8brsToH\94eCheck
+
+po\9a\8brs_to_h\94e_check_fÜ_v®ue
+) {
+
+412
+DCHECK
+(!
+objeù
+.
+is
+(
+v®ue
+));
+
+413 ià(
+em\99_debug_code
+()) {
+
+414
+LßdP
+(
+r0
+,
+MemO³¿nd
+(
+add»ss
+));
+
+415
+cmp
+(
+r0
+,
+v®ue
+);
+
+416
+Check
+(
+eq
+,
+kWrÚgAdd»ssOrV®uePas£dToRecÜdWr\99e
+);
+
+419 ià(
+ g»memb\94ed_£t_aùiÚ
+ =ð
+OMIT_REMEMBERED_SET
+ &&
+
+420 !
+FLAG_\9aüem\92\8fl_m¬k\9ag
+) {
+
+426
+Lab\96
+
+ gdÚe
+;
+
+428 ià(
+ gsmi_check
+ =ð
+INLINE_SMI_CHECK
+) {
+
+429
+JumpIfSmi
+(
+v®ue
+, &
+dÚe
+);
+
+432 ià(
+ gpo\9a\8brs_to_h\94e_check_fÜ_v®ue
+ !ð
+kPo\9a\8brsToH\94eA»AlwaysIÁ\94e¡\9ag
+) {
+
+433
+CheckPageFÏg
+(
+v®ue
+,
+
+434
+v®ue
+,
+
+435
+MemÜyChunk
+::
+kPo\9a\8brsToH\94eA»IÁ\94e¡\9agMask
+,
+eq
+, &
+dÚe
+);
+
+437
+CheckPageFÏg
+(
+objeù
+,
+
+438
+v®ue
+,
+
+439
+MemÜyChunk
+::
+kPo\9a\8brsFromH\94eA»IÁ\94e¡\9agMask
+,
+eq
+, &
+dÚe
+);
+
+442 ià(
+ gÌ_¡©us
+ =ð
+kLRHasNÙB\93nSaved
+) {
+
+443
+mær
+(
+r0
+);
+
+444
+push
+(
+r0
+);
+
+446
+RecÜdWr\99eStub
+
+¡ub
+(
+isީe
+(),
+objeù
+,
+v®ue
+,
+add»ss
+,
+»memb\94ed_£t_aùiÚ
+,
+
+447
+å_mode
+);
+
+448
+C®lStub
+(&
+¡ub
+);
+
+449 ià(
+ gÌ_¡©us
+ =ð
+kLRHasNÙB\93nSaved
+) {
+
+450
+pÝ
+(
+r0
+);
+
+451
+m\8er
+(
+r0
+);
+
+454
+b\9ad
+(&
+dÚe
+);
+
+457
+isީe
+()->
+couÁ\94s
+()->
+wr\99e_b¬r\9brs_¡©ic
+()->
+Inüem\92t
+();
+
+458
+Inüem\92tCouÁ\94
+(
+isީe
+()->
+couÁ\94s
+()->
+wr\99e_b¬r\9brs_dyÇmic
+(), 1,
+\9d
+,
+
+459
+v®ue
+);
+
+463 ià(
+em\99_debug_code
+()) {
+
+464
+mov
+(
+add»ss
+,
+O³¿nd
+(
+b\99_ÿ¡
+<
+\9a\8d\8c_t
+>(
+kZV®ue
+ + 12)));
+
+465
+mov
+(
+v®ue
+,
+O³¿nd
+(
+b\99_ÿ¡
+<
+\9a\8d\8c_t
+>(
+kZV®ue
+ + 16)));
+
+470 \1e
+ gMaüoAs£mbËr
+::
+Rememb\94edS\91H\96³r
+(
+Regi¡\94
+
+objeù
+,
+
+471
+Regi¡\94
+
+add»ss
+, Regi¡\94
+sü©ch
+,
+
+472
+SaveFPRegsMode
+
+å_mode
+,
+
+473
+Rememb\94edS\91F\9a®AùiÚ
+
+ªd_th\92
+) {
+
+474
+Lab\96
+
+ gdÚe
+;
+
+475 ià(
+em\99_debug_code
+()) {
+
+476
+Lab\96
+
+ gok
+;
+
+477
+JumpIfNÙInNewS·û
+(
+objeù
+,
+sü©ch
+, &
+ok
+);
+
+478
+¡Ý
+("Remembered set\85ointer is in\82ew space");
+
+479
+b\9ad
+(&
+ok
+);
+
+482
+Ex\8bº®Reã»nû
+
+ g¡Üe_bufãr
+ =
+
+483
+Ex\8bº®Reã»nû
+::
+¡Üe_bufãr_tÝ
+(
+isީe
+());
+
+484
+mov
+(
+\9d
+,
+O³¿nd
+(
+¡Üe_bufãr
+));
+
+485
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(
+\9d
+));
+
+487
+StÜeP
+(
+add»ss
+,
+MemO³¿nd
+(
+sü©ch
+));
+
+488
+addi
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+490
+StÜeP
+(
+sü©ch
+,
+MemO³¿nd
+(
+\9d
+));
+
+493
+mov
+(
+r0
+,
+O³¿nd
+(
+StÜeBufãr
+::
+kStÜeBufãrOv\94æowB\99
+));
+
+494
+ªd_
+(
+r0
+,
+sü©ch
+,\840,
+S\91RC
+);
+
+496 ià(
+ gªd_th\92
+ =ð
+kF®lThroughAtEnd
+) {
+
+497
+beq
+(&
+dÚe
+,
+ü0
+);
+
+499
+DCHECK
+(
+ªd_th\92
+ =ð
+kR\91uºAtEnd
+);
+
+500
+beq
+(&
+dÚe
+,
+ü0
+);
+
+502
+mær
+(
+r0
+);
+
+503
+push
+(
+r0
+);
+
+504
+StÜeBufãrOv\94æowStub
+
+¡Üe_bufãr_ov\94æow
+(
+isީe
+(),
+å_mode
+);
+
+505
+C®lStub
+(&
+¡Üe_bufãr_ov\94æow
+);
+
+506
+pÝ
+(
+r0
+);
+
+507
+m\8er
+(
+r0
+);
+
+508
+b\9ad
+(&
+dÚe
+);
+
+509 ià(
+ gªd_th\92
+ =ð
+kR\91uºAtEnd
+) {
+
+510
+R\91
+();
+
+515 \1e
+ gMaüoAs£mbËr
+::
+PushFixedF¿me
+(
+Regi¡\94
+
+m¬k\94_»g
+) {
+
+516
+mær
+(
+r0
+);
+
+517 #ià
+V8_OOL_CONSTANT_POOL
+
+
+518 ià(
+ gm¬k\94_»g
+.
+is_v®id
+()) {
+
+519
+Push
+(
+r0
+,
+å
+,
+kCÚ¡ªtPoÞRegi¡\94
+,
+ý
+,
+m¬k\94_»g
+);
+
+521
+Push
+(
+r0
+,
+å
+,
+kCÚ¡ªtPoÞRegi¡\94
+,
+ý
+);
+
+524 ià(
+ gm¬k\94_»g
+.
+is_v®id
+()) {
+
+525
+Push
+(
+r0
+,
+å
+,
+ý
+,
+m¬k\94_»g
+);
+
+527
+Push
+(
+r0
+,
+å
+,
+ý
+);
+
+533 \1e
+ gMaüoAs£mbËr
+::
+PÝFixedF¿me
+(
+Regi¡\94
+
+m¬k\94_»g
+) {
+
+534 #ià
+V8_OOL_CONSTANT_POOL
+
+
+535 ià(
+m¬k\94_»g
+.
+is_v®id
+()) {
+
+536
+PÝ
+(
+r0
+,
+å
+,
+kCÚ¡ªtPoÞRegi¡\94
+,
+ý
+,
+m¬k\94_»g
+);
+
+538
+PÝ
+(
+r0
+,
+å
+,
+kCÚ¡ªtPoÞRegi¡\94
+,
+ý
+);
+
+541 ià(
+ gm¬k\94_»g
+.
+is_v®id
+()) {
+
+542
+PÝ
+(
+r0
+,
+å
+,
+ý
+,
+m¬k\94_»g
+);
+
+544
+PÝ
+(
+r0
+,
+å
+,
+ý
+);
+
+547
+m\8er
+(
+r0
+);
+
+552 \1e
+ gMaüoAs£mbËr
+::
+PushSaãpo\9atRegi¡\94s
+() {
+
+555 cڡ \12
+num_un§ved
+ =
+kNumSaãpo\9atRegi¡\94s
+ -
+kNumSaãpo\9atSavedRegi¡\94s
+;
+
+556
+DCHECK
+(
+num_un§ved
+ >= 0);
+
+557 ià(
+ gnum_un§ved
+ > 0) {
+
+558
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+num_un§ved
+ *
+kPo\9a\8brSize
+));
+
+560
+MuÉiPush
+(
+kSaãpo\9atSavedRegi¡\94s
+);
+
+564 \1e
+ gMaüoAs£mbËr
+::
+PÝSaãpo\9atRegi¡\94s
+() {
+
+565 cڡ \12
+num_un§ved
+ =
+kNumSaãpo\9atRegi¡\94s
+ -
+kNumSaãpo\9atSavedRegi¡\94s
+;
+
+566
+MuÉiPÝ
+(
+kSaãpo\9atSavedRegi¡\94s
+);
+
+567 ià(
+ gnum_un§ved
+ > 0) {
+
+568
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+num_un§ved
+ *
+kPo\9a\8brSize
+));
+
+573 \1e
+ gMaüoAs£mbËr
+::
+StÜeToSaãpo\9atRegi¡\94SlÙ
+(
+Regi¡\94
+
+¤c
+, Regi¡\94
+d¡
+) {
+
+574
+StÜeP
+(
+¤c
+,
+Saãpo\9atRegi¡\94SlÙ
+(
+d¡
+));
+
+578 \1e
+ gMaüoAs£mbËr
+::
+LßdFromSaãpo\9atRegi¡\94SlÙ
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+) {
+
+579
+LßdP
+(
+d¡
+,
+Saãpo\9atRegi¡\94SlÙ
+(
+¤c
+));
+
+583 \12
+ gMaüoAs£mbËr
+::
+Saãpo\9atRegi¡\94S\8fckIndex
+(\12
+»g_code
+) {
+
+586
+RegLi¡
+
+»gs
+ =
+kSaãpo\9atSavedRegi¡\94s
+;
+
+587 \12
+ g\9adex
+ = 0;
+
+589
+DCHECK
+(
+»g_code
+ >ð0 &&\84eg_cod\90<
+kNumRegi¡\94s
+);
+
+591 \ f
+\9at16_t
+
+ gi
+ = 0; i <
+ g»g_code
+; i++) {
+
+592 ià((
+ g»gs
+ & (1 <<
+ gi
+)) != 0) {
+
+593
+\9adex
+++;
+
+597 \15
+ g\9adex
+;
+
+601
+MemO³¿nd
+
+ gMaüoAs£mbËr
+::
+Saãpo\9atRegi¡\94SlÙ
+(
+Regi¡\94
+
+»g
+) {
+
+602 \15
+MemO³¿nd
+(
+¥
+,
+Saãpo\9atRegi¡\94S\8fckIndex
+(
+»g
+.
+code
+()è*
+kPo\9a\8brSize
+);
+
+606
+MemO³¿nd
+
+ gMaüoAs£mbËr
+::
+Saãpo\9atRegi¡\94sAndDoubËsSlÙ
+(
+Regi¡\94
+
+»g
+) {
+
+608 \12
+doubËs_size
+ =
+DoubËRegi¡\94
+::
+NumAÎoÿ\8fbËRegi¡\94s
+(è*
+kDoubËSize
+;
+
+609 \12
+ g»gi¡\94_off£t
+ =
+Saãpo\9atRegi¡\94S\8fckIndex
+(
+»g
+.
+code
+()è*
+kPo\9a\8brSize
+;
+
+610 \15
+MemO³¿nd
+(
+¥
+,
+doubËs_size
+ +
+»gi¡\94_off£t
+);
+
+614 \1e
+ gMaüoAs£mbËr
+::
+CªÚiÿlizeNaN
+(cڡ
+DoubËRegi¡\94
+
+d¡
+,
+
+615 cڡ
+DoubËRegi¡\94
+
+¤c
+) {
+
+616
+Lab\96
+
+ gdÚe
+;
+
+619
+fcmpu
+(
+¤c
+, src);
+
+621 ià(
+ gd¡
+.
+is
+(
+¤c
+)) {
+
+622
+bÜd\94ed
+(&
+dÚe
+);
+
+624
+Lab\96
+
+ gis_Çn
+;
+
+625
+bunÜd\94ed
+(&
+is_Çn
+);
+
+626
+fmr
+(
+d¡
+,
+¤c
+);
+
+627
+b
+(&
+dÚe
+);
+
+628
+b\9ad
+(&
+is_Çn
+);
+
+632 \b
+ gÇn_v®ue
+ =
+FixedDoubËA¼ay
+::
+ÿnÚiÿl_nÙ_the_hÞe_Çn_as_doubË
+();
+
+633
+LßdDoubËL\99\94®
+(
+d¡
+,
+Çn_v®ue
+,
+r0
+);
+
+635
+b\9ad
+(&
+dÚe
+);
+
+639 \1e
+ gMaüoAs£mbËr
+::
+CÚv\94tIÁToDoubË
+(
+Regi¡\94
+
+¤c
+,
+
+640
+DoubËRegi¡\94
+
+doubË_d¡
+) {
+
+641
+MovIÁToDoubË
+(
+doubË_d¡
+,
+¤c
+,
+r0
+);
+
+642
+fcfid
+(
+doubË_d¡
+, double_dst);
+
+646 \1e
+ gMaüoAs£mbËr
+::
+CÚv\94tUnsigÃdIÁToDoubË
+(
+Regi¡\94
+
+¤c
+,
+
+647
+DoubËRegi¡\94
+
+doubË_d¡
+) {
+
+648
+MovUnsigÃdIÁToDoubË
+(
+doubË_d¡
+,
+¤c
+,
+r0
+);
+
+649
+fcfid
+(
+doubË_d¡
+, double_dst);
+
+653 \1e
+ gMaüoAs£mbËr
+::
+CÚv\94tIÁToFlßt
+(cڡ
+DoubËRegi¡\94
+
+d¡
+,
+
+654 cڡ
+Regi¡\94
+
+¤c
+,
+
+655 cڡ
+Regi¡\94
+
+\9at_sü©ch
+) {
+
+656
+MovIÁToDoubË
+(
+d¡
+,
+¤c
+,
+\9at_sü©ch
+);
+
+657
+fcfid
+(
+d¡
+, dst);
+
+658
+ä¥
+(
+d¡
+, dst);
+
+662 \1e
+ gMaüoAs£mbËr
+::
+CÚv\94tDoubËToIÁ64
+(cڡ
+DoubËRegi¡\94
+
+doubË_\9aput
+,
+
+663 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+664 cڡ
+Regi¡\94
+
+d¡_hi
+,
+
+666 cڡ
+Regi¡\94
+
+d¡
+,
+
+667 cڡ
+DoubËRegi¡\94
+
+doubË_d¡
+,
+
+668
+FPRound\9agMode
+
+round\9ag_mode
+) {
+
+669 ià(
+ ground\9ag_mode
+ =ð
+kRoundToZ\94o
+) {
+
+670
+fùidz
+(
+doubË_d¡
+,
+doubË_\9aput
+);
+
+672
+S\91Round\9agMode
+(
+round\9ag_mode
+);
+
+673
+fùid
+(
+doubË_d¡
+,
+doubË_\9aput
+);
+
+674
+Re£tRound\9agMode
+();
+
+677
+MovDoubËToIÁ64
+(
+
+678 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+679
+d¡_hi
+,
+
+681
+d¡
+,
+doubË_d¡
+);
+
+685 #ià
+V8_OOL_CONSTANT_POOL
+
+
+686 \1e
+ gMaüoAs£mbËr
+::
+LßdCÚ¡ªtPoÞPo\9a\8brRegi¡\94
+(
+
+687
+CodeObjeùAcûssM\91hod
+
+acûss_m\91hod
+, \12
+\9d_code_\92\8cy_d\96\8f
+) {
+
+688
+Regi¡\94
+
+ gba£
+;
+
+689 \12
+ gcÚ¡ªt_poÞ_off£t
+ =
+Code
+::
+kCÚ¡ªtPoÞOff£t
+ - Code::
+kH\97d\94Size
+;
+
+690 ià(
+ gacûss_m\91hod
+ =ð
+CAN_USE_IP
+) {
+
+691
+ba£
+ =
+\9d
+;
+
+692
+ gcÚ¡ªt_poÞ_off£t
+ +ð
+\9d_code_\92\8cy_d\96\8f
+;
+
+694
+DCHECK
+(
+acûss_m\91hod
+ =ð
+CONSTRUCT_INTERNAL_REFERENCE
+);
+
+695
+ gba£
+ =
+kCÚ¡ªtPoÞRegi¡\94
+;
+
+696
+CÚ¡ªtPoÞUÇva\9eabËScÝe
+
+cÚ¡ªt_poÞ_uÇva\9eabË
+(
+this
+);
+
+700
+Ensu»S·ûFÜ
+(
+kMovIn¡ruùiÚsNoCÚ¡ªtPoÞ
+ *
+kIn¡rSize
+);
+
+702
+u\9a\8d\8c_t
+
+ gcode_¡¬t
+ =
+»\9a\8b½»t_ÿ¡
+<u\9a\8d\8c_t>(
+pc_
+è-
+pc_off£t
+();
+
+703
+mov
+(
+ba£
+,
+O³¿nd
+(
+code_¡¬t
+,
+R\96ocInfo
+::
+INTERNAL_REFERENCE
+));
+
+705
+LßdP
+(
+kCÚ¡ªtPoÞRegi¡\94
+,
+MemO³¿nd
+(
+ba£
+,
+cÚ¡ªt_poÞ_off£t
+));
+
+710 \1e
+ gMaüoAs£mbËr
+::
+StubPrÞogue
+(\12
+´Þogue_off£t
+) {
+
+711
+LßdSmiL\99\94®
+(
+r11
+,
+Smi
+::
+FromIÁ
+(
+S\8fckF¿me
+::
+STUB
+));
+
+712
+PushFixedF¿me
+(
+r11
+);
+
+714
+addi
+(
+å
+,
+¥
+,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSizeFromFp
+));
+
+715 #ià
+V8_OOL_CONSTANT_POOL
+
+
+717
+LßdCÚ¡ªtPoÞPo\9a\8brRegi¡\94
+(
+CAN_USE_IP
+, -
+´Þogue_off£t
+);
+
+718
+£t_oÞ_cÚ¡ªt_poÞ_ava\9eabË
+(
+\8cue
+);
+
+723 \1e
+ gMaüoAs£mbËr
+::
+PrÞogue
+(
+boÞ
+
+code_´e_ag\9ag
+, \12
+´Þogue_off£t
+) {
+
+725
+P»diùabËCodeSizeScÝe
+
+´ediùibË_code_size_scÝe
+(
+
+726
+this
+,
+kNoCodeAgeSequ\92ûL\92gth
+);
+
+727
+ gAs£mbËr
+::
+BlockT¿mpÞ\9aePoÞScÝe
+
+block_\8campÞ\9ae_poÞ
+(
+this
+);
+
+730 ià(
+ gcode_´e_ag\9ag
+) {
+
+733
+Code
+*
+ g¡ub
+ = Code::
+G\91P»AgedCodeAgeStub
+(
+isީe
+());
+
+734
+\9a\8d\8c_t
+
+ g\8frg\91
+ =
+»\9a\8b½»t_ÿ¡
+<\9a\8d\8c_t>(
+¡ub
+->
+\9a¡ruùiÚ_¡¬t
+());
+
+736
+nÝ
+();
+
+737
+mov
+(
+r3
+,
+O³¿nd
+(
+\8frg\91
+));
+
+738
+Jump
+(
+r3
+);
+
+739 \ f\12
+ gi
+ = 0; i <
+ gkCodeAg\9agSequ\92ûNÝs
+; i++) {
+
+740
+nÝ
+();
+
+744
+PushFixedF¿me
+(
+r4
+);
+
+746
+addi
+(
+å
+,
+¥
+,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSizeFromFp
+));
+
+747 \ f\12
+ gi
+ = 0; i <
+ gkNoCodeAgeSequ\92ûNÝs
+; i++) {
+
+748
+nÝ
+();
+
+752 #ià
+V8_OOL_CONSTANT_POOL
+
+
+754
+LßdCÚ¡ªtPoÞPo\9a\8brRegi¡\94
+(
+CAN_USE_IP
+, -
+´Þogue_off£t
+);
+
+755
+£t_oÞ_cÚ¡ªt_poÞ_ava\9eabË
+(
+\8cue
+);
+
+760 \1e
+ gMaüoAs£mbËr
+::
+EÁ\94F¿me
+(
+S\8fckF¿me
+::
+Ty³
+
+ty³
+,
+
+761
+boÞ
+
+lßd_cÚ¡ªt_poÞ_po\9a\8br_»g
+) {
+
+762 ià(
+ gFLAG_\92abË_oÞ_cÚ¡ªt_poÞ
+ &&
+ glßd_cÚ¡ªt_poÞ_po\9a\8br_»g
+) {
+
+763
+PushFixedF¿me
+();
+
+764 #ià
+V8_OOL_CONSTANT_POOL
+
+
+766
+LßdCÚ¡ªtPoÞPo\9a\8brRegi¡\94
+(
+CONSTRUCT_INTERNAL_REFERENCE
+);
+
+768
+LßdSmiL\99\94®
+(
+\9d
+,
+Smi
+::
+FromIÁ
+(
+ty³
+));
+
+769
+push
+(
+\9d
+);
+
+771
+LßdSmiL\99\94®
+(
+\9d
+,
+Smi
+::
+FromIÁ
+(
+ty³
+));
+
+772
+PushFixedF¿me
+(
+\9d
+);
+
+775
+addi
+(
+å
+,
+¥
+,
+O³¿nd
+(
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kFixedF¿meSizeFromFp
+));
+
+777
+mov
+(
+r0
+,
+O³¿nd
+(
+CodeObjeù
+()));
+
+778
+push
+(
+r0
+);
+
+782 \12
+ gMaüoAs£mbËr
+::
+L\97veF¿me
+(
+S\8fckF¿me
+::
+Ty³
+
+ty³
+, \12
+¡ack_adju¡m\92t
+) {
+
+783 #ià
+V8_OOL_CONSTANT_POOL
+
+
+784
+CÚ¡ªtPoÞUÇva\9eabËScÝe
+
+cÚ¡ªt_poÞ_uÇva\9eabË
+(
+this
+);
+
+792 \12
+ gäame_\92ds
+;
+
+793
+LßdP
+(
+r0
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrPCOff£t
+));
+
+794
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+));
+
+795 #ià
+V8_OOL_CONSTANT_POOL
+
+
+796 cڡ \12
+ gex\99Off£t
+ =
+Ex\99F¿meCÚ¡ªts
+::
+kCÚ¡ªtPoÞOff£t
+;
+
+797 cڡ \12
+ g¡ªd¬dOff£t
+ =
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ¡ªtPoÞOff£t
+;
+
+798 cڡ \12
+ goff£t
+ = ((
+ty³
+ =ð
+S\8fckF¿me
+::
+EXIT
+è?
+ex\99Off£t
+ :
+¡ªd¬dOff£t
+);
+
+799
+LßdP
+(
+kCÚ¡ªtPoÞRegi¡\94
+,
+MemO³¿nd
+(
+å
+,
+off£t
+));
+
+801
+m\8er
+(
+r0
+);
+
+802
+ gäame_\92ds
+ =
+pc_off£t
+();
+
+803
+Add
+(
+¥
+,
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kC®ËrSPOff£t
+ +
+¡ack_adju¡m\92t
+,
+r0
+);
+
+804
+mr
+(
+å
+,
+\9d
+);
+
+805 \15
+ gäame_\92ds
+;
+
+825 \1e
+ gMaüoAs£mbËr
+::
+EÁ\94Ex\99F¿me
+(
+boÞ
+
+§ve_doubËs
+, \12
+¡ack_¥aû
+) {
+
+827
+DCHECK_EQ
+(2 *
+kPo\9a\8brSize
+,
+Ex\99F¿meCÚ¡ªts
+::
+kC®ËrSPDi¥Ïûm\92t
+);
+
+828
+DCHECK_EQ
+(1 *
+kPo\9a\8brSize
+,
+Ex\99F¿meCÚ¡ªts
+::
+kC®ËrPCOff£t
+);
+
+829
+DCHECK_EQ
+(0 *
+kPo\9a\8brSize
+,
+Ex\99F¿meCÚ¡ªts
+::
+kC®ËrFPOff£t
+);
+
+830
+DCHECK
+(
+¡ack_¥aû
+ > 0);
+
+837
+mær
+(
+r0
+);
+
+838
+Push
+(
+r0
+,
+å
+);
+
+839
+mr
+(
+å
+,
+¥
+);
+
+841
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+Ex\99F¿meCÚ¡ªts
+::
+kF¿meSize
+));
+
+843 ià(
+em\99_debug_code
+()) {
+
+844
+li
+(
+r8
+,
+O³¿nd
+::
+Z\94o
+());
+
+845
+StÜeP
+(
+r8
+,
+MemO³¿nd
+(
+å
+,
+Ex\99F¿meCÚ¡ªts
+::
+kSPOff£t
+));
+
+847 #ià
+V8_OOL_CONSTANT_POOL
+
+
+848
+StÜeP
+(
+kCÚ¡ªtPoÞRegi¡\94
+,
+
+849
+MemO³¿nd
+(
+å
+,
+Ex\99F¿meCÚ¡ªts
+::
+kCÚ¡ªtPoÞOff£t
+));
+
+851
+mov
+(
+r8
+,
+O³¿nd
+(
+CodeObjeù
+()));
+
+852
+StÜeP
+(
+r8
+,
+MemO³¿nd
+(
+å
+,
+Ex\99F¿meCÚ¡ªts
+::
+kCodeOff£t
+));
+
+855
+mov
+(
+r8
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kCEÁryFPAdd»ss
+,
+isީe
+())));
+
+856
+StÜeP
+(
+å
+,
+MemO³¿nd
+(
+r8
+));
+
+857
+mov
+(
+r8
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kCÚ\8bxtAdd»ss
+,
+isީe
+())));
+
+858
+StÜeP
+(
+ý
+,
+MemO³¿nd
+(
+r8
+));
+
+861 ià(
+ g§ve_doubËs
+) {
+
+862
+SaveFPRegs
+(
+¥
+, 0,
+DoubËRegi¡\94
+::
+kNumVÞ©\9eeRegi¡\94s
+);
+
+869
+addi
+(
+¥
+, sp,
+O³¿nd
+(-
+¡ack_¥aû
+ *
+kPo\9a\8brSize
+));
+
+873 cڡ \12
+ gäame_®ignm\92t
+ =
+Aùiv©iÚF¿meAlignm\92t
+();
+
+874 ià(
+ gäame_®ignm\92t
+ >
+ gkPo\9a\8brSize
+) {
+
+875
+DCHECK
+(
+ba£
+::
+b\99s
+::
+IsPow\94OfTwo32
+(
+äame_®ignm\92t
+));
+
+876
+CˬRightImm
+(
+¥
+, sp,
+O³¿nd
+(
+WhichPow\94Of2
+(
+äame_®ignm\92t
+)));
+
+878
+li
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+879
+StÜePU
+(
+r0
+,
+MemO³¿nd
+(
+¥
+, -
+kNumRequ\9cedS\8fckF¿meSlÙs
+ *
+kPo\9a\8brSize
+));
+
+883
+addi
+(
+r8
+,
+¥
+,
+O³¿nd
+((
+kS\8fckF¿meEx\8caP¬amSlÙ
+ + 1è*
+kPo\9a\8brSize
+));
+
+884
+StÜeP
+(
+r8
+,
+MemO³¿nd
+(
+å
+,
+Ex\99F¿meCÚ¡ªts
+::
+kSPOff£t
+));
+
+888 \1e
+ gMaüoAs£mbËr
+::
+In\99\9flizeNewS\8c\9ag
+(
+Regi¡\94
+
+¡r\9ag
+, Regi¡\94
+Ëngth
+,
+
+889
+H\97p
+::
+RoÙLi¡Index
+
+m_\9adex
+,
+
+890
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+) {
+
+891
+SmiTag
+(
+sü©ch1
+,
+Ëngth
+);
+
+892
+LßdRoÙ
+(
+sü©ch2
+,
+m_\9adex
+);
+
+893
+StÜeP
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+),
+r0
+);
+
+894
+li
+(
+sü©ch1
+,
+O³¿nd
+(
+S\8c\9ag
+::
+kEm±yHashF\9bld
+));
+
+895
+StÜeP
+(
+sü©ch2
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+H\97pObjeù
+::
+kMOff£t
+),
+r0
+);
+
+896
+StÜeP
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+S\8c\9ag
+::
+kHashF\9bldSlÙ
+),
+r0
+);
+
+900 \12
+ gMaüoAs£mbËr
+::
+Aùiv©iÚF¿meAlignm\92t
+() {
+
+901 #ià!
+def\9aed
+(
+USE_SIMULATOR
+)
+
+906 \15
+ba£
+::
+OS
+::
+Aùiv©iÚF¿meAlignm\92t
+();
+
+912 \15
+ gFLAG_sim_¡ack_®ignm\92t
+;
+
+917 \1e
+ gMaüoAs£mbËr
+::
+L\97veEx\99F¿me
+(
+boÞ
+
+§ve_doubËs
+,
+Regi¡\94
+
+¬gum\92t_couÁ
+,
+
+918
+boÞ
+
+»¡Üe_cÚ\8bxt
+) {
+
+919 #ià
+V8_OOL_CONSTANT_POOL
+
+
+920
+CÚ¡ªtPoÞUÇva\9eabËScÝe
+
+cÚ¡ªt_poÞ_uÇva\9eabË
+(
+this
+);
+
+923 ià(
+ g§ve_doubËs
+) {
+
+925 cڡ \12
+ gkNumRegs
+ =
+DoubËRegi¡\94
+::
+kNumVÞ©\9eeRegi¡\94s
+;
+
+926 cڡ \12
+ goff£t
+ =
+
+927 (
+Ex\99F¿meCÚ¡ªts
+::
+kF¿meSize
+ +
+kNumRegs
+ *
+kDoubËSize
+);
+
+928
+addi
+(
+r6
+,
+å
+,
+O³¿nd
+(-
+off£t
+));
+
+929
+Re¡ÜeFPRegs
+(
+r6
+, 0,
+kNumRegs
+);
+
+933
+li
+(
+r6
+,
+O³¿nd
+::
+Z\94o
+());
+
+934
+mov
+(
+\9d
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kCEÁryFPAdd»ss
+,
+isީe
+())));
+
+935
+StÜeP
+(
+r6
+,
+MemO³¿nd
+(
+\9d
+));
+
+938 ià(
+ g»¡Üe_cÚ\8bxt
+) {
+
+939
+mov
+(
+\9d
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kCÚ\8bxtAdd»ss
+,
+isީe
+())));
+
+940
+LßdP
+(
+ý
+,
+MemO³¿nd
+(
+\9d
+));
+
+942 #ifdeà
+DEBUG
+
+
+943
+mov
+(
+\9d
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kCÚ\8bxtAdd»ss
+,
+isީe
+())));
+
+944
+StÜeP
+(
+r6
+,
+MemO³¿nd
+(
+\9d
+));
+
+948
+L\97veF¿me
+(
+S\8fckF¿me
+::
+EXIT
+);
+
+950 ià(
+ g¬gum\92t_couÁ
+.
+is_v®id
+()) {
+
+951
+ShiáLeáImm
+(
+¬gum\92t_couÁ
+,\87rgum\92t_couÁ,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+952
+add
+(
+¥
+, sp,
+¬gum\92t_couÁ
+);
+
+957 \1e
+ gMaüoAs£mbËr
+::
+MovFromFlßtResuÉ
+(cڡ
+DoubËRegi¡\94
+
+d¡
+) {
+
+958
+Move
+(
+d¡
+,
+d1
+);
+
+962 \1e
+ gMaüoAs£mbËr
+::
+MovFromFlßtP¬am\91\94
+(cڡ
+DoubËRegi¡\94
+
+d¡
+) {
+
+963
+Move
+(
+d¡
+,
+d1
+);
+
+967 \1e
+ gMaüoAs£mbËr
+::
+InvokePrÞogue
+(cڡ
+P¬am\91\94CouÁ
+&
+ex³ùed
+,
+
+968 cڡ
+P¬am\91\94CouÁ
+&
+aùu®
+,
+
+969
+HªdË
+<
+Code
+>
+code_cÚ¡ªt
+,
+
+970
+Regi¡\94
+
+code_»g
+,
+Lab\96
+*
+dÚe
+,
+
+971
+boÞ
+*
+def\9a\99\96y_mism©ches
+,
+
+972
+InvokeFÏg
+
+æag
+,
+
+973 cڡ
+C®lW¿µ\94
+&
+ÿÎ_w¿µ\94
+) {
+
+974
+boÞ
+
+ gdef\9a\99\96y_m©ches
+ =
+çl£
+;
+
+975 *
+ gdef\9a\99\96y_mism©ches
+ =
+çl£
+;
+
+976
+Lab\96
+
+ g»guÏr_\9avoke
+;
+
+994 ià(
+ gex³ùed
+.
+is_immed\9f\8b
+()) {
+
+995
+DCHECK
+(
+aùu®
+.
+is_immed\9f\8b
+());
+
+996 ià(
+ gex³ùed
+.
+immed\9f\8b
+(è=ð
+aùu®
+.immediate()) {
+
+997
+def\9a\99\96y_m©ches
+ =
+\8cue
+;
+
+999
+mov
+(
+r3
+,
+O³¿nd
+(
+aùu®
+.
+immed\9f\8b
+()));
+
+1000 cڡ \12
+ g£Á\9a\96
+ =
+Sh¬edFunùiÚInfo
+::
+kDÚtAdtArgum\92tsS\92t\9a\96
+;
+
+1001 ià(
+ gex³ùed
+.
+immed\9f\8b
+(è=ð
+£Á\9a\96
+) {
+
+1006
+def\9a\99\96y_m©ches
+ =
+\8cue
+;
+
+1008 *
+ gdef\9a\99\96y_mism©ches
+ =
+\8cue
+;
+
+1009
+mov
+(
+r5
+,
+O³¿nd
+(
+ex³ùed
+.
+immed\9f\8b
+()));
+
+1013 ià(
+ gaùu®
+.
+is_immed\9f\8b
+()) {
+
+1014
+cmpi
+(
+ex³ùed
+.
+»g
+(),
+O³¿nd
+(
+aùu®
+.
+immed\9f\8b
+()));
+
+1015
+beq
+(&
+»guÏr_\9avoke
+);
+
+1016
+mov
+(
+r3
+,
+O³¿nd
+(
+aùu®
+.
+immed\9f\8b
+()));
+
+1018
+cmp
+(
+ex³ùed
+.
+»g
+(),
+aùu®
+.reg());
+
+1019
+beq
+(&
+»guÏr_\9avoke
+);
+
+1023 ià(!
+ gdef\9a\99\96y_m©ches
+) {
+
+1024 ià(!
+ gcode_cÚ¡ªt
+.
+is_nuÎ
+()) {
+
+1025
+mov
+(
+r6
+,
+O³¿nd
+(
+code_cÚ¡ªt
+));
+
+1026
+addi
+(
+r6
+,\846,
+O³¿nd
+(
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+1029
+ gHªdË
+<
+ gCode
+>
+ gadtÜ
+ =
+isީe
+()->
+bu\9et\9as
+()->
+Argum\92tsAdtÜT¿mpÞ\9ae
+();
+
+1030 ià(
+ gæag
+ =ð
+CALL_FUNCTION
+) {
+
+1031
+ÿÎ_w¿µ\94
+.
+BefÜeC®l
+(
+C®lSize
+(
+adtÜ
+));
+
+1032
+C®l
+(
+adtÜ
+);
+
+1033
+ gÿÎ_w¿µ\94
+.
+Aá\94C®l
+();
+
+1034 ià(!*
+ gdef\9a\99\96y_mism©ches
+) {
+
+1035
+b
+(
+dÚe
+);
+
+1038
+Jump
+(
+adtÜ
+,
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+1040
+b\9ad
+(&
+»guÏr_\9avoke
+);
+
+1045 \1e
+ gMaüoAs£mbËr
+::
+InvokeCode
+(
+Regi¡\94
+
+code
+, cڡ
+P¬am\91\94CouÁ
+&
+ex³ùed
+,
+
+1046 cڡ
+P¬am\91\94CouÁ
+&
+aùu®
+,
+InvokeFÏg
+
+æag
+,
+
+1047 cڡ
+C®lW¿µ\94
+&
+ÿÎ_w¿µ\94
+) {
+
+1049
+DCHECK
+(
+æag
+ =ð
+JUMP_FUNCTION
+ ||
+has_äame
+());
+
+1051
+Lab\96
+
+ gdÚe
+;
+
+1052
+boÞ
+
+ gdef\9a\99\96y_mism©ches
+ =
+çl£
+;
+
+1053
+InvokePrÞogue
+(
+ex³ùed
+,
+aùu®
+,
+HªdË
+<
+Code
+>::
+nuÎ
+(),
+code
+, &
+dÚe
+,
+
+1054 &
+def\9a\99\96y_mism©ches
+,
+æag
+,
+ÿÎ_w¿µ\94
+);
+
+1055 ià(!
+ gdef\9a\99\96y_mism©ches
+) {
+
+1056 ià(
+ gæag
+ =ð
+CALL_FUNCTION
+) {
+
+1057
+ÿÎ_w¿µ\94
+.
+BefÜeC®l
+(
+C®lSize
+(
+code
+));
+
+1058
+C®lJSEÁry
+(
+code
+);
+
+1059
+ gÿÎ_w¿µ\94
+.
+Aá\94C®l
+();
+
+1061
+DCHECK
+(
+æag
+ =ð
+JUMP_FUNCTION
+);
+
+1062
+JumpToJSEÁry
+(
+code
+);
+
+1067
+b\9ad
+(&
+dÚe
+);
+
+1072 \1e
+ gMaüoAs£mbËr
+::
+InvokeFunùiÚ
+(
+Regi¡\94
+
+fun
+, cڡ
+P¬am\91\94CouÁ
+&
+aùu®
+,
+
+1073
+InvokeFÏg
+
+æag
+,
+
+1074 cڡ
+C®lW¿µ\94
+&
+ÿÎ_w¿µ\94
+) {
+
+1076
+DCHECK
+(
+æag
+ =ð
+JUMP_FUNCTION
+ ||
+has_äame
+());
+
+1079
+DCHECK
+(
+fun
+.
+is
+(
+r4
+));
+
+1081
+Regi¡\94
+
+ gex³ùed_»g
+ =
+r5
+;
+
+1082
+Regi¡\94
+
+ gcode_»g
+ =
+\9d
+;
+
+1084
+LßdP
+(
+code_»g
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+1085
+LßdP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCÚ\8bxtOff£t
+));
+
+1086
+LßdWÜdAr\99h
+(
+ex³ùed_»g
+,
+
+1087
+F\9bldMemO³¿nd
+(
+
+1088
+code_»g
+,
+Sh¬edFunùiÚInfo
+::
+kFÜm®P¬am\91\94CouÁOff£t
+));
+
+1089 #ià!
+def\9aed
+(
+V8_TARGET_ARCH_PPC64
+)
+
+1090
+SmiUÁag
+(
+ex³ùed_»g
+);
+
+1092
+LßdP
+(
+code_»g
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCodeEÁryOff£t
+));
+
+1094
+P¬am\91\94CouÁ
+
+ex³ùed
+(
+ex³ùed_»g
+);
+
+1095
+InvokeCode
+(
+code_»g
+,
+ex³ùed
+,
+aùu®
+,
+æag
+,
+ÿÎ_w¿µ\94
+);
+
+1099 \1e
+ gMaüoAs£mbËr
+::
+InvokeFunùiÚ
+(
+Regi¡\94
+
+funùiÚ
+,
+
+1100 cڡ
+P¬am\91\94CouÁ
+&
+ex³ùed
+,
+
+1101 cڡ
+P¬am\91\94CouÁ
+&
+aùu®
+,
+
+1102
+InvokeFÏg
+
+æag
+,
+
+1103 cڡ
+C®lW¿µ\94
+&
+ÿÎ_w¿µ\94
+) {
+
+1105
+DCHECK
+(
+æag
+ =ð
+JUMP_FUNCTION
+ ||
+has_äame
+());
+
+1108
+DCHECK
+(
+funùiÚ
+.
+is
+(
+r4
+));
+
+1111
+LßdP
+(
+ý
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCÚ\8bxtOff£t
+));
+
+1116
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCodeEÁryOff£t
+));
+
+1117
+InvokeCode
+(
+\9d
+,
+ex³ùed
+,
+aùu®
+,
+æag
+,
+ÿÎ_w¿µ\94
+);
+
+1121 \1e
+ gMaüoAs£mbËr
+::
+InvokeFunùiÚ
+(
+HªdË
+<
+JSFunùiÚ
+>
+funùiÚ
+,
+
+1122 cڡ
+P¬am\91\94CouÁ
+&
+ex³ùed
+,
+
+1123 cڡ
+P¬am\91\94CouÁ
+&
+aùu®
+,
+
+1124
+InvokeFÏg
+
+æag
+,
+
+1125 cڡ
+C®lW¿µ\94
+&
+ÿÎ_w¿µ\94
+) {
+
+1126
+Move
+(
+r4
+,
+funùiÚ
+);
+
+1127
+InvokeFunùiÚ
+(
+r4
+,
+ex³ùed
+,
+aùu®
+,
+æag
+,
+ÿÎ_w¿µ\94
+);
+
+1131 \1e
+ gMaüoAs£mbËr
+::
+IsObjeùJSObjeùTy³
+(
+Regi¡\94
+
+h\97p_objeù
+, Regi¡\94
+m
+,
+
+1132
+Regi¡\94
+
+sü©ch
+,
+Lab\96
+*
+ç\9e
+) {
+
+1133
+LßdP
+(
+m
+,
+F\9bldMemO³¿nd
+(
+h\97p_objeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1134
+IsIn¡ªûJSObjeùTy³
+(
+m
+,
+sü©ch
+,
+ç\9e
+);
+
+1138 \1e
+ gMaüoAs£mbËr
+::
+IsIn¡ªûJSObjeùTy³
+(
+Regi¡\94
+
+m
+, Regi¡\94
+sü©ch
+,
+
+1139
+Lab\96
+*
+ç\9e
+) {
+
+1140
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+1141
+cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+FIRST_NONCALLABLE_SPEC_OBJECT_TYPE
+));
+
+1142
+bÉ
+(
+ç\9e
+);
+
+1143
+cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+LAST_NONCALLABLE_SPEC_OBJECT_TYPE
+));
+
+1144
+bgt
+(
+ç\9e
+);
+
+1148 \1e
+ gMaüoAs£mbËr
+::
+IsObjeùJSS\8c\9agTy³
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch
+,
+
+1149
+Lab\96
+*
+ç\9e
+) {
+
+1150
+DCHECK
+(
+kNÙS\8c\9agTag
+ != 0);
+
+1152
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1153
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+1154
+ªdi
+(
+r0
+,
+sü©ch
+,
+O³¿nd
+(
+kIsNÙS\8c\9agMask
+));
+
+1155
+bÃ
+(
+ç\9e
+,
+ü0
+);
+
+1159 \1e
+ gMaüoAs£mbËr
+::
+IsObjeùNameTy³
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch
+,
+
+1160
+Lab\96
+*
+ç\9e
+) {
+
+1161
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1162
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+1163
+cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+LAST_NAME_TYPE
+));
+
+1164
+bgt
+(
+ç\9e
+);
+
+1168 \1e
+ gMaüoAs£mbËr
+::
+DebugB»ak
+() {
+
+1169
+li
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+1170
+mov
+(
+r4
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+RuÁime
+::
+kDebugB»ak
+,
+isީe
+())));
+
+1171
+CEÁryStub
+
+ûs
+(
+isީe
+(), 1);
+
+1172
+DCHECK
+(
+AÎowThisStubC®l
+(&
+ûs
+));
+
+1173
+C®l
+(
+ûs
+.
+G\91Code
+(),
+R\96ocInfo
+::
+DEBUG_BREAK
+);
+
+1177 \1e
+ gMaüoAs£mbËr
+::
+PushTryHªdËr
+(
+S\8fckHªdËr
+::
+K\9ad
+
+k\9ad
+,
+
+1178 \12
+hªdËr_\9adex
+) {
+
+1180
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kSize
+ =ð5 *
+kPo\9a\8brSize
+);
+
+1181
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kNextOff£t
+ =ð0 *
+kPo\9a\8brSize
+);
+
+1182
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kCodeOff£t
+ =ð1 *
+kPo\9a\8brSize
+);
+
+1183
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kS\8f\8bOff£t
+ =ð2 *
+kPo\9a\8brSize
+);
+
+1184
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+ =ð3 *
+kPo\9a\8brSize
+);
+
+1185
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kFPOff£t
+ =ð4 *
+kPo\9a\8brSize
+);
+
+1196
+mov
+(
+r8
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kHªdËrAdd»ss
+,
+isީe
+())));
+
+1197
+LßdP
+(
+r0
+,
+MemO³¿nd
+(
+r8
+));
+
+1198
+StÜePU
+(
+r0
+,
+MemO³¿nd
+(
+¥
+, -
+S\8fckHªdËrCÚ¡ªts
+::
+kSize
+));
+
+1200
+StÜeP
+(
+¥
+,
+MemO³¿nd
+(
+r8
+));
+
+1202 ià(
+ gk\9ad
+ =ð
+S\8fckHªdËr
+::
+JS_ENTRY
+) {
+
+1203
+li
+(
+r8
+,
+O³¿nd
+::
+Z\94o
+());
+
+1204
+StÜeP
+(
+r8
+,
+MemO³¿nd
+(
+¥
+,
+S\8fckHªdËrCÚ¡ªts
+::
+kFPOff£t
+));
+
+1205
+LßdSmiL\99\94®
+(
+r8
+,
+Smi
+::
+FromIÁ
+(0));
+
+1206
+StÜeP
+(
+r8
+,
+MemO³¿nd
+(
+¥
+,
+S\8fckHªdËrCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+1209
+StÜeP
+(
+å
+,
+MemO³¿nd
+(
+¥
+,
+S\8fckHªdËrCÚ¡ªts
+::
+kFPOff£t
+));
+
+1210
+StÜeP
+(
+ý
+,
+MemO³¿nd
+(
+¥
+,
+S\8fckHªdËrCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+1212 \1d
+ g¡©e
+ =
+S\8fckHªdËr
+::
+IndexF\9bld
+::
+\92code
+(
+hªdËr_\9adex
+) |
+
+1213
+S\8fckHªdËr
+::
+K\9adF\9bld
+::
+\92code
+(
+k\9ad
+);
+
+1214
+LßdIÁL\99\94®
+(
+r8
+,
+¡©e
+);
+
+1215
+StÜeP
+(
+r8
+,
+MemO³¿nd
+(
+¥
+,
+S\8fckHªdËrCÚ¡ªts
+::
+kS\8f\8bOff£t
+));
+
+1216
+mov
+(
+r8
+,
+O³¿nd
+(
+CodeObjeù
+()));
+
+1217
+StÜeP
+(
+r8
+,
+MemO³¿nd
+(
+¥
+,
+S\8fckHªdËrCÚ¡ªts
+::
+kCodeOff£t
+));
+
+1221 \1e
+ gMaüoAs£mbËr
+::
+PÝTryHªdËr
+() {
+
+1222
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kNextOff£t
+ == 0);
+
+1223
+pÝ
+(
+r4
+);
+
+1224
+mov
+(
+\9d
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kHªdËrAdd»ss
+,
+isީe
+())));
+
+1225
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kSize
+ -
+kPo\9a\8brSize
+));
+
+1226
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+\9d
+));
+
+1231 \1e
+ gMaüoAs£mbËr
+::
+JumpToHªdËrEÁry
+() {
+
+1235 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1236
+CÚ¡ªtPoÞUÇva\9eabËScÝe
+
+cÚ¡ªt_poÞ_uÇva\9eabË
+(
+this
+);
+
+1237
+LßdP
+(
+kCÚ¡ªtPoÞRegi¡\94
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+Code
+::
+kCÚ¡ªtPoÞOff£t
+));
+
+1239
+LßdP
+(
+r6
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+Code
+::
+kHªdËrTabËOff£t
+));
+
+1240
+addi
+(
+r6
+,\846,
+O³¿nd
+(
+FixedA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+1241
+¤wi
+(
+r5
+,\845,
+O³¿nd
+(
+S\8fckHªdËr
+::
+kK\9adWidth
+));
+
+1242
+¦wi
+(
+\9d
+,
+r5
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+1243
+add
+(
+\9d
+,
+r6
+, ip);
+
+1244
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+\9d
+));
+
+1245
+addi
+(
+r4
+,\844,
+O³¿nd
+(
+Code
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+1246
+SmiUÁag
+(
+\9d
+,
+r5
+);
+
+1247
+add
+(
+r0
+,
+r4
+,
+\9d
+);
+
+1248
+mtùr
+(
+r0
+);
+
+1249
+bùr
+();
+
+1253 \1e
+ gMaüoAs£mbËr
+::
+Throw
+(
+Regi¡\94
+
+v®ue
+) {
+
+1255
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kSize
+ =ð5 *
+kPo\9a\8brSize
+);
+
+1256
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kNextOff£t
+ == 0);
+
+1257
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kCodeOff£t
+ =ð1 *
+kPo\9a\8brSize
+);
+
+1258
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kS\8f\8bOff£t
+ =ð2 *
+kPo\9a\8brSize
+);
+
+1259
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+ =ð3 *
+kPo\9a\8brSize
+);
+
+1260
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kFPOff£t
+ =ð4 *
+kPo\9a\8brSize
+);
+
+1261
+Lab\96
+
+ gsk\9d
+;
+
+1264 ià(!
+ gv®ue
+.
+is
+(
+r3
+)) {
+
+1265
+mr
+(
+r3
+,
+v®ue
+);
+
+1268
+mov
+(
+r6
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kHªdËrAdd»ss
+,
+isީe
+())));
+
+1269
+LßdP
+(
+¥
+,
+MemO³¿nd
+(
+r6
+));
+
+1271
+pÝ
+(
+r5
+);
+
+1272
+StÜeP
+(
+r5
+,
+MemO³¿nd
+(
+r6
+));
+
+1276
+pÝ
+(
+r4
+);
+
+1277
+pÝ
+(
+r5
+);
+
+1278
+pÝ
+(
+ý
+);
+
+1279
+pÝ
+(
+å
+);
+
+1284
+cmpi
+(
+ý
+,
+O³¿nd
+::
+Z\94o
+());
+
+1285
+beq
+(&
+sk\9d
+);
+
+1286
+StÜeP
+(
+ý
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+1287
+b\9ad
+(&
+sk\9d
+);
+
+1289
+JumpToHªdËrEÁry
+();
+
+1293 \1e
+ gMaüoAs£mbËr
+::
+ThrowUnÿtchabË
+(
+Regi¡\94
+
+v®ue
+) {
+
+1295
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kSize
+ =ð5 *
+kPo\9a\8brSize
+);
+
+1296
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kNextOff£t
+ =ð0 *
+kPo\9a\8brSize
+);
+
+1297
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kCodeOff£t
+ =ð1 *
+kPo\9a\8brSize
+);
+
+1298
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kS\8f\8bOff£t
+ =ð2 *
+kPo\9a\8brSize
+);
+
+1299
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+ =ð3 *
+kPo\9a\8brSize
+);
+
+1300
+STATIC_ASSERT
+(
+S\8fckHªdËrCÚ¡ªts
+::
+kFPOff£t
+ =ð4 *
+kPo\9a\8brSize
+);
+
+1303 ià(!
+ gv®ue
+.
+is
+(
+r3
+)) {
+
+1304
+mr
+(
+r3
+,
+v®ue
+);
+
+1307
+mov
+(
+r6
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+Isީe
+::
+kHªdËrAdd»ss
+,
+isީe
+())));
+
+1308
+LßdP
+(
+¥
+,
+MemO³¿nd
+(
+r6
+));
+
+1311
+Lab\96
+
+ gãtch_Ãxt
+,
+ gcheck_k\9ad
+;
+
+1312
+b
+(&
+check_k\9ad
+);
+
+1313
+b\9ad
+(&
+ãtch_Ãxt
+);
+
+1314
+LßdP
+(
+¥
+,
+MemO³¿nd
+(¥,
+S\8fckHªdËrCÚ¡ªts
+::
+kNextOff£t
+));
+
+1316
+b\9ad
+(&
+check_k\9ad
+);
+
+1317
+STATIC_ASSERT
+(
+S\8fckHªdËr
+::
+JS_ENTRY
+ == 0);
+
+1318
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+¥
+,
+S\8fckHªdËrCÚ¡ªts
+::
+kS\8f\8bOff£t
+));
+
+1319
+ªdi
+(
+r0
+,
+r5
+,
+O³¿nd
+(
+S\8fckHªdËr
+::
+K\9adF\9bld
+::
+kMask
+));
+
+1320
+bÃ
+(&
+ãtch_Ãxt
+,
+ü0
+);
+
+1323
+pÝ
+(
+r5
+);
+
+1324
+StÜeP
+(
+r5
+,
+MemO³¿nd
+(
+r6
+));
+
+1327
+pÝ
+(
+r4
+);
+
+1328
+pÝ
+(
+r5
+);
+
+1329
+pÝ
+(
+ý
+);
+
+1330
+pÝ
+(
+å
+);
+
+1332
+JumpToHªdËrEÁry
+();
+
+1336 \1e
+ gMaüoAs£mbËr
+::
+CheckAcûssGlob®Proxy
+(
+Regi¡\94
+
+hÞd\94_»g
+,
+
+1337
+Regi¡\94
+
+sü©ch
+,
+Lab\96
+*
+miss
+) {
+
+1338
+Lab\96
+
+ g§me_cÚ\8bxts
+;
+
+1340
+DCHECK
+(!
+hÞd\94_»g
+.
+is
+(
+sü©ch
+));
+
+1341
+DCHECK
+(!
+hÞd\94_»g
+.
+is
+(
+\9d
+));
+
+1342
+DCHECK
+(!
+sü©ch
+.
+is
+(
+\9d
+));
+
+1345
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(
+å
+,
+S\8fnd¬dF¿meCÚ¡ªts
+::
+kCÚ\8bxtOff£t
+));
+
+1347 #ifdeà
+DEBUG
+
+
+1348
+cmpi
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+1349
+Check
+(
+Ã
+,
+kWeShouldNÙHaveAnEm±yLexiÿlCÚ\8bxt
+);
+
+1353 \12
+ goff£t
+ =
+
+1354
+Cڋxt
+::
+kH\97d\94Size
+ + Cڋxt::
+GLOBAL_OBJECT_INDEX
+ *
+kPo\9a\8brSize
+;
+
+1355
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+off£t
+));
+
+1356
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+Glob®Objeù
+::
+kN©iveCÚ\8bxtOff£t
+));
+
+1359 ià(
+em\99_debug_code
+()) {
+
+1362
+push
+(
+hÞd\94_»g
+);
+
+1364
+LßdP
+(
+hÞd\94_»g
+,
+F\9bldMemO³¿nd
+(
+sü©ch
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1365
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kN©iveCÚ\8bxtMRoÙIndex
+);
+
+1366
+cmp
+(
+hÞd\94_»g
+,
+\9d
+);
+
+1367
+Check
+(
+eq
+,
+kJSGlob®ObjeùN©iveCÚ\8bxtShouldBeAN©iveCÚ\8bxt
+);
+
+1368
+pÝ
+(
+hÞd\94_»g
+);
+
+1372
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+hÞd\94_»g
+,
+JSGlob®Proxy
+::
+kN©iveCÚ\8bxtOff£t
+));
+
+1373
+cmp
+(
+sü©ch
+,
+\9d
+);
+
+1374
+beq
+(&
+§me_cÚ\8bxts
+);
+
+1377 ià(
+em\99_debug_code
+()) {
+
+1380
+push
+(
+hÞd\94_»g
+);
+
+1381
+mr
+(
+hÞd\94_»g
+,
+\9d
+);
+
+1382
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kNuÎV®ueRoÙIndex
+);
+
+1383
+cmp
+(
+hÞd\94_»g
+,
+\9d
+);
+
+1384
+Check
+(
+Ã
+,
+kJSGlob®ProxyCÚ\8bxtShouldNÙBeNuÎ
+);
+
+1386
+LßdP
+(
+hÞd\94_»g
+,
+F\9bldMemO³¿nd
+(hÞd\94_»g,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1387
+LßdRoÙ
+(
+\9d
+,
+H\97p
+::
+kN©iveCÚ\8bxtMRoÙIndex
+);
+
+1388
+cmp
+(
+hÞd\94_»g
+,
+\9d
+);
+
+1389
+Check
+(
+eq
+,
+kJSGlob®ObjeùN©iveCÚ\8bxtShouldBeAN©iveCÚ\8bxt
+);
+
+1391
+pÝ
+(
+hÞd\94_»g
+);
+
+1393
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+hÞd\94_»g
+,
+JSGlob®Proxy
+::
+kN©iveCÚ\8bxtOff£t
+));
+
+1399 \12
+ gtok\92_off£t
+ =
+
+1400
+Cڋxt
+::
+kH\97d\94Size
+ + Cڋxt::
+SECURITY_TOKEN_INDEX
+ *
+kPo\9a\8brSize
+;
+
+1402
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+tok\92_off£t
+));
+
+1403
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(\9d,
+tok\92_off£t
+));
+
+1404
+cmp
+(
+sü©ch
+,
+\9d
+);
+
+1405
+bÃ
+(
+miss
+);
+
+1407
+b\9ad
+(&
+§me_cÚ\8bxts
+);
+
+1414 \1e
+ gMaüoAs£mbËr
+::
+G\91Numb\94Hash
+(
+Regi¡\94
+
+t0
+, Regi¡\94
+sü©ch
+) {
+
+1416
+LßdRoÙ
+(
+sü©ch
+,
+H\97p
+::
+kHashS\93dRoÙIndex
+);
+
+1417
+SmiUÁag
+(
+sü©ch
+);
+
+1420
+xÜ_
+(
+t0
+,\810,
+sü©ch
+);
+
+1426
+nÙx
+(
+sü©ch
+,
+t0
+);
+
+1427
+¦wi
+(
+t0
+,\810,
+O³¿nd
+(15));
+
+1428
+add
+(
+t0
+,
+sü©ch
+,\810);
+
+1430
+¤wi
+(
+sü©ch
+,
+t0
+,
+O³¿nd
+(12));
+
+1431
+xÜ_
+(
+t0
+,\810,
+sü©ch
+);
+
+1433
+¦wi
+(
+sü©ch
+,
+t0
+,
+O³¿nd
+(2));
+
+1434
+add
+(
+t0
+,\810,
+sü©ch
+);
+
+1436
+¤wi
+(
+sü©ch
+,
+t0
+,
+O³¿nd
+(4));
+
+1437
+xÜ_
+(
+t0
+,\810,
+sü©ch
+);
+
+1439
+mr
+(
+r0
+,
+t0
+);
+
+1440
+¦wi
+(
+sü©ch
+,
+t0
+,
+O³¿nd
+(3));
+
+1441
+add
+(
+t0
+,\810,
+sü©ch
+);
+
+1442
+¦wi
+(
+sü©ch
+,
+r0
+,
+O³¿nd
+(11));
+
+1443
+add
+(
+t0
+,\810,
+sü©ch
+);
+
+1445
+¤wi
+(
+sü©ch
+,
+t0
+,
+O³¿nd
+(16));
+
+1446
+xÜ_
+(
+t0
+,\810,
+sü©ch
+);
+
+1450 \1e
+ gMaüoAs£mbËr
+::
+LßdFromNumb\94DiùiÚ¬y
+(
+Lab\96
+*
+miss
+,
+Regi¡\94
+
+\96em\92ts
+,
+
+1451
+Regi¡\94
+
+key
+, Regi¡\94
+»suÉ
+,
+
+1452
+Regi¡\94
+
+t0
+, Regi¡\94
+t1
+,
+
+1453
+Regi¡\94
+
+t2
+) {
+
+1474
+Lab\96
+
+ gdÚe
+;
+
+1476
+G\91Numb\94Hash
+(
+t0
+,
+t1
+);
+
+1479
+LßdP
+(
+t1
+,
+F\9bldMemO³¿nd
+(
+\96em\92ts
+,
+S\93dedNumb\94DiùiÚ¬y
+::
+kCac\99yOff£t
+));
+
+1480
+SmiUÁag
+(
+t1
+);
+
+1481
+subi
+(
+t1
+,\811,
+O³¿nd
+(1));
+
+1484 \ f\12
+ gi
+ = 0; i <
+ gkNumb\94DiùiÚ¬yProbes
+; i++) {
+
+1486
+mr
+(
+t2
+,
+t0
+);
+
+1488 ià(
+ gi
+ > 0) {
+
+1489
+addi
+(
+t2
+,\812,
+O³¿nd
+(
+S\93dedNumb\94DiùiÚ¬y
+::
+G\91ProbeOff£t
+(
+i
+)));
+
+1491
+ªd_
+(
+t2
+,\812,
+t1
+);
+
+1494
+DCHECK
+(
+S\93dedNumb\94DiùiÚ¬y
+::
+kEÁrySize
+ == 3);
+
+1495
+¦wi
+(
+\9d
+,
+t2
+,
+O³¿nd
+(1));
+
+1496
+add
+(
+t2
+,\812,
+\9d
+);
+
+1499
+¦wi
+(
+t2
+,\812,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+1500
+add
+(
+t2
+,
+\96em\92ts
+,\812);
+
+1501
+LßdP
+(
+\9d
+,
+
+1502
+F\9bldMemO³¿nd
+(
+t2
+,
+S\93dedNumb\94DiùiÚ¬y
+::
+kEËm\92tsS\8f¹Off£t
+));
+
+1503
+cmp
+(
+key
+,
+\9d
+);
+
+1504 ià(
+ gi
+ !ð
+kNumb\94DiùiÚ¬yProbes
+ - 1) {
+
+1505
+beq
+(&
+dÚe
+);
+
+1507
+bÃ
+(
+miss
+);
+
+1511
+b\9ad
+(&
+dÚe
+);
+
+1514 cڡ \12
+ gkD\91a\9esOff£t
+ =
+
+1515
+S\93dedNumb\94DiùiÚ¬y
+::
+kEËm\92tsS\8f¹Off£t
+ + 2 *
+kPo\9a\8brSize
+;
+
+1516
+LßdP
+(
+t1
+,
+F\9bldMemO³¿nd
+(
+t2
+,
+kD\91a\9esOff£t
+));
+
+1517
+LßdSmiL\99\94®
+(
+\9d
+,
+Smi
+::
+FromIÁ
+(
+PrÝ\94tyD\91a\9es
+::
+Ty³F\9bld
+::
+kMask
+));
+
+1518
+ªd_
+(
+r0
+,
+t1
+,
+\9d
+,
+S\91RC
+);
+
+1519
+bÃ
+(
+miss
+,
+ü0
+);
+
+1522 cڡ \12
+ gkV®ueOff£t
+ =
+
+1523
+S\93dedNumb\94DiùiÚ¬y
+::
+kEËm\92tsS\8f¹Off£t
+ +
+kPo\9a\8brSize
+;
+
+1524
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+(
+t2
+,
+kV®ueOff£t
+));
+
+1528 \1e
+ gMaüoAs£mbËr
+::
+AÎoÿ\8b
+(\12
+objeù_size
+,
+Regi¡\94
+
+»suÉ
+,
+
+1529
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+1530
+Lab\96
+*
+gc_»qu\9ced
+,
+AÎoÿtiÚFÏgs
+
+æags
+) {
+
+1531
+DCHECK
+(
+objeù_size
+ <ð
+Page
+::
+kMaxReguÏrH\97pObjeùSize
+);
+
+1532 ià(!
+ gFLAG_\9al\9ae_Ãw
+) {
+
+1533 ià(
+em\99_debug_code
+()) {
+
+1535
+li
+(
+»suÉ
+,
+O³¿nd
+(0x7091));
+
+1536
+li
+(
+sü©ch1
+,
+O³¿nd
+(0x7191));
+
+1537
+li
+(
+sü©ch2
+,
+O³¿nd
+(0x7291));
+
+1539
+b
+(
+gc_»qu\9ced
+);
+
+1543
+DCHECK
+(!
+»suÉ
+.
+is
+(
+sü©ch1
+));
+
+1544
+DCHECK
+(!
+»suÉ
+.
+is
+(
+sü©ch2
+));
+
+1545
+DCHECK
+(!
+sü©ch1
+.
+is
+(
+sü©ch2
+));
+
+1546
+DCHECK
+(!
+sü©ch1
+.
+is
+(
+\9d
+));
+
+1547
+DCHECK
+(!
+sü©ch2
+.
+is
+(
+\9d
+));
+
+1550 ià((
+ gæags
+ &
+ gSIZE_IN_WORDS
+) != 0) {
+
+1551
+objeù_size
+ *ð
+kPo\9a\8brSize
+;
+
+1553
+DCHECK_EQ
+(0,
+¡©ic_ÿ¡
+<\12>(
+objeù_size
+ &
+kObjeùAlignm\92tMask
+));
+
+1556
+Ex\8bº®Reã»nû
+
+ g®loÿtiÚ_tÝ
+ =
+
+1557
+AÎoÿtiÚUt\9es
+::
+G\91AÎoÿtiÚTÝReã»nû
+(
+isީe
+(),
+æags
+);
+
+1558
+Ex\8bº®Reã»nû
+
+ g®loÿtiÚ_lim\99
+ =
+
+1559
+AÎoÿtiÚUt\9es
+::
+G\91AÎoÿtiÚLim\99Reã»nû
+(
+isީe
+(),
+æags
+);
+
+1561
+\9a\8d\8c_t
+
+ gtÝ
+ =
+»\9a\8b½»t_ÿ¡
+<\9a\8d\8c_t>(
+®loÿtiÚ_tÝ
+.
+add»ss
+());
+
+1562
+\9a\8d\8c_t
+
+ glim\99
+ =
+»\9a\8b½»t_ÿ¡
+<\9a\8d\8c_t>(
+®loÿtiÚ_lim\99
+.
+add»ss
+());
+
+1563
+DCHECK
+((
+lim\99
+ -
+tÝ
+è=ð
+kPo\9a\8brSize
+);
+
+1566
+Regi¡\94
+
+ gtÝaddr
+ =
+sü©ch1
+;
+
+1567
+mov
+(
+tÝaddr
+,
+O³¿nd
+(
+®loÿtiÚ_tÝ
+));
+
+1571 ià((
+ gæags
+ &
+ gRESULT_CONTAINS_TOP
+) == 0) {
+
+1573
+LßdP
+(
+»suÉ
+,
+MemO³¿nd
+(
+tÝaddr
+));
+
+1574
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+tÝaddr
+,
+kPo\9a\8brSize
+));
+
+1576 ià(
+em\99_debug_code
+()) {
+
+1580
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+tÝaddr
+));
+
+1581
+cmp
+(
+»suÉ
+,
+\9d
+);
+
+1582
+Check
+(
+eq
+,
+kUÃx³ùedAÎoÿtiÚTÝ
+);
+
+1585
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+tÝaddr
+,
+lim\99
+ -
+tÝ
+),
+r0
+);
+
+1588 ià((
+ gæags
+ &
+ gDOUBLE_ALIGNMENT
+) != 0) {
+
+1591
+DCHECK
+((
+æags
+ &
+PRETENURE_OLD_POINTER_SPACE
+) == 0);
+
+1592 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1593
+STATIC_ASSERT
+(
+kPo\9a\8brAlignm\92t
+ =ð
+kDoubËAlignm\92t
+);
+
+1595
+STATIC_ASSERT
+(
+kPo\9a\8brAlignm\92t
+ * 2 =ð
+kDoubËAlignm\92t
+);
+
+1596
+ªdi
+(
+sü©ch2
+,
+»suÉ
+,
+O³¿nd
+(
+kDoubËAlignm\92tMask
+));
+
+1597
+Lab\96
+
+ g®igÃd
+;
+
+1598
+beq
+(&
+®igÃd
+,
+ü0
+);
+
+1599 ià((
+ gæags
+ &
+ gPRETENURE_OLD_DATA_SPACE
+) != 0) {
+
+1600
+cm¶
+(
+»suÉ
+,
+\9d
+);
+
+1601
+bge
+(
+gc_»qu\9ced
+);
+
+1603
+mov
+(
+sü©ch2
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+Úe_po\9a\8br_f\9eËr_m
+()));
+
+1604
+¡w
+(
+sü©ch2
+,
+MemO³¿nd
+(
+»suÉ
+));
+
+1605
+addi
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(
+kDoubËSize
+ / 2));
+
+1606
+b\9ad
+(&
+®igÃd
+);
+
+1612
+sub
+(
+r0
+,
+\9d
+,
+»suÉ
+);
+
+1613 ià(
+is_\9at16
+(
+objeù_size
+)) {
+
+1614
+cmpi
+(
+r0
+,
+O³¿nd
+(
+objeù_size
+));
+
+1615
+bÉ
+(
+gc_»qu\9ced
+);
+
+1616
+addi
+(
+sü©ch2
+,
+»suÉ
+,
+O³¿nd
+(
+objeù_size
+));
+
+1618
+Cmpi
+(
+r0
+,
+O³¿nd
+(
+objeù_size
+),
+sü©ch2
+);
+
+1619
+bÉ
+(
+gc_»qu\9ced
+);
+
+1620
+add
+(
+sü©ch2
+,
+»suÉ
+, scratch2);
+
+1622
+StÜeP
+(
+sü©ch2
+,
+MemO³¿nd
+(
+tÝaddr
+));
+
+1625 ià((
+ gæags
+ &
+ gTAG_OBJECT
+) != 0) {
+
+1626
+addi
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(
+kH\97pObjeùTag
+));
+
+1631 \1e
+ gMaüoAs£mbËr
+::
+AÎoÿ\8b
+(
+Regi¡\94
+
+objeù_size
+, Regi¡\94
+»suÉ
+,
+
+1632
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+1633
+Lab\96
+*
+gc_»qu\9ced
+,
+AÎoÿtiÚFÏgs
+
+æags
+) {
+
+1634 ià(!
+ gFLAG_\9al\9ae_Ãw
+) {
+
+1635 ià(
+em\99_debug_code
+()) {
+
+1637
+li
+(
+»suÉ
+,
+O³¿nd
+(0x7091));
+
+1638
+li
+(
+sü©ch1
+,
+O³¿nd
+(0x7191));
+
+1639
+li
+(
+sü©ch2
+,
+O³¿nd
+(0x7291));
+
+1641
+b
+(
+gc_»qu\9ced
+);
+
+1647
+DCHECK
+(!
+»suÉ
+.
+is
+(
+sü©ch1
+));
+
+1648
+DCHECK
+(!
+»suÉ
+.
+is
+(
+sü©ch2
+));
+
+1649
+DCHECK
+(!
+sü©ch1
+.
+is
+(
+sü©ch2
+));
+
+1650
+DCHECK
+(!
+objeù_size
+.
+is
+(
+\9d
+));
+
+1651
+DCHECK
+(!
+»suÉ
+.
+is
+(
+\9d
+));
+
+1652
+DCHECK
+(!
+sü©ch1
+.
+is
+(
+\9d
+));
+
+1653
+DCHECK
+(!
+sü©ch2
+.
+is
+(
+\9d
+));
+
+1656
+Ex\8bº®Reã»nû
+
+ g®loÿtiÚ_tÝ
+ =
+
+1657
+AÎoÿtiÚUt\9es
+::
+G\91AÎoÿtiÚTÝReã»nû
+(
+isީe
+(),
+æags
+);
+
+1658
+Ex\8bº®Reã»nû
+
+ g®loÿtiÚ_lim\99
+ =
+
+1659
+AÎoÿtiÚUt\9es
+::
+G\91AÎoÿtiÚLim\99Reã»nû
+(
+isީe
+(),
+æags
+);
+
+1660
+\9a\8d\8c_t
+
+ gtÝ
+ =
+»\9a\8b½»t_ÿ¡
+<\9a\8d\8c_t>(
+®loÿtiÚ_tÝ
+.
+add»ss
+());
+
+1661
+\9a\8d\8c_t
+
+ glim\99
+ =
+»\9a\8b½»t_ÿ¡
+<\9a\8d\8c_t>(
+®loÿtiÚ_lim\99
+.
+add»ss
+());
+
+1662
+DCHECK
+((
+lim\99
+ -
+tÝ
+è=ð
+kPo\9a\8brSize
+);
+
+1665
+Regi¡\94
+
+ gtÝaddr
+ =
+sü©ch1
+;
+
+1666
+mov
+(
+tÝaddr
+,
+O³¿nd
+(
+®loÿtiÚ_tÝ
+));
+
+1670 ià((
+ gæags
+ &
+ gRESULT_CONTAINS_TOP
+) == 0) {
+
+1672
+LßdP
+(
+»suÉ
+,
+MemO³¿nd
+(
+tÝaddr
+));
+
+1673
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+tÝaddr
+,
+kPo\9a\8brSize
+));
+
+1675 ià(
+em\99_debug_code
+()) {
+
+1679
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+tÝaddr
+));
+
+1680
+cmp
+(
+»suÉ
+,
+\9d
+);
+
+1681
+Check
+(
+eq
+,
+kUÃx³ùedAÎoÿtiÚTÝ
+);
+
+1684
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+tÝaddr
+,
+lim\99
+ -
+tÝ
+));
+
+1687 ià((
+ gæags
+ &
+ gDOUBLE_ALIGNMENT
+) != 0) {
+
+1690
+DCHECK
+((
+æags
+ &
+PRETENURE_OLD_POINTER_SPACE
+) == 0);
+
+1691 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1692
+STATIC_ASSERT
+(
+kPo\9a\8brAlignm\92t
+ =ð
+kDoubËAlignm\92t
+);
+
+1694
+STATIC_ASSERT
+(
+kPo\9a\8brAlignm\92t
+ * 2 =ð
+kDoubËAlignm\92t
+);
+
+1695
+ªdi
+(
+sü©ch2
+,
+»suÉ
+,
+O³¿nd
+(
+kDoubËAlignm\92tMask
+));
+
+1696
+Lab\96
+
+ g®igÃd
+;
+
+1697
+beq
+(&
+®igÃd
+,
+ü0
+);
+
+1698 ià((
+ gæags
+ &
+ gPRETENURE_OLD_DATA_SPACE
+) != 0) {
+
+1699
+cm¶
+(
+»suÉ
+,
+\9d
+);
+
+1700
+bge
+(
+gc_»qu\9ced
+);
+
+1702
+mov
+(
+sü©ch2
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+Úe_po\9a\8br_f\9eËr_m
+()));
+
+1703
+¡w
+(
+sü©ch2
+,
+MemO³¿nd
+(
+»suÉ
+));
+
+1704
+addi
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(
+kDoubËSize
+ / 2));
+
+1705
+b\9ad
+(&
+®igÃd
+);
+
+1712
+sub
+(
+r0
+,
+\9d
+,
+»suÉ
+);
+
+1713 ià((
+ gæags
+ &
+ gSIZE_IN_WORDS
+) != 0) {
+
+1714
+ShiáLeáImm
+(
+sü©ch2
+,
+objeù_size
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+1715
+cmp
+(
+r0
+,
+sü©ch2
+);
+
+1716
+bÉ
+(
+gc_»qu\9ced
+);
+
+1717
+add
+(
+sü©ch2
+,
+»suÉ
+, scratch2);
+
+1719
+cmp
+(
+r0
+,
+objeù_size
+);
+
+1720
+bÉ
+(
+gc_»qu\9ced
+);
+
+1721
+add
+(
+sü©ch2
+,
+»suÉ
+,
+objeù_size
+);
+
+1725 ià(
+em\99_debug_code
+()) {
+
+1726
+ªdi
+(
+r0
+,
+sü©ch2
+,
+O³¿nd
+(
+kObjeùAlignm\92tMask
+));
+
+1727
+Check
+(
+eq
+,
+kUÇligÃdAÎoÿtiÚInNewS·û
+,
+ü0
+);
+
+1729
+StÜeP
+(
+sü©ch2
+,
+MemO³¿nd
+(
+tÝaddr
+));
+
+1732 ià((
+ gæags
+ &
+ gTAG_OBJECT
+) != 0) {
+
+1733
+addi
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(
+kH\97pObjeùTag
+));
+
+1738 \1e
+ gMaüoAs£mbËr
+::
+UndoAÎoÿtiÚInNewS·û
+(
+Regi¡\94
+
+objeù
+,
+
+1739
+Regi¡\94
+
+sü©ch
+) {
+
+1740
+Ex\8bº®Reã»nû
+
+ gÃw_¥aû_®loÿtiÚ_tÝ
+ =
+
+1741
+Ex\8bº®Reã»nû
+::
+Ãw_¥aû_®loÿtiÚ_tÝ_add»ss
+(
+isީe
+());
+
+1744
+mov
+(
+r0
+,
+O³¿nd
+(~
+kH\97pObjeùTagMask
+));
+
+1745
+ªd_
+(
+objeù
+, objeù,
+r0
+);
+
+1747 #ifdeà
+DEBUG
+
+
+1749
+mov
+(
+sü©ch
+,
+O³¿nd
+(
+Ãw_¥aû_®loÿtiÚ_tÝ
+));
+
+1750
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(scratch));
+
+1751
+cmp
+(
+objeù
+,
+sü©ch
+);
+
+1752
+Check
+(
+É
+,
+kUndoAÎoÿtiÚOfNÚAÎoÿ\8bdMemÜy
+);
+
+1755
+mov
+(
+sü©ch
+,
+O³¿nd
+(
+Ãw_¥aû_®loÿtiÚ_tÝ
+));
+
+1756
+StÜeP
+(
+objeù
+,
+MemO³¿nd
+(
+sü©ch
+));
+
+1760 \1e
+ gMaüoAs£mbËr
+::
+AÎoÿ\8bTwoBy\8bS\8c\9ag
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+Ëngth
+,
+
+1761
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+1762
+Regi¡\94
+
+sü©ch3
+,
+
+1763
+Lab\96
+*
+gc_»qu\9ced
+) {
+
+1766
+DCHECK
+((
+SeqTwoBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ &
+kObjeùAlignm\92tMask
+) == 0);
+
+1767
+¦wi
+(
+sü©ch1
+,
+Ëngth
+,
+O³¿nd
+(1));
+
+1768
+addi
+(
+sü©ch1
+, scratch1,
+
+1769
+O³¿nd
+(
+kObjeùAlignm\92tMask
+ +
+SeqTwoBy\8bS\8c\9ag
+::
+kH\97d\94Size
+));
+
+1770
+mov
+(
+r0
+,
+O³¿nd
+(~
+kObjeùAlignm\92tMask
+));
+
+1771
+ªd_
+(
+sü©ch1
+, sü©ch1,
+r0
+);
+
+1774
+AÎoÿ\8b
+(
+sü©ch1
+,
+»suÉ
+,
+sü©ch2
+,
+sü©ch3
+,
+gc_»qu\9ced
+,
+TAG_OBJECT
+);
+
+1777
+In\99\9flizeNewS\8c\9ag
+(
+»suÉ
+,
+Ëngth
+,
+H\97p
+::
+kS\8c\9agMRoÙIndex
+,
+sü©ch1
+,
+
+1778
+sü©ch2
+);
+
+1782 \1e
+ gMaüoAs£mbËr
+::
+AÎoÿ\8bOÃBy\8bS\8c\9ag
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+Ëngth
+,
+
+1783
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+1784
+Regi¡\94
+
+sü©ch3
+,
+
+1785
+Lab\96
+*
+gc_»qu\9ced
+) {
+
+1788
+DCHECK
+((
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+ &
+kObjeùAlignm\92tMask
+) == 0);
+
+1789
+DCHECK
+(
+kCh¬Size
+ == 1);
+
+1790
+addi
+(
+sü©ch1
+,
+Ëngth
+,
+
+1791
+O³¿nd
+(
+kObjeùAlignm\92tMask
+ +
+SeqOÃBy\8bS\8c\9ag
+::
+kH\97d\94Size
+));
+
+1792
+li
+(
+r0
+,
+O³¿nd
+(~
+kObjeùAlignm\92tMask
+));
+
+1793
+ªd_
+(
+sü©ch1
+, sü©ch1,
+r0
+);
+
+1796
+AÎoÿ\8b
+(
+sü©ch1
+,
+»suÉ
+,
+sü©ch2
+,
+sü©ch3
+,
+gc_»qu\9ced
+,
+TAG_OBJECT
+);
+
+1799
+In\99\9flizeNewS\8c\9ag
+(
+»suÉ
+,
+Ëngth
+,
+H\97p
+::
+kOÃBy\8bS\8c\9agMRoÙIndex
+,
+
+1800
+sü©ch1
+,
+sü©ch2
+);
+
+1804 \1e
+ gMaüoAs£mbËr
+::
+AÎoÿ\8bTwoBy\8bCÚsS\8c\9ag
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+Ëngth
+,
+
+1805
+Regi¡\94
+
+sü©ch1
+,
+
+1806
+Regi¡\94
+
+sü©ch2
+,
+
+1807
+Lab\96
+*
+gc_»qu\9ced
+) {
+
+1808
+AÎoÿ\8b
+(
+CÚsS\8c\9ag
+::
+kSize
+,
+»suÉ
+,
+sü©ch1
+,
+sü©ch2
+,
+gc_»qu\9ced
+,
+
+1809
+TAG_OBJECT
+);
+
+1811
+In\99\9flizeNewS\8c\9ag
+(
+»suÉ
+,
+Ëngth
+,
+H\97p
+::
+kCÚsS\8c\9agMRoÙIndex
+,
+sü©ch1
+,
+
+1812
+sü©ch2
+);
+
+1816 \1e
+ gMaüoAs£mbËr
+::
+AÎoÿ\8bOÃBy\8bCÚsS\8c\9ag
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+Ëngth
+,
+
+1817
+Regi¡\94
+
+sü©ch1
+,
+
+1818
+Regi¡\94
+
+sü©ch2
+,
+
+1819
+Lab\96
+*
+gc_»qu\9ced
+) {
+
+1820
+AÎoÿ\8b
+(
+CÚsS\8c\9ag
+::
+kSize
+,
+»suÉ
+,
+sü©ch1
+,
+sü©ch2
+,
+gc_»qu\9ced
+,
+
+1821
+TAG_OBJECT
+);
+
+1823
+In\99\9flizeNewS\8c\9ag
+(
+»suÉ
+,
+Ëngth
+,
+H\97p
+::
+kCÚsOÃBy\8bS\8c\9agMRoÙIndex
+,
+
+1824
+sü©ch1
+,
+sü©ch2
+);
+
+1828 \1e
+ gMaüoAs£mbËr
+::
+AÎoÿ\8bTwoBy\8bSliûdS\8c\9ag
+(
+Regi¡\94
+
+»suÉ
+,
+
+1829
+Regi¡\94
+
+Ëngth
+,
+
+1830
+Regi¡\94
+
+sü©ch1
+,
+
+1831
+Regi¡\94
+
+sü©ch2
+,
+
+1832
+Lab\96
+*
+gc_»qu\9ced
+) {
+
+1833
+AÎoÿ\8b
+(
+SliûdS\8c\9ag
+::
+kSize
+,
+»suÉ
+,
+sü©ch1
+,
+sü©ch2
+,
+gc_»qu\9ced
+,
+
+1834
+TAG_OBJECT
+);
+
+1836
+In\99\9flizeNewS\8c\9ag
+(
+»suÉ
+,
+Ëngth
+,
+H\97p
+::
+kSliûdS\8c\9agMRoÙIndex
+,
+sü©ch1
+,
+
+1837
+sü©ch2
+);
+
+1841 \1e
+ gMaüoAs£mbËr
+::
+AÎoÿ\8bOÃBy\8bSliûdS\8c\9ag
+(
+Regi¡\94
+
+»suÉ
+,
+
+1842
+Regi¡\94
+
+Ëngth
+,
+
+1843
+Regi¡\94
+
+sü©ch1
+,
+
+1844
+Regi¡\94
+
+sü©ch2
+,
+
+1845
+Lab\96
+*
+gc_»qu\9ced
+) {
+
+1846
+AÎoÿ\8b
+(
+SliûdS\8c\9ag
+::
+kSize
+,
+»suÉ
+,
+sü©ch1
+,
+sü©ch2
+,
+gc_»qu\9ced
+,
+
+1847
+TAG_OBJECT
+);
+
+1849
+In\99\9flizeNewS\8c\9ag
+(
+»suÉ
+,
+Ëngth
+,
+H\97p
+::
+kSliûdOÃBy\8bS\8c\9agMRoÙIndex
+,
+
+1850
+sü©ch1
+,
+sü©ch2
+);
+
+1854 \1e
+ gMaüoAs£mbËr
+::
+Com·»ObjeùTy³
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+m
+,
+
+1855
+Regi¡\94
+
+ty³_»g
+,
+In¡ªûTy³
+
+ty³
+) {
+
+1856 cڡ
+Regi¡\94
+
+ g\8bmp
+ =
+ty³_»g
+.
+is
+(
+no_»g
+è?
+r0
+ :\81ype_reg;
+
+1858
+LßdP
+(
+m
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1859
+Com·»In¡ªûTy³
+(
+m
+,
+\8bmp
+,
+ty³
+);
+
+1863 \1e
+ gMaüoAs£mbËr
+::
+CheckObjeùTy³Rªge
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+m
+,
+
+1864
+In¡ªûTy³
+
+m\9a_ty³
+,
+
+1865
+In¡ªûTy³
+
+max_ty³
+,
+
+1866
+Lab\96
+*
+çl£_Ïb\96
+) {
+
+1867
+STATIC_ASSERT
+(
+M
+::
+kIn¡ªûTy³Off£t
+ < 4096);
+
+1868
+STATIC_ASSERT
+(
+LAST_TYPE
+ < 256);
+
+1869
+LßdP
+(
+m
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+1870
+lbz
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+1871
+subi
+(
+\9d
+, ip,
+O³¿nd
+(
+m\9a_ty³
+));
+
+1872
+cm¶i
+(
+\9d
+,
+O³¿nd
+(
+max_ty³
+ -
+m\9a_ty³
+));
+
+1873
+bgt
+(
+çl£_Ïb\96
+);
+
+1877 \1e
+ gMaüoAs£mbËr
+::
+Com·»In¡ªûTy³
+(
+Regi¡\94
+
+m
+, Regi¡\94
+ty³_»g
+,
+
+1878
+In¡ªûTy³
+
+ty³
+) {
+
+1879
+STATIC_ASSERT
+(
+M
+::
+kIn¡ªûTy³Off£t
+ < 4096);
+
+1880
+STATIC_ASSERT
+(
+LAST_TYPE
+ < 256);
+
+1881
+lbz
+(
+ty³_»g
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+1882
+cmpi
+(
+ty³_»g
+,
+O³¿nd
+(
+ty³
+));
+
+1886 \1e
+ gMaüoAs£mbËr
+::
+Com·»RoÙ
+(
+Regi¡\94
+
+obj
+,
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+) {
+
+1887
+DCHECK
+(!
+obj
+.
+is
+(
+r0
+));
+
+1888
+LßdRoÙ
+(
+r0
+,
+\9adex
+);
+
+1889
+cmp
+(
+obj
+,
+r0
+);
+
+1893 \1e
+ gMaüoAs£mbËr
+::
+CheckFa¡EËm\92ts
+(
+Regi¡\94
+
+m
+, Regi¡\94
+sü©ch
+,
+
+1894
+Lab\96
+*
+ç\9e
+) {
+
+1895
+STATIC_ASSERT
+(
+FAST_SMI_ELEMENTS
+ == 0);
+
+1896
+STATIC_ASSERT
+(
+FAST_HOLEY_SMI_ELEMENTS
+ == 1);
+
+1897
+STATIC_ASSERT
+(
+FAST_ELEMENTS
+ == 2);
+
+1898
+STATIC_ASSERT
+(
+FAST_HOLEY_ELEMENTS
+ == 3);
+
+1899
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kB\99F\9bld2Off£t
+));
+
+1900
+STATIC_ASSERT
+(
+M
+::
+kMaximumB\99F\9bld2Fa¡HÞeyEËm\92tV®ue
+ < 0x8000);
+
+1901
+cm¶i
+(
+sü©ch
+,
+O³¿nd
+(
+M
+::
+kMaximumB\99F\9bld2Fa¡HÞeyEËm\92tV®ue
+));
+
+1902
+bgt
+(
+ç\9e
+);
+
+1906 \1e
+ gMaüoAs£mbËr
+::
+CheckFa¡ObjeùEËm\92ts
+(
+Regi¡\94
+
+m
+, Regi¡\94
+sü©ch
+,
+
+1907
+Lab\96
+*
+ç\9e
+) {
+
+1908
+STATIC_ASSERT
+(
+FAST_SMI_ELEMENTS
+ == 0);
+
+1909
+STATIC_ASSERT
+(
+FAST_HOLEY_SMI_ELEMENTS
+ == 1);
+
+1910
+STATIC_ASSERT
+(
+FAST_ELEMENTS
+ == 2);
+
+1911
+STATIC_ASSERT
+(
+FAST_HOLEY_ELEMENTS
+ == 3);
+
+1912
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kB\99F\9bld2Off£t
+));
+
+1913
+cm¶i
+(
+sü©ch
+,
+O³¿nd
+(
+M
+::
+kMaximumB\99F\9bld2Fa¡HÞeySmiEËm\92tV®ue
+));
+
+1914
+bË
+(
+ç\9e
+);
+
+1915
+cm¶i
+(
+sü©ch
+,
+O³¿nd
+(
+M
+::
+kMaximumB\99F\9bld2Fa¡HÞeyEËm\92tV®ue
+));
+
+1916
+bgt
+(
+ç\9e
+);
+
+1920 \1e
+ gMaüoAs£mbËr
+::
+CheckFa¡SmiEËm\92ts
+(
+Regi¡\94
+
+m
+, Regi¡\94
+sü©ch
+,
+
+1921
+Lab\96
+*
+ç\9e
+) {
+
+1922
+STATIC_ASSERT
+(
+FAST_SMI_ELEMENTS
+ == 0);
+
+1923
+STATIC_ASSERT
+(
+FAST_HOLEY_SMI_ELEMENTS
+ == 1);
+
+1924
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kB\99F\9bld2Off£t
+));
+
+1925
+cm¶i
+(
+sü©ch
+,
+O³¿nd
+(
+M
+::
+kMaximumB\99F\9bld2Fa¡HÞeySmiEËm\92tV®ue
+));
+
+1926
+bgt
+(
+ç\9e
+);
+
+1930 \1e
+ gMaüoAs£mbËr
+::
+StÜeNumb\94ToDoubËEËm\92ts
+(
+
+1931
+Regi¡\94
+
+v®ue_»g
+, Regi¡\94
+key_»g
+, Regi¡\94
+\96em\92ts_»g
+,
+
+1932
+Regi¡\94
+
+sü©ch1
+,
+DoubËRegi¡\94
+
+doubË_sü©ch
+,
+Lab\96
+*
+ç\9e
+,
+
+1933 \12
+\96em\92ts_off£t
+) {
+
+1934
+Lab\96
+
+ gsmi_v®ue
+,
+ g¡Üe
+;
+
+1937
+JumpIfSmi
+(
+v®ue_»g
+, &
+smi_v®ue
+);
+
+1940
+CheckM
+(
+v®ue_»g
+,
+sü©ch1
+,
+isީe
+()->
+çùÜy
+()->
+h\97p_numb\94_m
+(),
+ç\9e
+,
+
+1941
+DONT_DO_SMI_CHECK
+);
+
+1943
+lfd
+(
+doubË_sü©ch
+,
+F\9bldMemO³¿nd
+(
+v®ue_»g
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+1945
+CªÚiÿlizeNaN
+(
+doubË_sü©ch
+);
+
+1946
+b
+(&
+¡Üe
+);
+
+1948
+b\9ad
+(&
+smi_v®ue
+);
+
+1949
+SmiToDoubË
+(
+doubË_sü©ch
+,
+v®ue_»g
+);
+
+1951
+b\9ad
+(&
+¡Üe
+);
+
+1952
+SmiToDoubËA¼ayOff£t
+(
+sü©ch1
+,
+key_»g
+);
+
+1953
+add
+(
+sü©ch1
+,
+\96em\92ts_»g
+, scratch1);
+
+1954
+¡fd
+(
+doubË_sü©ch
+,
+F\9bldMemO³¿nd
+(
+sü©ch1
+,
+FixedDoubËA¼ay
+::
+kH\97d\94Size
+ -
+
+1955
+\96em\92ts_off£t
+));
+
+1959 \1e
+ gMaüoAs£mbËr
+::
+AddAndCheckFÜOv\94æow
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+Ëá
+,
+
+1960
+Regi¡\94
+
+right
+,
+
+1961
+Regi¡\94
+
+ov\94æow_d¡
+,
+
+1962
+Regi¡\94
+
+sü©ch
+) {
+
+1963
+DCHECK
+(!
+d¡
+.
+is
+(
+ov\94æow_d¡
+));
+
+1964
+DCHECK
+(!
+d¡
+.
+is
+(
+sü©ch
+));
+
+1965
+DCHECK
+(!
+ov\94æow_d¡
+.
+is
+(
+sü©ch
+));
+
+1966
+DCHECK
+(!
+ov\94æow_d¡
+.
+is
+(
+Ëá
+));
+
+1967
+DCHECK
+(!
+ov\94æow_d¡
+.
+is
+(
+right
+));
+
+1970 ià(
+ gd¡
+.
+is
+(
+Ëá
+)) {
+
+1971
+mr
+(
+sü©ch
+,
+Ëá
+);
+
+1972
+add
+(
+d¡
+,
+Ëá
+,
+right
+);
+
+1973
+xÜ_
+(
+sü©ch
+,
+d¡
+, scratch);
+
+1974
+xÜ_
+(
+ov\94æow_d¡
+,
+d¡
+,
+right
+);
+
+1975 } \vià(
+ gd¡
+.
+is
+(
+right
+)) {
+
+1976
+mr
+(
+sü©ch
+,
+right
+);
+
+1977
+add
+(
+d¡
+,
+Ëá
+,
+right
+);
+
+1978
+xÜ_
+(
+sü©ch
+,
+d¡
+, scratch);
+
+1979
+xÜ_
+(
+ov\94æow_d¡
+,
+d¡
+,
+Ëá
+);
+
+1981
+add
+(
+d¡
+,
+Ëá
+,
+right
+);
+
+1982
+xÜ_
+(
+ov\94æow_d¡
+,
+d¡
+,
+Ëá
+);
+
+1983
+xÜ_
+(
+sü©ch
+,
+d¡
+,
+right
+);
+
+1985
+ªd_
+(
+ov\94æow_d¡
+,
+sü©ch
+, ov\94æow_d¡,
+S\91RC
+);
+
+1989 \1e
+ gMaüoAs£mbËr
+::
+AddAndCheckFÜOv\94æow
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+Ëá
+,
+
+1990
+\9a\8d\8c_t
+
+right
+,
+
+1991
+Regi¡\94
+
+ov\94æow_d¡
+,
+
+1992
+Regi¡\94
+
+sü©ch
+) {
+
+1993
+Regi¡\94
+
+ gÜig\9a®_Ëá
+ =
+Ëá
+;
+
+1994
+DCHECK
+(!
+d¡
+.
+is
+(
+ov\94æow_d¡
+));
+
+1995
+DCHECK
+(!
+d¡
+.
+is
+(
+sü©ch
+));
+
+1996
+DCHECK
+(!
+ov\94æow_d¡
+.
+is
+(
+sü©ch
+));
+
+1997
+DCHECK
+(!
+ov\94æow_d¡
+.
+is
+(
+Ëá
+));
+
+2000 ià(
+ gd¡
+.
+is
+(
+Ëá
+)) {
+
+2002
+ gÜig\9a®_Ëá
+ =
+ov\94æow_d¡
+;
+
+2003
+mr
+(
+Üig\9a®_Ëá
+,
+Ëá
+);
+
+2005
+Add
+(
+d¡
+,
+Ëá
+,
+right
+,
+sü©ch
+);
+
+2006
+xÜ_
+(
+ov\94æow_d¡
+,
+d¡
+,
+Üig\9a®_Ëá
+);
+
+2007 ià(
+ gright
+ >= 0) {
+
+2008
+ªd_
+(
+ov\94æow_d¡
+, ov\94æow_d¡,
+d¡
+,
+S\91RC
+);
+
+2010
+ªdc
+(
+ov\94æow_d¡
+, ov\94æow_d¡,
+d¡
+,
+S\91RC
+);
+
+2015 \1e
+ gMaüoAs£mbËr
+::
+SubAndCheckFÜOv\94æow
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+Ëá
+,
+
+2016
+Regi¡\94
+
+right
+,
+
+2017
+Regi¡\94
+
+ov\94æow_d¡
+,
+
+2018
+Regi¡\94
+
+sü©ch
+) {
+
+2019
+DCHECK
+(!
+d¡
+.
+is
+(
+ov\94æow_d¡
+));
+
+2020
+DCHECK
+(!
+d¡
+.
+is
+(
+sü©ch
+));
+
+2021
+DCHECK
+(!
+ov\94æow_d¡
+.
+is
+(
+sü©ch
+));
+
+2022
+DCHECK
+(!
+ov\94æow_d¡
+.
+is
+(
+Ëá
+));
+
+2023
+DCHECK
+(!
+ov\94æow_d¡
+.
+is
+(
+right
+));
+
+2026 ià(
+ gd¡
+.
+is
+(
+Ëá
+)) {
+
+2027
+mr
+(
+sü©ch
+,
+Ëá
+);
+
+2028
+sub
+(
+d¡
+,
+Ëá
+,
+right
+);
+
+2029
+xÜ_
+(
+ov\94æow_d¡
+,
+d¡
+,
+sü©ch
+);
+
+2030
+xÜ_
+(
+sü©ch
+, sü©ch,
+right
+);
+
+2031
+ªd_
+(
+ov\94æow_d¡
+, ov\94æow_d¡,
+sü©ch
+,
+S\91RC
+);
+
+2032 } \vià(
+ gd¡
+.
+is
+(
+right
+)) {
+
+2033
+mr
+(
+sü©ch
+,
+right
+);
+
+2034
+sub
+(
+d¡
+,
+Ëá
+,
+right
+);
+
+2035
+xÜ_
+(
+ov\94æow_d¡
+,
+d¡
+,
+Ëá
+);
+
+2036
+xÜ_
+(
+sü©ch
+,
+Ëá
+, scratch);
+
+2037
+ªd_
+(
+ov\94æow_d¡
+, ov\94æow_d¡,
+sü©ch
+,
+S\91RC
+);
+
+2039
+sub
+(
+d¡
+,
+Ëá
+,
+right
+);
+
+2040
+xÜ_
+(
+ov\94æow_d¡
+,
+d¡
+,
+Ëá
+);
+
+2041
+xÜ_
+(
+sü©ch
+,
+Ëá
+,
+right
+);
+
+2042
+ªd_
+(
+ov\94æow_d¡
+,
+sü©ch
+, ov\94æow_d¡,
+S\91RC
+);
+
+2047 \1e
+ gMaüoAs£mbËr
+::
+Com·»M
+(
+Regi¡\94
+
+obj
+, Regi¡\94
+sü©ch
+,
+HªdË
+<
+M
+>
+m
+,
+
+2048
+Lab\96
+*
+\97¾y_sucûss
+) {
+
+2049
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+obj
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2050
+Com·»M
+(
+sü©ch
+,
+m
+,
+\97¾y_sucûss
+);
+
+2054 \1e
+ gMaüoAs£mbËr
+::
+Com·»M
+(
+Regi¡\94
+
+obj_m
+,
+HªdË
+<
+M
+>
+m
+,
+
+2055
+Lab\96
+*
+\97¾y_sucûss
+) {
+
+2056
+mov
+(
+r0
+,
+O³¿nd
+(
+m
+));
+
+2057
+cmp
+(
+obj_m
+,
+r0
+);
+
+2061 \1e
+ gMaüoAs£mbËr
+::
+CheckM
+(
+Regi¡\94
+
+obj
+, Regi¡\94
+sü©ch
+,
+HªdË
+<
+M
+>
+m
+,
+
+2062
+Lab\96
+*
+ç\9e
+,
+SmiCheckTy³
+
+smi_check_ty³
+) {
+
+2063 ià(
+ gsmi_check_ty³
+ =ð
+DO_SMI_CHECK
+) {
+
+2064
+JumpIfSmi
+(
+obj
+,
+ç\9e
+);
+
+2067
+Lab\96
+
+ gsucûss
+;
+
+2068
+Com·»M
+(
+obj
+,
+sü©ch
+,
+m
+, &
+sucûss
+);
+
+2069
+bÃ
+(
+ç\9e
+);
+
+2070
+b\9ad
+(&
+sucûss
+);
+
+2074 \1e
+ gMaüoAs£mbËr
+::
+CheckM
+(
+Regi¡\94
+
+obj
+, Regi¡\94
+sü©ch
+,
+
+2075
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+,
+Lab\96
+*
+ç\9e
+,
+
+2076
+SmiCheckTy³
+
+smi_check_ty³
+) {
+
+2077 ià(
+ gsmi_check_ty³
+ =ð
+DO_SMI_CHECK
+) {
+
+2078
+JumpIfSmi
+(
+obj
+,
+ç\9e
+);
+
+2080
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+obj
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2081
+LßdRoÙ
+(
+r0
+,
+\9adex
+);
+
+2082
+cmp
+(
+sü©ch
+,
+r0
+);
+
+2083
+bÃ
+(
+ç\9e
+);
+
+2087 \1e
+ gMaüoAs£mbËr
+::
+Di¥©chM
+(
+Regi¡\94
+
+obj
+, Regi¡\94
+sü©ch
+,
+
+2088
+HªdË
+<
+M
+>
+m
+, HªdË<
+Code
+>
+sucûss
+,
+
+2089
+SmiCheckTy³
+
+smi_check_ty³
+) {
+
+2090
+Lab\96
+
+ gç\9e
+;
+
+2091 ià(
+ gsmi_check_ty³
+ =ð
+DO_SMI_CHECK
+) {
+
+2092
+JumpIfSmi
+(
+obj
+, &
+ç\9e
+);
+
+2094
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+obj
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2095
+mov
+(
+r0
+,
+O³¿nd
+(
+m
+));
+
+2096
+cmp
+(
+sü©ch
+,
+r0
+);
+
+2097
+bÃ
+(&
+ç\9e
+);
+
+2098
+Jump
+(
+sucûss
+,
+R\96ocInfo
+::
+CODE_TARGET
+,
+®
+);
+
+2099
+b\9ad
+(&
+ç\9e
+);
+
+2103 \1e
+ gMaüoAs£mbËr
+::
+TryG\91FunùiÚPrÙÙy³
+(
+Regi¡\94
+
+funùiÚ
+, Regi¡\94
+»suÉ
+,
+
+2104
+Regi¡\94
+
+sü©ch
+,
+Lab\96
+*
+miss
+,
+
+2105
+boÞ
+
+miss_Ú_bound_funùiÚ
+) {
+
+2106
+Lab\96
+
+ gnÚ_\9a¡ªû
+;
+
+2107 ià(
+ gmiss_Ú_bound_funùiÚ
+) {
+
+2109
+JumpIfSmi
+(
+funùiÚ
+,
+miss
+);
+
+2112
+Com·»ObjeùTy³
+(
+funùiÚ
+,
+»suÉ
+,
+sü©ch
+,
+JS_FUNCTION_TYPE
+);
+
+2113
+bÃ
+(
+miss
+);
+
+2115
+LßdP
+(
+sü©ch
+,
+
+2116
+F\9bldMemO³¿nd
+(
+funùiÚ
+,
+JSFunùiÚ
+::
+kSh¬edFunùiÚInfoOff£t
+));
+
+2117
+lwz
+(
+sü©ch
+,
+
+2118
+F\9bldMemO³¿nd
+(
+sü©ch
+,
+Sh¬edFunùiÚInfo
+::
+kComp\9e\94H\9atsOff£t
+));
+
+2119
+Te¡B\99
+(
+sü©ch
+,
+
+2120 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2121
+Sh¬edFunùiÚInfo
+::
+kBoundFunùiÚ
+,
+
+2123
+Sh¬edFunùiÚInfo
+::
+kBoundFunùiÚ
+ +
+kSmiTagSize
+,
+
+2125
+r0
+);
+
+2126
+bÃ
+(
+miss
+,
+ü0
+);
+
+2129
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+»suÉ
+,
+M
+::
+kB\99F\9bldOff£t
+));
+
+2130
+ªdi
+(
+r0
+,
+sü©ch
+,
+O³¿nd
+(1 <<
+M
+::
+kHasNÚIn¡ªûPrÙÙy³
+));
+
+2131
+bÃ
+(&
+nÚ_\9a¡ªû
+,
+ü0
+);
+
+2135
+LßdP
+(
+»suÉ
+,
+
+2136
+F\9bldMemO³¿nd
+(
+funùiÚ
+,
+JSFunùiÚ
+::
+kPrÙÙy³OrIn\99\9flMOff£t
+));
+
+2141
+LßdRoÙ
+(
+r0
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+2142
+cmp
+(
+»suÉ
+,
+r0
+);
+
+2143
+beq
+(
+miss
+);
+
+2146
+Lab\96
+
+ gdÚe
+;
+
+2147
+Com·»ObjeùTy³
+(
+»suÉ
+,
+sü©ch
+, sü©ch,
+MAP_TYPE
+);
+
+2148
+bÃ
+(&
+dÚe
+);
+
+2151
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+ÔesuÉ,
+M
+::
+kPrÙÙy³Off£t
+));
+
+2153 ià(
+ gmiss_Ú_bound_funùiÚ
+) {
+
+2154
+b
+(&
+dÚe
+);
+
+2158
+b\9ad
+(&
+nÚ_\9a¡ªû
+);
+
+2159
+LßdP
+(
+»suÉ
+,
+F\9bldMemO³¿nd
+ÔesuÉ,
+M
+::
+kCÚ¡ruùÜOff£t
+));
+
+2163
+b\9ad
+(&
+dÚe
+);
+
+2167 \1e
+ gMaüoAs£mbËr
+::
+C®lStub
+(
+CodeStub
+*
+¡ub
+,
+Ty³F\93dbackId
+
+a¡_id
+,
+
+2168
+CÚd\99iÚ
+
+cÚd
+) {
+
+2169
+DCHECK
+(
+AÎowThisStubC®l
+(
+¡ub
+));
+
+2170
+C®l
+(
+¡ub
+->
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+,
+a¡_id
+,
+cÚd
+);
+
+2174 \1e
+ gMaüoAs£mbËr
+::
+Ta\9eC®lStub
+(
+CodeStub
+*
+¡ub
+,
+CÚd\99iÚ
+
+cÚd
+) {
+
+2175
+Jump
+(
+¡ub
+->
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+,
+cÚd
+);
+
+2179 \18\12
+Add»ssOff£t
+(
+Ex\8bº®Reã»nû
+
+»f0
+, Ex\8bº®Reã»nû
+»f1
+) {
+
+2180 \15
+ g»f0
+.
+add»ss
+(è-
+ g»f1
+.address();
+
+2184 \1e
+ gMaüoAs£mbËr
+::
+C®lApiFunùiÚAndR\91uº
+(
+
+2185
+Regi¡\94
+
+funùiÚ_add»ss
+,
+Ex\8bº®Reã»nû
+
+thunk_»f
+, \12
+¡ack_¥aû
+,
+
+2186
+MemO³¿nd
+
+»tuº_v®ue_Ý\94ªd
+, MemO³¿nd*
+cÚ\8bxt_»¡Üe_Ý\94ªd
+) {
+
+2187
+Ex\8bº®Reã»nû
+
+ gÃxt_add»ss
+ =
+
+2188
+Ex\8bº®Reã»nû
+::
+hªdË_scÝe_Ãxt_add»ss
+(
+isީe
+());
+
+2189 cڡ \12
+ gkNextOff£t
+ = 0;
+
+2190 cڡ \12
+ gkLim\99Off£t
+ =
+Add»ssOff£t
+(
+
+2191
+Ex\8bº®Reã»nû
+::
+hªdË_scÝe_lim\99_add»ss
+(
+isީe
+()),
+Ãxt_add»ss
+);
+
+2192 cڡ \12
+ gkLev\96Off£t
+ =
+Add»ssOff£t
+(
+
+2193
+Ex\8bº®Reã»nû
+::
+hªdË_scÝe_Ëv\96_add»ss
+(
+isީe
+()),
+Ãxt_add»ss
+);
+
+2195
+DCHECK
+(
+funùiÚ_add»ss
+.
+is
+(
+r4
+è|| funùiÚ_add»ss.is(
+r5
+));
+
+2196
+Regi¡\94
+
+ gsü©ch
+ =
+r6
+;
+
+2198
+Lab\96
+
+ g´of\9e\94_di§bËd
+;
+
+2199
+Lab\96
+
+ g\92d_´of\9e\94_check
+;
+
+2200
+mov
+(
+sü©ch
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+is_´of\9e\9ag_add»ss
+(
+isީe
+())));
+
+2201
+lbz
+(
+sü©ch
+,
+MemO³¿nd
+(scratch, 0));
+
+2202
+cmpi
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+2203
+beq
+(&
+´of\9e\94_di§bËd
+);
+
+2206
+mov
+(
+sü©ch
+,
+O³¿nd
+(
+thunk_»f
+));
+
+2207
+jmp
+(&
+\92d_´of\9e\94_check
+);
+
+2209
+b\9ad
+(&
+´of\9e\94_di§bËd
+);
+
+2210
+mr
+(
+sü©ch
+,
+funùiÚ_add»ss
+);
+
+2211
+b\9ad
+(&
+\92d_´of\9e\94_check
+);
+
+2218
+mov
+(
+r17
+,
+O³¿nd
+(
+Ãxt_add»ss
+));
+
+2219
+LßdP
+(
+r14
+,
+MemO³¿nd
+(
+r17
+,
+kNextOff£t
+));
+
+2220
+LßdP
+(
+r15
+,
+MemO³¿nd
+(
+r17
+,
+kLim\99Off£t
+));
+
+2221
+lwz
+(
+r16
+,
+MemO³¿nd
+(
+r17
+,
+kLev\96Off£t
+));
+
+2222
+addi
+(
+r16
+,\8416,
+O³¿nd
+(1));
+
+2223
+¡w
+(
+r16
+,
+MemO³¿nd
+(
+r17
+,
+kLev\96Off£t
+));
+
+2225 ià(
+ gFLAG_log_tim\94_ev\92ts
+) {
+
+2226
+F¿meScÝe
+
+äame
+(
+this
+,
+S\8fckF¿me
+::
+MANUAL
+);
+
+2227
+PushSaãpo\9atRegi¡\94s
+();
+
+2228
+P»·»C®lCFunùiÚ
+(1,
+r3
+);
+
+2229
+mov
+(
+r3
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+isީe
+())));
+
+2230
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+::
+log_\92\8br_ex\8bº®_funùiÚ
+(
+isީe
+()), 1);
+
+2231
+PÝSaãpo\9atRegi¡\94s
+();
+
+2237
+D\9ceùCEÁryStub
+
+¡ub
+(
+isީe
+());
+
+2238
+ g¡ub
+.
+G\92\94©eC®l
+(
+this
+,
+sü©ch
+);
+
+2240 ià(
+ gFLAG_log_tim\94_ev\92ts
+) {
+
+2241
+F¿meScÝe
+
+äame
+(
+this
+,
+S\8fckF¿me
+::
+MANUAL
+);
+
+2242
+PushSaãpo\9atRegi¡\94s
+();
+
+2243
+P»·»C®lCFunùiÚ
+(1,
+r3
+);
+
+2244
+mov
+(
+r3
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+isީe
+())));
+
+2245
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+::
+log_Ëave_ex\8bº®_funùiÚ
+(
+isީe
+()), 1);
+
+2246
+PÝSaãpo\9atRegi¡\94s
+();
+
+2249
+Lab\96
+
+ g´omÙe_scheduËd_exû±iÚ
+;
+
+2250
+Lab\96
+
+ gexû±iÚ_hªdËd
+;
+
+2251
+Lab\96
+
+ gd\96\91e_®loÿ\8bd_hªdËs
+;
+
+2252
+Lab\96
+
+ gËave_ex\99_äame
+;
+
+2253
+Lab\96
+
+ g»tuº_v®ue_lßded
+;
+
+2256
+LßdP
+(
+r3
+,
+»tuº_v®ue_Ý\94ªd
+);
+
+2257
+b\9ad
+(&
+»tuº_v®ue_lßded
+);
+
+2260
+StÜeP
+(
+r14
+,
+MemO³¿nd
+(
+r17
+,
+kNextOff£t
+));
+
+2261 ià(
+em\99_debug_code
+()) {
+
+2262
+lwz
+(
+r4
+,
+MemO³¿nd
+(
+r17
+,
+kLev\96Off£t
+));
+
+2263
+cmp
+(
+r4
+,
+r16
+);
+
+2264
+Check
+(
+eq
+,
+kUÃx³ùedLev\96Aá\94R\91uºFromApiC®l
+);
+
+2266
+subi
+(
+r16
+,\8416,
+O³¿nd
+(1));
+
+2267
+¡w
+(
+r16
+,
+MemO³¿nd
+(
+r17
+,
+kLev\96Off£t
+));
+
+2268
+LßdP
+(
+r0
+,
+MemO³¿nd
+(
+r17
+,
+kLim\99Off£t
+));
+
+2269
+cmp
+(
+r15
+,
+r0
+);
+
+2270
+bÃ
+(&
+d\96\91e_®loÿ\8bd_hªdËs
+);
+
+2273
+b\9ad
+(&
+Ëave_ex\99_äame
+);
+
+2274
+LßdRoÙ
+(
+r14
+,
+H\97p
+::
+kTheHÞeV®ueRoÙIndex
+);
+
+2275
+mov
+(
+r15
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+scheduËd_exû±iÚ_add»ss
+(
+isީe
+())));
+
+2276
+LßdP
+(
+r15
+,
+MemO³¿nd
+(r15));
+
+2277
+cmp
+(
+r14
+,
+r15
+);
+
+2278
+bÃ
+(&
+´omÙe_scheduËd_exû±iÚ
+);
+
+2279
+b\9ad
+(&
+exû±iÚ_hªdËd
+);
+
+2281
+boÞ
+
+ g»¡Üe_cÚ\8bxt
+ =
+cÚ\8bxt_»¡Üe_Ý\94ªd
+ !ð
+NULL
+;
+
+2282 ià(
+ g»¡Üe_cÚ\8bxt
+) {
+
+2283
+LßdP
+(
+ý
+, *
+cÚ\8bxt_»¡Üe_Ý\94ªd
+);
+
+2286
+mov
+(
+r14
+,
+O³¿nd
+(
+¡ack_¥aû
+));
+
+2287
+L\97veEx\99F¿me
+(
+çl£
+,
+r14
+, !
+»¡Üe_cÚ\8bxt
+);
+
+2288
+bÌ
+();
+
+2290
+b\9ad
+(&
+´omÙe_scheduËd_exû±iÚ
+);
+
+2292
+F¿meScÝe
+
+äame
+(
+this
+,
+S\8fckF¿me
+::
+INTERNAL
+);
+
+2293
+C®lEx\8bº®Reã»nû
+(
+
+2294
+Ex\8bº®Reã»nû
+(
+RuÁime
+::
+kPromÙeScheduËdExû±iÚ
+,
+isީe
+()), 0);
+
+2296
+jmp
+(&
+exû±iÚ_hªdËd
+);
+
+2299
+b\9ad
+(&
+d\96\91e_®loÿ\8bd_hªdËs
+);
+
+2300
+StÜeP
+(
+r15
+,
+MemO³¿nd
+(
+r17
+,
+kLim\99Off£t
+));
+
+2301
+mr
+(
+r14
+,
+r3
+);
+
+2302
+P»·»C®lCFunùiÚ
+(1,
+r15
+);
+
+2303
+mov
+(
+r3
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+isީe
+())));
+
+2304
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+::
+d\96\91e_hªdË_scÝe_ex\8bnsiÚs
+(
+isީe
+()),
+
+2306
+mr
+(
+r3
+,
+r14
+);
+
+2307
+b
+(&
+Ëave_ex\99_äame
+);
+
+2311
+boÞ
+
+ gMaüoAs£mbËr
+::
+AÎowThisStubC®l
+(
+CodeStub
+*
+¡ub
+) {
+
+2312 \15
+has_äame_
+ || !
+¡ub
+->
+Som\91imesS\91sUpAF¿me
+();
+
+2316 \1e
+ gMaüoAs£mbËr
+::
+IndexFromHash
+(
+Regi¡\94
+
+hash
+, Regi¡\94
+\9adex
+) {
+
+2321
+DCHECK
+(
+T\92ToThe
+(
+S\8c\9ag
+::
+kMaxCachedA¼ayIndexL\92gth
+) <
+
+2322 (1 <<
+S\8c\9ag
+::
+kA¼ayIndexV®ueB\99s
+));
+
+2323
+ gDecodeF\9bldToSmi
+<
+ gS\8c\9ag
+::
+A¼ayIndexV®ueB\99s
+>(
+\9adex
+,
+ ghash
+);
+
+2327 \1e
+ gMaüoAs£mbËr
+::
+SmiToDoubË
+(
+DoubËRegi¡\94
+
+v®ue
+,
+Regi¡\94
+
+smi
+) {
+
+2328
+SmiUÁag
+(
+\9d
+,
+smi
+);
+
+2329
+CÚv\94tIÁToDoubË
+(
+\9d
+,
+v®ue
+);
+
+2333 \1e
+ gMaüoAs£mbËr
+::
+Te¡DoubËIsIÁ32
+(
+DoubËRegi¡\94
+
+doubË_\9aput
+,
+
+2334
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+2335
+DoubËRegi¡\94
+
+doubË_sü©ch
+) {
+
+2336
+TryDoubËToIÁ32Exaù
+(
+sü©ch1
+,
+doubË_\9aput
+,
+sü©ch2
+,
+doubË_sü©ch
+);
+
+2340 \1e
+ gMaüoAs£mbËr
+::
+TryDoubËToIÁ32Exaù
+(
+Regi¡\94
+
+»suÉ
+,
+
+2341
+DoubËRegi¡\94
+
+doubË_\9aput
+,
+
+2342
+Regi¡\94
+
+sü©ch
+,
+
+2343
+DoubËRegi¡\94
+
+doubË_sü©ch
+) {
+
+2344
+Lab\96
+
+ gdÚe
+;
+
+2345
+DCHECK
+(!
+doubË_\9aput
+.
+is
+(
+doubË_sü©ch
+));
+
+2347
+CÚv\94tDoubËToIÁ64
+(
+doubË_\9aput
+,
+
+2348 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+2349
+sü©ch
+,
+
+2351
+»suÉ
+,
+doubË_sü©ch
+);
+
+2353 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2354
+Te¡IfIÁ32
+(
+»suÉ
+,
+sü©ch
+,
+r0
+);
+
+2356
+Te¡IfIÁ32
+(
+sü©ch
+,
+»suÉ
+,
+r0
+);
+
+2358
+bÃ
+(&
+dÚe
+);
+
+2361
+fcfid
+(
+doubË_sü©ch
+, double_scratch);
+
+2362
+fcmpu
+(
+doubË_sü©ch
+,
+doubË_\9aput
+);
+
+2363
+b\9ad
+(&
+dÚe
+);
+
+2367 \1e
+ gMaüoAs£mbËr
+::
+TryIÁ32FloÜ
+(
+Regi¡\94
+
+»suÉ
+,
+DoubËRegi¡\94
+
+doubË_\9aput
+,
+
+2368
+Regi¡\94
+
+\9aput_high
+, Regi¡\94
+sü©ch
+,
+
+2369
+DoubËRegi¡\94
+
+doubË_sü©ch
+,
+Lab\96
+*
+dÚe
+,
+
+2370
+Lab\96
+*
+exaù
+) {
+
+2371
+DCHECK
+(!
+»suÉ
+.
+is
+(
+\9aput_high
+));
+
+2372
+DCHECK
+(!
+doubË_\9aput
+.
+is
+(
+doubË_sü©ch
+));
+
+2373
+Lab\96
+
+ gexû±iÚ
+;
+
+2375
+MovDoubËHighToIÁ
+(
+\9aput_high
+,
+doubË_\9aput
+);
+
+2378
+Ex\8caùB\99Mask
+(
+»suÉ
+,
+\9aput_high
+,
+H\97pNumb\94
+::
+kExpڒtMask
+);
+
+2379
+cm¶i
+(
+»suÉ
+,
+O³¿nd
+(0x7ff));
+
+2380
+beq
+(&
+exû±iÚ
+);
+
+2383
+CÚv\94tDoubËToIÁ64
+(
+doubË_\9aput
+,
+
+2384 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+2385
+sü©ch
+,
+
+2387
+»suÉ
+,
+doubË_sü©ch
+,
+kRoundToM\9ausInf
+);
+
+2390 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2391
+Te¡IfIÁ32
+(
+»suÉ
+,
+sü©ch
+,
+r0
+);
+
+2393
+Te¡IfIÁ32
+(
+sü©ch
+,
+»suÉ
+,
+r0
+);
+
+2395
+bÃ
+(&
+exû±iÚ
+);
+
+2398
+fcfid
+(
+doubË_sü©ch
+, double_scratch);
+
+2399
+fcmpu
+(
+doubË_sü©ch
+,
+doubË_\9aput
+);
+
+2400
+beq
+(
+exaù
+);
+
+2401
+b
+(
+dÚe
+);
+
+2403
+b\9ad
+(&
+exû±iÚ
+);
+
+2407 \1e
+ gMaüoAs£mbËr
+::
+TryIÆ\9aeTrunÿ\8bDoubËToI
+(
+Regi¡\94
+
+»suÉ
+,
+
+2408
+DoubËRegi¡\94
+
+doubË_\9aput
+,
+
+2409
+Lab\96
+*
+dÚe
+) {
+
+2410
+DoubËRegi¡\94
+
+ gdoubË_sü©ch
+ =
+kSü©chDoubËReg
+;
+
+2411
+Regi¡\94
+
+ gsü©ch
+ =
+\9d
+;
+
+2413
+CÚv\94tDoubËToIÁ64
+(
+doubË_\9aput
+,
+
+2414 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+2415
+sü©ch
+,
+
+2417
+»suÉ
+,
+doubË_sü©ch
+);
+
+2420 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2421
+Te¡IfIÁ32
+(
+»suÉ
+,
+sü©ch
+,
+r0
+);
+
+2423
+Te¡IfIÁ32
+(
+sü©ch
+,
+»suÉ
+,
+r0
+);
+
+2425
+beq
+(
+dÚe
+);
+
+2429 \1e
+ gMaüoAs£mbËr
+::
+Trunÿ\8bDoubËToI
+(
+Regi¡\94
+
+»suÉ
+,
+
+2430
+DoubËRegi¡\94
+
+doubË_\9aput
+) {
+
+2431
+Lab\96
+
+ gdÚe
+;
+
+2433
+TryIÆ\9aeTrunÿ\8bDoubËToI
+(
+»suÉ
+,
+doubË_\9aput
+, &
+dÚe
+);
+
+2436
+mær
+(
+r0
+);
+
+2437
+push
+(
+r0
+);
+
+2439
+¡fdu
+(
+doubË_\9aput
+,
+MemO³¿nd
+(
+¥
+, -
+kDoubËSize
+));
+
+2441
+DoubËToIStub
+
+¡ub
+(
+isީe
+(),
+¥
+,
+»suÉ
+, 0,
+\8cue
+,\81rue);
+
+2442
+C®lStub
+(&
+¡ub
+);
+
+2444
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+2445
+pÝ
+(
+r0
+);
+
+2446
+m\8er
+(
+r0
+);
+
+2448
+b\9ad
+(&
+dÚe
+);
+
+2452 \1e
+ gMaüoAs£mbËr
+::
+Trunÿ\8bH\97pNumb\94ToI
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+objeù
+) {
+
+2453
+Lab\96
+
+ gdÚe
+;
+
+2454
+DoubËRegi¡\94
+
+ gdoubË_sü©ch
+ =
+kSü©chDoubËReg
+;
+
+2455
+DCHECK
+(!
+»suÉ
+.
+is
+(
+objeù
+));
+
+2457
+lfd
+(
+doubË_sü©ch
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+2458
+TryIÆ\9aeTrunÿ\8bDoubËToI
+(
+»suÉ
+,
+doubË_sü©ch
+, &
+dÚe
+);
+
+2461
+mær
+(
+r0
+);
+
+2462
+push
+(
+r0
+);
+
+2463
+DoubËToIStub
+
+¡ub
+(
+isީe
+(),
+objeù
+,
+»suÉ
+,
+
+2464
+H\97pNumb\94
+::
+kV®ueOff£t
+ -
+kH\97pObjeùTag
+,
+\8cue
+,\81rue);
+
+2465
+C®lStub
+(&
+¡ub
+);
+
+2466
+pÝ
+(
+r0
+);
+
+2467
+m\8er
+(
+r0
+);
+
+2469
+b\9ad
+(&
+dÚe
+);
+
+2473 \1e
+ gMaüoAs£mbËr
+::
+Trunÿ\8bNumb\94ToI
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+»suÉ
+,
+
+2474
+Regi¡\94
+
+h\97p_numb\94_m
+,
+
+2475
+Regi¡\94
+
+sü©ch1
+,
+Lab\96
+*
+nÙ_numb\94
+) {
+
+2476
+Lab\96
+
+ gdÚe
+;
+
+2477
+DCHECK
+(!
+»suÉ
+.
+is
+(
+objeù
+));
+
+2479
+UÁagAndJumpIfSmi
+(
+»suÉ
+,
+objeù
+, &
+dÚe
+);
+
+2480
+JumpIfNÙH\97pNumb\94
+(
+objeù
+,
+h\97p_numb\94_m
+,
+sü©ch1
+,
+nÙ_numb\94
+);
+
+2481
+Trunÿ\8bH\97pNumb\94ToI
+(
+»suÉ
+,
+objeù
+);
+
+2483
+b\9ad
+(&
+dÚe
+);
+
+2487 \1e
+ gMaüoAs£mbËr
+::
+G\91L\97¡B\99sFromSmi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+
+2488 \12
+num_Ëa¡_b\99s
+) {
+
+2489 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2490
+¾diþ
+(
+d¡
+,
+¤c
+,
+kB\99sP\94Po\9a\8br
+ -
+kSmiShiá
+,
+
+2491
+kB\99sP\94Po\9a\8br
+ -
+num_Ëa¡_b\99s
+);
+
+2493
+¾w\9am
+(
+d¡
+,
+¤c
+,
+kB\99sP\94Po\9a\8br
+ -
+kSmiShiá
+,
+
+2494
+kB\99sP\94Po\9a\8br
+ -
+num_Ëa¡_b\99s
+, 31);
+
+2499 \1e
+ gMaüoAs£mbËr
+::
+G\91L\97¡B\99sFromIÁ32
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+
+2500 \12
+num_Ëa¡_b\99s
+) {
+
+2501
+¾w\9am
+(
+d¡
+,
+¤c
+, 0, 32 -
+num_Ëa¡_b\99s
+, 31);
+
+2505 \1e
+ gMaüoAs£mbËr
+::
+C®lRuÁime
+(cڡ
+RuÁime
+::
+FunùiÚ
+*
+f
+, \12
+num_¬gum\92ts
+,
+
+2506
+SaveFPRegsMode
+
+§ve_doubËs
+) {
+
+2512
+CHECK
+(
+f
+->
+Çrgs
+ < 0 || f->Çrg =ð
+num_¬gum\92ts
+);
+
+2518
+mov
+(
+r3
+,
+O³¿nd
+(
+num_¬gum\92ts
+));
+
+2519
+mov
+(
+r4
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+f
+,
+isީe
+())));
+
+2520
+CEÁryStub
+
+¡ub
+(
+isީe
+(),
+
+2521 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2522
+f
+->
+»suÉ_size
+,
+
+2526
+§ve_doubËs
+);
+
+2527
+C®lStub
+(&
+¡ub
+);
+
+2531 \1e
+ gMaüoAs£mbËr
+::
+C®lEx\8bº®Reã»nû
+(cڡ
+Ex\8bº®Reã»nû
+&
+ext
+,
+
+2532 \12
+num_¬gum\92ts
+) {
+
+2533
+mov
+(
+r3
+,
+O³¿nd
+(
+num_¬gum\92ts
+));
+
+2534
+mov
+(
+r4
+,
+O³¿nd
+(
+ext
+));
+
+2536
+CEÁryStub
+
+¡ub
+(
+isީe
+(), 1);
+
+2537
+C®lStub
+(&
+¡ub
+);
+
+2541 \1e
+ gMaüoAs£mbËr
+::
+Ta\9eC®lEx\8bº®Reã»nû
+(cڡ
+Ex\8bº®Reã»nû
+&
+ext
+,
+
+2542 \12
+num_¬gum\92ts
+,
+
+2543 \12
+»suÉ_size
+) {
+
+2548
+mov
+(
+r3
+,
+O³¿nd
+(
+num_¬gum\92ts
+));
+
+2549
+JumpToEx\8bº®Reã»nû
+(
+ext
+);
+
+2553 \1e
+ gMaüoAs£mbËr
+::
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+FunùiÚId
+
+fid
+, \12
+num_¬gum\92ts
+,
+
+2554 \12
+»suÉ_size
+) {
+
+2555
+Ta\9eC®lEx\8bº®Reã»nû
+(
+Ex\8bº®Reã»nû
+(
+fid
+,
+isީe
+()),
+num_¬gum\92ts
+,
+
+2556
+»suÉ_size
+);
+
+2560 \1e
+ gMaüoAs£mbËr
+::
+JumpToEx\8bº®Reã»nû
+(cڡ
+Ex\8bº®Reã»nû
+&
+bu\9et\9a
+) {
+
+2561
+mov
+(
+r4
+,
+O³¿nd
+(
+bu\9et\9a
+));
+
+2562
+CEÁryStub
+
+¡ub
+(
+isީe
+(), 1);
+
+2563
+Jump
+(
+¡ub
+.
+G\91Code
+(),
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+2567 \1e
+ gMaüoAs£mbËr
+::
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+JavaSü\9dt
+
+id
+,
+InvokeFÏg
+
+æag
+,
+
+2568 cڡ
+C®lW¿µ\94
+&
+ÿÎ_w¿µ\94
+) {
+
+2570
+DCHECK
+(
+æag
+ =ð
+JUMP_FUNCTION
+ ||
+has_äame
+());
+
+2572
+G\91Bu\9et\9aEÁry
+(
+\9d
+,
+id
+);
+
+2573 ià(
+ gæag
+ =ð
+CALL_FUNCTION
+) {
+
+2574
+ÿÎ_w¿µ\94
+.
+BefÜeC®l
+(
+C®lSize
+(
+\9d
+));
+
+2575
+C®lJSEÁry
+(
+\9d
+);
+
+2576
+ gÿÎ_w¿µ\94
+.
+Aá\94C®l
+();
+
+2578
+DCHECK
+(
+æag
+ =ð
+JUMP_FUNCTION
+);
+
+2579
+JumpToJSEÁry
+(
+\9d
+);
+
+2584 \1e
+ gMaüoAs£mbËr
+::
+G\91Bu\9et\9aFunùiÚ
+(
+Regi¡\94
+
+\8frg\91
+,
+
+2585
+Bu\9et\9as
+::
+JavaSü\9dt
+
+id
+) {
+
+2587
+LßdP
+(
+\8frg\91
+,
+
+2588
+MemO³¿nd
+(
+ý
+,
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+GLOBAL_OBJECT_INDEX
+)));
+
+2589
+LßdP
+(
+\8frg\91
+,
+F\9bldMemO³¿nd
+Ѭg\91,
+Glob®Objeù
+::
+kBu\9et\9asOff£t
+));
+
+2591
+LßdP
+(
+\8frg\91
+,
+
+2592
+F\9bldMemO³¿nd
+(
+\8frg\91
+,
+JSBu\9et\9asObjeù
+::
+Off£tOfFunùiÚW\99hId
+(
+id
+)),
+
+2593
+r0
+);
+
+2597 \1e
+ gMaüoAs£mbËr
+::
+G\91Bu\9et\9aEÁry
+(
+Regi¡\94
+
+\8frg\91
+,
+Bu\9et\9as
+::
+JavaSü\9dt
+
+id
+) {
+
+2598
+DCHECK
+(!
+\8frg\91
+.
+is
+(
+r4
+));
+
+2599
+G\91Bu\9et\9aFunùiÚ
+(
+r4
+,
+id
+);
+
+2601
+LßdP
+(
+\8frg\91
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+JSFunùiÚ
+::
+kCodeEÁryOff£t
+));
+
+2605 \1e
+ gMaüoAs£mbËr
+::
+S\91CouÁ\94
+(
+S\8ftsCouÁ\94
+*
+couÁ\94
+, \12
+v®ue
+,
+
+2606
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+) {
+
+2607 ià(
+ gFLAG_Çtive_code_couÁ\94s
+ &&
+ gcouÁ\94
+->
+EÇbËd
+()) {
+
+2608
+mov
+(
+sü©ch1
+,
+O³¿nd
+(
+v®ue
+));
+
+2609
+mov
+(
+sü©ch2
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+couÁ\94
+)));
+
+2610
+¡w
+(
+sü©ch1
+,
+MemO³¿nd
+(
+sü©ch2
+));
+
+2615 \1e
+ gMaüoAs£mbËr
+::
+Inüem\92tCouÁ\94
+(
+S\8ftsCouÁ\94
+*
+couÁ\94
+, \12
+v®ue
+,
+
+2616
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+) {
+
+2617
+DCHECK
+(
+v®ue
+ > 0);
+
+2618 ià(
+ gFLAG_Çtive_code_couÁ\94s
+ &&
+ gcouÁ\94
+->
+EÇbËd
+()) {
+
+2619
+mov
+(
+sü©ch2
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+couÁ\94
+)));
+
+2620
+lwz
+(
+sü©ch1
+,
+MemO³¿nd
+(
+sü©ch2
+));
+
+2621
+addi
+(
+sü©ch1
+, sü©ch1,
+O³¿nd
+(
+v®ue
+));
+
+2622
+¡w
+(
+sü©ch1
+,
+MemO³¿nd
+(
+sü©ch2
+));
+
+2627 \1e
+ gMaüoAs£mbËr
+::
+Deüem\92tCouÁ\94
+(
+S\8ftsCouÁ\94
+*
+couÁ\94
+, \12
+v®ue
+,
+
+2628
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+) {
+
+2629
+DCHECK
+(
+v®ue
+ > 0);
+
+2630 ià(
+ gFLAG_Çtive_code_couÁ\94s
+ &&
+ gcouÁ\94
+->
+EÇbËd
+()) {
+
+2631
+mov
+(
+sü©ch2
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+(
+couÁ\94
+)));
+
+2632
+lwz
+(
+sü©ch1
+,
+MemO³¿nd
+(
+sü©ch2
+));
+
+2633
+subi
+(
+sü©ch1
+, sü©ch1,
+O³¿nd
+(
+v®ue
+));
+
+2634
+¡w
+(
+sü©ch1
+,
+MemO³¿nd
+(
+sü©ch2
+));
+
+2639 \1e
+ gMaüoAs£mbËr
+::
+As£¹
+(
+CÚd\99iÚ
+
+cÚd
+,
+Ba\9eoutR\97sÚ
+
+»asÚ
+,
+
+2640
+CRegi¡\94
+
+ü
+) {
+
+2641 ià(
+em\99_debug_code
+()è
+Check
+(
+cÚd
+,
+»asÚ
+,
+ü
+);
+
+2645 \1e
+ gMaüoAs£mbËr
+::
+As£¹Fa¡EËm\92ts
+(
+Regi¡\94
+
+\96em\92ts
+) {
+
+2646 ià(
+em\99_debug_code
+()) {
+
+2647
+DCHECK
+(!
+\96em\92ts
+.
+is
+(
+r0
+));
+
+2648
+Lab\96
+
+ gok
+;
+
+2649
+push
+(
+\96em\92ts
+);
+
+2650
+LßdP
+(
+\96em\92ts
+,
+F\9bldMemO³¿nd
+ÓËm\92ts,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2651
+LßdRoÙ
+(
+r0
+,
+H\97p
+::
+kFixedA¼ayMRoÙIndex
+);
+
+2652
+cmp
+(
+\96em\92ts
+,
+r0
+);
+
+2653
+beq
+(&
+ok
+);
+
+2654
+LßdRoÙ
+(
+r0
+,
+H\97p
+::
+kFixedDoubËA¼ayMRoÙIndex
+);
+
+2655
+cmp
+(
+\96em\92ts
+,
+r0
+);
+
+2656
+beq
+(&
+ok
+);
+
+2657
+LßdRoÙ
+(
+r0
+,
+H\97p
+::
+kFixedCOWA¼ayMRoÙIndex
+);
+
+2658
+cmp
+(
+\96em\92ts
+,
+r0
+);
+
+2659
+beq
+(&
+ok
+);
+
+2660
+AbÜt
+(
+kJSObjeùW\99hFa¡EËm\92tsMHasSlowEËm\92ts
+);
+
+2661
+b\9ad
+(&
+ok
+);
+
+2662
+pÝ
+(
+\96em\92ts
+);
+
+2667 \1e
+ gMaüoAs£mbËr
+::
+Check
+(
+CÚd\99iÚ
+
+cÚd
+,
+Ba\9eoutR\97sÚ
+
+»asÚ
+,
+CRegi¡\94
+
+ü
+) {
+
+2668
+Lab\96
+
+ gL
+;
+
+2669
+b
+(
+cÚd
+, &
+L
+,
+ü
+);
+
+2670
+AbÜt
+(
+»asÚ
+);
+
+2672
+b\9ad
+(&
+L
+);
+
+2676 \1e
+ gMaüoAs£mbËr
+::
+AbÜt
+(
+Ba\9eoutR\97sÚ
+
+»asÚ
+) {
+
+2677
+Lab\96
+
+abÜt_¡¬t
+;
+
+2678
+b\9ad
+(&
+abÜt_¡¬t
+);
+
+2679 #ifdeà
+DEBUG
+
+
+2680 cڡ \ 5*
+ gmsg
+ =
+G\91Ba\9eoutR\97sÚ
+(
+»asÚ
+);
+
+2681 ià(
+ gmsg
+ !ð
+NULL
+) {
+
+2682
+RecÜdComm\92t
+("Abort message: ");
+
+2683
+RecÜdComm\92t
+(
+msg
+);
+
+2686 ià(
+ gFLAG_\8c_Ú_abÜt
+) {
+
+2687
+¡Ý
+(
+msg
+);
+
+2692
+LßdSmiL\99\94®
+(
+r0
+,
+Smi
+::
+FromIÁ
+(
+»asÚ
+));
+
+2693
+push
+(
+r0
+);
+
+2695 ià(!
+ ghas_äame_
+) {
+
+2698
+F¿meScÝe
+
+scÝe
+(
+this
+,
+S\8fckF¿me
+::
+NONE
+);
+
+2699
+C®lRuÁime
+(
+RuÁime
+::
+kAbÜt
+, 1);
+
+2701
+C®lRuÁime
+(
+RuÁime
+::
+kAbÜt
+, 1);
+
+2707 \1e
+ gMaüoAs£mbËr
+::
+LßdCÚ\8bxt
+(
+Regi¡\94
+
+d¡
+, \12
+cÚ\8bxt_cha\9a_Ëngth
+) {
+
+2708 ià(
+ gcÚ\8bxt_cha\9a_Ëngth
+ > 0) {
+
+2710
+LßdP
+(
+d¡
+,
+MemO³¿nd
+(
+ý
+,
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+PREVIOUS_INDEX
+)));
+
+2711 \ f\12
+ gi
+ = 1; i <
+ gcÚ\8bxt_cha\9a_Ëngth
+; i++) {
+
+2712
+LßdP
+(
+d¡
+,
+MemO³¿nd
+(d¡,
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+PREVIOUS_INDEX
+)));
+
+2718
+mr
+(
+d¡
+,
+ý
+);
+
+2723 \1e
+ gMaüoAs£mbËr
+::
+LßdT¿ns\99iÚedA¼ayMCÚd\99iÚ®
+(
+
+2724
+EËm\92tsK\9ad
+
+ex³ùed_k\9ad
+, EËm\92tsK\9ad
+\8cªs\99iÚed_k\9ad
+,
+
+2725
+Regi¡\94
+
+m_\9a_out
+, Regi¡\94
+sü©ch
+,
+Lab\96
+*
+no_m_m©ch
+) {
+
+2727
+LßdP
+(
+sü©ch
+,
+
+2728
+MemO³¿nd
+(
+ý
+,
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+GLOBAL_OBJECT_INDEX
+)));
+
+2729
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+Glob®Objeù
+::
+kN©iveCÚ\8bxtOff£t
+));
+
+2732
+LßdP
+(
+sü©ch
+,
+
+2733
+MemO³¿nd
+(
+sü©ch
+,
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+JS_ARRAY_MAPS_INDEX
+)));
+
+2734
+size_t
+
+ goff£t
+ =
+ex³ùed_k\9ad
+ *
+kPo\9a\8brSize
+ +
+FixedA¼ayBa£
+::
+kH\97d\94Size
+;
+
+2735
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+off£t
+));
+
+2736
+cmp
+(
+m_\9a_out
+,
+sü©ch
+);
+
+2737
+bÃ
+(
+no_m_m©ch
+);
+
+2740
+ goff£t
+ =
+\8cªs\99iÚed_k\9ad
+ *
+kPo\9a\8brSize
+ +
+FixedA¼ayBa£
+::
+kH\97d\94Size
+;
+
+2741
+LßdP
+(
+m_\9a_out
+,
+F\9bldMemO³¿nd
+(
+sü©ch
+,
+off£t
+));
+
+2745 \1e
+ gMaüoAs£mbËr
+::
+LßdGlob®FunùiÚ
+(\12
+\9adex
+,
+Regi¡\94
+
+funùiÚ
+) {
+
+2747
+LßdP
+(
+funùiÚ
+,
+
+2748
+MemO³¿nd
+(
+ý
+,
+Cڋxt
+::
+SlÙOff£t
+(Cڋxt::
+GLOBAL_OBJECT_INDEX
+)));
+
+2750
+LßdP
+(
+funùiÚ
+,
+
+2751
+F\9bldMemO³¿nd
+(
+funùiÚ
+,
+Glob®Objeù
+::
+kN©iveCÚ\8bxtOff£t
+));
+
+2753
+LßdP
+(
+funùiÚ
+,
+MemO³¿nd
+(funùiÚ,
+Cڋxt
+::
+SlÙOff£t
+(
+\9adex
+)),
+r0
+);
+
+2757 \1e
+ gMaüoAs£mbËr
+::
+LßdGlob®FunùiÚIn\99\9flM
+(
+Regi¡\94
+
+funùiÚ
+,
+
+2758
+Regi¡\94
+
+m
+,
+
+2759
+Regi¡\94
+
+sü©ch
+) {
+
+2761
+LßdP
+(
+m
+,
+
+2762
+F\9bldMemO³¿nd
+(
+funùiÚ
+,
+JSFunùiÚ
+::
+kPrÙÙy³OrIn\99\9flMOff£t
+));
+
+2763 ià(
+em\99_debug_code
+()) {
+
+2764
+Lab\96
+
+ gok
+,
+ gç\9e
+;
+
+2765
+CheckM
+(
+m
+,
+sü©ch
+,
+H\97p
+::
+kM\91aMRoÙIndex
+, &
+ç\9e
+,
+DO_SMI_CHECK
+);
+
+2766
+b
+(&
+ok
+);
+
+2767
+b\9ad
+(&
+ç\9e
+);
+
+2768
+AbÜt
+(
+kGlob®FunùiÚsMu¡HaveIn\99\9flM
+);
+
+2769
+b\9ad
+(&
+ok
+);
+
+2774 \1e
+ gMaüoAs£mbËr
+::
+JumpIfNÙPow\94OfTwoOrZ\94o
+(
+
+2775
+Regi¡\94
+
+»g
+, Regi¡\94
+sü©ch
+,
+Lab\96
+*
+nÙ_pow\94_of_two_Ü_z\94o
+) {
+
+2776
+subi
+(
+sü©ch
+,
+»g
+,
+O³¿nd
+(1));
+
+2777
+cmpi
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+2778
+bÉ
+(
+nÙ_pow\94_of_two_Ü_z\94o
+);
+
+2779
+ªd_
+(
+r0
+,
+sü©ch
+,
+»g
+,
+S\91RC
+);
+
+2780
+bÃ
+(
+nÙ_pow\94_of_two_Ü_z\94o
+,
+ü0
+);
+
+2784 \1e
+ gMaüoAs£mbËr
+::
+JumpIfNÙPow\94OfTwoOrZ\94oAndNeg
+(
+Regi¡\94
+
+»g
+,
+
+2785
+Regi¡\94
+
+sü©ch
+,
+
+2786
+Lab\96
+*
+z\94o_ªd_Ãg
+,
+
+2787
+Lab\96
+*
+nÙ_pow\94_of_two
+) {
+
+2788
+subi
+(
+sü©ch
+,
+»g
+,
+O³¿nd
+(1));
+
+2789
+cmpi
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+2790
+bÉ
+(
+z\94o_ªd_Ãg
+);
+
+2791
+ªd_
+(
+r0
+,
+sü©ch
+,
+»g
+,
+S\91RC
+);
+
+2792
+bÃ
+(
+nÙ_pow\94_of_two
+,
+ü0
+);
+
+2795 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+2796 \1e
+ gMaüoAs£mbËr
+::
+SmiTagCheckOv\94æow
+(
+Regi¡\94
+
+»g
+, Regi¡\94
+ov\94æow
+) {
+
+2797
+DCHECK
+(!
+»g
+.
+is
+(
+ov\94æow
+));
+
+2798
+mr
+(
+ov\94æow
+,
+»g
+);
+
+2799
+SmiTag
+(
+»g
+);
+
+2800
+xÜ_
+(
+ov\94æow
+, ov\94æow,
+»g
+,
+S\91RC
+);
+
+2804 \1e
+ gMaüoAs£mbËr
+::
+SmiTagCheckOv\94æow
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+
+2805
+Regi¡\94
+
+ov\94æow
+) {
+
+2806 ià(
+ gd¡
+.
+is
+(
+¤c
+)) {
+
+2808
+SmiTagCheckOv\94æow
+(
+d¡
+,
+ov\94æow
+);
+
+2810
+DCHECK
+(!
+d¡
+.
+is
+(
+¤c
+));
+
+2811
+DCHECK
+(!
+d¡
+.
+is
+(
+ov\94æow
+));
+
+2812
+DCHECK
+(!
+¤c
+.
+is
+(
+ov\94æow
+));
+
+2813
+SmiTag
+(
+d¡
+,
+¤c
+);
+
+2814
+xÜ_
+(
+ov\94æow
+,
+d¡
+,
+¤c
+,
+S\91RC
+);
+
+2819 \1e
+ gMaüoAs£mbËr
+::
+JumpIfNÙBÙhSmi
+(
+Regi¡\94
+
+»g1
+, Regi¡\94
+»g2
+,
+
+2820
+Lab\96
+*
+Ú_nÙ_bÙh_smi
+) {
+
+2821
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+2822
+DCHECK_EQ
+(1,
+¡©ic_ÿ¡
+<\12>(
+kSmiTagMask
+));
+
+2823
+Üx
+(
+r0
+,
+»g1
+,
+»g2
+,
+L\97veRC
+);
+
+2824
+JumpIfNÙSmi
+(
+r0
+,
+Ú_nÙ_bÙh_smi
+);
+
+2828 \1e
+ gMaüoAs£mbËr
+::
+UÁagAndJumpIfSmi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+
+2829
+Lab\96
+*
+smi_ÿ£
+) {
+
+2830
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+2831
+STATIC_ASSERT
+(
+kSmiTagSize
+ == 1);
+
+2832
+Te¡B\99
+(
+¤c
+, 0,
+r0
+);
+
+2833
+SmiUÁag
+(
+d¡
+,
+¤c
+);
+
+2834
+beq
+(
+smi_ÿ£
+,
+ü0
+);
+
+2838 \1e
+ gMaüoAs£mbËr
+::
+UÁagAndJumpIfNÙSmi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+
+2839
+Lab\96
+*
+nÚ_smi_ÿ£
+) {
+
+2840
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+2841
+STATIC_ASSERT
+(
+kSmiTagSize
+ == 1);
+
+2842
+Te¡B\99
+(
+¤c
+, 0,
+r0
+);
+
+2843
+SmiUÁag
+(
+d¡
+,
+¤c
+);
+
+2844
+bÃ
+(
+nÚ_smi_ÿ£
+,
+ü0
+);
+
+2848 \1e
+ gMaüoAs£mbËr
+::
+JumpIfE\99h\94Smi
+(
+Regi¡\94
+
+»g1
+, Regi¡\94
+»g2
+,
+
+2849
+Lab\96
+*
+Ú_e\99h\94_smi
+) {
+
+2850
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+2851
+JumpIfSmi
+(
+»g1
+,
+Ú_e\99h\94_smi
+);
+
+2852
+JumpIfSmi
+(
+»g2
+,
+Ú_e\99h\94_smi
+);
+
+2856 \1e
+ gMaüoAs£mbËr
+::
+As£¹NÙSmi
+(
+Regi¡\94
+
+objeù
+) {
+
+2857 ià(
+em\99_debug_code
+()) {
+
+2858
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+2859
+Te¡IfSmi
+(
+objeù
+,
+r0
+);
+
+2860
+Check
+(
+Ã
+,
+kO³¿ndIsASmi
+,
+ü0
+);
+
+2865 \1e
+ gMaüoAs£mbËr
+::
+As£¹Smi
+(
+Regi¡\94
+
+objeù
+) {
+
+2866 ià(
+em\99_debug_code
+()) {
+
+2867
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+2868
+Te¡IfSmi
+(
+objeù
+,
+r0
+);
+
+2869
+Check
+(
+eq
+,
+kO³¿ndIsNÙSmi
+,
+ü0
+);
+
+2874 \1e
+ gMaüoAs£mbËr
+::
+As£¹S\8c\9ag
+(
+Regi¡\94
+
+objeù
+) {
+
+2875 ià(
+em\99_debug_code
+()) {
+
+2876
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+2877
+Te¡IfSmi
+(
+objeù
+,
+r0
+);
+
+2878
+Check
+(
+Ã
+,
+kO³¿ndIsASmiAndNÙAS\8c\9ag
+,
+ü0
+);
+
+2879
+push
+(
+objeù
+);
+
+2880
+LßdP
+(
+objeù
+,
+F\9bldMemO³¿nd
+(objeù,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2881
+Com·»In¡ªûTy³
+(
+objeù
+, objeù,
+FIRST_NONSTRING_TYPE
+);
+
+2882
+pÝ
+(
+objeù
+);
+
+2883
+Check
+(
+É
+,
+kO³¿ndIsNÙAS\8c\9ag
+);
+
+2888 \1e
+ gMaüoAs£mbËr
+::
+As£¹Name
+(
+Regi¡\94
+
+objeù
+) {
+
+2889 ià(
+em\99_debug_code
+()) {
+
+2890
+STATIC_ASSERT
+(
+kSmiTag
+ == 0);
+
+2891
+Te¡IfSmi
+(
+objeù
+,
+r0
+);
+
+2892
+Check
+(
+Ã
+,
+kO³¿ndIsASmiAndNÙAName
+,
+ü0
+);
+
+2893
+push
+(
+objeù
+);
+
+2894
+LßdP
+(
+objeù
+,
+F\9bldMemO³¿nd
+(objeù,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2895
+Com·»In¡ªûTy³
+(
+objeù
+, objeù,
+LAST_NAME_TYPE
+);
+
+2896
+pÝ
+(
+objeù
+);
+
+2897
+Check
+(
+Ë
+,
+kO³¿ndIsNÙAName
+);
+
+2902 \1e
+ gMaüoAs£mbËr
+::
+As£¹Undef\9aedOrAÎoÿtiÚS\99e
+(
+Regi¡\94
+
+objeù
+,
+
+2903
+Regi¡\94
+
+sü©ch
+) {
+
+2904 ià(
+em\99_debug_code
+()) {
+
+2905
+Lab\96
+
+ gdÚe_check\9ag
+;
+
+2906
+As£¹NÙSmi
+(
+objeù
+);
+
+2907
+Com·»RoÙ
+(
+objeù
+,
+H\97p
+::
+kUndef\9aedV®ueRoÙIndex
+);
+
+2908
+beq
+(&
+dÚe_check\9ag
+);
+
+2909
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2910
+Com·»RoÙ
+(
+sü©ch
+,
+H\97p
+::
+kAÎoÿtiÚS\99eMRoÙIndex
+);
+
+2911
+As£¹
+(
+eq
+,
+kEx³ùedUndef\9aedOrC\96l
+);
+
+2912
+b\9ad
+(&
+dÚe_check\9ag
+);
+
+2917 \1e
+ gMaüoAs£mbËr
+::
+As£¹IsRoÙ
+(
+Regi¡\94
+
+»g
+,
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+) {
+
+2918 ià(
+em\99_debug_code
+()) {
+
+2919
+Com·»RoÙ
+(
+»g
+,
+\9adex
+);
+
+2920
+Check
+(
+eq
+,
+kH\97pNumb\94MRegi¡\94Clobb\94ed
+);
+
+2925 \1e
+ gMaüoAs£mbËr
+::
+JumpIfNÙH\97pNumb\94
+(
+Regi¡\94
+
+objeù
+,
+
+2926
+Regi¡\94
+
+h\97p_numb\94_m
+,
+
+2927
+Regi¡\94
+
+sü©ch
+,
+
+2928
+Lab\96
+*
+Ú_nÙ_h\97p_numb\94
+) {
+
+2929
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+2930
+As£¹IsRoÙ
+(
+h\97p_numb\94_m
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+2931
+cmp
+(
+sü©ch
+,
+h\97p_numb\94_m
+);
+
+2932
+bÃ
+(
+Ú_nÙ_h\97p_numb\94
+);
+
+2936 \1e
+ gMaüoAs£mbËr
+::
+LookupNumb\94S\8c\9agCache
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+»suÉ
+,
+
+2937
+Regi¡\94
+
+sü©ch1
+,
+
+2938
+Regi¡\94
+
+sü©ch2
+,
+
+2939
+Regi¡\94
+
+sü©ch3
+,
+
+2940
+Lab\96
+*
+nÙ_found
+) {
+
+2942
+Regi¡\94
+
+ gnumb\94_¡r\9ag_ÿche
+ =
+»suÉ
+;
+
+2943
+Regi¡\94
+
+ gmask
+ =
+sü©ch3
+;
+
+2946
+LßdRoÙ
+(
+numb\94_¡r\9ag_ÿche
+,
+H\97p
+::
+kNumb\94S\8c\9agCacheRoÙIndex
+);
+
+2950
+LßdP
+(
+mask
+,
+F\9bldMemO³¿nd
+(
+numb\94_¡r\9ag_ÿche
+,
+FixedA¼ay
+::
+kL\92gthOff£t
+));
+
+2952
+ShiáRightAr\99hImm
+(
+mask
+, mask,
+kSmiTagSize
+ +
+kSmiShiáSize
+ + 1);
+
+2953
+subi
+(
+mask
+, mask,
+O³¿nd
+(1));
+
+2959
+Lab\96
+
+ gis_smi
+;
+
+2960
+Lab\96
+
+ glßd_»suÉ_äom_ÿche
+;
+
+2961
+JumpIfSmi
+(
+objeù
+, &
+is_smi
+);
+
+2962
+CheckM
+(
+objeù
+,
+sü©ch1
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+,
+nÙ_found
+,
+
+2963
+DONT_DO_SMI_CHECK
+);
+
+2965
+STATIC_ASSERT
+(8 =ð
+kDoubËSize
+);
+
+2966
+lwz
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pNumb\94
+::
+kExpÚ\92tOff£t
+));
+
+2967
+lwz
+(
+sü©ch2
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pNumb\94
+::
+kMªtis§Off£t
+));
+
+2968
+xÜ_
+(
+sü©ch1
+, sü©ch1,
+sü©ch2
+);
+
+2969
+ªd_
+(
+sü©ch1
+, sü©ch1,
+mask
+);
+
+2973
+ShiáLeáImm
+(
+sü©ch1
+, sü©ch1,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+ + 1));
+
+2974
+add
+(
+sü©ch1
+,
+numb\94_¡r\9ag_ÿche
+, scratch1);
+
+2976
+Regi¡\94
+
+ g´obe
+ =
+mask
+;
+
+2977
+LßdP
+(
+´obe
+,
+F\9bldMemO³¿nd
+(
+sü©ch1
+,
+FixedA¼ay
+::
+kH\97d\94Size
+));
+
+2978
+JumpIfSmi
+(
+´obe
+,
+nÙ_found
+);
+
+2979
+lfd
+(
+d0
+,
+F\9bldMemO³¿nd
+(
+objeù
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+2980
+lfd
+(
+d1
+,
+F\9bldMemO³¿nd
+(
+´obe
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+2981
+fcmpu
+(
+d0
+,
+d1
+);
+
+2982
+bÃ
+(
+nÙ_found
+);
+
+2983
+b
+(&
+lßd_»suÉ_äom_ÿche
+);
+
+2985
+b\9ad
+(&
+is_smi
+);
+
+2986
+Regi¡\94
+
+ gsü©ch
+ =
+sü©ch1
+;
+
+2987
+SmiUÁag
+(
+sü©ch
+,
+objeù
+);
+
+2988
+ªd_
+(
+sü©ch
+,
+mask
+, scratch);
+
+2991
+ShiáLeáImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+ + 1));
+
+2992
+add
+(
+sü©ch
+,
+numb\94_¡r\9ag_ÿche
+, scratch);
+
+2995
+LßdP
+(
+´obe
+,
+F\9bldMemO³¿nd
+(
+sü©ch
+,
+FixedA¼ay
+::
+kH\97d\94Size
+));
+
+2996
+cmp
+(
+objeù
+,
+´obe
+);
+
+2997
+bÃ
+(
+nÙ_found
+);
+
+3000
+b\9ad
+(&
+lßd_»suÉ_äom_ÿche
+);
+
+3001
+LßdP
+(
+»suÉ
+,
+
+3002
+F\9bldMemO³¿nd
+(
+sü©ch
+,
+FixedA¼ay
+::
+kH\97d\94Size
+ +
+kPo\9a\8brSize
+));
+
+3003
+Inüem\92tCouÁ\94
+(
+isީe
+()->
+couÁ\94s
+()->
+numb\94_to_¡r\9ag_Çtive
+(), 1,
+
+3004
+sü©ch1
+,
+sü©ch2
+);
+
+3008 \1e
+ gMaüoAs£mbËr
+::
+JumpIfNÚSmisNÙBÙhSequ\92t\9flOÃBy\8bS\8c\9ags
+(
+
+3009
+Regi¡\94
+
+f\9c¡
+, Regi¡\94
+£cÚd
+, Regi¡\94
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+3010
+Lab\96
+*
+ç\9eu»
+) {
+
+3013
+LßdP
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(
+f\9c¡
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3014
+LßdP
+(
+sü©ch2
+,
+F\9bldMemO³¿nd
+(
+£cÚd
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3015
+lbz
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(sü©ch1,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3016
+lbz
+(
+sü©ch2
+,
+F\9bldMemO³¿nd
+(sü©ch2,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3018
+JumpIfBÙhIn¡ªûTy³sA»NÙSequ\92t\9flOÃBy\8b
+(
+sü©ch1
+,
+sü©ch2
+, scratch1,
+
+3019
+sü©ch2
+,
+ç\9eu»
+);
+
+3022 \1e
+ gMaüoAs£mbËr
+::
+JumpIfNÙBÙhSequ\92t\9flOÃBy\8bS\8c\9ags
+(
+Regi¡\94
+
+f\9c¡
+,
+
+3023
+Regi¡\94
+
+£cÚd
+,
+
+3024
+Regi¡\94
+
+sü©ch1
+,
+
+3025
+Regi¡\94
+
+sü©ch2
+,
+
+3026
+Lab\96
+*
+ç\9eu»
+) {
+
+3028
+ªd_
+(
+sü©ch1
+,
+f\9c¡
+,
+£cÚd
+);
+
+3029
+JumpIfSmi
+(
+sü©ch1
+,
+ç\9eu»
+);
+
+3030
+JumpIfNÚSmisNÙBÙhSequ\92t\9flOÃBy\8bS\8c\9ags
+(
+f\9c¡
+,
+£cÚd
+,
+sü©ch1
+,
+
+3031
+sü©ch2
+,
+ç\9eu»
+);
+
+3035 \1e
+ gMaüoAs£mbËr
+::
+JumpIfNÙUniqueNameIn¡ªûTy³
+(
+Regi¡\94
+
+»g
+,
+
+3036
+Lab\96
+*
+nÙ_unique_Çme
+) {
+
+3037
+STATIC_ASSERT
+(
+kIÁ\94ÇlizedTag
+ =ð0 &&
+kS\8c\9agTag
+ == 0);
+
+3038
+Lab\96
+
+ gsucûed
+;
+
+3039
+ªdi
+(
+r0
+,
+»g
+,
+O³¿nd
+(
+kIsNÙS\8c\9agMask
+ |
+kIsNÙIÁ\94ÇlizedMask
+));
+
+3040
+beq
+(&
+sucûed
+,
+ü0
+);
+
+3041
+cmpi
+(
+»g
+,
+O³¿nd
+(
+SYMBOL_TYPE
+));
+
+3042
+bÃ
+(
+nÙ_unique_Çme
+);
+
+3044
+b\9ad
+(&
+sucûed
+);
+
+3050 \1e
+ gMaüoAs£mbËr
+::
+AÎoÿ\8bH\97pNumb\94
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+sü©ch1
+,
+
+3051
+Regi¡\94
+
+sü©ch2
+,
+
+3052
+Regi¡\94
+
+h\97p_numb\94_m
+,
+
+3053
+Lab\96
+*
+gc_»qu\9ced
+,
+
+3054
+Tagg\9agMode
+
+\8fgg\9ag_mode
+,
+
+3055
+Mu\8fbËMode
+
+mode
+) {
+
+3058
+AÎoÿ\8b
+(
+H\97pNumb\94
+::
+kSize
+,
+»suÉ
+,
+sü©ch1
+,
+sü©ch2
+,
+gc_»qu\9ced
+,
+
+3059
+\8fgg\9ag_mode
+ =ð
+TAG_RESULT
+ ?
+TAG_OBJECT
+ :
+NO_ALLOCATION_FLAGS
+);
+
+3061
+ gH\97p
+::
+RoÙLi¡Index
+
+m_\9adex
+ =
+mode
+ =ð
+MUTABLE
+
+
+3062 ?
+H\97p
+::
+kMu\8fbËH\97pNumb\94MRoÙIndex
+
+
+3063 :
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+;
+
+3064
+As£¹IsRoÙ
+(
+h\97p_numb\94_m
+,
+m_\9adex
+);
+
+3067 ià(
+ g\8fgg\9ag_mode
+ =ð
+TAG_RESULT
+) {
+
+3068
+StÜeP
+(
+h\97p_numb\94_m
+,
+F\9bldMemO³¿nd
+(
+»suÉ
+,
+H\97pObjeù
+::
+kMOff£t
+),
+
+3069
+r0
+);
+
+3071
+StÜeP
+(
+h\97p_numb\94_m
+,
+MemO³¿nd
+(
+»suÉ
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3076 \1e
+ gMaüoAs£mbËr
+::
+AÎoÿ\8bH\97pNumb\94W\99hV®ue
+(
+
+3077
+Regi¡\94
+
+»suÉ
+,
+DoubËRegi¡\94
+
+v®ue
+, Regi¡\94
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+3078
+Regi¡\94
+
+h\97p_numb\94_m
+,
+Lab\96
+*
+gc_»qu\9ced
+) {
+
+3079
+AÎoÿ\8bH\97pNumb\94
+(
+»suÉ
+,
+sü©ch1
+,
+sü©ch2
+,
+h\97p_numb\94_m
+,
+gc_»qu\9ced
+);
+
+3080
+¡fd
+(
+v®ue
+,
+F\9bldMemO³¿nd
+(
+»suÉ
+,
+H\97pNumb\94
+::
+kV®ueOff£t
+));
+
+3085 \1e
+ gMaüoAs£mbËr
+::
+CÝyF\9blds
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+RegLi¡
+
+\8bmps
+,
+
+3086 \12
+f\9bld_couÁ
+) {
+
+3088
+DCHECK
+((
+\8bmps
+ & ((1 << 15) - 1)) != 0);
+
+3089
+DCHECK
+((
+\8bmps
+ &
+d¡
+.
+b\99
+()) == 0);
+
+3090
+DCHECK
+((
+\8bmps
+ &
+¤c
+.
+b\99
+()) == 0);
+
+3093
+Regi¡\94
+
+ gtmp
+ =
+no_»g
+;
+
+3095 \ f\12
+ gi
+ = 0; i < 15; i++) {
+
+3096 ià((
+ g\8bmps
+ & (1 <<
+ gi
+)) != 0) {
+
+3097
+tmp
+.
+£t_code
+(
+i
+);
+
+3101
+DCHECK
+(!
+tmp
+.
+is
+(
+no_»g
+));
+
+3103 \ f\12
+ gi
+ = 0; i <
+ gf\9bld_couÁ
+; i++) {
+
+3104
+LßdP
+(
+tmp
+,
+F\9bldMemO³¿nd
+(
+¤c
+,
+i
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+3105
+StÜeP
+(
+tmp
+,
+F\9bldMemO³¿nd
+(
+d¡
+,
+i
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+3110 \1e
+ gMaüoAs£mbËr
+::
+CÝyBy\8bs
+(
+Regi¡\94
+
+¤c
+, Regi¡\94
+d¡
+, Regi¡\94
+Ëngth
+,
+
+3111
+Regi¡\94
+
+sü©ch
+) {
+
+3112
+Lab\96
+
+ g®ign_loÝ
+,
+ g®igÃd
+,
+ gwÜd_loÝ
+,
+ gby\8b_loÝ
+,
+ gby\8b_loÝ_1
+,
+ gdÚe
+;
+
+3114
+DCHECK
+(!
+sü©ch
+.
+is
+(
+r0
+));
+
+3116
+cmpi
+(
+Ëngth
+,
+O³¿nd
+::
+Z\94o
+());
+
+3117
+beq
+(&
+dÚe
+);
+
+3120
+ªdi
+(
+sü©ch
+,
+¤c
+,
+O³¿nd
+(
+kPo\9a\8brSize
+ - 1));
+
+3121
+beq
+(&
+®igÃd
+,
+ü0
+);
+
+3122
+subfic
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kPo\9a\8brSize
+ * 2));
+
+3123
+cmp
+(
+Ëngth
+,
+sü©ch
+);
+
+3124
+bÉ
+(&
+by\8b_loÝ
+);
+
+3127
+subi
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+3128
+mtùr
+(
+sü©ch
+);
+
+3129
+b\9ad
+(&
+®ign_loÝ
+);
+
+3130
+lbz
+(
+sü©ch
+,
+MemO³¿nd
+(
+¤c
+));
+
+3131
+addi
+(
+¤c
+, src,
+O³¿nd
+(1));
+
+3132
+subi
+(
+Ëngth
+,\86\92gth,
+O³¿nd
+(1));
+
+3133
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+));
+
+3134
+addi
+(
+d¡
+, d¡,
+O³¿nd
+(1));
+
+3135
+bdnz
+(&
+®ign_loÝ
+);
+
+3137
+b\9ad
+(&
+®igÃd
+);
+
+3140 ià(
+em\99_debug_code
+()) {
+
+3141
+ªdi
+(
+r0
+,
+¤c
+,
+O³¿nd
+(
+kPo\9a\8brSize
+ - 1));
+
+3142
+As£¹
+(
+eq
+,
+kEx³ù\9agAlignm\92tFÜCÝyBy\8bs
+,
+ü0
+);
+
+3145
+ShiáRightImm
+(
+sü©ch
+,
+Ëngth
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+3146
+cmpi
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+3147
+beq
+(&
+by\8b_loÝ
+);
+
+3149
+mtùr
+(
+sü©ch
+);
+
+3150
+b\9ad
+(&
+wÜd_loÝ
+);
+
+3151
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¤c
+));
+
+3152
+addi
+(
+¤c
+, src,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+3153
+subi
+(
+Ëngth
+,\86\92gth,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+3154 ià(
+ gCpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+UNALIGNED_ACCESSES
+)) {
+
+3156
+StÜeP
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+));
+
+3157
+addi
+(
+d¡
+, d¡,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+3159 #ià
+V8_TARGET_LITTLE_ENDIAN
+
+
+3160
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 0));
+
+3161
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3162
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 1));
+
+3163
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3164
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 2));
+
+3165
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3166
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 3));
+
+3167 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3168
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3169
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 4));
+
+3170
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3171
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 5));
+
+3172
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3173
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 6));
+
+3174
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3175
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 7));
+
+3178 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3179
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 7));
+
+3180
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3181
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 6));
+
+3182
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3183
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 5));
+
+3184
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3185
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 4));
+
+3186
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3188
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 3));
+
+3189
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3190
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 2));
+
+3191
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3192
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 1));
+
+3193
+ShiáRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(8));
+
+3194
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+, 0));
+
+3196
+addi
+(
+d¡
+, d¡,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+3198
+bdnz
+(&
+wÜd_loÝ
+);
+
+3201
+cmpi
+(
+Ëngth
+,
+O³¿nd
+::
+Z\94o
+());
+
+3202
+beq
+(&
+dÚe
+);
+
+3204
+b\9ad
+(&
+by\8b_loÝ
+);
+
+3205
+mtùr
+(
+Ëngth
+);
+
+3206
+b\9ad
+(&
+by\8b_loÝ_1
+);
+
+3207
+lbz
+(
+sü©ch
+,
+MemO³¿nd
+(
+¤c
+));
+
+3208
+addi
+(
+¤c
+, src,
+O³¿nd
+(1));
+
+3209
+¡b
+(
+sü©ch
+,
+MemO³¿nd
+(
+d¡
+));
+
+3210
+addi
+(
+d¡
+, d¡,
+O³¿nd
+(1));
+
+3211
+bdnz
+(&
+by\8b_loÝ_1
+);
+
+3213
+b\9ad
+(&
+dÚe
+);
+
+3217 \1e
+ gMaüoAs£mbËr
+::
+In\99\9flizeNF\9bldsW\99hF\9eËr
+(
+Regi¡\94
+
+¡¬t_off£t
+,
+
+3218
+Regi¡\94
+
+couÁ
+,
+
+3219
+Regi¡\94
+
+f\9eËr
+) {
+
+3220
+Lab\96
+
+ gloÝ
+;
+
+3221
+mtùr
+(
+couÁ
+);
+
+3222
+b\9ad
+(&
+loÝ
+);
+
+3223
+StÜeP
+(
+f\9eËr
+,
+MemO³¿nd
+(
+¡¬t_off£t
+));
+
+3224
+addi
+(
+¡¬t_off£t
+, s\8f¹_off£t,
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+3225
+bdnz
+(&
+loÝ
+);
+
+3228 \1e
+ gMaüoAs£mbËr
+::
+In\99\9flizeF\9bldsW\99hF\9eËr
+(
+Regi¡\94
+
+¡¬t_off£t
+,
+
+3229
+Regi¡\94
+
+\92d_off£t
+,
+
+3230
+Regi¡\94
+
+f\9eËr
+) {
+
+3231
+Lab\96
+
+ gdÚe
+;
+
+3232
+sub
+(
+r0
+,
+\92d_off£t
+,
+¡¬t_off£t
+,
+L\97veOE
+,
+S\91RC
+);
+
+3233
+beq
+(&
+dÚe
+,
+ü0
+);
+
+3234
+ShiáRightImm
+(
+r0
+,\840,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+));
+
+3235
+In\99\9flizeNF\9bldsW\99hF\9eËr
+(
+¡¬t_off£t
+,
+r0
+,
+f\9eËr
+);
+
+3236
+b\9ad
+(&
+dÚe
+);
+
+3240 \1e
+ gMaüoAs£mbËr
+::
+SaveFPRegs
+(
+Regi¡\94
+
+loÿtiÚ
+, \12
+f\9c¡
+, \12
+couÁ
+) {
+
+3241
+DCHECK
+(
+couÁ
+ > 0);
+
+3242 \12
+ gcur
+ =
+f\9c¡
+;
+
+3243
+subi
+(
+loÿtiÚ
+,\86oÿtiÚ,
+O³¿nd
+(
+couÁ
+ *
+kDoubËSize
+));
+
+3244 \ f\12
+ gi
+ = 0; i <
+ gcouÁ
+; i++) {
+
+3245
+DoubËRegi¡\94
+
+ g»g
+ = DoubËRegi¡\94::
+äom_code
+(
+cur
+++);
+
+3246
+¡fd
+(
+»g
+,
+MemO³¿nd
+(
+loÿtiÚ
+,
+i
+ *
+kDoubËSize
+));
+
+3251 \1e
+ gMaüoAs£mbËr
+::
+Re¡ÜeFPRegs
+(
+Regi¡\94
+
+loÿtiÚ
+, \12
+f\9c¡
+, \12
+couÁ
+) {
+
+3252
+DCHECK
+(
+couÁ
+ > 0);
+
+3253 \12
+ gcur
+ =
+f\9c¡
+ +
+couÁ
+ - 1;
+
+3254 \ f\12
+ gi
+ =
+couÁ
+ - 1; i >= 0; i--) {
+
+3255
+DoubËRegi¡\94
+
+ g»g
+ = DoubËRegi¡\94::
+äom_code
+(
+cur
+--);
+
+3256
+lfd
+(
+»g
+,
+MemO³¿nd
+(
+loÿtiÚ
+,
+i
+ *
+kDoubËSize
+));
+
+3258
+addi
+(
+loÿtiÚ
+,\86oÿtiÚ,
+O³¿nd
+(
+couÁ
+ *
+kDoubËSize
+));
+
+3262 \1e
+ gMaüoAs£mbËr
+::
+JumpIfBÙhIn¡ªûTy³sA»NÙSequ\92t\9flOÃBy\8b
+(
+
+3263
+Regi¡\94
+
+f\9c¡
+, Regi¡\94
+£cÚd
+, Regi¡\94
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+3264
+Lab\96
+*
+ç\9eu»
+) {
+
+3265 cڡ \12
+ gkFÏtOÃBy\8bS\8c\9agMask
+ =
+
+3266
+kIsNÙS\8c\9agMask
+ |
+kS\8c\9agEncod\9agMask
+ |
+kS\8c\9agR\95»£Á©iÚMask
+;
+
+3267 cڡ \12
+ gkFÏtOÃBy\8bS\8c\9agTag
+ =
+
+3268
+kS\8c\9agTag
+ |
+kOÃBy\8bS\8c\9agTag
+ |
+kSeqS\8c\9agTag
+;
+
+3269
+ªdi
+(
+sü©ch1
+,
+f\9c¡
+,
+O³¿nd
+(
+kFÏtOÃBy\8bS\8c\9agMask
+));
+
+3270
+ªdi
+(
+sü©ch2
+,
+£cÚd
+,
+O³¿nd
+(
+kFÏtOÃBy\8bS\8c\9agMask
+));
+
+3271
+cmpi
+(
+sü©ch1
+,
+O³¿nd
+(
+kFÏtOÃBy\8bS\8c\9agTag
+));
+
+3272
+bÃ
+(
+ç\9eu»
+);
+
+3273
+cmpi
+(
+sü©ch2
+,
+O³¿nd
+(
+kFÏtOÃBy\8bS\8c\9agTag
+));
+
+3274
+bÃ
+(
+ç\9eu»
+);
+
+3278 \1e
+ gMaüoAs£mbËr
+::
+JumpIfIn¡ªûTy³IsNÙSequ\92t\9flOÃBy\8b
+(
+Regi¡\94
+
+ty³
+,
+
+3279
+Regi¡\94
+
+sü©ch
+,
+
+3280
+Lab\96
+*
+ç\9eu»
+) {
+
+3281 cڡ \12
+ gkFÏtOÃBy\8bS\8c\9agMask
+ =
+
+3282
+kIsNÙS\8c\9agMask
+ |
+kS\8c\9agEncod\9agMask
+ |
+kS\8c\9agR\95»£Á©iÚMask
+;
+
+3283 cڡ \12
+ gkFÏtOÃBy\8bS\8c\9agTag
+ =
+
+3284
+kS\8c\9agTag
+ |
+kOÃBy\8bS\8c\9agTag
+ |
+kSeqS\8c\9agTag
+;
+
+3285
+ªdi
+(
+sü©ch
+,
+ty³
+,
+O³¿nd
+(
+kFÏtOÃBy\8bS\8c\9agMask
+));
+
+3286
+cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+kFÏtOÃBy\8bS\8c\9agTag
+));
+
+3287
+bÃ
+(
+ç\9eu»
+);
+
+3290 \18cڡ \12
+ gkRegi¡\94Pas£dArgum\92ts
+ = 8;
+
+3293 \12
+ gMaüoAs£mbËr
+::
+C®cuÏ\8bS\8fckPas£dWÜds
+(\12
+num_»g_¬gum\92ts
+,
+
+3294 \12
+num_doubË_¬gum\92ts
+) {
+
+3295 \12
+ g¡ack_·s£d_wÜds
+ = 0;
+
+3296 ià(
+ gnum_doubË_¬gum\92ts
+ >
+ gDoubËRegi¡\94
+::
+kNumRegi¡\94s
+) {
+
+3297
+¡ack_·s£d_wÜds
+ +=
+
+3298 2 * (
+num_doubË_¬gum\92ts
+ -
+DoubËRegi¡\94
+::
+kNumRegi¡\94s
+);
+
+3301 ià(
+ gnum_»g_¬gum\92ts
+ >
+ gkRegi¡\94Pas£dArgum\92ts
+) {
+
+3302
+ g¡ack_·s£d_wÜds
+ +ð
+num_»g_¬gum\92ts
+ -
+kRegi¡\94Pas£dArgum\92ts
+;
+
+3304 \15
+ g¡ack_·s£d_wÜds
+;
+
+3308 \1e
+ gMaüoAs£mbËr
+::
+Em\99SeqS\8c\9agS\91Ch¬Check
+(
+Regi¡\94
+
+¡r\9ag
+, Regi¡\94
+\9adex
+,
+
+3309
+Regi¡\94
+
+v®ue
+,
+
+3310
+u\9at32_t
+
+\92cod\9ag_mask
+) {
+
+3311
+Lab\96
+
+ gis_objeù
+;
+
+3312
+Te¡IfSmi
+(
+¡r\9ag
+,
+r0
+);
+
+3313
+Check
+(
+Ã
+,
+kNÚObjeù
+,
+ü0
+);
+
+3315
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3316
+lbz
+(
+\9d
+,
+F\9bldMemO³¿nd
+(\9d,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3318
+ªdi
+(
+\9d
+, ip,
+O³¿nd
+(
+kS\8c\9agR\95»£Á©iÚMask
+ |
+kS\8c\9agEncod\9agMask
+));
+
+3319
+cmpi
+(
+\9d
+,
+O³¿nd
+(
+\92cod\9ag_mask
+));
+
+3320
+Check
+(
+eq
+,
+kUÃx³ùedS\8c\9agTy³
+);
+
+3325 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+3326
+Lab\96
+
+ g\9adex_\8fg_ok
+,
+ g\9adex_\8fg_bad
+;
+
+3327
+JumpIfNÙSmiCªdid©e
+(
+\9adex
+,
+r0
+, &
+\9adex_\8fg_bad
+);
+
+3329
+SmiTag
+(
+\9adex
+, index);
+
+3330 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+3331
+b
+(&
+\9adex_\8fg_ok
+);
+
+3332
+b\9ad
+(&
+\9adex_\8fg_bad
+);
+
+3333
+AbÜt
+(
+kIndexIsTooL¬ge
+);
+
+3334
+b\9ad
+(&
+\9adex_\8fg_ok
+);
+
+3337
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+¡r\9ag
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+3338
+cmp
+(
+\9adex
+,
+\9d
+);
+
+3339
+Check
+(
+É
+,
+kIndexIsTooL¬ge
+);
+
+3341
+DCHECK
+(
+Smi
+::
+FromIÁ
+(0) == 0);
+
+3342
+cmpi
+(
+\9adex
+,
+O³¿nd
+::
+Z\94o
+());
+
+3343
+Check
+(
+ge
+,
+kIndexIsNeg©ive
+);
+
+3345
+SmiUÁag
+(
+\9adex
+, index);
+
+3349 \1e
+ gMaüoAs£mbËr
+::
+P»·»C®lCFunùiÚ
+(\12
+num_»g_¬gum\92ts
+,
+
+3350 \12
+num_doubË_¬gum\92ts
+,
+
+3351
+Regi¡\94
+
+sü©ch
+) {
+
+3352 \12
+ gäame_®ignm\92t
+ =
+Aùiv©iÚF¿meAlignm\92t
+();
+
+3353 \12
+ g¡ack_·s£d_¬gum\92ts
+ =
+
+3354
+C®cuÏ\8bS\8fckPas£dWÜds
+(
+num_»g_¬gum\92ts
+,
+num_doubË_¬gum\92ts
+);
+
+3355 \12
+ g¡ack_¥aû
+ =
+kNumRequ\9cedS\8fckF¿meSlÙs
+;
+
+3357 ià(
+ gäame_®ignm\92t
+ >
+ gkPo\9a\8brSize
+) {
+
+3360
+mr
+(
+sü©ch
+,
+¥
+);
+
+3361
+addi
+(
+¥
+, sp,
+O³¿nd
+(-(
+¡ack_·s£d_¬gum\92ts
+ + 1è*
+kPo\9a\8brSize
+));
+
+3362
+DCHECK
+(
+ba£
+::
+b\99s
+::
+IsPow\94OfTwo32
+(
+äame_®ignm\92t
+));
+
+3363
+CˬRightImm
+(
+¥
+, sp,
+O³¿nd
+(
+WhichPow\94Of2
+(
+äame_®ignm\92t
+)));
+
+3364
+StÜeP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+,
+¡ack_·s£d_¬gum\92ts
+ *
+kPo\9a\8brSize
+));
+
+3367
+ g¡ack_¥aû
+ +ð
+¡ack_·s£d_¬gum\92ts
+;
+
+3371
+li
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+3372
+StÜePU
+(
+r0
+,
+MemO³¿nd
+(
+¥
+, -
+¡ack_¥aû
+ *
+kPo\9a\8brSize
+));
+
+3376 \1e
+ gMaüoAs£mbËr
+::
+P»·»C®lCFunùiÚ
+(\12
+num_»g_¬gum\92ts
+,
+
+3377
+Regi¡\94
+
+sü©ch
+) {
+
+3378
+P»·»C®lCFunùiÚ
+(
+num_»g_¬gum\92ts
+, 0,
+sü©ch
+);
+
+3382 \1e
+ gMaüoAs£mbËr
+::
+MovToFlßtP¬am\91\94
+(
+DoubËRegi¡\94
+
+¤c
+è{
+Move
+(
+d1
+, src); }
+
+3385 \1e
+ gMaüoAs£mbËr
+::
+MovToFlßtResuÉ
+(
+DoubËRegi¡\94
+
+¤c
+è{
+Move
+(
+d1
+, src); }
+
+3388 \1e
+ gMaüoAs£mbËr
+::
+MovToFlßtP¬am\91\94s
+(
+DoubËRegi¡\94
+
+¤c1
+,
+
+3389
+DoubËRegi¡\94
+
+¤c2
+) {
+
+3390 ià(
+ g¤c2
+.
+is
+(
+d1
+)) {
+
+3391
+DCHECK
+(!
+¤c1
+.
+is
+(
+d2
+));
+
+3392
+Move
+(
+d2
+,
+¤c2
+);
+
+3393
+Move
+(
+d1
+,
+¤c1
+);
+
+3395
+Move
+(
+d1
+,
+¤c1
+);
+
+3396
+Move
+(
+d2
+,
+¤c2
+);
+
+3401 \1e
+ gMaüoAs£mbËr
+::
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+
+funùiÚ
+,
+
+3402 \12
+num_»g_¬gum\92ts
+,
+
+3403 \12
+num_doubË_¬gum\92ts
+) {
+
+3404
+mov
+(
+\9d
+,
+O³¿nd
+(
+funùiÚ
+));
+
+3405
+C®lCFunùiÚH\96³r
+(
+\9d
+,
+num_»g_¬gum\92ts
+,
+num_doubË_¬gum\92ts
+);
+
+3409 \1e
+ gMaüoAs£mbËr
+::
+C®lCFunùiÚ
+(
+Regi¡\94
+
+funùiÚ
+, \12
+num_»g_¬gum\92ts
+,
+
+3410 \12
+num_doubË_¬gum\92ts
+) {
+
+3411
+C®lCFunùiÚH\96³r
+(
+funùiÚ
+,
+num_»g_¬gum\92ts
+,
+num_doubË_¬gum\92ts
+);
+
+3415 \1e
+ gMaüoAs£mbËr
+::
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+
+funùiÚ
+,
+
+3416 \12
+num_¬gum\92ts
+) {
+
+3417
+C®lCFunùiÚ
+(
+funùiÚ
+,
+num_¬gum\92ts
+, 0);
+
+3421 \1e
+ gMaüoAs£mbËr
+::
+C®lCFunùiÚ
+(
+Regi¡\94
+
+funùiÚ
+, \12
+num_¬gum\92ts
+) {
+
+3422
+C®lCFunùiÚ
+(
+funùiÚ
+,
+num_¬gum\92ts
+, 0);
+
+3426 \1e
+ gMaüoAs£mbËr
+::
+C®lCFunùiÚH\96³r
+(
+Regi¡\94
+
+funùiÚ
+,
+
+3427 \12
+num_»g_¬gum\92ts
+,
+
+3428 \12
+num_doubË_¬gum\92ts
+) {
+
+3429
+DCHECK
+(
+has_äame
+());
+
+3433 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+ && !
+def\9aed
+(
+USE_SIMULATOR
+)
+
+3436
+LßdP
+(
+ToRegi¡\94
+(
+ABI_TOC_REGISTER
+),
+MemO³¿nd
+(
+funùiÚ
+,
+kPo\9a\8brSize
+));
+
+3437
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(
+funùiÚ
+, 0));
+
+3438
+Regi¡\94
+
+ gde¡
+ =
+\9d
+;
+
+3439 #\96ià
+ABI_TOC_ADDRESSABILITY_VIA_IP
+
+
+3440
+Move
+(
+\9d
+,
+funùiÚ
+);
+
+3441
+Regi¡\94
+
+ gde¡
+ =
+\9d
+;
+
+3443
+Regi¡\94
+
+ gde¡
+ =
+funùiÚ
+;
+
+3446
+C®l
+(
+de¡
+);
+
+3449 \12
+ g¡ack_·s£d_¬gum\92ts
+ =
+
+3450
+C®cuÏ\8bS\8fckPas£dWÜds
+(
+num_»g_¬gum\92ts
+,
+num_doubË_¬gum\92ts
+);
+
+3451 \12
+ g¡ack_¥aû
+ =
+kNumRequ\9cedS\8fckF¿meSlÙs
+ +
+¡ack_·s£d_¬gum\92ts
+;
+
+3452 ià(
+Aùiv©iÚF¿meAlignm\92t
+(è>
+ gkPo\9a\8brSize
+) {
+
+3453
+LßdP
+(
+¥
+,
+MemO³¿nd
+(¥,
+¡ack_¥aû
+ *
+kPo\9a\8brSize
+));
+
+3455
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+¡ack_¥aû
+ *
+kPo\9a\8brSize
+));
+
+3460 \1e
+ gMaüoAs£mbËr
+::
+FlushICache
+(
+Regi¡\94
+
+add»ss
+,
+size_t
+
+size
+,
+
+3461
+Regi¡\94
+
+sü©ch
+) {
+
+3462 ià(
+ gCpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+INSTR_AND_DATA_CACHE_COHERENCY
+)) {
+
+3463
+sync
+();
+
+3464
+icbi
+(
+r0
+,
+add»ss
+);
+
+3465
+isync
+();
+
+3469
+Lab\96
+
+ gdÚe
+;
+
+3471
+dcbf
+(
+r0
+,
+add»ss
+);
+
+3472
+sync
+();
+
+3473
+icbi
+(
+r0
+,
+add»ss
+);
+
+3474
+isync
+();
+
+3478 cڡ \12
+ gkCacheL\9aeSizeLog2
+ =
+WhichPow\94Of2
+(
+CpuF\97tu»s
+::
+ÿche_l\9ae_size
+());
+
+3480
+DCHECK
+(
+size
+ > 0 && siz\90<ð(
+size_t
+)(1 <<
+kCacheL\9aeSizeLog2
+));
+
+3481
+addi
+(
+sü©ch
+,
+add»ss
+,
+O³¿nd
+(
+size
+ - 1));
+
+3482
+CˬRightImm
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kCacheL\9aeSizeLog2
+));
+
+3483
+cm¶
+(
+sü©ch
+,
+add»ss
+);
+
+3484
+bË
+(&
+dÚe
+);
+
+3486
+dcbf
+(
+r0
+,
+sü©ch
+);
+
+3487
+sync
+();
+
+3488
+icbi
+(
+r0
+,
+sü©ch
+);
+
+3489
+isync
+();
+
+3491
+b\9ad
+(&
+dÚe
+);
+
+3495 \1e
+ gMaüoAs£mbËr
+::
+S\91R\96oÿ\8bdV®ue
+(
+Regi¡\94
+
+loÿtiÚ
+, Regi¡\94
+sü©ch
+,
+
+3496
+Regi¡\94
+
+Ãw_v®ue
+) {
+
+3497
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+));
+
+3499 #ià
+V8_OOL_CONSTANT_POOL
+
+
+3500 ià(
+em\99_debug_code
+()) {
+
+3502 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3503
+And
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kOpcodeMask
+ | (0x1à*
+B16
+)));
+
+3504
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+ADDI
+),
+r0
+);
+
+3505
+Check
+(
+eq
+,
+kTheIn¡ruùiÚShouldBeALi
+);
+
+3506
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+,
+kIn¡rSize
+));
+
+3508
+Ex\8caùB\99Mask
+(
+sü©ch
+, sü©ch, 0x1à*
+B16
+);
+
+3509
+cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+kCÚ¡ªtPoÞRegi¡\94
+.
+code
+()));
+
+3510
+Check
+(
+eq
+,
+kTheIn¡ruùiÚToP©chShouldBeALßdFromCÚ¡ªtPoÞ
+);
+
+3512
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+));
+
+3515
+ªdi
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kImm16Mask
+));
+
+3516
+StÜePX
+(
+Ãw_v®ue
+,
+MemO³¿nd
+(
+kCÚ¡ªtPoÞRegi¡\94
+,
+sü©ch
+));
+
+3521 ià(
+em\99_debug_code
+()) {
+
+3522
+And
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kOpcodeMask
+ | (0x1à*
+B16
+)));
+
+3523
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+ADDIS
+),
+r0
+);
+
+3524
+Check
+(
+eq
+,
+kTheIn¡ruùiÚToP©chShouldBeALis
+);
+
+3525
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+));
+
+3529 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3530
+¤di
+(
+\9d
+,
+Ãw_v®ue
+,
+O³¿nd
+(32));
+
+3531
+¾wimi
+(
+sü©ch
+,
+\9d
+, 16, 16, 31);
+
+3533
+¾wimi
+(
+sü©ch
+,
+Ãw_v®ue
+, 16, 16, 31);
+
+3536
+¡w
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+));
+
+3538
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+,
+kIn¡rSize
+));
+
+3540 ià(
+em\99_debug_code
+()) {
+
+3541
+And
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kOpcodeMask
+));
+
+3542
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+ORI
+),
+r0
+);
+
+3543
+Check
+(
+eq
+,
+kTheIn¡ruùiÚShouldBeAnOri
+);
+
+3544
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+,
+kIn¡rSize
+));
+
+3548 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3549
+¾wimi
+(
+sü©ch
+,
+\9d
+, 0, 16, 31);
+
+3551
+¾wimi
+(
+sü©ch
+,
+Ãw_v®ue
+, 0, 16, 31);
+
+3553
+¡w
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+,
+kIn¡rSize
+));
+
+3555 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3556 ià(
+em\99_debug_code
+()) {
+
+3557
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+, 2 *
+kIn¡rSize
+));
+
+3559
+And
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kOpcodeMask
+ |
+kExt5OpcodeMask
+));
+
+3560
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+EXT5
+ |
+RLDICR
+),
+r0
+);
+
+3561
+Check
+(
+eq
+,
+kTheIn¡ruùiÚShouldBeASldi
+);
+
+3564
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+, 3 *
+kIn¡rSize
+));
+
+3566 ià(
+em\99_debug_code
+()) {
+
+3567
+And
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kOpcodeMask
+));
+
+3568
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+ORIS
+),
+r0
+);
+
+3569
+Check
+(
+eq
+,
+kTheIn¡ruùiÚShouldBeAnOris
+);
+
+3570
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+, 3 *
+kIn¡rSize
+));
+
+3573
+¾wimi
+(
+sü©ch
+,
+Ãw_v®ue
+, 16, 16, 31);
+
+3574
+¡w
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+, 3 *
+kIn¡rSize
+));
+
+3576
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+, 4 *
+kIn¡rSize
+));
+
+3578 ià(
+em\99_debug_code
+()) {
+
+3579
+And
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kOpcodeMask
+));
+
+3580
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+ORI
+),
+r0
+);
+
+3581
+Check
+(
+eq
+,
+kTheIn¡ruùiÚShouldBeAnOri
+);
+
+3582
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+, 4 *
+kIn¡rSize
+));
+
+3584
+¾wimi
+(
+sü©ch
+,
+Ãw_v®ue
+, 0, 16, 31);
+
+3585
+¡w
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+, 4 *
+kIn¡rSize
+));
+
+3589 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3590
+FlushICache
+(
+loÿtiÚ
+, 5 *
+kIn¡rSize
+,
+sü©ch
+);
+
+3592
+FlushICache
+(
+loÿtiÚ
+, 2 *
+kIn¡rSize
+,
+sü©ch
+);
+
+3598 \1e
+ gMaüoAs£mbËr
+::
+G\91R\96oÿ\8bdV®ue
+(
+Regi¡\94
+
+loÿtiÚ
+, Regi¡\94
+»suÉ
+,
+
+3599
+Regi¡\94
+
+sü©ch
+) {
+
+3600
+lwz
+(
+»suÉ
+,
+MemO³¿nd
+(
+loÿtiÚ
+));
+
+3602 #ià
+V8_OOL_CONSTANT_POOL
+
+
+3603 ià(
+em\99_debug_code
+()) {
+
+3605 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3606
+And
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(
+kOpcodeMask
+ | (0x1à*
+B16
+)));
+
+3607
+Cmpi
+(
+»suÉ
+,
+O³¿nd
+(
+ADDI
+),
+r0
+);
+
+3608
+Check
+(
+eq
+,
+kTheIn¡ruùiÚShouldBeALi
+);
+
+3609
+lwz
+(
+»suÉ
+,
+MemO³¿nd
+(
+loÿtiÚ
+,
+kIn¡rSize
+));
+
+3611
+Ex\8caùB\99Mask
+(
+»suÉ
+,\84esuÉ, 0x1à*
+B16
+);
+
+3612
+cmpi
+(
+»suÉ
+,
+O³¿nd
+(
+kCÚ¡ªtPoÞRegi¡\94
+.
+code
+()));
+
+3613
+Check
+(
+eq
+,
+kTheIn¡ruùiÚToP©chShouldBeALßdFromCÚ¡ªtPoÞ
+);
+
+3614
+lwz
+(
+»suÉ
+,
+MemO³¿nd
+(
+loÿtiÚ
+));
+
+3617
+ªdi
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(
+kImm16Mask
+));
+
+3618
+LßdPX
+(
+»suÉ
+,
+MemO³¿nd
+(
+kCÚ¡ªtPoÞRegi¡\94
+,\84esult));
+
+3621 ià(
+em\99_debug_code
+()) {
+
+3622
+And
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(
+kOpcodeMask
+ | (0x1à*
+B16
+)));
+
+3623
+Cmpi
+(
+»suÉ
+,
+O³¿nd
+(
+ADDIS
+),
+r0
+);
+
+3624
+Check
+(
+eq
+,
+kTheIn¡ruùiÚShouldBeALis
+);
+
+3625
+lwz
+(
+»suÉ
+,
+MemO³¿nd
+(
+loÿtiÚ
+));
+
+3629
+¦wi
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(16));
+
+3631
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+,
+kIn¡rSize
+));
+
+3632 ià(
+em\99_debug_code
+()) {
+
+3633
+And
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kOpcodeMask
+));
+
+3634
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+ORI
+),
+r0
+);
+
+3635
+Check
+(
+eq
+,
+kTheIn¡ruùiÚShouldBeAnOri
+);
+
+3636
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+,
+kIn¡rSize
+));
+
+3639
+¾wimi
+(
+»suÉ
+,
+sü©ch
+, 0, 16, 31);
+
+3641 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3642 ià(
+em\99_debug_code
+()) {
+
+3643
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+, 2 *
+kIn¡rSize
+));
+
+3645
+And
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kOpcodeMask
+ |
+kExt5OpcodeMask
+));
+
+3646
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+EXT5
+ |
+RLDICR
+),
+r0
+);
+
+3647
+Check
+(
+eq
+,
+kTheIn¡ruùiÚShouldBeASldi
+);
+
+3650
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+, 3 *
+kIn¡rSize
+));
+
+3652 ià(
+em\99_debug_code
+()) {
+
+3653
+And
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kOpcodeMask
+));
+
+3654
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+ORIS
+),
+r0
+);
+
+3655
+Check
+(
+eq
+,
+kTheIn¡ruùiÚShouldBeAnOris
+);
+
+3656
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+, 3 *
+kIn¡rSize
+));
+
+3658
+¦di
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(16));
+
+3659
+¾dimi
+(
+»suÉ
+,
+sü©ch
+, 0, 48);
+
+3661
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+, 4 *
+kIn¡rSize
+));
+
+3663 ià(
+em\99_debug_code
+()) {
+
+3664
+And
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kOpcodeMask
+));
+
+3665
+Cmpi
+(
+sü©ch
+,
+O³¿nd
+(
+ORI
+),
+r0
+);
+
+3666
+Check
+(
+eq
+,
+kTheIn¡ruùiÚShouldBeAnOri
+);
+
+3667
+lwz
+(
+sü©ch
+,
+MemO³¿nd
+(
+loÿtiÚ
+, 4 *
+kIn¡rSize
+));
+
+3669
+¦di
+(
+»suÉ
+,\84esuÉ,
+O³¿nd
+(16));
+
+3670
+¾dimi
+(
+»suÉ
+,
+sü©ch
+, 0, 48);
+
+3676 \1e
+ gMaüoAs£mbËr
+::
+CheckPageFÏg
+(
+
+3677
+Regi¡\94
+
+objeù
+,
+
+3678
+Regi¡\94
+
+sü©ch
+,
+
+3679 \12
+mask
+,
+CÚd\99iÚ
+
+cc
+,
+Lab\96
+*
+cÚd\99iÚ_m\91
+) {
+
+3680
+DCHECK
+(
+cc
+ =ð
+Ã
+ || cø=ð
+eq
+);
+
+3681
+CˬRightImm
+(
+sü©ch
+,
+objeù
+,
+O³¿nd
+(
+kPageSizeB\99s
+));
+
+3682
+LßdP
+(
+sü©ch
+,
+MemO³¿nd
+(sü©ch,
+MemÜyChunk
+::
+kFÏgsOff£t
+));
+
+3684
+And
+(
+r0
+,
+sü©ch
+,
+O³¿nd
+(
+mask
+),
+S\91RC
+);
+
+3686 ià(
+ gcc
+ =ð
+Ã
+) {
+
+3687
+bÃ
+(
+cÚd\99iÚ_m\91
+,
+ü0
+);
+
+3689 ià(
+ gcc
+ =ð
+eq
+) {
+
+3690
+beq
+(
+cÚd\99iÚ_m\91
+,
+ü0
+);
+
+3695 \1e
+ gMaüoAs£mbËr
+::
+CheckMD\95»ÿ\8bd
+(
+HªdË
+<
+M
+>
+m
+,
+Regi¡\94
+
+sü©ch
+,
+
+3696
+Lab\96
+*
+if_d\95»ÿ\8bd
+) {
+
+3697 ià(
+ gm
+->
+CªBeD\95»ÿ\8bd
+()) {
+
+3698
+mov
+(
+sü©ch
+,
+O³¿nd
+(
+m
+));
+
+3699
+lwz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+M
+::
+kB\99F\9bld3Off£t
+));
+
+3700
+Ex\8caùB\99Mask
+(
+sü©ch
+, sü©ch,
+M
+::
+D\95»ÿ\8bd
+::
+kMask
+,
+S\91RC
+);
+
+3701
+bÃ
+(
+if_d\95»ÿ\8bd
+,
+ü0
+);
+
+3706 \1e
+ gMaüoAs£mbËr
+::
+JumpIfBÏck
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch0
+,
+
+3707
+Regi¡\94
+
+sü©ch1
+,
+Lab\96
+*
+Ú_bÏck
+) {
+
+3708
+HasCÞÜ
+(
+objeù
+,
+sü©ch0
+,
+sü©ch1
+,
+Ú_bÏck
+, 1, 0);
+
+3709
+DCHECK
+(
+¡rcmp
+(
+M¬k\9ag
+::
+kBÏckB\99P©\8bº
+, "10") == 0);
+
+3713 \1e
+ gMaüoAs£mbËr
+::
+HasCÞÜ
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+b\99m_sü©ch
+,
+
+3714
+Regi¡\94
+
+mask_sü©ch
+,
+Lab\96
+*
+has_cÞÜ
+,
+
+3715 \12
+f\9c¡_b\99
+, \12
+£cÚd_b\99
+) {
+
+3716
+DCHECK
+(!
+A»Al\9f£d
+(
+objeù
+,
+b\99m_sü©ch
+,
+mask_sü©ch
+,
+no_»g
+));
+
+3718
+G\91M¬kB\99s
+(
+objeù
+,
+b\99m_sü©ch
+,
+mask_sü©ch
+);
+
+3720
+Lab\96
+
+ gÙh\94_cÞÜ
+,
+ gwÜd_bound¬y
+;
+
+3721
+lwz
+(
+\9d
+,
+MemO³¿nd
+(
+b\99m_sü©ch
+,
+MemÜyChunk
+::
+kH\97d\94Size
+));
+
+3723
+ªd_
+(
+r0
+,
+\9d
+,
+mask_sü©ch
+,
+S\91RC
+);
+
+3724
+b
+(
+f\9c¡_b\99
+ =ð1 ?
+eq
+ :
+Ã
+, &
+Ùh\94_cÞÜ
+,
+ü0
+);
+
+3727
+¦wi
+(
+mask_sü©ch
+, mask_sü©ch,
+O³¿nd
+(1),
+S\91RC
+);
+
+3728
+beq
+(&
+wÜd_bound¬y
+,
+ü0
+);
+
+3730
+ªd_
+(
+r0
+,
+\9d
+,
+mask_sü©ch
+,
+S\91RC
+);
+
+3731
+b
+(
+£cÚd_b\99
+ =ð1 ?
+Ã
+ :
+eq
+,
+has_cÞÜ
+,
+ü0
+);
+
+3732
+b
+(&
+Ùh\94_cÞÜ
+);
+
+3734
+b\9ad
+(&
+wÜd_bound¬y
+);
+
+3735
+lwz
+(
+\9d
+,
+MemO³¿nd
+(
+b\99m_sü©ch
+,
+MemÜyChunk
+::
+kH\97d\94Size
+ +
+kIÁSize
+));
+
+3736
+ªdi
+(
+r0
+,
+\9d
+,
+O³¿nd
+(1));
+
+3737
+b
+(
+£cÚd_b\99
+ =ð1 ?
+Ã
+ :
+eq
+,
+has_cÞÜ
+,
+ü0
+);
+
+3738
+b\9ad
+(&
+Ùh\94_cÞÜ
+);
+
+3745 \1e
+ gMaüoAs£mbËr
+::
+JumpIfD©aObjeù
+(
+Regi¡\94
+
+v®ue
+, Regi¡\94
+sü©ch
+,
+
+3746
+Lab\96
+*
+nÙ_d©a_objeù
+) {
+
+3747
+Lab\96
+
+ gis_d©a_objeù
+;
+
+3748
+LßdP
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(
+v®ue
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3749
+Com·»RoÙ
+(
+sü©ch
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+3750
+beq
+(&
+is_d©a_objeù
+);
+
+3751
+DCHECK
+(
+kIsInd\9ceùS\8c\9agTag
+ =ð1 &&
+kIsInd\9ceùS\8c\9agMask
+ == 1);
+
+3752
+DCHECK
+(
+kNÙS\8c\9agTag
+ =ð0x80 &&
+kIsNÙS\8c\9agMask
+ == 0x80);
+
+3755
+lbz
+(
+sü©ch
+,
+F\9bldMemO³¿nd
+(sü©ch,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3756
+STATIC_ASSERT
+((
+kIsInd\9ceùS\8c\9agMask
+ |
+kIsNÙS\8c\9agMask
+) == 0x81);
+
+3757
+ªdi
+(
+sü©ch
+, sü©ch,
+O³¿nd
+(
+kIsInd\9ceùS\8c\9agMask
+ |
+kIsNÙS\8c\9agMask
+));
+
+3758
+bÃ
+(
+nÙ_d©a_objeù
+,
+ü0
+);
+
+3759
+b\9ad
+(&
+is_d©a_objeù
+);
+
+3763 \1e
+ gMaüoAs£mbËr
+::
+G\91M¬kB\99s
+(
+Regi¡\94
+
+addr_»g
+, Regi¡\94
+b\99m_»g
+,
+
+3764
+Regi¡\94
+
+mask_»g
+) {
+
+3765
+DCHECK
+(!
+A»Al\9f£d
+(
+addr_»g
+,
+b\99m_»g
+,
+mask_»g
+,
+no_»g
+));
+
+3766
+DCHECK
+((~
+Page
+::
+kPageAlignm\92tMask
+ & 0xffff) == 0);
+
+3767
+lis
+(
+r0
+,
+O³¿nd
+((~
+Page
+::
+kPageAlignm\92tMask
+ >> 16)));
+
+3768
+ªd_
+(
+b\99m_»g
+,
+addr_»g
+,
+r0
+);
+
+3769 cڡ \12
+ gkLowB\99s
+ =
+kPo\9a\8brSizeLog2
+ +
+B\99m
+::
+kB\99sP\94C\96lLog2
+;
+
+3770
+Ex\8caùB\99Rªge
+(
+mask_»g
+,
+addr_»g
+,
+kLowB\99s
+ - 1,
+kPo\9a\8brSizeLog2
+);
+
+3771
+Ex\8caùB\99Rªge
+(
+\9d
+,
+addr_»g
+,
+kPageSizeB\99s
+ - 1,
+kLowB\99s
+);
+
+3772
+ShiáLeáImm
+(
+\9d
+, ip,
+O³¿nd
+(
+B\99m
+::
+kBy\8bsP\94C\96lLog2
+));
+
+3773
+add
+(
+b\99m_»g
+, b\99m_»g,
+\9d
+);
+
+3774
+li
+(
+\9d
+,
+O³¿nd
+(1));
+
+3775
+¦w
+(
+mask_»g
+,
+\9d
+, mask_reg);
+
+3779 \1e
+ gMaüoAs£mbËr
+::
+Ensu»NÙWh\99e
+(
+Regi¡\94
+
+v®ue
+, Regi¡\94
+b\99m_sü©ch
+,
+
+3780
+Regi¡\94
+
+mask_sü©ch
+,
+
+3781
+Regi¡\94
+
+lßd_sü©ch
+,
+
+3782
+Lab\96
+*
+v®ue_is_wh\99e_ªd_nÙ_d©a
+) {
+
+3783
+DCHECK
+(!
+A»Al\9f£d
+(
+v®ue
+,
+b\99m_sü©ch
+,
+mask_sü©ch
+,
+\9d
+));
+
+3784
+G\91M¬kB\99s
+(
+v®ue
+,
+b\99m_sü©ch
+,
+mask_sü©ch
+);
+
+3787
+DCHECK
+(
+¡rcmp
+(
+M¬k\9ag
+::
+kWh\99eB\99P©\8bº
+, "00") == 0);
+
+3788
+DCHECK
+(
+¡rcmp
+(
+M¬k\9ag
+::
+kBÏckB\99P©\8bº
+, "10") == 0);
+
+3789
+DCHECK
+(
+¡rcmp
+(
+M¬k\9ag
+::
+kG»yB\99P©\8bº
+, "11") == 0);
+
+3790
+DCHECK
+(
+¡rcmp
+(
+M¬k\9ag
+::
+kImpossibËB\99P©\8bº
+, "01") == 0);
+
+3792
+Lab\96
+
+ gdÚe
+;
+
+3796
+lwz
+(
+lßd_sü©ch
+,
+MemO³¿nd
+(
+b\99m_sü©ch
+,
+MemÜyChunk
+::
+kH\97d\94Size
+));
+
+3797
+ªd_
+(
+r0
+,
+mask_sü©ch
+,
+lßd_sü©ch
+,
+S\91RC
+);
+
+3798
+bÃ
+(&
+dÚe
+,
+ü0
+);
+
+3800 ià(
+em\99_debug_code
+()) {
+
+3802
+Lab\96
+
+ gok
+;
+
+3804
+¦wi
+(
+r0
+,
+mask_sü©ch
+,
+O³¿nd
+(1));
+
+3805
+ªd_
+(
+r0
+,
+lßd_sü©ch
+,\840,
+S\91RC
+);
+
+3806
+beq
+(&
+ok
+,
+ü0
+);
+
+3807
+¡Ý
+("Impossible marking bit\85attern");
+
+3808
+b\9ad
+(&
+ok
+);
+
+3813
+Regi¡\94
+
+ gm
+ =
+lßd_sü©ch
+;
+
+3814
+Regi¡\94
+
+ gËngth
+ =
+lßd_sü©ch
+;
+
+3815
+Lab\96
+
+ gis_d©a_objeù
+,
+ gmaybe_¡r\9ag_objeù
+,
+ gis_¡r\9ag_objeù
+,
+ gis_\92coded
+;
+
+3816 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3817
+Lab\96
+
+ gËngth_compu\8bd
+;
+
+3822
+LßdP
+(
+m
+,
+F\9bldMemO³¿nd
+(
+v®ue
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3823
+Com·»RoÙ
+(
+m
+,
+H\97p
+::
+kH\97pNumb\94MRoÙIndex
+);
+
+3824
+bÃ
+(&
+maybe_¡r\9ag_objeù
+);
+
+3825
+li
+(
+Ëngth
+,
+O³¿nd
+(
+H\97pNumb\94
+::
+kSize
+));
+
+3826
+b
+(&
+is_d©a_objeù
+);
+
+3827
+b\9ad
+(&
+maybe_¡r\9ag_objeù
+);
+
+3830
+DCHECK
+(
+kIsInd\9ceùS\8c\9agTag
+ =ð1 &&
+kIsInd\9ceùS\8c\9agMask
+ == 1);
+
+3831
+DCHECK
+(
+kNÙS\8c\9agTag
+ =ð0x80 &&
+kIsNÙS\8c\9agMask
+ == 0x80);
+
+3834
+Regi¡\94
+
+ g\9a¡ªû_ty³
+ =
+lßd_sü©ch
+;
+
+3835
+lbz
+(
+\9a¡ªû_ty³
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+3836
+ªdi
+(
+r0
+,
+\9a¡ªû_ty³
+,
+O³¿nd
+(
+kIsInd\9ceùS\8c\9agMask
+ |
+kIsNÙS\8c\9agMask
+));
+
+3837
+bÃ
+(
+v®ue_is_wh\99e_ªd_nÙ_d©a
+,
+ü0
+);
+
+3843
+DCHECK_EQ
+(0,
+kSeqS\8c\9agTag
+ &
+kEx\8bº®S\8c\9agTag
+);
+
+3844
+DCHECK_EQ
+(0,
+kCÚsS\8c\9agTag
+ &
+kEx\8bº®S\8c\9agTag
+);
+
+3845
+ªdi
+(
+r0
+,
+\9a¡ªû_ty³
+,
+O³¿nd
+(
+kEx\8bº®S\8c\9agTag
+));
+
+3846
+beq
+(&
+is_¡r\9ag_objeù
+,
+ü0
+);
+
+3847
+li
+(
+Ëngth
+,
+O³¿nd
+(
+Ex\8bº®S\8c\9ag
+::
+kSize
+));
+
+3848
+b
+(&
+is_d©a_objeù
+);
+
+3849
+b\9ad
+(&
+is_¡r\9ag_objeù
+);
+
+3857
+DCHECK
+(
+kOÃBy\8bS\8c\9agTag
+ =ð4 &&
+kS\8c\9agEncod\9agMask
+ == 4);
+
+3858
+LßdP
+(
+\9d
+,
+F\9bldMemO³¿nd
+(
+v®ue
+,
+S\8c\9ag
+::
+kL\92gthOff£t
+));
+
+3859
+ªdi
+(
+r0
+,
+\9a¡ªû_ty³
+,
+O³¿nd
+(
+kS\8c\9agEncod\9agMask
+));
+
+3860
+beq
+(&
+is_\92coded
+,
+ü0
+);
+
+3861
+SmiUÁag
+(
+\9d
+);
+
+3862 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3863
+b
+(&
+Ëngth_compu\8bd
+);
+
+3865
+b\9ad
+(&
+is_\92coded
+);
+
+3866 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3867
+SmiToShÜtA¼ayOff£t
+(
+\9d
+, ip);
+
+3868
+b\9ad
+(&
+Ëngth_compu\8bd
+);
+
+3870
+DCHECK
+(
+kSmiShiá
+ == 1);
+
+3872
+addi
+(
+Ëngth
+,
+\9d
+,
+O³¿nd
+(
+SeqS\8c\9ag
+::
+kH\97d\94Size
+ +
+kObjeùAlignm\92tMask
+));
+
+3873
+li
+(
+r0
+,
+O³¿nd
+(~
+kObjeùAlignm\92tMask
+));
+
+3874
+ªd_
+(
+Ëngth
+,\86\92gth,
+r0
+);
+
+3876
+b\9ad
+(&
+is_d©a_objeù
+);
+
+3879
+lwz
+(
+\9d
+,
+MemO³¿nd
+(
+b\99m_sü©ch
+,
+MemÜyChunk
+::
+kH\97d\94Size
+));
+
+3880
+Üx
+(
+\9d
+, ip,
+mask_sü©ch
+);
+
+3881
+¡w
+(
+\9d
+,
+MemO³¿nd
+(
+b\99m_sü©ch
+,
+MemÜyChunk
+::
+kH\97d\94Size
+));
+
+3883
+mov
+(
+\9d
+,
+O³¿nd
+(~
+Page
+::
+kPageAlignm\92tMask
+));
+
+3884
+ªd_
+(
+b\99m_sü©ch
+, b\99m_sü©ch,
+\9d
+);
+
+3885
+lwz
+(
+\9d
+,
+MemO³¿nd
+(
+b\99m_sü©ch
+,
+MemÜyChunk
+::
+kLiveBy\8bsOff£t
+));
+
+3886
+add
+(
+\9d
+, ip,
+Ëngth
+);
+
+3887
+¡w
+(
+\9d
+,
+MemO³¿nd
+(
+b\99m_sü©ch
+,
+MemÜyChunk
+::
+kLiveBy\8bsOff£t
+));
+
+3889
+b\9ad
+(&
+dÚe
+);
+
+3897 \1e
+ gMaüoAs£mbËr
+::
+CÏmpU\9at8
+(
+Regi¡\94
+
+ou\8dut_»g
+, Regi¡\94
+\9aput_»g
+) {
+
+3898
+Lab\96
+
+ gdÚe
+,
+ gÃg©ive_Ïb\96
+,
+ gov\94æow_Ïb\96
+;
+
+3899 \12
+ g§tv®
+ = (1 << 8) - 1;
+
+3901
+cmpi
+(
+\9aput_»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+3902
+bÉ
+(&
+Ãg©ive_Ïb\96
+);
+
+3904
+cmpi
+(
+\9aput_»g
+,
+O³¿nd
+(
+§tv®
+));
+
+3905
+bgt
+(&
+ov\94æow_Ïb\96
+);
+
+3906 ià(!
+ gou\8dut_»g
+.
+is
+(
+\9aput_»g
+)) {
+
+3907
+mr
+(
+ou\8dut_»g
+,
+\9aput_»g
+);
+
+3909
+b
+(&
+dÚe
+);
+
+3911
+b\9ad
+(&
+Ãg©ive_Ïb\96
+);
+
+3912
+li
+(
+ou\8dut_»g
+,
+O³¿nd
+::
+Z\94o
+());
+
+3913
+b
+(&
+dÚe
+);
+
+3916
+b\9ad
+(&
+ov\94æow_Ïb\96
+);
+
+3917
+li
+(
+ou\8dut_»g
+,
+O³¿nd
+(
+§tv®
+));
+
+3919
+b\9ad
+(&
+dÚe
+);
+
+3923 \1e
+ gMaüoAs£mbËr
+::
+S\91Round\9agMode
+(
+FPRound\9agMode
+
+RN
+è{
+mtfsfi
+(7, RN); }
+
+3926 \1e
+ gMaüoAs£mbËr
+::
+Re£tRound\9agMode
+() {
+
+3927
+mtfsfi
+(7,
+kRoundToN\97»¡
+);
+
+3931 \1e
+ gMaüoAs£mbËr
+::
+CÏmpDoubËToU\9at8
+(
+Regi¡\94
+
+»suÉ_»g
+,
+
+3932
+DoubËRegi¡\94
+
+\9aput_»g
+,
+
+3933
+DoubËRegi¡\94
+
+doubË_sü©ch
+) {
+
+3934
+Lab\96
+
+ gabove_z\94o
+;
+
+3935
+Lab\96
+
+ gdÚe
+;
+
+3936
+Lab\96
+
+ g\9a_bounds
+;
+
+3938
+LßdDoubËL\99\94®
+(
+doubË_sü©ch
+, 0.0,
+»suÉ_»g
+);
+
+3939
+fcmpu
+(
+\9aput_»g
+,
+doubË_sü©ch
+);
+
+3940
+bgt
+(&
+above_z\94o
+);
+
+3943
+LßdIÁL\99\94®
+(
+»suÉ_»g
+, 0);
+
+3944
+b
+(&
+dÚe
+);
+
+3947
+b\9ad
+(&
+above_z\94o
+);
+
+3948
+LßdDoubËL\99\94®
+(
+doubË_sü©ch
+, 255.0,
+»suÉ_»g
+);
+
+3949
+fcmpu
+(
+\9aput_»g
+,
+doubË_sü©ch
+);
+
+3950
+bË
+(&
+\9a_bounds
+);
+
+3951
+LßdIÁL\99\94®
+(
+»suÉ_»g
+, 255);
+
+3952
+b
+(&
+dÚe
+);
+
+3955
+b\9ad
+(&
+\9a_bounds
+);
+
+3958
+fùiw
+(
+doubË_sü©ch
+,
+\9aput_»g
+);
+
+3959
+MovDoubËLowToIÁ
+(
+»suÉ_»g
+,
+doubË_sü©ch
+);
+
+3960
+b\9ad
+(&
+dÚe
+);
+
+3964 \1e
+ gMaüoAs£mbËr
+::
+LßdIn¡ªûDesü\9dtÜs
+(
+Regi¡\94
+
+m
+,
+
+3965
+Regi¡\94
+
+desü\9dtÜs
+) {
+
+3966
+LßdP
+(
+desü\9dtÜs
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kDesü\9dtÜsOff£t
+));
+
+3970 \1e
+ gMaüoAs£mbËr
+::
+Numb\94OfOwnDesü\9dtÜs
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+m
+) {
+
+3971
+lwz
+(
+d¡
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kB\99F\9bld3Off£t
+));
+
+3972
+ gDecodeF\9bld
+<
+ gM
+::
+Numb\94OfOwnDesü\9dtÜsB\99s
+>(
+d¡
+);
+
+3976 \1e
+ gMaüoAs£mbËr
+::
+EnumL\92gth
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+m
+) {
+
+3977
+STATIC_ASSERT
+(
+M
+::
+EnumL\92gthB\99s
+::
+kShiá
+ == 0);
+
+3978
+lwz
+(
+d¡
+,
+F\9bldMemO³¿nd
+(
+m
+,
+M
+::
+kB\99F\9bld3Off£t
+));
+
+3979
+Ex\8caùB\99Mask
+(
+d¡
+, d¡,
+M
+::
+EnumL\92gthB\99s
+::
+kMask
+);
+
+3980
+SmiTag
+(
+d¡
+);
+
+3984 \1e
+ gMaüoAs£mbËr
+::
+CheckEnumCache
+(
+Regi¡\94
+
+nuÎ_v®ue
+,
+Lab\96
+*
+ÿÎ_ruÁime
+) {
+
+3985
+Regi¡\94
+
+ gem±y_fixed_¬¿y_v®ue
+ =
+r9
+;
+
+3986
+LßdRoÙ
+(
+em±y_fixed_¬¿y_v®ue
+,
+H\97p
+::
+kEm±yFixedA¼ayRoÙIndex
+);
+
+3987
+Lab\96
+
+ gÃxt
+,
+ g¡¬t
+;
+
+3988
+mr
+(
+r5
+,
+r3
+);
+
+3992
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+3994
+EnumL\92gth
+(
+r6
+,
+r4
+);
+
+3995
+CmpSmiL\99\94®
+(
+r6
+,
+Smi
+::
+FromIÁ
+(
+kInv®idEnumCacheS\92t\9a\96
+),
+r0
+);
+
+3996
+beq
+(
+ÿÎ_ruÁime
+);
+
+3998
+b
+(&
+¡¬t
+);
+
+4000
+b\9ad
+(&
+Ãxt
+);
+
+4001
+LßdP
+(
+r4
+,
+F\9bldMemO³¿nd
+(
+r5
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+4004
+EnumL\92gth
+(
+r6
+,
+r4
+);
+
+4005
+CmpSmiL\99\94®
+(
+r6
+,
+Smi
+::
+FromIÁ
+(0),
+r0
+);
+
+4006
+bÃ
+(
+ÿÎ_ruÁime
+);
+
+4008
+b\9ad
+(&
+¡¬t
+);
+
+4012
+Lab\96
+
+ gno_\96em\92ts
+;
+
+4013
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+Ô5,
+JSObjeù
+::
+kEËm\92tsOff£t
+));
+
+4014
+cmp
+(
+r5
+,
+em±y_fixed_¬¿y_v®ue
+);
+
+4015
+beq
+(&
+no_\96em\92ts
+);
+
+4018
+Com·»RoÙ
+(
+r5
+,
+H\97p
+::
+kEm±ySlowEËm\92tDiùiÚ¬yRoÙIndex
+);
+
+4019
+bÃ
+(
+ÿÎ_ruÁime
+);
+
+4021
+b\9ad
+(&
+no_\96em\92ts
+);
+
+4022
+LßdP
+(
+r5
+,
+F\9bldMemO³¿nd
+(
+r4
+,
+M
+::
+kPrÙÙy³Off£t
+));
+
+4023
+cmp
+(
+r5
+,
+nuÎ_v®ue
+);
+
+4024
+bÃ
+(&
+Ãxt
+);
+
+4033 \1e
+ gMaüoAs£mbËr
+::
+LßdIÁL\99\94®
+(
+Regi¡\94
+
+d¡
+, \12
+v®ue
+) {
+
+4034
+mov
+(
+d¡
+,
+O³¿nd
+(
+v®ue
+));
+
+4038 \1e
+ gMaüoAs£mbËr
+::
+LßdSmiL\99\94®
+(
+Regi¡\94
+
+d¡
+,
+Smi
+*
+smi
+) {
+
+4039
+mov
+(
+d¡
+,
+O³¿nd
+(
+smi
+));
+
+4043 \1e
+ gMaüoAs£mbËr
+::
+LßdDoubËL\99\94®
+(
+DoubËRegi¡\94
+
+»suÉ
+, \b
+v®ue
+,
+
+4044
+Regi¡\94
+
+sü©ch
+) {
+
+4045 #ià
+V8_OOL_CONSTANT_POOL
+
+
+4048 ià(
+is_oÞ_cÚ¡ªt_poÞ_ava\9eabË
+(è&& !
+is_cÚ¡ªt_poÞ_fuÎ
+()) {
+
+4049
+R\96ocInfo
+
+r\9afo
+(
+pc_
+,
+v®ue
+);
+
+4050
+CÚ¡ªtPoÞAddEÁry
+(
+r\9afo
+);
+
+4051 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4053
+li
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+4054
+lfdx
+(
+»suÉ
+,
+MemO³¿nd
+(
+kCÚ¡ªtPoÞRegi¡\94
+,
+sü©ch
+));
+
+4056
+lfd
+(
+»suÉ
+,
+MemO³¿nd
+(
+kCÚ¡ªtPoÞRegi¡\94
+, 0));
+
+4064 \b
+ gdv®
+;
+
+4065 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4066
+\9a\8d\8c_t
+
+ giv®
+;
+
+4068
+\9a\8d\8c_t
+
+ giv®
+[2];
+
+4070 }
+ gl\99V®
+;
+
+4072
+ gl\99V®
+.
+ gdv®
+ =
+v®ue
+;
+
+4074 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4075 ià(
+ gCpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+FPR_GPR_MOV
+)) {
+
+4076
+mov
+(
+sü©ch
+,
+O³¿nd
+(
+l\99V®
+.
+iv®
+));
+
+4077
+mtård
+(
+»suÉ
+,
+sü©ch
+);
+
+4082
+addi
+(
+¥
+, sp,
+O³¿nd
+(-
+kDoubËSize
+));
+
+4083 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4084
+mov
+(
+sü©ch
+,
+O³¿nd
+(
+l\99V®
+.
+iv®
+));
+
+4085
+¡d
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+));
+
+4087
+LßdIÁL\99\94®
+(
+sü©ch
+,
+l\99V®
+.
+iv®
+[0]);
+
+4088
+¡w
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4089
+LßdIÁL\99\94®
+(
+sü©ch
+,
+l\99V®
+.
+iv®
+[1]);
+
+4090
+¡w
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+, 4));
+
+4092
+nÝ
+(
+GROUP_ENDING_NOP
+);
+
+4093
+lfd
+(
+»suÉ
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4094
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4098 \1e
+ gMaüoAs£mbËr
+::
+MovIÁToDoubË
+(
+DoubËRegi¡\94
+
+d¡
+,
+Regi¡\94
+
+¤c
+,
+
+4099
+Regi¡\94
+
+sü©ch
+) {
+
+4101 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4102 ià(
+ gCpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+FPR_GPR_MOV
+)) {
+
+4103
+mtårwa
+(
+d¡
+,
+¤c
+);
+
+4108
+DCHECK
+(!
+¤c
+.
+is
+(
+sü©ch
+));
+
+4109
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4110 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4111
+extsw
+(
+sü©ch
+,
+¤c
+);
+
+4112
+¡d
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4114
+¤awi
+(
+sü©ch
+,
+¤c
+, 31);
+
+4115
+¡w
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+,
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+4116
+¡w
+(
+¤c
+,
+MemO³¿nd
+(
+¥
+,
+Regi¡\94
+::
+kMªtis§Off£t
+));
+
+4118
+nÝ
+(
+GROUP_ENDING_NOP
+);
+
+4119
+lfd
+(
+d¡
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4120
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4124 \1e
+ gMaüoAs£mbËr
+::
+MovUnsigÃdIÁToDoubË
+(
+DoubËRegi¡\94
+
+d¡
+,
+Regi¡\94
+
+¤c
+,
+
+4125
+Regi¡\94
+
+sü©ch
+) {
+
+4127 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4128 ià(
+ gCpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+FPR_GPR_MOV
+)) {
+
+4129
+mtårwz
+(
+d¡
+,
+¤c
+);
+
+4134
+DCHECK
+(!
+¤c
+.
+is
+(
+sü©ch
+));
+
+4135
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4136 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4137
+þ¾di
+(
+sü©ch
+,
+¤c
+,
+O³¿nd
+(32));
+
+4138
+¡d
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4140
+li
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+4141
+¡w
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+,
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+4142
+¡w
+(
+¤c
+,
+MemO³¿nd
+(
+¥
+,
+Regi¡\94
+::
+kMªtis§Off£t
+));
+
+4144
+nÝ
+(
+GROUP_ENDING_NOP
+);
+
+4145
+lfd
+(
+d¡
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4146
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4150 \1e
+ gMaüoAs£mbËr
+::
+MovIÁ64ToDoubË
+(
+DoubËRegi¡\94
+
+d¡
+,
+
+4151 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+4152
+Regi¡\94
+
+¤c_hi
+,
+
+4154
+Regi¡\94
+
+¤c
+) {
+
+4155 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4156 ià(
+ gCpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+FPR_GPR_MOV
+)) {
+
+4157
+mtård
+(
+d¡
+,
+¤c
+);
+
+4162
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4163 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4164
+¡d
+(
+¤c
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4166
+¡w
+(
+¤c_hi
+,
+MemO³¿nd
+(
+¥
+,
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+4167
+¡w
+(
+¤c
+,
+MemO³¿nd
+(
+¥
+,
+Regi¡\94
+::
+kMªtis§Off£t
+));
+
+4169
+nÝ
+(
+GROUP_ENDING_NOP
+);
+
+4170
+lfd
+(
+d¡
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4171
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4175 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4176 \1e
+ gMaüoAs£mbËr
+::
+MovIÁ64CompÚ\92tsToDoubË
+(
+DoubËRegi¡\94
+
+d¡
+,
+
+4177
+Regi¡\94
+
+¤c_hi
+,
+
+4178
+Regi¡\94
+
+¤c_lo
+,
+
+4179
+Regi¡\94
+
+sü©ch
+) {
+
+4180 ià(
+ gCpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+FPR_GPR_MOV
+)) {
+
+4181
+¦di
+(
+sü©ch
+,
+¤c_hi
+,
+O³¿nd
+(32));
+
+4182
+¾dimi
+(
+sü©ch
+,
+¤c_lo
+, 0, 32);
+
+4183
+mtård
+(
+d¡
+,
+sü©ch
+);
+
+4187
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4188
+¡w
+(
+¤c_hi
+,
+MemO³¿nd
+(
+¥
+,
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+4189
+¡w
+(
+¤c_lo
+,
+MemO³¿nd
+(
+¥
+,
+Regi¡\94
+::
+kMªtis§Off£t
+));
+
+4190
+nÝ
+(
+GROUP_ENDING_NOP
+);
+
+4191
+lfd
+(
+d¡
+,
+MemO³¿nd
+(
+¥
+));
+
+4192
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4197 \1e
+ gMaüoAs£mbËr
+::
+MovDoubËLowToIÁ
+(
+Regi¡\94
+
+d¡
+,
+DoubËRegi¡\94
+
+¤c
+) {
+
+4198 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4199 ià(
+ gCpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+FPR_GPR_MOV
+)) {
+
+4200
+mfårwz
+(
+d¡
+,
+¤c
+);
+
+4205
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4206
+¡fd
+(
+¤c
+,
+MemO³¿nd
+(
+¥
+));
+
+4207
+nÝ
+(
+GROUP_ENDING_NOP
+);
+
+4208
+lwz
+(
+d¡
+,
+MemO³¿nd
+(
+¥
+,
+Regi¡\94
+::
+kMªtis§Off£t
+));
+
+4209
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4213 \1e
+ gMaüoAs£mbËr
+::
+MovDoubËHighToIÁ
+(
+Regi¡\94
+
+d¡
+,
+DoubËRegi¡\94
+
+¤c
+) {
+
+4214 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4215 ià(
+ gCpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+FPR_GPR_MOV
+)) {
+
+4216
+mfård
+(
+d¡
+,
+¤c
+);
+
+4217
+¤di
+(
+d¡
+, d¡,
+O³¿nd
+(32));
+
+4222
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4223
+¡fd
+(
+¤c
+,
+MemO³¿nd
+(
+¥
+));
+
+4224
+nÝ
+(
+GROUP_ENDING_NOP
+);
+
+4225
+lwz
+(
+d¡
+,
+MemO³¿nd
+(
+¥
+,
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+4226
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4230 \1e
+ gMaüoAs£mbËr
+::
+MovDoubËToIÁ64
+(
+
+4231 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+4232
+Regi¡\94
+
+d¡_hi
+,
+
+4234
+Regi¡\94
+
+d¡
+,
+DoubËRegi¡\94
+
+¤c
+) {
+
+4235 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4236 ià(
+ gCpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+FPR_GPR_MOV
+)) {
+
+4237
+mfård
+(
+d¡
+,
+¤c
+);
+
+4242
+subi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4243
+¡fd
+(
+¤c
+,
+MemO³¿nd
+(
+¥
+));
+
+4244
+nÝ
+(
+GROUP_ENDING_NOP
+);
+
+4245 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4246
+ld
+(
+d¡
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+4248
+lwz
+(
+d¡_hi
+,
+MemO³¿nd
+(
+¥
+,
+Regi¡\94
+::
+kExpÚ\92tOff£t
+));
+
+4249
+lwz
+(
+d¡
+,
+MemO³¿nd
+(
+¥
+,
+Regi¡\94
+::
+kMªtis§Off£t
+));
+
+4251
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+kDoubËSize
+));
+
+4255 \1e
+ gMaüoAs£mbËr
+::
+Add
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+\9a\8d\8c_t
+
+v®ue
+,
+
+4256
+Regi¡\94
+
+sü©ch
+) {
+
+4257 ià(
+is_\9at16
+(
+v®ue
+)) {
+
+4258
+addi
+(
+d¡
+,
+¤c
+,
+O³¿nd
+(
+v®ue
+));
+
+4260
+mov
+(
+sü©ch
+,
+O³¿nd
+(
+v®ue
+));
+
+4261
+add
+(
+d¡
+,
+¤c
+,
+sü©ch
+);
+
+4266 \1e
+ gMaüoAs£mbËr
+::
+Cmpi
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+, Regi¡\94
+sü©ch
+,
+
+4267
+CRegi¡\94
+
+ü
+) {
+
+4268
+\9a\8d\8c_t
+
+ gv®ue
+ =
+¤c2
+.
+immed\9f\8b
+();
+
+4269 ià(
+is_\9at16
+(
+v®ue
+)) {
+
+4270
+cmpi
+(
+¤c1
+,
+¤c2
+,
+ü
+);
+
+4272
+mov
+(
+sü©ch
+,
+¤c2
+);
+
+4273
+cmp
+(
+¤c1
+,
+sü©ch
+,
+ü
+);
+
+4278 \1e
+ gMaüoAs£mbËr
+::
+Cm¶i
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+, Regi¡\94
+sü©ch
+,
+
+4279
+CRegi¡\94
+
+ü
+) {
+
+4280
+\9a\8d\8c_t
+
+ gv®ue
+ =
+¤c2
+.
+immed\9f\8b
+();
+
+4281 ià(
+is_u\9at16
+(
+v®ue
+)) {
+
+4282
+cm¶i
+(
+¤c1
+,
+¤c2
+,
+ü
+);
+
+4284
+mov
+(
+sü©ch
+,
+¤c2
+);
+
+4285
+cm¶
+(
+¤c1
+,
+sü©ch
+,
+ü
+);
+
+4290 \1e
+ gMaüoAs£mbËr
+::
+Cmpwi
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+, Regi¡\94
+sü©ch
+,
+
+4291
+CRegi¡\94
+
+ü
+) {
+
+4292
+\9a\8d\8c_t
+
+ gv®ue
+ =
+¤c2
+.
+immed\9f\8b
+();
+
+4293 ià(
+is_\9at16
+(
+v®ue
+)) {
+
+4294
+cmpwi
+(
+¤c1
+,
+¤c2
+,
+ü
+);
+
+4296
+mov
+(
+sü©ch
+,
+¤c2
+);
+
+4297
+cmpw
+(
+¤c1
+,
+sü©ch
+,
+ü
+);
+
+4302 \1e
+ gMaüoAs£mbËr
+::
+Cm¶wi
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+,
+
+4303
+Regi¡\94
+
+sü©ch
+,
+CRegi¡\94
+
+ü
+) {
+
+4304
+\9a\8d\8c_t
+
+ gv®ue
+ =
+¤c2
+.
+immed\9f\8b
+();
+
+4305 ià(
+is_u\9at16
+(
+v®ue
+)) {
+
+4306
+cm¶wi
+(
+¤c1
+,
+¤c2
+,
+ü
+);
+
+4308
+mov
+(
+sü©ch
+,
+¤c2
+);
+
+4309
+cm¶w
+(
+¤c1
+,
+sü©ch
+,
+ü
+);
+
+4314 \1e
+ gMaüoAs£mbËr
+::
+And
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+rb
+,
+
+4315
+RCB\99
+
+rc
+) {
+
+4316 ià(
+ grb
+.
+is_»g
+()) {
+
+4317
+ªd_
+(
+¿
+,
+rs
+,
+rb
+.
+rm
+(),
+rc
+);
+
+4319 ià(
+is_u\9at16
+(
+rb
+.
+imm_
+è&&
+ gR\96ocInfo
+::
+IsNÚe
+Ôb.
+rmode_
+è&&
+rc
+ =ð
+S\91RC
+) {
+
+4320
+ªdi
+(
+¿
+,
+rs
+,
+rb
+);
+
+4323
+DCHECK
+(!
+rs
+.
+is
+(
+r0
+));
+
+4324
+mov
+(
+r0
+,
+rb
+);
+
+4325
+ªd_
+(
+¿
+,
+rs
+,
+r0
+,
+rc
+);
+
+4331 \1e
+ gMaüoAs£mbËr
+::
+Or
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+rb
+,
+RCB\99
+
+rc
+) {
+
+4332 ià(
+ grb
+.
+is_»g
+()) {
+
+4333
+Üx
+(
+¿
+,
+rs
+,
+rb
+.
+rm
+(),
+rc
+);
+
+4335 ià(
+is_u\9at16
+(
+rb
+.
+imm_
+è&&
+ gR\96ocInfo
+::
+IsNÚe
+Ôb.
+rmode_
+è&&
+rc
+ =ð
+L\97veRC
+) {
+
+4336
+Üi
+(
+¿
+,
+rs
+,
+rb
+);
+
+4339
+DCHECK
+(!
+rs
+.
+is
+(
+r0
+));
+
+4340
+mov
+(
+r0
+,
+rb
+);
+
+4341
+Üx
+(
+¿
+,
+rs
+,
+r0
+,
+rc
+);
+
+4347 \1e
+ gMaüoAs£mbËr
+::
+XÜ
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+rb
+,
+
+4348
+RCB\99
+
+rc
+) {
+
+4349 ià(
+ grb
+.
+is_»g
+()) {
+
+4350
+xÜ_
+(
+¿
+,
+rs
+,
+rb
+.
+rm
+(),
+rc
+);
+
+4352 ià(
+is_u\9at16
+(
+rb
+.
+imm_
+è&&
+ gR\96ocInfo
+::
+IsNÚe
+Ôb.
+rmode_
+è&&
+rc
+ =ð
+L\97veRC
+) {
+
+4353
+xÜi
+(
+¿
+,
+rs
+,
+rb
+);
+
+4356
+DCHECK
+(!
+rs
+.
+is
+(
+r0
+));
+
+4357
+mov
+(
+r0
+,
+rb
+);
+
+4358
+xÜ_
+(
+¿
+,
+rs
+,
+r0
+,
+rc
+);
+
+4364 \1e
+ gMaüoAs£mbËr
+::
+CmpSmiL\99\94®
+(
+Regi¡\94
+
+¤c1
+,
+Smi
+*
+smi
+, Regi¡\94
+sü©ch
+,
+
+4365
+CRegi¡\94
+
+ü
+) {
+
+4366 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4367
+LßdSmiL\99\94®
+(
+sü©ch
+,
+smi
+);
+
+4368
+cmp
+(
+¤c1
+,
+sü©ch
+,
+ü
+);
+
+4370
+Cmpi
+(
+¤c1
+,
+O³¿nd
+(
+smi
+),
+sü©ch
+,
+ü
+);
+
+4375 \1e
+ gMaüoAs£mbËr
+::
+Cm¶SmiL\99\94®
+(
+Regi¡\94
+
+¤c1
+,
+Smi
+*
+smi
+, Regi¡\94
+sü©ch
+,
+
+4376
+CRegi¡\94
+
+ü
+) {
+
+4377 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4378
+LßdSmiL\99\94®
+(
+sü©ch
+,
+smi
+);
+
+4379
+cm¶
+(
+¤c1
+,
+sü©ch
+,
+ü
+);
+
+4381
+Cm¶i
+(
+¤c1
+,
+O³¿nd
+(
+smi
+),
+sü©ch
+,
+ü
+);
+
+4386 \1e
+ gMaüoAs£mbËr
+::
+AddSmiL\99\94®
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+Smi
+*
+smi
+,
+
+4387
+Regi¡\94
+
+sü©ch
+) {
+
+4388 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4389
+LßdSmiL\99\94®
+(
+sü©ch
+,
+smi
+);
+
+4390
+add
+(
+d¡
+,
+¤c
+,
+sü©ch
+);
+
+4392
+Add
+(
+d¡
+,
+¤c
+,
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+smi
+),
+sü©ch
+);
+
+4397 \1e
+ gMaüoAs£mbËr
+::
+SubSmiL\99\94®
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+Smi
+*
+smi
+,
+
+4398
+Regi¡\94
+
+sü©ch
+) {
+
+4399 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4400
+LßdSmiL\99\94®
+(
+sü©ch
+,
+smi
+);
+
+4401
+sub
+(
+d¡
+,
+¤c
+,
+sü©ch
+);
+
+4403
+Add
+(
+d¡
+,
+¤c
+, -(
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+smi
+)),
+sü©ch
+);
+
+4408 \1e
+ gMaüoAs£mbËr
+::
+AndSmiL\99\94®
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+Smi
+*
+smi
+,
+
+4409
+Regi¡\94
+
+sü©ch
+,
+RCB\99
+
+rc
+) {
+
+4410 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4411
+LßdSmiL\99\94®
+(
+sü©ch
+,
+smi
+);
+
+4412
+ªd_
+(
+d¡
+,
+¤c
+,
+sü©ch
+,
+rc
+);
+
+4414
+And
+(
+d¡
+,
+¤c
+,
+O³¿nd
+(
+smi
+),
+rc
+);
+
+4420 \1e
+ gMaüoAs£mbËr
+::
+LßdP
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+4421
+Regi¡\94
+
+sü©ch
+) {
+
+4422 \12
+ goff£t
+ =
+mem
+.
+off£t
+();
+
+4424 ià(!
+ gsü©ch
+.
+is
+(
+no_»g
+è&& !
+is_\9at16
+(
+off£t
+)) {
+
+4426
+LßdIÁL\99\94®
+(
+sü©ch
+,
+off£t
+);
+
+4427 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4428
+ldx
+(
+d¡
+,
+MemO³¿nd
+(
+mem
+.
+¿
+(),
+sü©ch
+));
+
+4430
+lwzx
+(
+d¡
+,
+MemO³¿nd
+(
+mem
+.
+¿
+(),
+sü©ch
+));
+
+4433 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4434 \12
+ gmi§ligÃd
+ = (
+off£t
+ & 3);
+
+4435 ià(
+ gmi§ligÃd
+) {
+
+4438
+DCHECK
+(!
+d¡
+.
+is
+(
+r0
+));
+
+4439
+addi
+(
+d¡
+,
+mem
+.
+¿
+(),
+O³¿nd
+((
+off£t
+ & 3) - 4));
+
+4440
+ld
+(
+d¡
+,
+MemO³¿nd
+(d¡, (
+off£t
+ & ~3) + 4));
+
+4442
+ld
+(
+d¡
+,
+mem
+);
+
+4445
+lwz
+(
+d¡
+,
+mem
+);
+
+4452 \1e
+ gMaüoAs£mbËr
+::
+StÜeP
+(
+Regi¡\94
+
+¤c
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+4453
+Regi¡\94
+
+sü©ch
+) {
+
+4454 \12
+ goff£t
+ =
+mem
+.
+off£t
+();
+
+4456 ià(!
+ gsü©ch
+.
+is
+(
+no_»g
+è&& !
+is_\9at16
+(
+off£t
+)) {
+
+4458
+LßdIÁL\99\94®
+(
+sü©ch
+,
+off£t
+);
+
+4459 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4460
+¡dx
+(
+¤c
+,
+MemO³¿nd
+(
+mem
+.
+¿
+(),
+sü©ch
+));
+
+4462
+¡wx
+(
+¤c
+,
+MemO³¿nd
+(
+mem
+.
+¿
+(),
+sü©ch
+));
+
+4465 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4466 \12
+ gmi§ligÃd
+ = (
+off£t
+ & 3);
+
+4467 ià(
+ gmi§ligÃd
+) {
+
+4470
+DCHECK
+(!
+sü©ch
+.
+is
+(
+no_»g
+));
+
+4471 ià(
+ gsü©ch
+.
+is
+(
+r0
+)) {
+
+4472
+LßdIÁL\99\94®
+(
+sü©ch
+,
+off£t
+);
+
+4473
+¡dx
+(
+¤c
+,
+MemO³¿nd
+(
+mem
+.
+¿
+(),
+sü©ch
+));
+
+4475
+addi
+(
+sü©ch
+,
+mem
+.
+¿
+(),
+O³¿nd
+((
+off£t
+ & 3) - 4));
+
+4476
+¡d
+(
+¤c
+,
+MemO³¿nd
+(
+sü©ch
+, (
+off£t
+ & ~3) + 4));
+
+4479
+¡d
+(
+¤c
+,
+mem
+);
+
+4482
+¡w
+(
+¤c
+,
+mem
+);
+
+4487 \1e
+ gMaüoAs£mbËr
+::
+LßdWÜdAr\99h
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+4488
+Regi¡\94
+
+sü©ch
+) {
+
+4489 \12
+ goff£t
+ =
+mem
+.
+off£t
+();
+
+4491 ià(!
+ gsü©ch
+.
+is
+(
+no_»g
+è&& !
+is_\9at16
+(
+off£t
+)) {
+
+4493
+LßdIÁL\99\94®
+(
+sü©ch
+,
+off£t
+);
+
+4494 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4496
+DCHECK
+(0);
+
+4498
+lwzx
+(
+d¡
+,
+MemO³¿nd
+(
+mem
+.
+¿
+(),
+sü©ch
+));
+
+4501 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4502 \12
+ gmi§ligÃd
+ = (
+off£t
+ & 3);
+
+4503 ià(
+ gmi§ligÃd
+) {
+
+4506
+DCHECK
+(!
+d¡
+.
+is
+(
+r0
+));
+
+4507
+addi
+(
+d¡
+,
+mem
+.
+¿
+(),
+O³¿nd
+((
+off£t
+ & 3) - 4));
+
+4508
+lwa
+(
+d¡
+,
+MemO³¿nd
+(d¡, (
+off£t
+ & ~3) + 4));
+
+4510
+lwa
+(
+d¡
+,
+mem
+);
+
+4513
+lwz
+(
+d¡
+,
+mem
+);
+
+4521 \1e
+ gMaüoAs£mbËr
+::
+LßdWÜd
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+4522
+Regi¡\94
+
+sü©ch
+) {
+
+4523
+Regi¡\94
+
+ gba£
+ =
+mem
+.
+¿
+();
+
+4524 \12
+ goff£t
+ =
+mem
+.
+off£t
+();
+
+4526 ià(!
+is_\9at16
+(
+off£t
+)) {
+
+4527
+LßdIÁL\99\94®
+(
+sü©ch
+,
+off£t
+);
+
+4528
+lwzx
+(
+d¡
+,
+MemO³¿nd
+(
+ba£
+,
+sü©ch
+));
+
+4530
+lwz
+(
+d¡
+,
+mem
+);
+
+4537 \1e
+ gMaüoAs£mbËr
+::
+StÜeWÜd
+(
+Regi¡\94
+
+¤c
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+4538
+Regi¡\94
+
+sü©ch
+) {
+
+4539
+Regi¡\94
+
+ gba£
+ =
+mem
+.
+¿
+();
+
+4540 \12
+ goff£t
+ =
+mem
+.
+off£t
+();
+
+4542 ià(!
+is_\9at16
+(
+off£t
+)) {
+
+4543
+LßdIÁL\99\94®
+(
+sü©ch
+,
+off£t
+);
+
+4544
+¡wx
+(
+¤c
+,
+MemO³¿nd
+(
+ba£
+,
+sü©ch
+));
+
+4546
+¡w
+(
+¤c
+,
+mem
+);
+
+4553 \1e
+ gMaüoAs£mbËr
+::
+LßdH®fWÜd
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+4554
+Regi¡\94
+
+sü©ch
+) {
+
+4555
+Regi¡\94
+
+ gba£
+ =
+mem
+.
+¿
+();
+
+4556 \12
+ goff£t
+ =
+mem
+.
+off£t
+();
+
+4558 ià(!
+is_\9at16
+(
+off£t
+)) {
+
+4559
+LßdIÁL\99\94®
+(
+sü©ch
+,
+off£t
+);
+
+4560
+lhzx
+(
+d¡
+,
+MemO³¿nd
+(
+ba£
+,
+sü©ch
+));
+
+4562
+lhz
+(
+d¡
+,
+mem
+);
+
+4569 \1e
+ gMaüoAs£mbËr
+::
+StÜeH®fWÜd
+(
+Regi¡\94
+
+¤c
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+4570
+Regi¡\94
+
+sü©ch
+) {
+
+4571
+Regi¡\94
+
+ gba£
+ =
+mem
+.
+¿
+();
+
+4572 \12
+ goff£t
+ =
+mem
+.
+off£t
+();
+
+4574 ià(!
+is_\9at16
+(
+off£t
+)) {
+
+4575
+LßdIÁL\99\94®
+(
+sü©ch
+,
+off£t
+);
+
+4576
+¡hx
+(
+¤c
+,
+MemO³¿nd
+(
+ba£
+,
+sü©ch
+));
+
+4578
+¡h
+(
+¤c
+,
+mem
+);
+
+4585 \1e
+ gMaüoAs£mbËr
+::
+LßdBy\8b
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+4586
+Regi¡\94
+
+sü©ch
+) {
+
+4587
+Regi¡\94
+
+ gba£
+ =
+mem
+.
+¿
+();
+
+4588 \12
+ goff£t
+ =
+mem
+.
+off£t
+();
+
+4590 ià(!
+is_\9at16
+(
+off£t
+)) {
+
+4591
+LßdIÁL\99\94®
+(
+sü©ch
+,
+off£t
+);
+
+4592
+lbzx
+(
+d¡
+,
+MemO³¿nd
+(
+ba£
+,
+sü©ch
+));
+
+4594
+lbz
+(
+d¡
+,
+mem
+);
+
+4601 \1e
+ gMaüoAs£mbËr
+::
+StÜeBy\8b
+(
+Regi¡\94
+
+¤c
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+4602
+Regi¡\94
+
+sü©ch
+) {
+
+4603
+Regi¡\94
+
+ gba£
+ =
+mem
+.
+¿
+();
+
+4604 \12
+ goff£t
+ =
+mem
+.
+off£t
+();
+
+4606 ià(!
+is_\9at16
+(
+off£t
+)) {
+
+4607
+LßdIÁL\99\94®
+(
+sü©ch
+,
+off£t
+);
+
+4608
+¡bx
+(
+¤c
+,
+MemO³¿nd
+(
+ba£
+,
+sü©ch
+));
+
+4610
+¡b
+(
+¤c
+,
+mem
+);
+
+4615 \1e
+ gMaüoAs£mbËr
+::
+LßdR\95»£Á©iÚ
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+4616
+R\95»£Á©iÚ
+
+r
+,
+Regi¡\94
+
+sü©ch
+) {
+
+4617
+DCHECK
+(!
+r
+.
+IsDoubË
+());
+
+4618 ià(
+ gr
+.
+IsIÁeg\948
+()) {
+
+4619
+LßdBy\8b
+(
+d¡
+,
+mem
+,
+sü©ch
+);
+
+4620
+extsb
+(
+d¡
+, dst);
+
+4621 } \vià(
+ gr
+.
+IsUIÁeg\948
+()) {
+
+4622
+LßdBy\8b
+(
+d¡
+,
+mem
+,
+sü©ch
+);
+
+4623 } \vià(
+ gr
+.
+IsIÁeg\9416
+()) {
+
+4624
+LßdH®fWÜd
+(
+d¡
+,
+mem
+,
+sü©ch
+);
+
+4625
+extsh
+(
+d¡
+, dst);
+
+4626 } \vià(
+ gr
+.
+IsUIÁeg\9416
+()) {
+
+4627
+LßdH®fWÜd
+(
+d¡
+,
+mem
+,
+sü©ch
+);
+
+4628 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4629 } \vià(
+ gr
+.
+IsIÁeg\9432
+()) {
+
+4630
+LßdWÜd
+(
+d¡
+,
+mem
+,
+sü©ch
+);
+
+4633
+LßdP
+(
+d¡
+,
+mem
+,
+sü©ch
+);
+
+4638 \1e
+ gMaüoAs£mbËr
+::
+StÜeR\95»£Á©iÚ
+(
+Regi¡\94
+
+¤c
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+4639
+R\95»£Á©iÚ
+
+r
+,
+Regi¡\94
+
+sü©ch
+) {
+
+4640
+DCHECK
+(!
+r
+.
+IsDoubË
+());
+
+4641 ià(
+ gr
+.
+IsIÁeg\948
+(è||\84.
+IsUIÁeg\948
+()) {
+
+4642
+StÜeBy\8b
+(
+¤c
+,
+mem
+,
+sü©ch
+);
+
+4643 } \vià(
+ gr
+.
+IsIÁeg\9416
+(è||\84.
+IsUIÁeg\9416
+()) {
+
+4644
+StÜeH®fWÜd
+(
+¤c
+,
+mem
+,
+sü©ch
+);
+
+4645 #ià
+V8_TARGET_ARCH_PPC64
+
+
+4646 } \vià(
+ gr
+.
+IsIÁeg\9432
+()) {
+
+4647
+StÜeWÜd
+(
+¤c
+,
+mem
+,
+sü©ch
+);
+
+4650 ià(
+ gr
+.
+IsH\97pObjeù
+()) {
+
+4651
+As£¹NÙSmi
+(
+¤c
+);
+
+4652 } \vià(
+ gr
+.
+IsSmi
+()) {
+
+4653
+As£¹Smi
+(
+¤c
+);
+
+4655
+StÜeP
+(
+¤c
+,
+mem
+,
+sü©ch
+);
+
+4660 \1e
+ gMaüoAs£mbËr
+::
+Te¡JSA¼ayFÜAÎoÿtiÚMem\92to
+(
+Regi¡\94
+
+»ûiv\94_»g
+,
+
+4661
+Regi¡\94
+
+sü©ch_»g
+,
+
+4662
+Lab\96
+*
+no_mem\92to_found
+) {
+
+4663
+Ex\8bº®Reã»nû
+
+ gÃw_¥aû_¡¬t
+ =
+
+4664
+Ex\8bº®Reã»nû
+::
+Ãw_¥aû_¡¬t
+(
+isީe
+());
+
+4665
+Ex\8bº®Reã»nû
+
+ gÃw_¥aû_®loÿtiÚ_tÝ
+ =
+
+4666
+Ex\8bº®Reã»nû
+::
+Ãw_¥aû_®loÿtiÚ_tÝ_add»ss
+(
+isީe
+());
+
+4667
+addi
+(
+sü©ch_»g
+,
+»ûiv\94_»g
+,
+
+4668
+O³¿nd
+(
+JSA¼ay
+::
+kSize
+ +
+AÎoÿtiÚMem\92to
+::kSiz\90-
+kH\97pObjeùTag
+));
+
+4669
+Cmpi
+(
+sü©ch_»g
+,
+O³¿nd
+(
+Ãw_¥aû_¡¬t
+),
+r0
+);
+
+4670
+bÉ
+(
+no_mem\92to_found
+);
+
+4671
+mov
+(
+\9d
+,
+O³¿nd
+(
+Ãw_¥aû_®loÿtiÚ_tÝ
+));
+
+4672
+LßdP
+(
+\9d
+,
+MemO³¿nd
+(ip));
+
+4673
+cmp
+(
+sü©ch_»g
+,
+\9d
+);
+
+4674
+bgt
+(
+no_mem\92to_found
+);
+
+4675
+LßdP
+(
+sü©ch_»g
+,
+MemO³¿nd
+(sü©ch_»g, -
+AÎoÿtiÚMem\92to
+::
+kSize
+));
+
+4676
+Cmpi
+(
+sü©ch_»g
+,
+O³¿nd
+(
+isީe
+()->
+çùÜy
+()->
+®loÿtiÚ_mem\92to_m
+()),
+
+4677
+r0
+);
+
+4681
+Regi¡\94
+
+G\91Regi¡\94Th©IsNÙOÃOf
+(Regi¡\94
+»g1
+, Regi¡\94
+»g2
+, Regi¡\94
+»g3
+,
+
+4682
+Regi¡\94
+
+»g4
+, Regi¡\94
+»g5
+,
+
+4683
+Regi¡\94
+
+»g6
+) {
+
+4684
+RegLi¡
+
+ g»gs
+ = 0;
+
+4685 ià(
+ g»g1
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g1
+.
+b\99
+();
+
+4686 ià(
+ g»g2
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g2
+.
+b\99
+();
+
+4687 ià(
+ g»g3
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g3
+.
+b\99
+();
+
+4688 ià(
+ g»g4
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g4
+.
+b\99
+();
+
+4689 ià(
+ g»g5
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g5
+.
+b\99
+();
+
+4690 ià(
+ g»g6
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g6
+.
+b\99
+();
+
+4692 \ f\12
+ gi
+ = 0; i <
+ gRegi¡\94
+::
+NumAÎoÿ\8fbËRegi¡\94s
+(); i++) {
+
+4693
+Regi¡\94
+
+ gÿndid©e
+ = Regi¡\94::
+FromAÎoÿtiÚIndex
+(
+i
+);
+
+4694 ià(
+ g»gs
+ &
+ gÿndid©e
+.
+b\99
+()) \ 6;
+
+4695 \15
+ gÿndid©e
+;
+
+4697
+UNREACHABLE
+();
+
+4698 \15
+ gno_»g
+;
+
+4702 \1e
+ gMaüoAs£mbËr
+::
+JumpIfDiùiÚ¬yInPrÙÙy³Cha\9a
+(
+Regi¡\94
+
+objeù
+,
+
+4703
+Regi¡\94
+
+sü©ch0
+,
+
+4704
+Regi¡\94
+
+sü©ch1
+,
+
+4705
+Lab\96
+*
+found
+) {
+
+4706
+DCHECK
+(!
+sü©ch1
+.
+is
+(
+sü©ch0
+));
+
+4707
+FaùÜy
+*
+ gçùÜy
+ =
+isީe
+()->
+çùÜy
+();
+
+4708
+Regi¡\94
+
+ gcu¼\92t
+ =
+sü©ch0
+;
+
+4709
+Lab\96
+
+ gloÝ_aga\9a
+;
+
+4712
+mr
+(
+cu¼\92t
+,
+objeù
+);
+
+4715
+b\9ad
+(&
+loÝ_aga\9a
+);
+
+4716
+LßdP
+(
+cu¼\92t
+,
+F\9bldMemO³¿nd
+(cu¼\92t,
+H\97pObjeù
+::
+kMOff£t
+));
+
+4717
+lbz
+(
+sü©ch1
+,
+F\9bldMemO³¿nd
+(
+cu¼\92t
+,
+M
+::
+kB\99F\9bld2Off£t
+));
+
+4718
+ gDecodeF\9bld
+<
+ gM
+::
+EËm\92tsK\9adB\99s
+>(
+sü©ch1
+);
+
+4719
+cmpi
+(
+sü©ch1
+,
+O³¿nd
+(
+DICTIONARY_ELEMENTS
+));
+
+4720
+beq
+(
+found
+);
+
+4721
+LßdP
+(
+cu¼\92t
+,
+F\9bldMemO³¿nd
+(cu¼\92t,
+M
+::
+kPrÙÙy³Off£t
+));
+
+4722
+Cmpi
+(
+cu¼\92t
+,
+O³¿nd
+(
+çùÜy
+->
+nuÎ_v®ue
+()),
+r0
+);
+
+4723
+bÃ
+(&
+loÝ_aga\9a
+);
+
+4727 #ifdeà
+DEBUG
+
+
+4728
+boÞ
+
+A»Al\9f£d
+(
+Regi¡\94
+
+»g1
+, Regi¡\94
+»g2
+, Regi¡\94
+»g3
+, Regi¡\94
+»g4
+,
+
+4729
+Regi¡\94
+
+»g5
+, Regi¡\94
+»g6
+, Regi¡\94
+»g7
+, Regi¡\94
+»g8
+) {
+
+4730 \12
+ gn_of_v®id_»gs
+ =
+»g1
+.
+is_v®id
+(è+
+»g2
+.is_v®id(è+
+»g3
+.is_valid() +
+
+4731
+»g4
+.
+is_v®id
+(è+
+»g5
+.is_v®id(è+
+»g6
+.is_valid() +
+
+4732
+»g7
+.
+is_v®id
+(è+
+»g8
+.is_valid();
+
+4734
+RegLi¡
+
+ g»gs
+ = 0;
+
+4735 ià(
+ g»g1
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g1
+.
+b\99
+();
+
+4736 ià(
+ g»g2
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g2
+.
+b\99
+();
+
+4737 ià(
+ g»g3
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g3
+.
+b\99
+();
+
+4738 ià(
+ g»g4
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g4
+.
+b\99
+();
+
+4739 ià(
+ g»g5
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g5
+.
+b\99
+();
+
+4740 ià(
+ g»g6
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g6
+.
+b\99
+();
+
+4741 ià(
+ g»g7
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g7
+.
+b\99
+();
+
+4742 ià(
+ g»g8
+.
+is_v®id
+()è
+ g»gs
+ |ð
+»g8
+.
+b\99
+();
+
+4743 \12
+ gn_of_nÚ_®\9fs\9ag_»gs
+ =
+NumRegs
+(
+»gs
+);
+
+4745 \15
+ gn_of_v®id_»gs
+ !ð
+n_of_nÚ_®\9fs\9ag_»gs
+;
+
+4750
+ gCodeP©ch\94
+::
+CodeP©ch\94
+(
+by\8b
+*
+add»ss
+, \12
+\9a¡ruùiÚs
+,
+
+4751
+FlushICache
+
+æush_ÿche
+)
+
+4752 :
+add»ss_
+(
+add»ss
+),
+
+4753
+size_
+(
+\9a¡ruùiÚs
+ *
+As£mbËr
+::
+kIn¡rSize
+),
+
+4754
+masm_
+(
+NULL
+,
+add»ss
+,
+size_
+ +
+As£mbËr
+::
+kG
+),
+
+4755
+æush_ÿche_
+(
+æush_ÿche
+) {
+
+4759
+DCHECK
+(
+masm_
+.
+»loc_\9afo_wr\99\94
+.
+pos
+(è=ð
+add»ss_
+ +
+size_
+ +
+As£mbËr
+::
+kG
+);
+
+4763
+ gCodeP©ch\94
+::~
+CodeP©ch\94
+() {
+
+4765 ià(
+æush_ÿche_
+ =ð
+FLUSH
+) {
+
+4766
+CpuF\97tu»s
+::
+FlushICache
+(
+add»ss_
+,
+size_
+);
+
+4770
+DCHECK
+(
+masm_
+.
+pc_
+ =ð
+add»ss_
+ +
+size_
+);
+
+4771
+DCHECK
+(
+masm_
+.
+»loc_\9afo_wr\99\94
+.
+pos
+(è=ð
+add»ss_
+ +
+size_
+ +
+As£mbËr
+::
+kG
+);
+
+4775 \1e
+ gCodeP©ch\94
+::
+Em\99
+(
+In¡r
+
+\9a¡r
+è{
+masm
+()->
+em\99
+(instr); }
+
+4778 \1e
+ gCodeP©ch\94
+::
+Em\99CÚd\99iÚ
+(
+CÚd\99iÚ
+
+cÚd
+) {
+
+4779
+In¡r
+
+\9a¡r
+ =
+As£mbËr
+::
+\9a¡r_©
+(
+masm_
+.
+pc_
+);
+
+4780 \1a
+ gcÚd
+) {
+
+4781 \ 4
+ geq
+:
+
+4782
+\9a¡r
+ = (\9a¡¸& ~
+kCÚdMask
+è|
+BT
+;
+
+4784 \ 4
+ gÃ
+:
+
+4785
+\9a¡r
+ = (\9a¡¸& ~
+kCÚdMask
+è|
+BF
+;
+
+4788
+UNIMPLEMENTED
+();
+
+4790
+ gmasm_
+.
+em\99
+(
+\9a¡r
+);
+
+4794 \1e
+ gMaüoAs£mbËr
+::
+Trunÿt\9agDiv
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+divid\92d
+,
+
+4795
+\9at32_t
+
+divisÜ
+) {
+
+4796
+DCHECK
+(!
+divid\92d
+.
+is
+(
+»suÉ
+));
+
+4797
+DCHECK
+(!
+divid\92d
+.
+is
+(
+r0
+));
+
+4798
+DCHECK
+(!
+»suÉ
+.
+is
+(
+r0
+));
+
+4799
+ gba£
+::
+MagicNumb\94sFÜDivisiÚ
+<
+u\9at32_t
+>
+mag
+ =
+
+4800
+ba£
+::
+SigÃdDivisiÚByCÚ¡ªt
+(
+¡©ic_ÿ¡
+<
+u\9at32_t
+>(
+divisÜ
+));
+
+4801
+mov
+(
+r0
+,
+O³¿nd
+(
+mag
+.
+muÉ\9dl\9br
+));
+
+4802
+mulhw
+(
+»suÉ
+,
+divid\92d
+,
+r0
+);
+
+4803
+boÞ
+
+ gÃg
+ = (
+mag
+.
+muÉ\9dl\9br
+ & (
+¡©ic_ÿ¡
+<
+u\9at32_t
+>(1) << 31)) != 0;
+
+4804 ià(
+ gdivisÜ
+ > 0 &&
+ gÃg
+) {
+
+4805
+add
+(
+»suÉ
+,\84esuÉ,
+divid\92d
+);
+
+4807 ià(
+ gdivisÜ
+ < 0 && !
+ gÃg
+ &&
+ gmag
+.
+ gmuÉ\9dl\9br
+ > 0) {
+
+4808
+sub
+(
+»suÉ
+,\84esuÉ,
+divid\92d
+);
+
+4810 ià(
+ gmag
+.
+ gshiá
+ > 0è
+¤awi
+(
+»suÉ
+,\84esuÉ,
+mag
+.
+shiá
+);
+
+4811
+Ex\8caùB\99
+(
+r0
+,
+divid\92d
+, 31);
+
+4812
+add
+(
+»suÉ
+,\84esuÉ,
+r0
+);
+
+ @macro-assembler-ppc.h
+
+5 #iâdeà
+V8_PPC_MACRO_ASSEMBLER_PPC_H_
+
+
+6 \ 1
+ #V8_PPC_MACRO_ASSEMBLER_PPC_H_
+
+
+ )
+
+8 \ 2
+ ~"¤c/as£mbËr.h
+"
+
+9 \ 2
+ ~"¤c/ba\9eout-»asÚ.h
+"
+
+10 \ 2
+ ~"¤c/äames.h
+"
+
+11 \ 2
+ ~"¤c/glob®s.h
+"
+
+13
+Çme¥aû
+
+ gv8
+ {
+
+14
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+20
+\9al\9ae
+
+MemO³¿nd
+
+F\9bldMemO³¿nd
+(
+Regi¡\94
+
+objeù
+, \12
+off£t
+) {
+
+21 \15
+MemO³¿nd
+(
+objeù
+,
+off£t
+ -
+kH\97pObjeùTag
+);
+
+26 \f
+ eTagg\9agMode
+ {
+
+28
+ gTAG_RESULT
+,
+
+30
+ gDONT_TAG_RESULT
+
+
+34 \f
+ eRememb\94edS\91AùiÚ
+ {
+ gEMIT_REMEMBERED_SET
+,
+ gOMIT_REMEMBERED_SET
+ };
+
+35 \f
+ eSmiCheck
+ {
+ gINLINE_SMI_CHECK
+,
+ gOMIT_SMI_CHECK
+ };
+
+36 \f
+ ePo\9a\8brsToH\94eCheck
+ {
+
+37
+ gkPo\9a\8brsToH\94eMaybeIÁ\94e¡\9ag
+,
+
+38
+ gkPo\9a\8brsToH\94eA»AlwaysIÁ\94e¡\9ag
+
+
+40 \f
+ eL\9akRegi¡\94S\8ftus
+ {
+ gkLRHasNÙB\93nSaved
+,
+ gkLRHasB\93nSaved
+ };
+
+43
+Regi¡\94
+
+G\91Regi¡\94Th©IsNÙOÃOf
+(Regi¡\94
+»g1
+, Regi¡\94
+»g2
+ =
+no_»g
+,
+
+44
+Regi¡\94
+
+»g3
+ =
+no_»g
+,
+
+45
+Regi¡\94
+
+»g4
+ =
+no_»g
+,
+
+46
+Regi¡\94
+
+»g5
+ =
+no_»g
+,
+
+47
+Regi¡\94
+
+»g6
+ =
+no_»g
+);
+
+50 #ifdeà
+DEBUG
+
+
+51
+boÞ
+
+A»Al\9f£d
+(
+Regi¡\94
+
+»g1
+, Regi¡\94
+»g2
+, Regi¡\94
+»g3
+ =
+no_»g
+,
+
+52
+Regi¡\94
+
+»g4
+ =
+no_»g
+, Regi¡\94
+»g5
+ =\82o_reg,
+
+53
+Regi¡\94
+
+»g6
+ =
+no_»g
+, Regi¡\94
+»g7
+ =\82o_reg,
+
+54
+Regi¡\94
+
+»g8
+ =
+no_»g
+);
+
+58 #ià
+V8_TARGET_ARCH_PPC64
+
+
+59 \ 1
+ #LßdPU
+
+ldu
+
+
+ )
+
+60 \ 1
+ #LßdPX
+
+ldx
+
+
+ )
+
+61 \ 1
+ #LßdPUX
+
+ldux
+
+
+ )
+
+62 \ 1
+ #StÜePU
+
+¡du
+
+
+ )
+
+63 \ 1
+ #StÜePX
+
+¡dx
+
+
+ )
+
+64 \ 1
+ #StÜePUX
+
+¡dux
+
+
+ )
+
+65 \ 1
+ #ShiáLeáImm
+
+¦di
+
+
+ )
+
+66 \ 1
+ #ShiáRightImm
+
+¤di
+
+
+ )
+
+67 \ 1
+ #CˬLeáImm
+
+þ¾di
+
+
+ )
+
+68 \ 1
+ #CˬRightImm
+
+þ¼di
+
+
+ )
+
+69 \ 1
+ #ShiáRightAr\99hImm
+
+¤adi
+
+
+ )
+
+70 \ 1
+ #ShiáLeá_
+
+¦d
+
+
+ )
+
+71 \ 1
+ #ShiáRight_
+
+¤d
+
+
+ )
+
+72 \ 1
+ #ShiáRightAr\99h
+
+¤ad
+
+
+ )
+
+73 \ 1
+ #Mul
+
+muÎd
+
+
+ )
+
+74 \ 1
+ #Div
+
+divd
+
+
+ )
+
+76 \ 1
+ #LßdPU
+
+lwzu
+
+
+ )
+
+77 \ 1
+ #LßdPX
+
+lwzx
+
+
+ )
+
+78 \ 1
+ #LßdPUX
+
+lwzux
+
+
+ )
+
+79 \ 1
+ #StÜePU
+
+¡wu
+
+
+ )
+
+80 \ 1
+ #StÜePX
+
+¡wx
+
+
+ )
+
+81 \ 1
+ #StÜePUX
+
+¡wux
+
+
+ )
+
+82 \ 1
+ #ShiáLeáImm
+
+¦wi
+
+
+ )
+
+83 \ 1
+ #ShiáRightImm
+
+¤wi
+
+
+ )
+
+84 \ 1
+ #CˬLeáImm
+
+þ¾wi
+
+
+ )
+
+85 \ 1
+ #CˬRightImm
+
+þ¼wi
+
+
+ )
+
+86 \ 1
+ #ShiáRightAr\99hImm
+
+¤awi
+
+
+ )
+
+87 \ 1
+ #ShiáLeá_
+
+¦w
+
+
+ )
+
+88 \ 1
+ #ShiáRight_
+
+¤w
+
+
+ )
+
+89 \ 1
+ #ShiáRightAr\99h
+
+¤aw
+
+
+ )
+
+90 \ 1
+ #Mul
+
+muÎw
+
+
+ )
+
+91 \ 1
+ #Div
+
+divw
+
+
+ )
+
+96 þas
+ cMaüoAs£mbËr
+ :
+public
+
+As£mbËr
+ {
+
+97
+public
+:
+
+102
+MaüoAs£mbËr
+(
+Isީe
+*
+isީe
+, \1e*
+bufãr
+, \12
+size
+);
+
+108 \18\12
+C®lSize
+(
+Regi¡\94
+
+\8frg\91
+);
+
+109 \12
+C®lSize
+(
+Add»ss
+
+\8frg\91
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+110 \18\12
+C®lSizeNÙP»diùabËCodeSize
+(
+Add»ss
+
+\8frg\91
+,
+
+111
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+
+112
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+115 \1e
+Jump
+(
+Regi¡\94
+
+\8frg\91
+);
+
+116 \1e
+JumpToJSEÁry
+(
+Regi¡\94
+
+\8frg\91
+);
+
+117 \1e
+Jump
+(
+Add»ss
+
+\8frg\91
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+CÚd\99iÚ
+
+cÚd
+ =
+®
+,
+
+118
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+119 \1e
+Jump
+(
+HªdË
+<
+Code
+>
+code
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+120 \1e
+C®l
+(
+Regi¡\94
+
+\8frg\91
+);
+
+121 \1e
+C®lJSEÁry
+(
+Regi¡\94
+
+\8frg\91
+);
+
+122 \1e
+C®l
+(
+Add»ss
+
+\8frg\91
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+123 \12
+C®lSize
+(
+HªdË
+<
+Code
+>
+code
+,
+
+124
+R\96ocInfo
+::
+Mode
+
+rmode
+ = R\96ocInfo::
+CODE_TARGET
+,
+
+125
+Ty³F\93dbackId
+
+a¡_id
+ = Ty³F\93dbackId::
+NÚe
+(),
+
+126
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+127 \1e
+C®l
+(
+HªdË
+<
+Code
+>
+code
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+ = R\96ocInfo::
+CODE_TARGET
+,
+
+128
+Ty³F\93dbackId
+
+a¡_id
+ = Ty³F\93dbackId::
+NÚe
+(),
+
+129
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+130 \1e
+R\91
+(
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+134 \1e
+DrÝ
+(\12
+couÁ
+,
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+136 \1e
+R\91
+(\12
+drÝ
+,
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+138 \1e
+C®l
+(
+Lab\96
+*
+\8frg\91
+);
+
+141 \1e
+C®lS\96f
+() {
+
+142
+ gHªdË
+<
+ gCode
+>
+£lf
+(
+»\9a\8b½»t_ÿ¡
+<
+Code
+**>(
+CodeObjeù
+().
+loÿtiÚ
+()));
+
+143
+C®l
+(
+£lf
+,
+R\96ocInfo
+::
+CODE_TARGET
+);
+
+147 \1e
+Move
+(
+Regi¡\94
+
+d¡
+,
+HªdË
+<
+Objeù
+>
+v®ue
+);
+
+148 \1e
+Move
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+149 \1e
+Move
+(
+DoubËRegi¡\94
+
+d¡
+, DoubËRegi¡\94
+¤c
+);
+
+151 \1e
+MuÉiPush
+(
+RegLi¡
+
+»gs
+);
+
+152 \1e
+MuÉiPÝ
+(
+RegLi¡
+
+»gs
+);
+
+155 \1e
+LßdRoÙ
+(
+Regi¡\94
+
+de¡\9a©iÚ
+,
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+,
+
+156
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+158 \1e
+StÜeRoÙ
+(
+Regi¡\94
+
+sourû
+,
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+,
+
+159
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+164 \1e
+Inüem\92\8flM¬k\9agRecÜdWr\99eH\96³r
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+v®ue
+,
+
+165
+Regi¡\94
+
+add»ss
+);
+
+167 \f
+ eRememb\94edS\91F\9a®AùiÚ
+ {
+ gkR\91uºAtEnd
+,
+ gkF®lThroughAtEnd
+ };
+
+172 \1e
+Rememb\94edS\91H\96³r
+(
+Regi¡\94
+
+objeù
+,
+
+173
+Regi¡\94
+
+addr
+, Regi¡\94
+sü©ch
+,
+
+174
+SaveFPRegsMode
+
+§ve_å
+,
+
+175
+Rememb\94edS\91F\9a®AùiÚ
+
+ªd_th\92
+);
+
+177 \1e
+CheckPageFÏg
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch
+, \12
+mask
+,
+CÚd\99iÚ
+
+cc
+,
+
+178
+Lab\96
+*
+cÚd\99iÚ_m\91
+);
+
+180 \1e
+CheckMD\95»ÿ\8bd
+(
+HªdË
+<
+M
+>
+m
+,
+Regi¡\94
+
+sü©ch
+,
+
+181
+Lab\96
+*
+if_d\95»ÿ\8bd
+);
+
+185 \1e
+JumpIfNÙInNewS·û
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch
+,
+Lab\96
+*
+b¿nch
+) {
+
+186
+InNewS·û
+(
+objeù
+,
+sü©ch
+,
+Ã
+,
+b¿nch
+);
+
+191 \1e
+JumpIfInNewS·û
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch
+,
+Lab\96
+*
+b¿nch
+) {
+
+192
+InNewS·û
+(
+objeù
+,
+sü©ch
+,
+eq
+,
+b¿nch
+);
+
+196 \1e
+HasCÞÜ
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch0
+, Regi¡\94
+sü©ch1
+,
+
+197
+Lab\96
+*
+has_cÞÜ
+, \12
+f\9c¡_b\99
+, \12
+£cÚd_b\99
+);
+
+199 \1e
+JumpIfBÏck
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch0
+, Regi¡\94
+sü©ch1
+,
+
+200
+Lab\96
+*
+Ú_bÏck
+);
+
+207 \1e
+Ensu»NÙWh\99e
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+208
+Regi¡\94
+
+sü©ch3
+,
+Lab\96
+*
+objeù_is_wh\99e_ªd_nÙ_d©a
+);
+
+212 \1e
+JumpIfD©aObjeù
+(
+Regi¡\94
+
+v®ue
+, Regi¡\94
+sü©ch
+,
+
+213
+Lab\96
+*
+nÙ_d©a_objeù
+);
+
+220 \1e
+RecÜdWr\99eF\9bld
+(
+
+221
+Regi¡\94
+
+objeù
+, \12
+off£t
+, Regi¡\94
+v®ue
+, Regi¡\94
+sü©ch
+,
+
+222
+L\9akRegi¡\94S\8ftus
+
+Ì_¡©us
+,
+SaveFPRegsMode
+
+§ve_å
+,
+
+223
+Rememb\94edS\91AùiÚ
+
+»memb\94ed_£t_aùiÚ
+ =
+EMIT_REMEMBERED_SET
+,
+
+224
+SmiCheck
+
+smi_check
+ =
+INLINE_SMI_CHECK
+,
+
+225
+Po\9a\8brsToH\94eCheck
+
+po\9a\8brs_to_h\94e_check_fÜ_v®ue
+ =
+
+226
+kPo\9a\8brsToH\94eMaybeIÁ\94e¡\9ag
+);
+
+230
+\9al\9ae
+ \1e
+RecÜdWr\99eCÚ\8bxtSlÙ
+(
+
+231
+Regi¡\94
+
+cڋxt
+, \12
+off£t
+, Regi¡\94
+v®ue
+, Regi¡\94
+sü©ch
+,
+
+232
+L\9akRegi¡\94S\8ftus
+
+Ì_¡©us
+,
+SaveFPRegsMode
+
+§ve_å
+,
+
+233
+Rememb\94edS\91AùiÚ
+
+»memb\94ed_£t_aùiÚ
+ =
+EMIT_REMEMBERED_SET
+,
+
+234
+SmiCheck
+
+smi_check
+ =
+INLINE_SMI_CHECK
+,
+
+235
+Po\9a\8brsToH\94eCheck
+
+po\9a\8brs_to_h\94e_check_fÜ_v®ue
+ =
+
+236
+kPo\9a\8brsToH\94eMaybeIÁ\94e¡\9ag
+) {
+
+237
+RecÜdWr\99eF\9bld
+(
+cڋxt
+,
+off£t
+ +
+kH\97pObjeùTag
+,
+v®ue
+,
+sü©ch
+,
+
+238
+Ì_¡©us
+,
+§ve_å
+,
+»memb\94ed_£t_aùiÚ
+,
+smi_check
+,
+
+239
+po\9a\8brs_to_h\94e_check_fÜ_v®ue
+);
+
+242 \1e
+RecÜdWr\99eFÜM
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+m
+, Regi¡\94
+d¡
+,
+
+243
+L\9akRegi¡\94S\8ftus
+
+Ì_¡©us
+,
+SaveFPRegsMode
+
+§ve_å
+);
+
+248 \1e
+RecÜdWr\99e
+(
+
+249
+Regi¡\94
+
+objeù
+, Regi¡\94
+add»ss
+, Regi¡\94
+v®ue
+,
+
+250
+L\9akRegi¡\94S\8ftus
+
+Ì_¡©us
+,
+SaveFPRegsMode
+
+§ve_å
+,
+
+251
+Rememb\94edS\91AùiÚ
+
+»memb\94ed_£t_aùiÚ
+ =
+EMIT_REMEMBERED_SET
+,
+
+252
+SmiCheck
+
+smi_check
+ =
+INLINE_SMI_CHECK
+,
+
+253
+Po\9a\8brsToH\94eCheck
+
+po\9a\8brs_to_h\94e_check_fÜ_v®ue
+ =
+
+254
+kPo\9a\8brsToH\94eMaybeIÁ\94e¡\9ag
+);
+
+256 \1e
+Push
+(
+Regi¡\94
+
+¤c
+è{
+push
+(src); }
+
+259 \1e
+Push
+(
+HªdË
+<
+Objeù
+>
+hªdË
+);
+
+260 \1e
+Push
+(
+Smi
+*
+smi
+è{ Push(
+HªdË
+<Smi>(smi,
+isީe
+())); }
+
+263 \1e
+Push
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+) {
+
+264
+StÜePU
+(
+¤c2
+,
+MemO³¿nd
+(
+¥
+, -2 *
+kPo\9a\8brSize
+));
+
+265
+StÜeP
+(
+¤c1
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+269 \1e
+Push
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+, Regi¡\94
+¤c3
+) {
+
+270
+StÜePU
+(
+¤c3
+,
+MemO³¿nd
+(
+¥
+, -3 *
+kPo\9a\8brSize
+));
+
+271
+StÜeP
+(
+¤c2
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+272
+StÜeP
+(
+¤c1
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+276 \1e
+Push
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+, Regi¡\94
+¤c3
+, Regi¡\94
+¤c4
+) {
+
+277
+StÜePU
+(
+¤c4
+,
+MemO³¿nd
+(
+¥
+, -4 *
+kPo\9a\8brSize
+));
+
+278
+StÜeP
+(
+¤c3
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+279
+StÜeP
+(
+¤c2
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+280
+StÜeP
+(
+¤c1
+,
+MemO³¿nd
+(
+¥
+, 3 *
+kPo\9a\8brSize
+));
+
+284 \1e
+Push
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+, Regi¡\94
+¤c3
+, Regi¡\94
+¤c4
+,
+
+285
+Regi¡\94
+
+¤c5
+) {
+
+286
+StÜePU
+(
+¤c5
+,
+MemO³¿nd
+(
+¥
+, -5 *
+kPo\9a\8brSize
+));
+
+287
+StÜeP
+(
+¤c4
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+288
+StÜeP
+(
+¤c3
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+289
+StÜeP
+(
+¤c2
+,
+MemO³¿nd
+(
+¥
+, 3 *
+kPo\9a\8brSize
+));
+
+290
+StÜeP
+(
+¤c1
+,
+MemO³¿nd
+(
+¥
+, 4 *
+kPo\9a\8brSize
+));
+
+293 \1e
+PÝ
+(
+Regi¡\94
+
+d¡
+è{
+pÝ
+(dst); }
+
+296 \1e
+PÝ
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+) {
+
+297
+LßdP
+(
+¤c2
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+298
+LßdP
+(
+¤c1
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+299
+addi
+(
+¥
+, sp,
+O³¿nd
+(2 *
+kPo\9a\8brSize
+));
+
+303 \1e
+PÝ
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+, Regi¡\94
+¤c3
+) {
+
+304
+LßdP
+(
+¤c3
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+305
+LßdP
+(
+¤c2
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+306
+LßdP
+(
+¤c1
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+307
+addi
+(
+¥
+, sp,
+O³¿nd
+(3 *
+kPo\9a\8brSize
+));
+
+311 \1e
+PÝ
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+, Regi¡\94
+¤c3
+, Regi¡\94
+¤c4
+) {
+
+312
+LßdP
+(
+¤c4
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+313
+LßdP
+(
+¤c3
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+314
+LßdP
+(
+¤c2
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+315
+LßdP
+(
+¤c1
+,
+MemO³¿nd
+(
+¥
+, 3 *
+kPo\9a\8brSize
+));
+
+316
+addi
+(
+¥
+, sp,
+O³¿nd
+(4 *
+kPo\9a\8brSize
+));
+
+320 \1e
+PÝ
+(
+Regi¡\94
+
+¤c1
+, Regi¡\94
+¤c2
+, Regi¡\94
+¤c3
+, Regi¡\94
+¤c4
+,
+
+321
+Regi¡\94
+
+¤c5
+) {
+
+322
+LßdP
+(
+¤c5
+,
+MemO³¿nd
+(
+¥
+, 0));
+
+323
+LßdP
+(
+¤c4
+,
+MemO³¿nd
+(
+¥
+,
+kPo\9a\8brSize
+));
+
+324
+LßdP
+(
+¤c3
+,
+MemO³¿nd
+(
+¥
+, 2 *
+kPo\9a\8brSize
+));
+
+325
+LßdP
+(
+¤c2
+,
+MemO³¿nd
+(
+¥
+, 3 *
+kPo\9a\8brSize
+));
+
+326
+LßdP
+(
+¤c1
+,
+MemO³¿nd
+(
+¥
+, 4 *
+kPo\9a\8brSize
+));
+
+327
+addi
+(
+¥
+, sp,
+O³¿nd
+(5 *
+kPo\9a\8brSize
+));
+
+332 \1e
+PushFixedF¿me
+(
+Regi¡\94
+
+m¬k\94_»g
+ =
+no_»g
+);
+
+333 \1e
+PÝFixedF¿me
+(
+Regi¡\94
+
+m¬k\94_»g
+ =
+no_»g
+);
+
+337 \1e
+PushSaãpo\9atRegi¡\94s
+();
+
+338 \1e
+PÝSaãpo\9atRegi¡\94s
+();
+
+341 \1e
+StÜeToSaãpo\9atRegi¡\94SlÙ
+(
+Regi¡\94
+
+¤c
+, Regi¡\94
+d¡
+);
+
+344 \1e
+LßdFromSaãpo\9atRegi¡\94SlÙ
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+);
+
+349 \1e
+FlushICache
+(
+Regi¡\94
+
+add»ss
+,
+size_t
+
+size
+, Regi¡\94
+sü©ch
+);
+
+352 \1e
+CªÚiÿlizeNaN
+(cڡ
+DoubËRegi¡\94
+
+d¡
+, cÚ¡ DoubËRegi¡\94
+¤c
+);
+
+353 \1e
+CªÚiÿlizeNaN
+(cڡ
+DoubËRegi¡\94
+
+v®ue
+) {
+
+354
+CªÚiÿlizeNaN
+(
+v®ue
+, value);
+
+359 \1e
+CÚv\94tIÁToDoubË
+(
+Regi¡\94
+
+¤c
+,
+DoubËRegi¡\94
+
+doubË_d¡
+);
+
+363 \1e
+CÚv\94tUnsigÃdIÁToDoubË
+(
+Regi¡\94
+
+¤c
+,
+DoubËRegi¡\94
+
+doubË_d¡
+);
+
+368 \1e
+CÚv\94tIÁToFlßt
+(cڡ
+DoubËRegi¡\94
+
+d¡
+, cڡ
+Regi¡\94
+
+¤c
+,
+
+369 cڡ
+Regi¡\94
+
+\9at_sü©ch
+);
+
+373 \1e
+CÚv\94tDoubËToIÁ64
+(cڡ
+DoubËRegi¡\94
+
+doubË_\9aput
+,
+
+374 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+375 cڡ
+Regi¡\94
+
+d¡_hi
+,
+
+377 cڡ
+Regi¡\94
+
+d¡
+, cڡ
+DoubËRegi¡\94
+
+doubË_d¡
+,
+
+378
+FPRound\9agMode
+
+round\9ag_mode
+ =
+kRoundToZ\94o
+);
+
+381 \1e
+StubPrÞogue
+(\12
+´Þogue_off£t
+ = 0);
+
+382 \1e
+PrÞogue
+(
+boÞ
+
+code_´e_ag\9ag
+, \12
+´Þogue_off£t
+ = 0);
+
+386 \1e
+EÁ\94Ex\99F¿me
+(
+boÞ
+
+§ve_doubËs
+, \12
+¡ack_¥aû
+ = 0);
+
+391 \1e
+L\97veEx\99F¿me
+(
+boÞ
+
+§ve_doubËs
+,
+Regi¡\94
+
+¬gum\92t_couÁ
+,
+
+392
+boÞ
+
+»¡Üe_cÚ\8bxt
+);
+
+395 \18\12
+Aùiv©iÚF¿meAlignm\92t
+();
+
+397 \1e
+LßdCÚ\8bxt
+(
+Regi¡\94
+
+d¡
+, \12
+cÚ\8bxt_cha\9a_Ëngth
+);
+
+403 \1e
+LßdT¿ns\99iÚedA¼ayMCÚd\99iÚ®
+(
+EËm\92tsK\9ad
+
+ex³ùed_k\9ad
+,
+
+404
+EËm\92tsK\9ad
+
+\8cªs\99iÚed_k\9ad
+,
+
+405
+Regi¡\94
+
+m_\9a_out
+,
+
+406
+Regi¡\94
+
+sü©ch
+,
+
+407
+Lab\96
+*
+no_m_m©ch
+);
+
+409 \1e
+LßdGlob®FunùiÚ
+(\12
+\9adex
+,
+Regi¡\94
+
+funùiÚ
+);
+
+413 \1e
+LßdGlob®FunùiÚIn\99\9flM
+(
+Regi¡\94
+
+funùiÚ
+, Regi¡\94
+m
+,
+
+414
+Regi¡\94
+
+sü©ch
+);
+
+416 \1e
+In\99\9flizeRoÙRegi¡\94
+() {
+
+417
+Ex\8bº®Reã»nû
+
+ groÙs_¬¿y_¡¬t
+ =
+
+418
+Ex\8bº®Reã»nû
+::
+roÙs_¬¿y_¡¬t
+(
+isީe
+());
+
+419
+mov
+(
+kRoÙRegi¡\94
+,
+O³¿nd
+(
+roÙs_¬¿y_¡¬t
+));
+
+427 \1e
+LßdIÁL\99\94®
+(
+Regi¡\94
+
+d¡
+, \12
+v®ue
+);
+
+430 \1e
+LßdSmiL\99\94®
+(
+Regi¡\94
+
+d¡
+,
+Smi
+*
+smi
+);
+
+433 \1e
+LßdDoubËL\99\94®
+(
+DoubËRegi¡\94
+
+»suÉ
+, \b
+v®ue
+,
+Regi¡\94
+
+sü©ch
+);
+
+435 \1e
+LßdWÜd
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+mem
+, Regi¡\94
+sü©ch
+);
+
+437 \1e
+LßdWÜdAr\99h
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+438
+Regi¡\94
+
+sü©ch
+ =
+no_»g
+);
+
+440 \1e
+StÜeWÜd
+(
+Regi¡\94
+
+¤c
+, cڡ
+MemO³¿nd
+&
+mem
+, Regi¡\94
+sü©ch
+);
+
+442 \1e
+LßdH®fWÜd
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+mem
+, Regi¡\94
+sü©ch
+);
+
+444 \1e
+StÜeH®fWÜd
+(
+Regi¡\94
+
+¤c
+, cڡ
+MemO³¿nd
+&
+mem
+, Regi¡\94
+sü©ch
+);
+
+446 \1e
+LßdBy\8b
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+mem
+, Regi¡\94
+sü©ch
+);
+
+448 \1e
+StÜeBy\8b
+(
+Regi¡\94
+
+¤c
+, cڡ
+MemO³¿nd
+&
+mem
+, Regi¡\94
+sü©ch
+);
+
+450 \1e
+LßdR\95»£Á©iÚ
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+mem
+,
+R\95»£Á©iÚ
+
+r
+,
+
+451
+Regi¡\94
+
+sü©ch
+ =
+no_»g
+);
+
+453 \1e
+StÜeR\95»£Á©iÚ
+(
+Regi¡\94
+
+¤c
+, cڡ
+MemO³¿nd
+&
+mem
+,
+
+454
+R\95»£Á©iÚ
+
+r
+,
+Regi¡\94
+
+sü©ch
+ =
+no_»g
+);
+
+457 \1e
+MovIÁToDoubË
+(
+DoubËRegi¡\94
+
+d¡
+,
+Regi¡\94
+
+¤c
+, Regi¡\94
+sü©ch
+);
+
+458 \1e
+MovUnsigÃdIÁToDoubË
+(
+DoubËRegi¡\94
+
+d¡
+,
+Regi¡\94
+
+¤c
+,
+
+459
+Regi¡\94
+
+sü©ch
+);
+
+460 \1e
+MovIÁ64ToDoubË
+(
+DoubËRegi¡\94
+
+d¡
+,
+
+461 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+462
+Regi¡\94
+
+¤c_hi
+,
+
+464
+Regi¡\94
+
+¤c
+);
+
+465 #ià
+V8_TARGET_ARCH_PPC64
+
+
+466 \1e
+MovIÁ64CompÚ\92tsToDoubË
+(
+DoubËRegi¡\94
+
+d¡
+,
+Regi¡\94
+
+¤c_hi
+,
+
+467
+Regi¡\94
+
+¤c_lo
+, Regi¡\94
+sü©ch
+);
+
+469 \1e
+MovDoubËLowToIÁ
+(
+Regi¡\94
+
+d¡
+,
+DoubËRegi¡\94
+
+¤c
+);
+
+470 \1e
+MovDoubËHighToIÁ
+(
+Regi¡\94
+
+d¡
+,
+DoubËRegi¡\94
+
+¤c
+);
+
+471 \1e
+MovDoubËToIÁ64
+(
+
+472 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+473
+Regi¡\94
+
+d¡_hi
+,
+
+475
+Regi¡\94
+
+d¡
+,
+DoubËRegi¡\94
+
+¤c
+);
+
+477 \1e
+Add
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+\9a\8d\8c_t
+
+v®ue
+, Regi¡\94
+sü©ch
+);
+
+478 \1e
+Cmpi
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+, Regi¡\94
+sü©ch
+,
+
+479
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+480 \1e
+Cm¶i
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+, Regi¡\94
+sü©ch
+,
+
+481
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+482 \1e
+Cmpwi
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+, Regi¡\94
+sü©ch
+,
+
+483
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+484 \1e
+Cm¶wi
+(
+Regi¡\94
+
+¤c1
+, cڡ
+O³¿nd
+&
+¤c2
+, Regi¡\94
+sü©ch
+,
+
+485
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+486 \1e
+And
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+rb
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+487 \1e
+Or
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+rb
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+488 \1e
+XÜ
+(
+Regi¡\94
+
+¿
+, Regi¡\94
+rs
+, cڡ
+O³¿nd
+&
+rb
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+490 \1e
+AddSmiL\99\94®
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+Smi
+*
+smi
+, Regi¡\94
+sü©ch
+);
+
+491 \1e
+SubSmiL\99\94®
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+Smi
+*
+smi
+, Regi¡\94
+sü©ch
+);
+
+492 \1e
+CmpSmiL\99\94®
+(
+Regi¡\94
+
+¤c1
+,
+Smi
+*
+smi
+, Regi¡\94
+sü©ch
+,
+
+493
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+494 \1e
+Cm¶SmiL\99\94®
+(
+Regi¡\94
+
+¤c1
+,
+Smi
+*
+smi
+, Regi¡\94
+sü©ch
+,
+
+495
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+496 \1e
+AndSmiL\99\94®
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+Smi
+*
+smi
+, Regi¡\94
+sü©ch
+,
+
+497
+RCB\99
+
+rc
+ =
+L\97veRC
+);
+
+500 \1e
+S\91Round\9agMode
+(
+FPRound\9agMode
+
+RN
+);
+
+503 \1e
+Re£tRound\9agMode
+();
+
+506 \1e
+LßdP
+(
+Regi¡\94
+
+d¡
+, cڡ
+MemO³¿nd
+&
+mem
+, Regi¡\94
+sü©ch
+ =
+no_»g
+);
+
+507 \1e
+StÜeP
+(
+Regi¡\94
+
+¤c
+, cڡ
+MemO³¿nd
+&
+mem
+, Regi¡\94
+sü©ch
+ =
+no_»g
+);
+
+513 \1e
+InvokeCode
+(
+Regi¡\94
+
+code
+, cڡ
+P¬am\91\94CouÁ
+&
+ex³ùed
+,
+
+514 cڡ
+P¬am\91\94CouÁ
+&
+aùu®
+,
+InvokeFÏg
+
+æag
+,
+
+515 cڡ
+C®lW¿µ\94
+&
+ÿÎ_w¿µ\94
+);
+
+519 \1e
+InvokeFunùiÚ
+(
+Regi¡\94
+
+funùiÚ
+, cڡ
+P¬am\91\94CouÁ
+&
+aùu®
+,
+
+520
+InvokeFÏg
+
+æag
+, cڡ
+C®lW¿µ\94
+&
+ÿÎ_w¿µ\94
+);
+
+522 \1e
+InvokeFunùiÚ
+(
+Regi¡\94
+
+funùiÚ
+, cڡ
+P¬am\91\94CouÁ
+&
+ex³ùed
+,
+
+523 cڡ
+P¬am\91\94CouÁ
+&
+aùu®
+,
+InvokeFÏg
+
+æag
+,
+
+524 cڡ
+C®lW¿µ\94
+&
+ÿÎ_w¿µ\94
+);
+
+526 \1e
+InvokeFunùiÚ
+(
+HªdË
+<
+JSFunùiÚ
+>
+funùiÚ
+,
+
+527 cڡ
+P¬am\91\94CouÁ
+&
+ex³ùed
+,
+
+528 cڡ
+P¬am\91\94CouÁ
+&
+aùu®
+,
+InvokeFÏg
+
+æag
+,
+
+529 cڡ
+C®lW¿µ\94
+&
+ÿÎ_w¿µ\94
+);
+
+531 \1e
+IsObjeùJSObjeùTy³
+(
+Regi¡\94
+
+h\97p_objeù
+, Regi¡\94
+m
+,
+
+532
+Regi¡\94
+
+sü©ch
+,
+Lab\96
+*
+ç\9e
+);
+
+534 \1e
+IsIn¡ªûJSObjeùTy³
+(
+Regi¡\94
+
+m
+, Regi¡\94
+sü©ch
+,
+Lab\96
+*
+ç\9e
+);
+
+536 \1e
+IsObjeùJSS\8c\9agTy³
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch
+,
+Lab\96
+*
+ç\9e
+);
+
+538 \1e
+IsObjeùNameTy³
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch
+,
+Lab\96
+*
+ç\9e
+);
+
+543 \1e
+DebugB»ak
+();
+
+549 \1e
+PushTryHªdËr
+(
+S\8fckHªdËr
+::
+K\9ad
+
+k\9ad
+, \12
+hªdËr_\9adex
+);
+
+553 \1e
+PÝTryHªdËr
+();
+
+556 \1e
+Throw
+(
+Regi¡\94
+
+v®ue
+);
+
+560 \1e
+ThrowUnÿtchabË
+(
+Regi¡\94
+
+v®ue
+);
+
+568 \1e
+CheckAcûssGlob®Proxy
+(
+Regi¡\94
+
+hÞd\94_»g
+, Regi¡\94
+sü©ch
+,
+
+569
+Lab\96
+*
+miss
+);
+
+571 \1e
+G\91Numb\94Hash
+(
+Regi¡\94
+
+t0
+, Regi¡\94
+sü©ch
+);
+
+573 \1e
+LßdFromNumb\94DiùiÚ¬y
+(
+Lab\96
+*
+miss
+,
+Regi¡\94
+
+\96em\92ts
+, Regi¡\94
+key
+,
+
+574
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+t0
+, Regi¡\94
+t1
+,
+
+575
+Regi¡\94
+
+t2
+);
+
+578
+\9al\9ae
+ \1e
+M¬kCode
+(
+NÝM¬k\94Ty³s
+
+ty³
+è{
+nÝ
+(type); }
+
+584 \18
+\9al\9ae
+
+boÞ
+
+IsM¬kedCode
+(
+In¡r
+
+\9a¡r
+, \12
+ty³
+) {
+
+585
+DCHECK
+((
+FIRST_IC_MARKER
+ <ð
+ty³
+è&& (ty³ <
+LAST_CODE_MARKER
+));
+
+586 \15
+IsNÝ
+(
+\9a¡r
+,
+ty³
+);
+
+590 \18
+\9al\9ae
+ \12
+G\91CodeM¬k\94
+(
+In¡r
+
+\9a¡r
+) {
+
+591 \12
+ gd¡_»g_off£t
+ = 12;
+
+592 \12
+ gd¡_mask
+ = 0xà<<
+d¡_»g_off£t
+;
+
+593 \12
+ g¤c_mask
+ = 0xf;
+
+594 \12
+ gd¡_»g
+ = (
+\9a¡r
+ &
+d¡_mask
+è>>
+d¡_»g_off£t
+;
+
+595 \12
+ g¤c_»g
+ =
+\9a¡r
+ &
+¤c_mask
+;
+
+596
+u\9at32_t
+
+ gnÚ_»gi¡\94_mask
+ = ~(
+d¡_mask
+ |
+¤c_mask
+);
+
+597
+u\9at32_t
+
+ gmov_mask
+ =
+®
+ | 13 << 21;
+
+600 \12
+ gty³
+ = ((
+\9a¡r
+ &
+nÚ_»gi¡\94_mask
+è=ð
+mov_mask
+) &&
+
+601 (
+d¡_»g
+ =ð
+¤c_»g
+è&& (
+FIRST_IC_MARKER
+ <= dst_reg) &&
+
+602 (
+d¡_»g
+ <
+LAST_CODE_MARKER
+)
+
+603 ?
+¤c_»g
+
+
+605
+DCHECK
+((
+ty³
+ == -1) ||
+
+606 ((
+FIRST_IC_MARKER
+ <ð
+ty³
+è&& (ty³ <
+LAST_CODE_MARKER
+)));
+
+607 \15
+ gty³
+;
+
+621 \1e
+AÎoÿ\8b
+(\12
+objeù_size
+,
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+sü©ch1
+,
+
+622
+Regi¡\94
+
+sü©ch2
+,
+Lab\96
+*
+gc_»qu\9ced
+,
+AÎoÿtiÚFÏgs
+
+æags
+);
+
+624 \1e
+AÎoÿ\8b
+(
+Regi¡\94
+
+objeù_size
+, Regi¡\94
+»suÉ
+, Regi¡\94
+sü©ch1
+,
+
+625
+Regi¡\94
+
+sü©ch2
+,
+Lab\96
+*
+gc_»qu\9ced
+,
+AÎoÿtiÚFÏgs
+
+æags
+);
+
+631 \1e
+UndoAÎoÿtiÚInNewS·û
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch
+);
+
+634 \1e
+AÎoÿ\8bTwoBy\8bS\8c\9ag
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+Ëngth
+,
+
+635
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+636
+Regi¡\94
+
+sü©ch3
+,
+Lab\96
+*
+gc_»qu\9ced
+);
+
+637 \1e
+AÎoÿ\8bOÃBy\8bS\8c\9ag
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+Ëngth
+,
+
+638
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+639
+Regi¡\94
+
+sü©ch3
+,
+Lab\96
+*
+gc_»qu\9ced
+);
+
+640 \1e
+AÎoÿ\8bTwoBy\8bCÚsS\8c\9ag
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+Ëngth
+,
+
+641
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+642
+Lab\96
+*
+gc_»qu\9ced
+);
+
+643 \1e
+AÎoÿ\8bOÃBy\8bCÚsS\8c\9ag
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+Ëngth
+,
+
+644
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+645
+Lab\96
+*
+gc_»qu\9ced
+);
+
+646 \1e
+AÎoÿ\8bTwoBy\8bSliûdS\8c\9ag
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+Ëngth
+,
+
+647
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+648
+Lab\96
+*
+gc_»qu\9ced
+);
+
+649 \1e
+AÎoÿ\8bOÃBy\8bSliûdS\8c\9ag
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+Ëngth
+,
+
+650
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+651
+Lab\96
+*
+gc_»qu\9ced
+);
+
+656 \1e
+AÎoÿ\8bH\97pNumb\94
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+657
+Regi¡\94
+
+h\97p_numb\94_m
+,
+Lab\96
+*
+gc_»qu\9ced
+,
+
+658
+Tagg\9agMode
+
+\8fgg\9ag_mode
+ =
+TAG_RESULT
+,
+
+659
+Mu\8fbËMode
+
+mode
+ =
+IMMUTABLE
+);
+
+660 \1e
+AÎoÿ\8bH\97pNumb\94W\99hV®ue
+(
+Regi¡\94
+
+»suÉ
+,
+DoubËRegi¡\94
+
+v®ue
+,
+
+661
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+662
+Regi¡\94
+
+h\97p_numb\94_m
+,
+
+663
+Lab\96
+*
+gc_»qu\9ced
+);
+
+666 \1e
+CÝyF\9blds
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+RegLi¡
+
+\8bmps
+, \12
+f\9bld_couÁ
+);
+
+671 \1e
+CÝyBy\8bs
+(
+Regi¡\94
+
+¤c
+, Regi¡\94
+d¡
+, Regi¡\94
+Ëngth
+, Regi¡\94
+sü©ch
+);
+
+677 \1e
+In\99\9flizeNF\9bldsW\99hF\9eËr
+(
+Regi¡\94
+
+¡¬t_off£t
+, Regi¡\94
+couÁ
+,
+
+678
+Regi¡\94
+
+f\9eËr
+);
+
+683 \1e
+In\99\9flizeF\9bldsW\99hF\9eËr
+(
+Regi¡\94
+
+¡¬t_off£t
+, Regi¡\94
+\92d_off£t
+,
+
+684
+Regi¡\94
+
+f\9eËr
+);
+
+694 \1e
+TryG\91FunùiÚPrÙÙy³
+(
+Regi¡\94
+
+funùiÚ
+, Regi¡\94
+»suÉ
+,
+
+695
+Regi¡\94
+
+sü©ch
+,
+Lab\96
+*
+miss
+,
+
+696
+boÞ
+
+miss_Ú_bound_funùiÚ
+ =
+çl£
+);
+
+706 \1e
+Com·»ObjeùTy³
+(
+Regi¡\94
+
+h\97p_objeù
+, Regi¡\94
+m
+, Regi¡\94
+ty³_»g
+,
+
+707
+In¡ªûTy³
+
+ty³
+);
+
+712 \1e
+CheckObjeùTy³Rªge
+(
+Regi¡\94
+
+h\97p_objeù
+, Regi¡\94
+m
+,
+
+713
+In¡ªûTy³
+
+m\9a_ty³
+, In¡ªûTy³
+max_ty³
+,
+
+714
+Lab\96
+*
+çl£_Ïb\96
+);
+
+719 \1e
+Com·»In¡ªûTy³
+(
+Regi¡\94
+
+m
+, Regi¡\94
+ty³_»g
+,
+In¡ªûTy³
+
+ty³
+);
+
+724 \1e
+CheckFa¡EËm\92ts
+(
+Regi¡\94
+
+m
+, Regi¡\94
+sü©ch
+,
+Lab\96
+*
+ç\9e
+);
+
+728 \1e
+CheckFa¡ObjeùEËm\92ts
+(
+Regi¡\94
+
+m
+, Regi¡\94
+sü©ch
+,
+Lab\96
+*
+ç\9e
+);
+
+732 \1e
+CheckFa¡SmiEËm\92ts
+(
+Regi¡\94
+
+m
+, Regi¡\94
+sü©ch
+,
+Lab\96
+*
+ç\9e
+);
+
+737 \1e
+StÜeNumb\94ToDoubËEËm\92ts
+(
+Regi¡\94
+
+v®ue_»g
+, Regi¡\94
+key_»g
+,
+
+738
+Regi¡\94
+
+\96em\92ts_»g
+, Regi¡\94
+sü©ch1
+,
+
+739
+DoubËRegi¡\94
+
+doubË_sü©ch
+,
+Lab\96
+*
+ç\9e
+,
+
+740 \12
+\96em\92ts_off£t
+ = 0);
+
+746 \1e
+Com·»M
+(
+Regi¡\94
+
+obj
+, Regi¡\94
+sü©ch
+,
+HªdË
+<
+M
+>
+m
+,
+
+747
+Lab\96
+*
+\97¾y_sucûss
+);
+
+751 \1e
+Com·»M
+(
+Regi¡\94
+
+obj_m
+,
+HªdË
+<
+M
+>
+m
+,
+Lab\96
+*
+\97¾y_sucûss
+);
+
+757 \1e
+CheckM
+(
+Regi¡\94
+
+obj
+, Regi¡\94
+sü©ch
+,
+HªdË
+<
+M
+>
+m
+,
+Lab\96
+*
+ç\9e
+,
+
+758
+SmiCheckTy³
+
+smi_check_ty³
+);
+
+761 \1e
+CheckM
+(
+Regi¡\94
+
+obj
+, Regi¡\94
+sü©ch
+,
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+,
+
+762
+Lab\96
+*
+ç\9e
+,
+SmiCheckTy³
+
+smi_check_ty³
+);
+
+768 \1e
+Di¥©chM
+(
+Regi¡\94
+
+obj
+, Regi¡\94
+sü©ch
+,
+HªdË
+<
+M
+>
+m
+,
+
+769
+HªdË
+<
+Code
+>
+sucûss
+,
+SmiCheckTy³
+
+smi_check_ty³
+);
+
+774 \1e
+Com·»RoÙ
+(
+Regi¡\94
+
+obj
+,
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+);
+
+780
+CÚd\99iÚ
+
+IsObjeùS\8c\9agTy³
+(
+Regi¡\94
+
+obj
+, Regi¡\94
+ty³
+) {
+
+781
+LßdP
+(
+ty³
+,
+F\9bldMemO³¿nd
+(
+obj
+,
+H\97pObjeù
+::
+kMOff£t
+));
+
+782
+lbz
+(
+ty³
+,
+F\9bldMemO³¿nd
+Ñy³,
+M
+::
+kIn¡ªûTy³Off£t
+));
+
+783
+ªdi
+(
+r0
+,
+ty³
+,
+O³¿nd
+(
+kIsNÙS\8c\9agMask
+));
+
+784
+DCHECK_EQ
+(0,
+kS\8c\9agTag
+);
+
+785 \15
+ geq
+;
+
+793 \1e
+IndexFromHash
+(
+Regi¡\94
+
+hash
+, Regi¡\94
+\9adex
+);
+
+796 \1e
+G\91L\97¡B\99sFromSmi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, \12
+num_Ëa¡_b\99s
+);
+
+797 \1e
+G\91L\97¡B\99sFromIÁ32
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, \12
+mun_Ëa¡_b\99s
+);
+
+800 \1e
+SmiToDoubË
+(
+DoubËRegi¡\94
+
+v®ue
+,
+Regi¡\94
+
+smi
+);
+
+804 \1e
+Te¡DoubËIsIÁ32
+(
+DoubËRegi¡\94
+
+doubË_\9aput
+,
+Regi¡\94
+
+sü©ch1
+,
+
+805
+Regi¡\94
+
+sü©ch2
+,
+DoubËRegi¡\94
+
+doubË_sü©ch
+);
+
+809 \1e
+TryDoubËToIÁ32Exaù
+(
+Regi¡\94
+
+»suÉ
+,
+DoubËRegi¡\94
+
+doubË_\9aput
+,
+
+810
+Regi¡\94
+
+sü©ch
+,
+DoubËRegi¡\94
+
+doubË_sü©ch
+);
+
+816 \1e
+TryIÁ32FloÜ
+(
+Regi¡\94
+
+»suÉ
+,
+DoubËRegi¡\94
+
+doubË_\9aput
+,
+
+817
+Regi¡\94
+
+\9aput_high
+, Regi¡\94
+sü©ch
+,
+
+818
+DoubËRegi¡\94
+
+doubË_sü©ch
+,
+Lab\96
+*
+dÚe
+, Lab\96*
+exaù
+);
+
+826 \1e
+TryIÆ\9aeTrunÿ\8bDoubËToI
+(
+Regi¡\94
+
+»suÉ
+,
+DoubËRegi¡\94
+
+\9aput
+,
+
+827
+Lab\96
+*
+dÚe
+);
+
+832 \1e
+Trunÿ\8bDoubËToI
+(
+Regi¡\94
+
+»suÉ
+,
+DoubËRegi¡\94
+
+doubË_\9aput
+);
+
+837 \1e
+Trunÿ\8bH\97pNumb\94ToI
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+objeù
+);
+
+843 \1e
+Trunÿ\8bNumb\94ToI
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+»suÉ
+,
+
+844
+Regi¡\94
+
+h\97p_numb\94_m
+, Regi¡\94
+sü©ch1
+,
+
+845
+Lab\96
+*
+nÙ_\9at32
+);
+
+854 \1e
+AddAndCheckFÜOv\94æow
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+Ëá
+, Regi¡\94
+right
+,
+
+855
+Regi¡\94
+
+ov\94æow_d¡
+, Regi¡\94
+sü©ch
+ =
+r0
+);
+
+856 \1e
+AddAndCheckFÜOv\94æow
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+Ëá
+,
+\9a\8d\8c_t
+
+right
+,
+
+857
+Regi¡\94
+
+ov\94æow_d¡
+, Regi¡\94
+sü©ch
+ =
+r0
+);
+
+862 \1e
+SubAndCheckFÜOv\94æow
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+Ëá
+, Regi¡\94
+right
+,
+
+863
+Regi¡\94
+
+ov\94æow_d¡
+, Regi¡\94
+sü©ch
+ =
+r0
+);
+
+865 \1e
+B¿nchOnOv\94æow
+(
+Lab\96
+*
+Ïb\96
+è{
+bÉ
+Öab\96,
+ü0
+); }
+
+867 \1e
+B¿nchOnNoOv\94æow
+(
+Lab\96
+*
+Ïb\96
+è{
+bge
+Öab\96,
+ü0
+); }
+
+869 \1e
+R\91OnOv\94æow
+(\1e) {
+
+870
+Lab\96
+
+ gÏb\96
+;
+
+872
+bÉ
+(&
+Ïb\96
+,
+ü0
+);
+
+873
+R\91
+();
+
+874
+b\9ad
+(&
+Ïb\96
+);
+
+877 \1e
+R\91OnNoOv\94æow
+(\1e) {
+
+878
+Lab\96
+
+ gÏb\96
+;
+
+880
+bge
+(&
+Ïb\96
+,
+ü0
+);
+
+881
+R\91
+();
+
+882
+b\9ad
+(&
+Ïb\96
+);
+
+886 \1e
+SaveFPRegs
+(
+Regi¡\94
+
+loÿtiÚ
+, \12
+f\9c¡
+, \12
+couÁ
+);
+
+889 \1e
+Re¡ÜeFPRegs
+(
+Regi¡\94
+
+loÿtiÚ
+, \12
+f\9c¡
+, \12
+couÁ
+);
+
+895 \1e
+C®lStub
+(
+CodeStub
+*
+¡ub
+,
+Ty³F\93dbackId
+
+a¡_id
+ = Ty³F\93dbackId::
+NÚe
+(),
+
+896
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+899 \1e
+Ta\9eC®lStub
+(
+CodeStub
+*
+¡ub
+,
+CÚd\99iÚ
+
+cÚd
+ =
+®
+);
+
+902 \1e
+C®lRuÁime
+(cڡ
+RuÁime
+::
+FunùiÚ
+*
+f
+, \12
+num_¬gum\92ts
+,
+
+903
+SaveFPRegsMode
+
+§ve_doubËs
+ =
+kDÚtSaveFPRegs
+);
+
+904 \1e
+C®lRuÁimeSaveDoubËs
+(
+RuÁime
+::
+FunùiÚId
+
+id
+) {
+
+905 cڡ
+RuÁime
+::
+FunùiÚ
+*
+funùiÚ
+ = RuÁime::
+FunùiÚFÜId
+(
+id
+);
+
+906
+C®lRuÁime
+(
+funùiÚ
+, funùiÚ->
+Çrgs
+,
+kSaveFPRegs
+);
+
+910 \1e
+C®lRuÁime
+(
+RuÁime
+::
+FunùiÚId
+
+id
+, \12
+num_¬gum\92ts
+,
+
+911
+SaveFPRegsMode
+
+§ve_doubËs
+ =
+kDÚtSaveFPRegs
+) {
+
+912
+C®lRuÁime
+(
+RuÁime
+::
+FunùiÚFÜId
+(
+id
+),
+num_¬gum\92ts
+,
+§ve_doubËs
+);
+
+916 \1e
+C®lEx\8bº®Reã»nû
+(cڡ
+Ex\8bº®Reã»nû
+&
+ext
+, \12
+num_¬gum\92ts
+);
+
+921 \1e
+Ta\9eC®lEx\8bº®Reã»nû
+(cڡ
+Ex\8bº®Reã»nû
+&
+ext
+,
+
+922 \12
+num_¬gum\92ts
+, \12
+»suÉ_size
+);
+
+925 \1e
+Ta\9eC®lRuÁime
+(
+RuÁime
+::
+FunùiÚId
+
+fid
+, \12
+num_¬gum\92ts
+,
+
+926 \12
+»suÉ_size
+);
+
+928 \12
+C®cuÏ\8bS\8fckPas£dWÜds
+(\12
+num_»g_¬gum\92ts
+,
+
+929 \12
+num_doubË_¬gum\92ts
+);
+
+941 \1e
+P»·»C®lCFunùiÚ
+(\12
+num_»g_¬gum\92ts
+, \12
+num_doubË_»gi¡\94s
+,
+
+942
+Regi¡\94
+
+sü©ch
+);
+
+943 \1e
+P»·»C®lCFunùiÚ
+(\12
+num_»g_¬gum\92ts
+,
+Regi¡\94
+
+sü©ch
+);
+
+949 \1e
+MovToFlßtP¬am\91\94
+(
+DoubËRegi¡\94
+
+¤c
+);
+
+950 \1e
+MovToFlßtP¬am\91\94s
+(
+DoubËRegi¡\94
+
+¤c1
+, DoubËRegi¡\94
+¤c2
+);
+
+951 \1e
+MovToFlßtResuÉ
+(
+DoubËRegi¡\94
+
+¤c
+);
+
+958 \1e
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+
+funùiÚ
+, \12
+num_¬gum\92ts
+);
+
+959 \1e
+C®lCFunùiÚ
+(
+Regi¡\94
+
+funùiÚ
+, \12
+num_¬gum\92ts
+);
+
+960 \1e
+C®lCFunùiÚ
+(
+Ex\8bº®Reã»nû
+
+funùiÚ
+, \12
+num_»g_¬gum\92ts
+,
+
+961 \12
+num_doubË_¬gum\92ts
+);
+
+962 \1e
+C®lCFunùiÚ
+(
+Regi¡\94
+
+funùiÚ
+, \12
+num_»g_¬gum\92ts
+,
+
+963 \12
+num_doubË_¬gum\92ts
+);
+
+965 \1e
+MovFromFlßtP¬am\91\94
+(
+DoubËRegi¡\94
+
+d¡
+);
+
+966 \1e
+MovFromFlßtResuÉ
+(
+DoubËRegi¡\94
+
+d¡
+);
+
+972 \1e
+C®lApiFunùiÚAndR\91uº
+(
+Regi¡\94
+
+funùiÚ_add»ss
+,
+
+973
+Ex\8bº®Reã»nû
+
+thunk_»f
+, \12
+¡ack_¥aû
+,
+
+974
+MemO³¿nd
+
+»tuº_v®ue_Ý\94ªd
+,
+
+975
+MemO³¿nd
+*
+cÚ\8bxt_»¡Üe_Ý\94ªd
+);
+
+978 \1e
+JumpToEx\8bº®Reã»nû
+(cڡ
+Ex\8bº®Reã»nû
+&
+bu\9et\9a
+);
+
+982 \1e
+InvokeBu\9et\9a
+(
+Bu\9et\9as
+::
+JavaSü\9dt
+
+id
+,
+InvokeFÏg
+
+æag
+,
+
+983 cڡ
+C®lW¿µ\94
+&
+ÿÎ_w¿µ\94
+ =
+NuÎC®lW¿µ\94
+());
+
+987 \1e
+G\91Bu\9et\9aEÁry
+(
+Regi¡\94
+
+\8frg\91
+,
+Bu\9et\9as
+::
+JavaSü\9dt
+
+id
+);
+
+990 \1e
+G\91Bu\9et\9aFunùiÚ
+(
+Regi¡\94
+
+\8frg\91
+,
+Bu\9et\9as
+::
+JavaSü\9dt
+
+id
+);
+
+992
+ gHªdË
+<
+ gObjeù
+>
+CodeObjeù
+() {
+
+993
+DCHECK
+(!
+code_objeù_
+.
+is_nuÎ
+());
+
+994 \15
+ gcode_objeù_
+;
+
+1000 \1e
+Trunÿt\9agDiv
+(
+Regi¡\94
+
+»suÉ
+, Regi¡\94
+divid\92d
+,
+\9at32_t
+
+divisÜ
+);
+
+1005 \1e
+S\91CouÁ\94
+(
+S\8ftsCouÁ\94
+*
+couÁ\94
+, \12
+v®ue
+,
+Regi¡\94
+
+sü©ch1
+,
+
+1006
+Regi¡\94
+
+sü©ch2
+);
+
+1007 \1e
+Inüem\92tCouÁ\94
+(
+S\8ftsCouÁ\94
+*
+couÁ\94
+, \12
+v®ue
+,
+Regi¡\94
+
+sü©ch1
+,
+
+1008
+Regi¡\94
+
+sü©ch2
+);
+
+1009 \1e
+Deüem\92tCouÁ\94
+(
+S\8ftsCouÁ\94
+*
+couÁ\94
+, \12
+v®ue
+,
+Regi¡\94
+
+sü©ch1
+,
+
+1010
+Regi¡\94
+
+sü©ch2
+);
+
+1018 \1e
+As£¹
+(
+CÚd\99iÚ
+
+cÚd
+,
+Ba\9eoutR\97sÚ
+
+»asÚ
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+1019 \1e
+As£¹Fa¡EËm\92ts
+(
+Regi¡\94
+
+\96em\92ts
+);
+
+1022 \1e
+Check
+(
+CÚd\99iÚ
+
+cÚd
+,
+Ba\9eoutR\97sÚ
+
+»asÚ
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+1025 \1e
+AbÜt
+(
+Ba\9eoutR\97sÚ
+
+»asÚ
+);
+
+1028 \1e
+£t_g\92\94©\9ag_¡ub
+(
+boÞ
+
+v®ue
+è{
+ gg\92\94©\9ag_¡ub_
+ = value; }
+
+1029
+boÞ
+
+g\92\94©\9ag_¡ub
+(è{ \15
+ gg\92\94©\9ag_¡ub_
+; }
+
+1030 \1e
+£t_has_äame
+(
+boÞ
+
+v®ue
+è{
+ ghas_äame_
+ = value; }
+
+1031
+boÞ
+
+has_äame
+(è{ \15
+ ghas_äame_
+; }
+
+1032
+\9al\9ae
+
+boÞ
+
+AÎowThisStubC®l
+(
+CodeStub
+*
+¡ub
+);
+
+1041 \1e
+JumpIfNÙPow\94OfTwoOrZ\94o
+(
+Regi¡\94
+
+»g
+, Regi¡\94
+sü©ch
+,
+
+1042
+Lab\96
+*
+nÙ_pow\94_of_two_Ü_z\94o
+);
+
+1049 \1e
+JumpIfNÙPow\94OfTwoOrZ\94oAndNeg
+(
+Regi¡\94
+
+»g
+, Regi¡\94
+sü©ch
+,
+
+1050
+Lab\96
+*
+z\94o_ªd_Ãg
+,
+
+1051
+Lab\96
+*
+nÙ_pow\94_of_two
+);
+
+1061
+\9al\9ae
+ \1e
+Ex\8caùB\99Rªge
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, \12
+¿ngeS\8f¹
+,
+
+1062 \12
+¿ngeEnd
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+) {
+
+1063
+DCHECK
+(
+¿ngeS\8f¹
+ >ð
+¿ngeEnd
+ &&\84ªgeS\8f¹ <
+kB\99sP\94Po\9a\8br
+);
+
+1064 \12
+ gr٩e
+ = (
+¿ngeEnd
+ =ð0è? 0 :
+kB\99sP\94Po\9a\8br
+ -\84angeEnd;
+
+1065 \12
+ gwidth
+ =
+¿ngeS\8f¹
+ -
+¿ngeEnd
+ + 1;
+
+1066 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1067
+¾diþ
+(
+d¡
+,
+¤c
+,
+r٩e
+,
+kB\99sP\94Po\9a\8br
+ -
+width
+,
+rc
+);
+
+1069
+¾w\9am
+(
+d¡
+,
+¤c
+,
+r٩e
+,
+kB\99sP\94Po\9a\8br
+ -
+width
+, kB\99sP\94Po\9a\8b¸- 1,
+rc
+);
+
+1073
+\9al\9ae
+ \1e
+Ex\8caùB\99
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+u\9at32_t
+
+b\99Numb\94
+,
+
+1074
+RCB\99
+
+rc
+ =
+L\97veRC
+) {
+
+1075
+Ex\8caùB\99Rªge
+(
+d¡
+,
+¤c
+,
+b\99Numb\94
+, b\99Numb\94,
+rc
+);
+
+1080
+\9al\9ae
+ \1e
+Ex\8caùB\99Mask
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+u\9a\8d\8c_t
+
+mask
+,
+
+1081
+RCB\99
+
+rc
+ =
+L\97veRC
+) {
+
+1082 \12
+¡¬t
+ =
+kB\99sP\94Po\9a\8br
+ - 1;
+
+1083 \12
+ g\92d
+;
+
+1084
+u\9a\8d\8c_t
+
+ gb\99
+ = (1L <<
+¡¬t
+);
+
+1086 \1f
+ gb\99
+ && (
+ gmask
+ & bit) == 0) {
+
+1087
+¡¬t
+--;
+
+1088
+ gb\99
+ >>= 1;
+
+1090
+ g\92d
+ =
+¡¬t
+;
+
+1091
+ gb\99
+ >>= 1;
+
+1093 \1f
+ gb\99
+ && (
+ gmask
+ & bit)) {
+
+1094
+ g\92d
+--;
+
+1095
+ gb\99
+ >>= 1;
+
+1099
+DCHECK
+(
+b\99
+ =ð0 || (
+mask
+ & ((bit << 1) - 1)) == 0);
+
+1101
+Ex\8caùB\99Rªge
+(
+d¡
+,
+¤c
+,
+¡¬t
+,
+\92d
+,
+rc
+);
+
+1105
+\9al\9ae
+ \1e
+Te¡B\99
+(
+Regi¡\94
+
+v®ue
+, \12
+b\99Numb\94
+, Regi¡\94
+sü©ch
+ =
+r0
+) {
+
+1106
+Ex\8caùB\99Rªge
+(
+sü©ch
+,
+v®ue
+,
+b\99Numb\94
+, b\99Numb\94,
+S\91RC
+);
+
+1111
+\9al\9ae
+ \1e
+Te¡B\99Rªge
+(
+Regi¡\94
+
+v®ue
+, \12
+¿ngeS\8f¹
+, \12
+¿ngeEnd
+,
+
+1112
+Regi¡\94
+
+sü©ch
+ =
+r0
+) {
+
+1113
+Ex\8caùB\99Rªge
+(
+sü©ch
+,
+v®ue
+,
+¿ngeS\8f¹
+,
+¿ngeEnd
+,
+S\91RC
+);
+
+1117
+\9al\9ae
+ \1e
+Te¡B\99Mask
+(
+Regi¡\94
+
+v®ue
+,
+u\9a\8d\8c_t
+
+mask
+,
+
+1118
+Regi¡\94
+
+sü©ch
+ =
+r0
+) {
+
+1119
+Ex\8caùB\99Mask
+(
+sü©ch
+,
+v®ue
+,
+mask
+,
+S\91RC
+);
+
+1127 \1e
+SmiTag
+(
+Regi¡\94
+
+»g
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+) { SmiTag(reg,\84eg,\84c); }
+
+1128 \1e
+SmiTag
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+) {
+
+1129
+ShiáLeáImm
+(
+d¡
+,
+¤c
+,
+O³¿nd
+(
+kSmiShiá
+),
+rc
+);
+
+1132 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+1134 \1e
+SmiTagCheckOv\94æow
+(
+Regi¡\94
+
+»g
+, Regi¡\94
+ov\94æow
+);
+
+1135 \1e
+SmiTagCheckOv\94æow
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, Regi¡\94
+ov\94æow
+);
+
+1137
+\9al\9ae
+ \1e
+JumpIfNÙSmiCªdid©e
+(
+Regi¡\94
+
+v®ue
+, Regi¡\94
+sü©ch
+,
+
+1138
+Lab\96
+*
+nÙ_smi_Ïb\96
+) {
+
+1140
+addis
+(
+sü©ch
+,
+v®ue
+,
+O³¿nd
+(0x40000000u >> 16));
+
+1141
+cmpi
+(
+sü©ch
+,
+O³¿nd
+::
+Z\94o
+());
+
+1142
+bÉ
+(
+nÙ_smi_Ïb\96
+);
+
+1145
+\9al\9ae
+ \1e
+Te¡UnsigÃdSmiCªdid©e
+(
+Regi¡\94
+
+v®ue
+, Regi¡\94
+sü©ch
+) {
+
+1149
+Te¡B\99Rªge
+(
+v®ue
+,
+kB\99sP\94Po\9a\8br
+ - 1, kB\99sP\94Po\9a\8b¸- 1 -
+kSmiShiá
+,
+
+1150
+sü©ch
+);
+
+1152
+\9al\9ae
+ \1e
+JumpIfNÙUnsigÃdSmiCªdid©e
+(
+Regi¡\94
+
+v®ue
+, Regi¡\94
+sü©ch
+,
+
+1153
+Lab\96
+*
+nÙ_smi_Ïb\96
+) {
+
+1154
+Te¡UnsigÃdSmiCªdid©e
+(
+v®ue
+,
+sü©ch
+);
+
+1155
+bÃ
+(
+nÙ_smi_Ïb\96
+,
+ü0
+);
+
+1158 \1e
+SmiUÁag
+(
+Regi¡\94
+
+»g
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+) { SmiUntag(reg,\84eg,\84c); }
+
+1160 \1e
+SmiUÁag
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+RCB\99
+
+rc
+ =
+L\97veRC
+) {
+
+1161
+ShiáRightAr\99hImm
+(
+d¡
+,
+¤c
+,
+kSmiShiá
+,
+rc
+);
+
+1164 \1e
+SmiToP\8cA¼ayOff£t
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+) {
+
+1165 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1166
+STATIC_ASSERT
+(
+kSmiTag
+ =ð0 &&
+kSmiShiá
+ >
+kPo\9a\8brSizeLog2
+);
+
+1167
+ShiáRightAr\99hImm
+(
+d¡
+,
+¤c
+,
+kSmiShiá
+ -
+kPo\9a\8brSizeLog2
+);
+
+1169
+STATIC_ASSERT
+(
+kSmiTag
+ =ð0 &&
+kSmiShiá
+ <
+kPo\9a\8brSizeLog2
+);
+
+1170
+ShiáLeáImm
+(
+d¡
+,
+¤c
+,
+O³¿nd
+(
+kPo\9a\8brSizeLog2
+ -
+kSmiShiá
+));
+
+1174 \1e
+SmiToBy\8bA¼ayOff£t
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+è{
+SmiUÁag
+(dst, src); }
+
+1176 \1e
+SmiToShÜtA¼ayOff£t
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+) {
+
+1177 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1178
+STATIC_ASSERT
+(
+kSmiTag
+ =ð0 &&
+kSmiShiá
+ > 1);
+
+1179
+ShiáRightAr\99hImm
+(
+d¡
+,
+¤c
+,
+kSmiShiá
+ - 1);
+
+1181
+STATIC_ASSERT
+(
+kSmiTag
+ =ð0 &&
+kSmiShiá
+ == 1);
+
+1182 ià(!
+ gd¡
+.
+is
+(
+¤c
+)) {
+
+1183
+mr
+(
+d¡
+,
+¤c
+);
+
+1188 \1e
+SmiToIÁA¼ayOff£t
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+) {
+
+1189 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1190
+STATIC_ASSERT
+(
+kSmiTag
+ =ð0 &&
+kSmiShiá
+ > 2);
+
+1191
+ShiáRightAr\99hImm
+(
+d¡
+,
+¤c
+,
+kSmiShiá
+ - 2);
+
+1193
+STATIC_ASSERT
+(
+kSmiTag
+ =ð0 &&
+kSmiShiá
+ < 2);
+
+1194
+ShiáLeáImm
+(
+d¡
+,
+¤c
+,
+O³¿nd
+(2 -
+kSmiShiá
+));
+
+1198 \ 1
+ #SmiToFlßtA¼ayOff£t
+
+SmiToIÁA¼ayOff£t
+
+
+ )
+
+1200 \1e
+SmiToDoubËA¼ayOff£t
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+) {
+
+1201 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1202
+STATIC_ASSERT
+(
+kSmiTag
+ =ð0 &&
+kSmiShiá
+ >
+kDoubËSizeLog2
+);
+
+1203
+ShiáRightAr\99hImm
+(
+d¡
+,
+¤c
+,
+kSmiShiá
+ -
+kDoubËSizeLog2
+);
+
+1205
+STATIC_ASSERT
+(
+kSmiTag
+ =ð0 &&
+kSmiShiá
+ <
+kDoubËSizeLog2
+);
+
+1206
+ShiáLeáImm
+(
+d¡
+,
+¤c
+,
+O³¿nd
+(
+kDoubËSizeLog2
+ -
+kSmiShiá
+));
+
+1210 \1e
+SmiToA¼ayOff£t
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, \12
+\96em\92tSizeLog2
+) {
+
+1211 ià(
+ gkSmiShiá
+ <
+ g\96em\92tSizeLog2
+) {
+
+1212
+ShiáLeáImm
+(
+d¡
+,
+¤c
+,
+O³¿nd
+(
+\96em\92tSizeLog2
+ -
+kSmiShiá
+));
+
+1213 } \vià(
+ gkSmiShiá
+ >
+ g\96em\92tSizeLog2
+) {
+
+1214
+ShiáRightAr\99hImm
+(
+d¡
+,
+¤c
+,
+kSmiShiá
+ -
+\96em\92tSizeLog2
+);
+
+1215 } \vià(!
+ gd¡
+.
+is
+(
+¤c
+)) {
+
+1216
+mr
+(
+d¡
+,
+¤c
+);
+
+1220 \1e
+IndexToA¼ayOff£t
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+, \12
+\96em\92tSizeLog2
+,
+
+1221
+boÞ
+
+isSmi
+) {
+
+1222 ià(
+ gisSmi
+) {
+
+1223
+SmiToA¼ayOff£t
+(
+d¡
+,
+¤c
+,
+\96em\92tSizeLog2
+);
+
+1225
+ShiáLeáImm
+(
+d¡
+,
+¤c
+,
+O³¿nd
+(
+\96em\92tSizeLog2
+));
+
+1231 \1e
+UÁagAndJumpIfSmi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+Lab\96
+*
+smi_ÿ£
+);
+
+1235 \1e
+UÁagAndJumpIfNÙSmi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+,
+Lab\96
+*
+nÚ_smi_ÿ£
+);
+
+1237
+\9al\9ae
+ \1e
+Te¡IfSmi
+(
+Regi¡\94
+
+v®ue
+, Regi¡\94
+sü©ch
+) {
+
+1238
+Te¡B\99
+(
+v®ue
+, 0,
+sü©ch
+);
+
+1241
+\9al\9ae
+ \1e
+Te¡IfPos\99iveSmi
+(
+Regi¡\94
+
+v®ue
+, Regi¡\94
+sü©ch
+) {
+
+1242
+STATIC_ASSERT
+((
+kSmiTagMask
+ |
+kSmiSignMask
+) ==
+
+1243 (
+\9a\8d\8c_t
+)(1UL << (
+kB\99sP\94Po\9a\8br
+ - 1) | 1));
+
+1244 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1245
+¾diþ
+(
+sü©ch
+,
+v®ue
+, 1,
+kB\99sP\94Po\9a\8br
+ - 2,
+S\91RC
+);
+
+1247
+¾w\9am
+(
+sü©ch
+,
+v®ue
+, 1,
+kB\99sP\94Po\9a\8br
+ - 2, kB\99sP\94Po\9a\8b¸- 1,
+S\91RC
+);
+
+1252
+\9al\9ae
+ \1e
+JumpIfSmi
+(
+Regi¡\94
+
+v®ue
+,
+Lab\96
+*
+smi_Ïb\96
+) {
+
+1253
+Te¡IfSmi
+(
+v®ue
+,
+r0
+);
+
+1254
+beq
+(
+smi_Ïb\96
+,
+ü0
+);
+
+1257
+\9al\9ae
+ \1e
+JumpIfNÙSmi
+(
+Regi¡\94
+
+v®ue
+,
+Lab\96
+*
+nÙ_smi_Ïb\96
+) {
+
+1258
+Te¡IfSmi
+(
+v®ue
+,
+r0
+);
+
+1259
+bÃ
+(
+nÙ_smi_Ïb\96
+,
+ü0
+);
+
+1262 \1e
+JumpIfNÙBÙhSmi
+(
+Regi¡\94
+
+»g1
+, Regi¡\94
+»g2
+,
+Lab\96
+*
+Ú_nÙ_bÙh_smi
+);
+
+1264 \1e
+JumpIfE\99h\94Smi
+(
+Regi¡\94
+
+»g1
+, Regi¡\94
+»g2
+,
+Lab\96
+*
+Ú_e\99h\94_smi
+);
+
+1267 \1e
+As£¹NÙSmi
+(
+Regi¡\94
+
+objeù
+);
+
+1268 \1e
+As£¹Smi
+(
+Regi¡\94
+
+objeù
+);
+
+1271 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1272
+\9al\9ae
+ \1e
+Te¡IfIÁ32
+(
+Regi¡\94
+
+v®ue
+, Regi¡\94
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+1273
+CRegi¡\94
+
+ü
+ =
+ü7
+) {
+
+1275
+¤awi
+(
+sü©ch1
+,
+v®ue
+, 31);
+
+1276
+¤adi
+(
+sü©ch2
+,
+v®ue
+, 32);
+
+1277
+cmp
+(
+sü©ch1
+,
+sü©ch2
+,
+ü
+);
+
+1280
+\9al\9ae
+ \1e
+Te¡IfIÁ32
+(
+Regi¡\94
+
+hi_wÜd
+, Regi¡\94
+lo_wÜd
+, Regi¡\94
+sü©ch
+,
+
+1281
+CRegi¡\94
+
+ü
+ =
+ü7
+) {
+
+1283
+¤awi
+(
+sü©ch
+,
+lo_wÜd
+, 31);
+
+1284
+cmp
+(
+sü©ch
+,
+hi_wÜd
+,
+ü
+);
+
+1289 \1e
+As£¹S\8c\9ag
+(
+Regi¡\94
+
+objeù
+);
+
+1292 \1e
+As£¹Name
+(
+Regi¡\94
+
+objeù
+);
+
+1296 \1e
+As£¹Undef\9aedOrAÎoÿtiÚS\99e
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch
+);
+
+1300 \1e
+As£¹IsRoÙ
+(
+Regi¡\94
+
+»g
+,
+H\97p
+::
+RoÙLi¡Index
+
+\9adex
+);
+
+1305 \1e
+JumpIfNÙH\97pNumb\94
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+h\97p_numb\94_m
+,
+
+1306
+Regi¡\94
+
+sü©ch
+,
+Lab\96
+*
+Ú_nÙ_h\97p_numb\94
+);
+
+1316 \1e
+LookupNumb\94S\8c\9agCache
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+»suÉ
+,
+
+1317
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+
+1318
+Regi¡\94
+
+sü©ch3
+,
+Lab\96
+*
+nÙ_found
+);
+
+1322 \1e
+JumpIfNÚSmisNÙBÙhSequ\92t\9flOÃBy\8bS\8c\9ags
+(
+Regi¡\94
+
+objeù1
+,
+
+1323
+Regi¡\94
+
+objeù2
+,
+
+1324
+Regi¡\94
+
+sü©ch1
+,
+
+1325
+Regi¡\94
+
+sü©ch2
+,
+
+1326
+Lab\96
+*
+ç\9eu»
+);
+
+1330 \1e
+JumpIfNÙBÙhSequ\92t\9flOÃBy\8bS\8c\9ags
+(
+Regi¡\94
+
+f\9c¡
+, Regi¡\94
+£cÚd
+,
+
+1331
+Regi¡\94
+
+sü©ch1
+,
+
+1332
+Regi¡\94
+
+sü©ch2
+,
+
+1333
+Lab\96
+*
+nÙ_æ©_Úe_by\8b_¡r\9ags
+);
+
+1337 \1e
+JumpIfBÙhIn¡ªûTy³sA»NÙSequ\92t\9flOÃBy\8b
+(
+
+1338
+Regi¡\94
+
+f\9c¡_objeù_\9a¡ªû_ty³
+, Regi¡\94
+£cÚd_objeù_\9a¡ªû_ty³
+,
+
+1339
+Regi¡\94
+
+sü©ch1
+, Regi¡\94
+sü©ch2
+,
+Lab\96
+*
+ç\9eu»
+);
+
+1343 \1e
+JumpIfIn¡ªûTy³IsNÙSequ\92t\9flOÃBy\8b
+(
+Regi¡\94
+
+ty³
+, Regi¡\94
+sü©ch
+,
+
+1344
+Lab\96
+*
+ç\9eu»
+);
+
+1346 \1e
+JumpIfNÙUniqueNameIn¡ªûTy³
+(
+Regi¡\94
+
+»g
+,
+Lab\96
+*
+nÙ_unique_Çme
+);
+
+1348 \1e
+Em\99SeqS\8c\9agS\91Ch¬Check
+(
+Regi¡\94
+
+¡r\9ag
+, Regi¡\94
+\9adex
+,
+
+1349
+Regi¡\94
+
+v®ue
+,
+u\9at32_t
+
+\92cod\9ag_mask
+);
+
+1355 \1e
+G\91R\96oÿ\8bdV®ue
+(
+Regi¡\94
+
+loÿtiÚ
+, Regi¡\94
+»suÉ
+, Regi¡\94
+sü©ch
+);
+
+1356 \1e
+S\91R\96oÿ\8bdV®ue
+(
+Regi¡\94
+
+loÿtiÚ
+, Regi¡\94
+sü©ch
+,
+
+1357
+Regi¡\94
+
+Ãw_v®ue
+);
+
+1359 \1e
+CÏmpU\9at8
+(
+Regi¡\94
+
+ou\8dut_»g
+, Regi¡\94
+\9aput_»g
+);
+
+1365 \1e
+CÏmpDoubËToU\9at8
+(
+Regi¡\94
+
+»suÉ_»g
+,
+DoubËRegi¡\94
+
+\9aput_»g
+,
+
+1366
+DoubËRegi¡\94
+
+\8bmp_doubË_»g
+);
+
+1369 \1e
+LßdIn¡ªûDesü\9dtÜs
+(
+Regi¡\94
+
+m
+, Regi¡\94
+desü\9dtÜs
+);
+
+1370 \1e
+EnumL\92gth
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+m
+);
+
+1371 \1e
+Numb\94OfOwnDesü\9dtÜs
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+m
+);
+
+1373
+ g\8bm¶©e
+ <
+ty³Çme
+
+ gF\9bld
+>
+
+1374 \1e
+DecodeF\9bld
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+) {
+
+1375
+Ex\8caùB\99Rªge
+(
+d¡
+,
+¤c
+,
+F\9bld
+::
+kShiá
+ + F\9bld::
+kSize
+ - 1, Field::kShift);
+
+1378
+ g\8bm¶©e
+ <
+ty³Çme
+
+ gF\9bld
+>
+
+1379 \1e
+DecodeF\9bld
+(
+Regi¡\94
+
+»g
+) {
+
+1380
+ gDecodeF\9bld
+<
+ gF\9bld
+>(
+ g»g
+,\84eg);
+
+1383
+ g\8bm¶©e
+ <
+ty³Çme
+
+ gF\9bld
+>
+
+1384 \1e
+DecodeF\9bldToSmi
+(
+Regi¡\94
+
+d¡
+, Regi¡\94
+¤c
+) {
+
+1385 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1386
+ gDecodeF\9bld
+<
+ gF\9bld
+>(
+ gd¡
+,
+ g¤c
+);
+
+1387
+SmiTag
+(
+d¡
+);
+
+1390 \12
+ g¡¬t
+ =
+F\9bld
+::
+kSize
+ +
+kSmiShiá
+ - 1;
+
+1391 \12
+ g\92d
+ =
+kSmiShiá
+;
+
+1392 \12
+ gr٩e
+ =
+kSmiShiá
+ -
+F\9bld
+::
+kShiá
+;
+
+1393 ià(
+ gr٩e
+ < 0) {
+
+1394
+ gr٩e
+ +ð
+kB\99sP\94Po\9a\8br
+;
+
+1396
+¾w\9am
+(
+d¡
+,
+¤c
+,
+r٩e
+,
+kB\99sP\94Po\9a\8br
+ -
+¡¬t
+ - 1,
+
+1397
+kB\99sP\94Po\9a\8br
+ -
+\92d
+ - 1);
+
+1401
+ g\8bm¶©e
+ <
+ty³Çme
+
+ gF\9bld
+>
+
+1402 \1e
+DecodeF\9bldToSmi
+(
+Regi¡\94
+
+»g
+) {
+
+1403
+ gDecodeF\9bldToSmi
+<
+ gF\9bld
+>(
+ g»g
+,\84eg);
+
+1407 \1e
+EÁ\94F¿me
+(
+S\8fckF¿me
+::
+Ty³
+
+ty³
+,
+
+1408
+boÞ
+
+lßd_cÚ¡ªt_poÞ_po\9a\8br_»g
+ =
+çl£
+);
+
+1410 \12
+L\97veF¿me
+(
+S\8fckF¿me
+::
+Ty³
+
+ty³
+, \12
+¡ack_adju¡m\92t
+ = 0);
+
+1414 \1e
+CheckEnumCache
+(
+Regi¡\94
+
+nuÎ_v®ue
+,
+Lab\96
+*
+ÿÎ_ruÁime
+);
+
+1422 \1e
+Te¡JSA¼ayFÜAÎoÿtiÚMem\92to
+(
+Regi¡\94
+
+»ûiv\94_»g
+,
+
+1423
+Regi¡\94
+
+sü©ch_»g
+,
+
+1424
+Lab\96
+*
+no_mem\92to_found
+);
+
+1426 \1e
+JumpIfJSA¼ayHasAÎoÿtiÚMem\92to
+(
+Regi¡\94
+
+»ûiv\94_»g
+,
+
+1427
+Regi¡\94
+
+sü©ch_»g
+,
+
+1428
+Lab\96
+*
+mem\92to_found
+) {
+
+1429
+Lab\96
+
+ gno_mem\92to_found
+;
+
+1430
+Te¡JSA¼ayFÜAÎoÿtiÚMem\92to
+(
+»ûiv\94_»g
+,
+sü©ch_»g
+,
+
+1431 &
+no_mem\92to_found
+);
+
+1432
+beq
+(
+mem\92to_found
+);
+
+1433
+b\9ad
+(&
+no_mem\92to_found
+);
+
+1437 \1e
+JumpIfDiùiÚ¬yInPrÙÙy³Cha\9a
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch0
+,
+
+1438
+Regi¡\94
+
+sü©ch1
+,
+Lab\96
+*
+found
+);
+
+1440
+ g´iv©e
+:
+
+1441 \18cڡ \12
+kSmiShiá
+ =
+kSmiTagSize
+ +
+kSmiShiáSize
+;
+
+1443 \1e
+C®lCFunùiÚH\96³r
+(
+Regi¡\94
+
+funùiÚ
+, \12
+num_»g_¬gum\92ts
+,
+
+1444 \12
+num_doubË_¬gum\92ts
+);
+
+1446 \1e
+Jump
+(
+\9a\8d\8c_t
+
+\8frg\91
+,
+R\96ocInfo
+::
+Mode
+
+rmode
+,
+CÚd\99iÚ
+
+cÚd
+ =
+®
+,
+
+1447
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+1450 \1e
+InvokePrÞogue
+(cڡ
+P¬am\91\94CouÁ
+&
+ex³ùed
+,
+
+1451 cڡ
+P¬am\91\94CouÁ
+&
+aùu®
+,
+HªdË
+<
+Code
+>
+code_cÚ¡ªt
+,
+
+1452
+Regi¡\94
+
+code_»g
+,
+Lab\96
+*
+dÚe
+,
+
+1453
+boÞ
+*
+def\9a\99\96y_mism©ches
+,
+InvokeFÏg
+
+æag
+,
+
+1454 cڡ
+C®lW¿µ\94
+&
+ÿÎ_w¿µ\94
+);
+
+1456 \1e
+In\99\9flizeNewS\8c\9ag
+(
+Regi¡\94
+
+¡r\9ag
+, Regi¡\94
+Ëngth
+,
+
+1457
+H\97p
+::
+RoÙLi¡Index
+
+m_\9adex
+,
+Regi¡\94
+
+sü©ch1
+,
+
+1458
+Regi¡\94
+
+sü©ch2
+);
+
+1461 \1e
+InNewS·û
+(
+Regi¡\94
+
+objeù
+, Regi¡\94
+sü©ch
+,
+
+1462
+CÚd\99iÚ
+
+cÚd
+,
+
+1463
+Lab\96
+*
+b¿nch
+);
+
+1468
+\9al\9ae
+ \1e
+G\91M¬kB\99s
+(
+Regi¡\94
+
+addr_»g
+, Regi¡\94
+b\99m_»g
+,
+
+1469
+Regi¡\94
+
+mask_»g
+);
+
+1473 \1e
+JumpToHªdËrEÁry
+();
+
+1476 \18\12
+Saãpo\9atRegi¡\94S\8fckIndex
+(\12
+»g_code
+);
+
+1477
+MemO³¿nd
+
+Saãpo\9atRegi¡\94SlÙ
+(
+Regi¡\94
+
+»g
+);
+
+1478
+MemO³¿nd
+
+Saãpo\9atRegi¡\94sAndDoubËsSlÙ
+(
+Regi¡\94
+
+»g
+);
+
+1480 #ià
+V8_OOL_CONSTANT_POOL
+
+
+1482 \f
+ eCodeObjeùAcûssM\91hod
+ {
+ gCAN_USE_IP
+,
+ gCONSTRUCT_INTERNAL_REFERENCE
+ };
+
+1483 \1e
+LßdCÚ¡ªtPoÞPo\9a\8brRegi¡\94
+(
+CodeObjeùAcûssM\91hod
+
+acûss_m\91hod
+,
+
+1484 \12
+\9d_code_\92\8cy_d\96\8f
+ = 0);
+
+1487
+boÞ
+
+ gg\92\94©\9ag_¡ub_
+;
+
+1488
+boÞ
+
+ ghas_äame_
+;
+
+1490
+ gHªdË
+<
+ gObjeù
+>
+ gcode_objeù_
+;
+
+1494
+ä\9bnd
+
+þass
+
+ gS\8fnd¬dF¿me
+;
+
+1503 þas
+ cCodeP©ch\94
+ {
+
+1504
+ gpublic
+:
+
+1505 \f
+ eFlushICache
+ {
+FLUSH
+,
+ gDONT_FLUSH
+ };
+
+1507
+CodeP©ch\94
+(
+by\8b
+*
+add»ss
+, \12
+\9a¡ruùiÚs
+,
+FlushICache
+
+æush_ÿche
+ =
+FLUSH
+);
+
+1508
+ gv\9ctu®
+ ~
+CodeP©ch\94
+();
+
+1511
+MaüoAs£mbËr
+*
+masm
+(è{ \15 &
+ gmasm_
+; }
+
+1514 \1e
+Em\99
+(
+In¡r
+
+\9a¡r
+);
+
+1518 \1e
+Em\99CÚd\99iÚ
+(
+CÚd\99iÚ
+
+cÚd
+);
+
+1520
+ g´iv©e
+:
+
+1521
+by\8b
+*
+add»ss_
+;
+
+1522 \12
+ gsize_
+;
+
+1523
+MaüoAs£mbËr
+
+ gmasm_
+;
+
+1524
+FlushICache
+
+ gæush_ÿche_
+;
+
+1531
+\9al\9ae
+
+MemO³¿nd
+
+CÚ\8bxtO³¿nd
+(
+Regi¡\94
+
+cڋxt
+, \12
+\9adex
+) {
+
+1532 \15
+MemO³¿nd
+(
+cڋxt
+,
+Cڋxt
+::
+SlÙOff£t
+(
+\9adex
+));
+
+1536
+\9al\9ae
+
+MemO³¿nd
+
+Glob®ObjeùO³¿nd
+() {
+
+1537 \15
+CÚ\8bxtO³¿nd
+(
+ý
+,
+Cڋxt
+::
+GLOBAL_OBJECT_INDEX
+);
+
+1541 #ifdeà
+GENERATED_CODE_COVERAGE
+
+
+1542 \ 1
+ #CODE_COVERAGE_STRINGIFY
+(
+x
+è#x
+
+ )
+
+1543 \ 1
+ #CODE_COVERAGE_TOSTRING
+(
+x
+è
+ `CODE_COVERAGE_STRINGIFY
+(x)
+
+ )
+
+1544 \ 1
+ #__FILE_LINE__
+
+__FILE__
+ ":"
+ `CODE_COVERAGE_TOSTRING
+(
+__LINE__
+)
+
+ )
+
+1545 \ 1
+ #ACCESS_MASM
+(
+masm
+) \
+
+1546
+masm
+->
+ `¡Ý
+(
+__FILE_LINE__
+); \
+
+1547
+masm
+->
+
+ )
+
+1549 \ 1
+ #ACCESS_MASM
+(
+masm
+èmasm->
+
+ )
+
+ @regexp-macro-assembler-ppc.cc
+
+5 \ 2
+ ~"¤c/v8.h
+"
+
+7 #ià
+V8_TARGET_ARCH_PPC
+
+
+9 \ 2
+ ~"¤c/ba£/b\99s.h
+"
+
+10 \ 2
+ ~"¤c/code-¡ubs.h
+"
+
+11 \ 2
+ ~"¤c/ýu-´of\9e\94.h
+"
+
+12 \ 2
+ ~"¤c/log.h
+"
+
+13 \ 2
+ ~"¤c/maüo-as£mbËr.h
+"
+
+14 \ 2
+ ~"¤c/»gexp-maüo-as£mbËr.h
+"
+
+15 \ 2
+ ~"¤c/»gexp-¡ack.h
+"
+
+16 \ 2
+ ~"¤c/unicode.h
+"
+
+18 \ 2
+ ~"¤c/µc/»gexp-maüo-as£mbËr-µc.h
+"
+
+20
+Çme¥aû
+
+ gv8
+ {
+
+21
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+23 #iâdeà
+V8_INTERPRETED_REGEXP
+
+
+99 \ 1
+ #__
+
+ `ACCESS_MASM
+(
+masm_
+)
+
+ )
+
+101
+ gRegExpMaüoAs£mbËrPPC
+::
+RegExpMaüoAs£mbËrPPC
+(
+Mode
+
+mode
+,
+
+102 \12
+»gi¡\94s_to_§ve
+,
+
+103
+ZÚe
+*
+zÚe
+)
+
+104 :
+N©iveRegExpMaüoAs£mbËr
+(
+zÚe
+),
+
+105
+masm_
+(
+Ãw
+
+MaüoAs£mbËr
+(
+zÚe
+->
+isީe
+(),
+NULL
+,
+kRegExpCodeSize
+)),
+
+106
+mode_
+(
+mode
+),
+
+107
+num_»gi¡\94s_
+(
+»gi¡\94s_to_§ve
+),
+
+108
+num_§ved_»gi¡\94s_
+(
+»gi¡\94s_to_§ve
+),
+
+109
+\92\8cy_Ïb\96_
+(),
+
+110
+¡¬t_Ïb\96_
+(),
+
+111
+sucûss_Ïb\96_
+(),
+
+112
+back\8cack_Ïb\96_
+(),
+
+113
+ex\99_Ïb\96_
+(),
+
+114
+\9a\8bº®_ç\9eu»_Ïb\96_
+() {
+
+115
+DCHECK_EQ
+(0,
+»gi¡\94s_to_§ve
+ % 2);
+
+118 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+
+
+119
+__
+
+funùiÚ_desü\9dtÜ
+();
+
+122
+__
+
+b
+(&
+\92\8cy_Ïb\96_
+);
+
+125
+__
+
+b\9ad
+(&
+\9a\8bº®_ç\9eu»_Ïb\96_
+);
+
+126
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+FAILURE
+));
+
+127
+__
+
+R\91
+();
+
+128
+__
+
+b\9ad
+(&
+¡¬t_Ïb\96_
+);
+
+132
+ gRegExpMaüoAs£mbËrPPC
+::~
+RegExpMaüoAs£mbËrPPC
+() {
+
+133
+d\96\91e
+
+masm_
+;
+
+135
+ g\92\8cy_Ïb\96_
+.
+Unu£
+();
+
+136
+ g¡¬t_Ïb\96_
+.
+Unu£
+();
+
+137
+ gsucûss_Ïb\96_
+.
+Unu£
+();
+
+138
+ gback\8cack_Ïb\96_
+.
+Unu£
+();
+
+139
+ gex\99_Ïb\96_
+.
+Unu£
+();
+
+140
+ gcheck_´\93m±_Ïb\96_
+.
+Unu£
+();
+
+141
+ g¡ack_ov\94æow_Ïb\96_
+.
+Unu£
+();
+
+142
+ g\9a\8bº®_ç\9eu»_Ïb\96_
+.
+Unu£
+();
+
+146 \12
+ gRegExpMaüoAs£mbËrPPC
+::
+¡ack_lim\99_¦ack
+() {
+
+147 \15
+RegExpS\8fck
+::
+kS\8fckLim\99SÏck
+;
+
+151 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+AdvªûCu¼\92tPos\99iÚ
+(\12
+by
+) {
+
+152 ià(
+by
+ != 0) {
+
+153
+__
+
+addi
+(
+cu¼\92t_\9aput_off£t
+(), current_input_offset(),
+
+154
+O³¿nd
+(
+by
+ *
+ch¬_size
+()));
+
+159 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+AdvªûRegi¡\94
+(\12
+»g
+, \12
+by
+) {
+
+160
+DCHECK
+(
+»g
+ >= 0);
+
+161
+DCHECK
+(
+»g
+ <
+num_»gi¡\94s_
+);
+
+162 ià(
+ gby
+ != 0) {
+
+163
+__
+
+LßdP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+»g
+),
+r0
+);
+
+164
+__
+
+mov
+(
+r0
+,
+O³¿nd
+(
+by
+));
+
+165
+__
+
+add
+(
+r3
+,\843,
+r0
+);
+
+166
+__
+
+StÜeP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+»g
+),
+r0
+);
+
+171 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+Back\8cack
+() {
+
+172
+CheckP»em±iÚ
+();
+
+174
+PÝ
+(
+r3
+);
+
+175
+__
+
+add
+(
+r3
+,\843,
+code_po\9a\8br
+());
+
+176
+__
+
+mtùr
+(
+r3
+);
+
+177
+__
+
+bùr
+();
+
+181 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+B\9ad
+(
+Lab\96
+*
+Ïb\96
+è{
+__
+
+b\9ad
+(label); }
+
+184 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckCh¬aù\94
+(
+u\9at32_t
+
+c
+,
+Lab\96
+*
+Ú_equ®
+) {
+
+185
+__
+
+Cm¶i
+(
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+(
+c
+),
+r0
+);
+
+186
+B¿nchOrBack\8cack
+(
+eq
+,
+Ú_equ®
+);
+
+190 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckCh¬aù\94GT
+(
+uc16
+
+lim\99
+,
+Lab\96
+*
+Ú_g»©\94
+) {
+
+191
+__
+
+Cm¶i
+(
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+(
+lim\99
+),
+r0
+);
+
+192
+B¿nchOrBack\8cack
+(
+gt
+,
+Ú_g»©\94
+);
+
+196 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckAtS\8f¹
+(
+Lab\96
+*
+Ú_©_¡¬t
+) {
+
+197
+Lab\96
+
+nÙ_©_¡¬t
+;
+
+199
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kS\8f¹Index
+));
+
+200
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+201
+B¿nchOrBack\8cack
+(
+Ã
+, &
+nÙ_©_¡¬t
+);
+
+204
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kIÅutS\8f¹
+));
+
+205
+__
+
+mr
+(
+r0
+,
+cu¼\92t_\9aput_off£t
+());
+
+206
+__
+
+add
+(
+r3
+,
+\92d_of_\9aput_add»ss
+(),
+r0
+);
+
+207
+__
+
+cmp
+(
+r4
+,
+r3
+);
+
+208
+B¿nchOrBack\8cack
+(
+eq
+,
+Ú_©_¡¬t
+);
+
+209
+__
+
+b\9ad
+(&
+nÙ_©_¡¬t
+);
+
+213 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckNÙAtS\8f¹
+(
+Lab\96
+*
+Ú_nÙ_©_¡¬t
+) {
+
+215
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kS\8f¹Index
+));
+
+216
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+217
+B¿nchOrBack\8cack
+(
+Ã
+,
+Ú_nÙ_©_¡¬t
+);
+
+219
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kIÅutS\8f¹
+));
+
+220
+__
+
+add
+(
+r3
+,
+\92d_of_\9aput_add»ss
+(),
+cu¼\92t_\9aput_off£t
+());
+
+221
+__
+
+cmp
+(
+r3
+,
+r4
+);
+
+222
+B¿nchOrBack\8cack
+(
+Ã
+,
+Ú_nÙ_©_¡¬t
+);
+
+226 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckCh¬aù\94LT
+(
+uc16
+
+lim\99
+,
+Lab\96
+*
+Ú_Ëss
+) {
+
+227
+__
+
+Cm¶i
+(
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+(
+lim\99
+),
+r0
+);
+
+228
+B¿nchOrBack\8cack
+(
+É
+,
+Ú_Ëss
+);
+
+232 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckG»edyLoÝ
+(
+Lab\96
+*
+Ú_equ®
+) {
+
+233
+Lab\96
+
+back\8cack_nÚ_equ®
+;
+
+234
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+back\8cack_¡ackpo\9a\8br
+(), 0));
+
+235
+__
+
+cmp
+(
+cu¼\92t_\9aput_off£t
+(),
+r3
+);
+
+236
+__
+
+bÃ
+(&
+back\8cack_nÚ_equ®
+);
+
+237
+__
+
+addi
+(
+back\8cack_¡ackpo\9a\8br
+(), backtrack_stackpointer(),
+
+238
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+240
+__
+
+b\9ad
+(&
+back\8cack_nÚ_equ®
+);
+
+241
+B¿nchOrBack\8cack
+(
+eq
+,
+Ú_equ®
+);
+
+245 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckNÙBackReã»nûIgnÜeCa£
+(
+
+246 \12
+¡¬t_»g
+,
+Lab\96
+*
+Ú_no_m©ch
+) {
+
+247
+Lab\96
+
+ gçÎthrough
+;
+
+248
+__
+
+LßdP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+¡¬t_»g
+),
+r0
+);
+
+249
+__
+
+LßdP
+(
+r4
+,
+»gi¡\94_loÿtiÚ
+(
+¡¬t_»g
+ + 1),
+r0
+);
+
+250
+__
+
+sub
+(
+r4
+,\844,
+r3
+,
+L\97veOE
+,
+S\91RC
+);
+
+254
+__
+
+beq
+(&
+çÎthrough
+,
+ü0
+);
+
+257
+__
+
+add
+(
+r0
+,
+r4
+,
+cu¼\92t_\9aput_off£t
+(),
+L\97veOE
+,
+S\91RC
+);
+
+259
+B¿nchOrBack\8cack
+(
+gt
+,
+Ú_no_m©ch
+,
+ü0
+);
+
+261 ià(
+ gmode_
+ =ð
+LATIN1
+) {
+
+262
+Lab\96
+
+sucûss
+;
+
+263
+Lab\96
+
+ gç\9e
+;
+
+264
+Lab\96
+
+ gloÝ_check
+;
+
+268
+__
+
+add
+(
+r3
+,\843,
+\92d_of_\9aput_add»ss
+());
+
+269
+__
+
+add
+(
+r5
+,
+\92d_of_\9aput_add»ss
+(),
+cu¼\92t_\9aput_off£t
+());
+
+270
+__
+
+add
+(
+r4
+,
+r3
+,\844);
+
+276
+Lab\96
+
+ gloÝ
+;
+
+277
+__
+
+b\9ad
+(&
+loÝ
+);
+
+278
+__
+
+lbz
+(
+r6
+,
+MemO³¿nd
+(
+r3
+));
+
+279
+__
+
+addi
+(
+r3
+,\843,
+O³¿nd
+(
+ch¬_size
+()));
+
+280
+__
+
+lbz
+(
+r25
+,
+MemO³¿nd
+(
+r5
+));
+
+281
+__
+
+addi
+(
+r5
+,\845,
+O³¿nd
+(
+ch¬_size
+()));
+
+282
+__
+
+cmp
+(
+r25
+,
+r6
+);
+
+283
+__
+
+beq
+(&
+loÝ_check
+);
+
+286
+__
+
+Üi
+(
+r6
+,\846,
+O³¿nd
+(0x20));
+
+287
+__
+
+Üi
+(
+r25
+,\8425,
+O³¿nd
+(0x20));
+
+288
+__
+
+cmp
+(
+r25
+,
+r6
+);
+
+289
+__
+
+bÃ
+(&
+ç\9e
+);
+
+290
+__
+
+subi
+(
+r6
+,\846,
+O³¿nd
+('a'));
+
+291
+__
+
+cm¶i
+(
+r6
+,
+O³¿nd
+('z' - 'a'));
+
+292
+__
+
+bË
+(&
+loÝ_check
+);
+
+294
+__
+
+subi
+(
+r6
+,\846,
+O³¿nd
+(224 - 'a'));
+
+295
+__
+
+cm¶i
+(
+r6
+,
+O³¿nd
+(254 - 224));
+
+296
+__
+
+bgt
+(&
+ç\9e
+);
+
+297
+__
+
+cmpi
+(
+r6
+,
+O³¿nd
+(247 - 224));
+
+298
+__
+
+beq
+(&
+ç\9e
+);
+
+300
+__
+
+b\9ad
+(&
+loÝ_check
+);
+
+301
+__
+
+cmp
+(
+r3
+,
+r4
+);
+
+302
+__
+
+bÉ
+(&
+loÝ
+);
+
+303
+__
+
+b
+(&
+sucûss
+);
+
+305
+__
+
+b\9ad
+(&
+ç\9e
+);
+
+306
+B¿nchOrBack\8cack
+(
+®
+,
+Ú_no_m©ch
+);
+
+308
+__
+
+b\9ad
+(&
+sucûss
+);
+
+310
+__
+
+sub
+(
+cu¼\92t_\9aput_off£t
+(),
+r5
+,
+\92d_of_\9aput_add»ss
+());
+
+312
+DCHECK
+(
+mode_
+ =ð
+UC16
+);
+
+313 \12
+ g¬gum\92t_couÁ
+ = 4;
+
+314
+__
+
+P»·»C®lCFunùiÚ
+(
+¬gum\92t_couÁ
+,
+r5
+);
+
+327
+__
+
+add
+(
+r3
+,\843,
+\92d_of_\9aput_add»ss
+());
+
+329
+__
+
+mr
+(
+r5
+,
+r4
+);
+
+331
+__
+
+mr
+(
+r25
+,
+r4
+);
+
+333
+__
+
+add
+(
+r4
+,
+cu¼\92t_\9aput_off£t
+(),
+\92d_of_\9aput_add»ss
+());
+
+335
+__
+
+mov
+(
+r6
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+isީe
+())));
+
+338
+AÎowEx\8bº®C®lTh©CªtCau£GC
+
+scÝe
+(
+masm_
+);
+
+339
+Ex\8bº®Reã»nû
+
+ gfunùiÚ
+ =
+
+340
+Ex\8bº®Reã»nû
+::
+»_ÿ£_\9a£ns\99ive_com·»_uc16
+(
+isީe
+());
+
+341
+__
+
+C®lCFunùiÚ
+(
+funùiÚ
+,
+¬gum\92t_couÁ
+);
+
+345
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+346
+B¿nchOrBack\8cack
+(
+eq
+,
+Ú_no_m©ch
+);
+
+348
+__
+
+add
+(
+cu¼\92t_\9aput_off£t
+(), cu¼\92t_\9aput_off£t(),
+r25
+);
+
+351
+__
+
+b\9ad
+(&
+çÎthrough
+);
+
+355 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckNÙBackReã»nû
+(\12
+¡¬t_»g
+,
+
+356
+Lab\96
+*
+Ú_no_m©ch
+) {
+
+357
+Lab\96
+
+ gçÎthrough
+;
+
+358
+Lab\96
+
+ gsucûss
+;
+
+361
+__
+
+LßdP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+¡¬t_»g
+),
+r0
+);
+
+362
+__
+
+LßdP
+(
+r4
+,
+»gi¡\94_loÿtiÚ
+(
+¡¬t_»g
+ + 1),
+r0
+);
+
+363
+__
+
+sub
+(
+r4
+,\844,
+r3
+,
+L\97veOE
+,
+S\91RC
+);
+
+365
+__
+
+beq
+(&
+çÎthrough
+,
+ü0
+);
+
+368
+__
+
+add
+(
+r0
+,
+r4
+,
+cu¼\92t_\9aput_off£t
+(),
+L\97veOE
+,
+S\91RC
+);
+
+369
+B¿nchOrBack\8cack
+(
+gt
+,
+Ú_no_m©ch
+,
+ü0
+);
+
+372
+__
+
+add
+(
+r3
+,\843,
+\92d_of_\9aput_add»ss
+());
+
+373
+__
+
+add
+(
+r5
+,
+\92d_of_\9aput_add»ss
+(),
+cu¼\92t_\9aput_off£t
+());
+
+374
+__
+
+add
+(
+r4
+,\844,
+r3
+);
+
+376
+Lab\96
+
+ gloÝ
+;
+
+377
+__
+
+b\9ad
+(&
+loÝ
+);
+
+378 ià(
+ gmode_
+ =ð
+LATIN1
+) {
+
+379
+__
+
+lbz
+(
+r6
+,
+MemO³¿nd
+(
+r3
+));
+
+380
+__
+
+addi
+(
+r3
+,\843,
+O³¿nd
+(
+ch¬_size
+()));
+
+381
+__
+
+lbz
+(
+r25
+,
+MemO³¿nd
+(
+r5
+));
+
+382
+__
+
+addi
+(
+r5
+,\845,
+O³¿nd
+(
+ch¬_size
+()));
+
+384
+DCHECK
+(
+mode_
+ =ð
+UC16
+);
+
+385
+__
+
+lhz
+(
+r6
+,
+MemO³¿nd
+(
+r3
+));
+
+386
+__
+
+addi
+(
+r3
+,\843,
+O³¿nd
+(
+ch¬_size
+()));
+
+387
+__
+
+lhz
+(
+r25
+,
+MemO³¿nd
+(
+r5
+));
+
+388
+__
+
+addi
+(
+r5
+,\845,
+O³¿nd
+(
+ch¬_size
+()));
+
+390
+__
+
+cmp
+(
+r6
+,
+r25
+);
+
+391
+B¿nchOrBack\8cack
+(
+Ã
+,
+Ú_no_m©ch
+);
+
+392
+__
+
+cmp
+(
+r3
+,
+r4
+);
+
+393
+__
+
+bÉ
+(&
+loÝ
+);
+
+396
+__
+
+sub
+(
+cu¼\92t_\9aput_off£t
+(),
+r5
+,
+\92d_of_\9aput_add»ss
+());
+
+397
+__
+
+b\9ad
+(&
+çÎthrough
+);
+
+401 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckNÙCh¬aù\94
+(\1d
+c
+,
+
+402
+Lab\96
+*
+Ú_nÙ_equ®
+) {
+
+403
+__
+
+Cm¶i
+(
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+(
+c
+),
+r0
+);
+
+404
+B¿nchOrBack\8cack
+(
+Ã
+,
+Ú_nÙ_equ®
+);
+
+408 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckCh¬aù\94Aá\94And
+(
+u\9at32_t
+
+c
+, u\9at32_\88
+mask
+,
+
+409
+Lab\96
+*
+Ú_equ®
+) {
+
+410
+__
+
+mov
+(
+r0
+,
+O³¿nd
+(
+mask
+));
+
+411 ià(
+ gc
+ == 0) {
+
+412
+__
+
+ªd_
+(
+r3
+,
+cu¼\92t_ch¬aù\94
+(),
+r0
+,
+S\91RC
+);
+
+414
+__
+
+ªd_
+(
+r3
+,
+cu¼\92t_ch¬aù\94
+(),
+r0
+);
+
+415
+__
+
+Cm¶i
+(
+r3
+,
+O³¿nd
+(
+c
+),
+r0
+,
+ü0
+);
+
+417
+B¿nchOrBack\8cack
+(
+eq
+,
+Ú_equ®
+,
+ü0
+);
+
+421 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckNÙCh¬aù\94Aá\94And
+(\1d
+c
+,
+
+422 \1d
+mask
+,
+
+423
+Lab\96
+*
+Ú_nÙ_equ®
+) {
+
+424
+__
+
+mov
+(
+r0
+,
+O³¿nd
+(
+mask
+));
+
+425 ià(
+ gc
+ == 0) {
+
+426
+__
+
+ªd_
+(
+r3
+,
+cu¼\92t_ch¬aù\94
+(),
+r0
+,
+S\91RC
+);
+
+428
+__
+
+ªd_
+(
+r3
+,
+cu¼\92t_ch¬aù\94
+(),
+r0
+);
+
+429
+__
+
+Cm¶i
+(
+r3
+,
+O³¿nd
+(
+c
+),
+r0
+,
+ü0
+);
+
+431
+B¿nchOrBack\8cack
+(
+Ã
+,
+Ú_nÙ_equ®
+,
+ü0
+);
+
+435 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckNÙCh¬aù\94Aá\94M\9ausAnd
+(
+
+436
+uc16
+
+c
+, uc16
+m\9aus
+, uc16
+mask
+,
+Lab\96
+*
+Ú_nÙ_equ®
+) {
+
+437
+DCHECK
+(
+m\9aus
+ <
+S\8c\9ag
+::
+kMaxUtf16CodeUn\99
+);
+
+438
+__
+
+subi
+(
+r3
+,
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+(
+m\9aus
+));
+
+439
+__
+
+mov
+(
+r0
+,
+O³¿nd
+(
+mask
+));
+
+440
+__
+
+ªd_
+(
+r3
+,\843,
+r0
+);
+
+441
+__
+
+Cm¶i
+(
+r3
+,
+O³¿nd
+(
+c
+),
+r0
+);
+
+442
+B¿nchOrBack\8cack
+(
+Ã
+,
+Ú_nÙ_equ®
+);
+
+446 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckCh¬aù\94InRªge
+(
+uc16
+
+äom
+, uc16
+to
+,
+
+447
+Lab\96
+*
+Ú_\9a_¿nge
+) {
+
+448
+__
+
+mov
+(
+r0
+,
+O³¿nd
+(
+äom
+));
+
+449
+__
+
+sub
+(
+r3
+,
+cu¼\92t_ch¬aù\94
+(),
+r0
+);
+
+450
+__
+
+Cm¶i
+(
+r3
+,
+O³¿nd
+(
+to
+ -
+äom
+),
+r0
+);
+
+451
+B¿nchOrBack\8cack
+(
+Ë
+,
+Ú_\9a_¿nge
+);
+
+455 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckCh¬aù\94NÙInRªge
+(
+uc16
+
+äom
+, uc16
+to
+,
+
+456
+Lab\96
+*
+Ú_nÙ_\9a_¿nge
+) {
+
+457
+__
+
+mov
+(
+r0
+,
+O³¿nd
+(
+äom
+));
+
+458
+__
+
+sub
+(
+r3
+,
+cu¼\92t_ch¬aù\94
+(),
+r0
+);
+
+459
+__
+
+Cm¶i
+(
+r3
+,
+O³¿nd
+(
+to
+ -
+äom
+),
+r0
+);
+
+460
+B¿nchOrBack\8cack
+(
+gt
+,
+Ú_nÙ_\9a_¿nge
+);
+
+464 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckB\99InTabË
+(
+HªdË
+<
+By\8bA¼ay
+>
+\8fbË
+,
+
+465
+Lab\96
+*
+Ú_b\99_£t
+) {
+
+466
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+\8fbË
+));
+
+467 ià(
+ gmode_
+ !ð
+LATIN1
+ ||
+kTabËMask
+ !ð
+S\8c\9ag
+::
+kMaxOÃBy\8bCh¬Code
+) {
+
+468
+__
+
+ªdi
+(
+r4
+,
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+(
+kTabËSize
+ - 1));
+
+469
+__
+
+addi
+(
+r4
+,\844,
+O³¿nd
+(
+By\8bA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+471
+__
+
+addi
+(
+r4
+,
+cu¼\92t_ch¬aù\94
+(),
+
+472
+O³¿nd
+(
+By\8bA¼ay
+::
+kH\97d\94Size
+ -
+kH\97pObjeùTag
+));
+
+474
+__
+
+lbzx
+(
+r3
+,
+MemO³¿nd
+Ô3,
+r4
+));
+
+475
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+476
+B¿nchOrBack\8cack
+(
+Ã
+,
+Ú_b\99_£t
+);
+
+480
+boÞ
+
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckS³c\9flCh¬aù\94CÏss
+(
+uc16
+
+ty³
+,
+
+481
+Lab\96
+*
+Ú_no_m©ch
+) {
+
+484 \1a
+ gty³
+) {
+
+487 ià(
+mode_
+ =ð
+LATIN1
+) {
+
+489
+Lab\96
+
+sucûss
+;
+
+490
+__
+
+cmpi
+(
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+(' '));
+
+491
+__
+
+beq
+(&
+sucûss
+);
+
+493
+__
+
+subi
+(
+r3
+,
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+('\t'));
+
+494
+__
+
+cm¶i
+(
+r3
+,
+O³¿nd
+('\r' - '\t'));
+
+495
+__
+
+bË
+(&
+sucûss
+);
+
+497
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+(0x00a0 - '\t'));
+
+498
+B¿nchOrBack\8cack
+(
+Ã
+,
+Ú_no_m©ch
+);
+
+499
+__
+
+b\9ad
+(&
+sucûss
+);
+
+500 \15
+ g\8cue
+;
+
+502 \15
+ gçl£
+;
+
+505 \15
+çl£
+;
+
+508
+__
+
+subi
+(
+r3
+,
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+('0'));
+
+509
+__
+
+cm¶i
+(
+r3
+,
+O³¿nd
+('9' - '0'));
+
+510
+B¿nchOrBack\8cack
+(
+gt
+,
+Ú_no_m©ch
+);
+
+511 \15
+ g\8cue
+;
+
+514
+__
+
+subi
+(
+r3
+,
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+('0'));
+
+515
+__
+
+cm¶i
+(
+r3
+,
+O³¿nd
+('9' - '0'));
+
+516
+B¿nchOrBack\8cack
+(
+Ë
+,
+Ú_no_m©ch
+);
+
+517 \15
+ g\8cue
+;
+
+520
+__
+
+xÜi
+(
+r3
+,
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+(0x01));
+
+522
+__
+
+subi
+(
+r3
+,\843,
+O³¿nd
+(0x0b));
+
+523
+__
+
+cm¶i
+(
+r3
+,
+O³¿nd
+(0x0c - 0x0b));
+
+524
+B¿nchOrBack\8cack
+(
+Ë
+,
+Ú_no_m©ch
+);
+
+525 ià(
+ gmode_
+ =ð
+UC16
+) {
+
+529
+__
+
+subi
+(
+r3
+,\843,
+O³¿nd
+(0x2028 - 0x0b));
+
+530
+__
+
+cm¶i
+(
+r3
+,
+O³¿nd
+(1));
+
+531
+B¿nchOrBack\8cack
+(
+Ë
+,
+Ú_no_m©ch
+);
+
+533 \15
+ g\8cue
+;
+
+537
+__
+
+xÜi
+(
+r3
+,
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+(0x01));
+
+539
+__
+
+subi
+(
+r3
+,\843,
+O³¿nd
+(0x0b));
+
+540
+__
+
+cm¶i
+(
+r3
+,
+O³¿nd
+(0x0c - 0x0b));
+
+541 ià(
+ gmode_
+ =ð
+LATIN1
+) {
+
+542
+B¿nchOrBack\8cack
+(
+gt
+,
+Ú_no_m©ch
+);
+
+544
+Lab\96
+
+ gdÚe
+;
+
+545
+__
+
+bË
+(&
+dÚe
+);
+
+549
+__
+
+subi
+(
+r3
+,\843,
+O³¿nd
+(0x2028 - 0x0b));
+
+550
+__
+
+cm¶i
+(
+r3
+,
+O³¿nd
+(1));
+
+551
+B¿nchOrBack\8cack
+(
+gt
+,
+Ú_no_m©ch
+);
+
+552
+__
+
+b\9ad
+(&
+dÚe
+);
+
+554 \15
+ g\8cue
+;
+
+557 ià(
+mode_
+ !ð
+LATIN1
+) {
+
+559
+__
+
+cmpi
+(
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+('z'));
+
+560
+B¿nchOrBack\8cack
+(
+gt
+,
+Ú_no_m©ch
+);
+
+562
+Ex\8bº®Reã»nû
+
+ gm
+ = Ex\8bº®Reã»nû::
+»_wÜd_ch¬aù\94_m
+();
+
+563
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+m
+));
+
+564
+__
+
+lbzx
+(
+r3
+,
+MemO³¿nd
+Ô3,
+cu¼\92t_ch¬aù\94
+()));
+
+565
+__
+
+cm¶i
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+566
+B¿nchOrBack\8cack
+(
+eq
+,
+Ú_no_m©ch
+);
+
+567 \15
+ g\8cue
+;
+
+570
+Lab\96
+
+dÚe
+;
+
+571 ià(
+ gmode_
+ !ð
+LATIN1
+) {
+
+573
+__
+
+cm¶i
+(
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+('z'));
+
+574
+__
+
+bgt
+(&
+dÚe
+);
+
+576
+Ex\8bº®Reã»nû
+
+ gm
+ = Ex\8bº®Reã»nû::
+»_wÜd_ch¬aù\94_m
+();
+
+577
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+m
+));
+
+578
+__
+
+lbzx
+(
+r3
+,
+MemO³¿nd
+Ô3,
+cu¼\92t_ch¬aù\94
+()));
+
+579
+__
+
+cm¶i
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+580
+B¿nchOrBack\8cack
+(
+Ã
+,
+Ú_no_m©ch
+);
+
+581 ià(
+ gmode_
+ !ð
+LATIN1
+) {
+
+582
+__
+
+b\9ad
+(&
+dÚe
+);
+
+584 \15
+ g\8cue
+;
+
+588 \15
+\8cue
+;
+
+591 \15
+çl£
+;
+
+596 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+Fa\9e
+() {
+
+597
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+FAILURE
+));
+
+598
+__
+
+b
+(&
+ex\99_Ïb\96_
+);
+
+602
+ gHªdË
+<
+ gH\97pObjeù
+>
+ gRegExpMaüoAs£mbËrPPC
+::
+G\91Code
+(
+HªdË
+<
+S\8c\9ag
+>
+sourû
+) {
+
+603
+Lab\96
+
+»tuº_r3
+;
+
+605 ià(
+ gmasm_
+->
+has_exû±iÚ
+()) {
+
+609
+__
+
+b\9ad_to
+(&
+\92\8cy_Ïb\96_
+,
+\9a\8bº®_ç\9eu»_Ïb\96_
+.
+pos
+());
+
+615
+__
+
+b\9ad
+(&
+\92\8cy_Ïb\96_
+);
+
+619
+F¿meScÝe
+
+scÝe
+(
+masm_
+,
+S\8fckF¿me
+::
+MANUAL
+);
+
+622
+DCHECK
+(
+r25
+.
+b\99
+(è&
+kRegExpC®ËeSaved
+);
+
+623
+DCHECK
+(
+code_po\9a\8br
+().
+b\99
+(è&
+kRegExpC®ËeSaved
+);
+
+624
+DCHECK
+(
+cu¼\92t_\9aput_off£t
+().
+b\99
+(è&
+kRegExpC®ËeSaved
+);
+
+625
+DCHECK
+(
+cu¼\92t_ch¬aù\94
+().
+b\99
+(è&
+kRegExpC®ËeSaved
+);
+
+626
+DCHECK
+(
+back\8cack_¡ackpo\9a\8br
+().
+b\99
+(è&
+kRegExpC®ËeSaved
+);
+
+627
+DCHECK
+(
+\92d_of_\9aput_add»ss
+().
+b\99
+(è&
+kRegExpC®ËeSaved
+);
+
+628
+DCHECK
+(
+äame_po\9a\8br
+().
+b\99
+(è&
+kRegExpC®ËeSaved
+);
+
+636
+RegLi¡
+
+ g»gi¡\94s_to_»\8f\9a
+ =
+kRegExpC®ËeSaved
+;
+
+637
+RegLi¡
+
+ g¬gum\92t_»gi¡\94s
+ =
+r3
+.
+b\99
+(è|
+r4
+.b\99(è|
+r5
+.b\99(è|
+r6
+.bit() |
+
+638
+r7
+.
+b\99
+(è|
+r8
+.b\99(è|
+r9
+.b\99(è|
+r10
+.bit();
+
+639
+__
+
+mær
+(
+r0
+);
+
+640
+__
+
+push
+(
+r0
+);
+
+641
+__
+
+MuÉiPush
+(
+¬gum\92t_»gi¡\94s
+ |
+»gi¡\94s_to_»\8f\9a
+);
+
+644
+__
+
+addi
+(
+äame_po\9a\8br
+(),
+¥
+,
+O³¿nd
+(8 *
+kPo\9a\8brSize
+));
+
+645
+__
+
+li
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+646
+__
+
+push
+(
+r3
+);
+
+647
+__
+
+push
+(
+r3
+);
+
+649
+Lab\96
+
+ g¡ack_lim\99_h\99
+;
+
+650
+Lab\96
+
+ g¡ack_ok
+;
+
+652
+Ex\8bº®Reã»nû
+
+ g¡ack_lim\99
+ =
+
+653
+Ex\8bº®Reã»nû
+::
+add»ss_of_¡ack_lim\99
+(
+isީe
+());
+
+654
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+¡ack_lim\99
+));
+
+655
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(r3));
+
+656
+__
+
+sub
+(
+r3
+,
+¥
+,\843,
+L\97veOE
+,
+S\91RC
+);
+
+658
+__
+
+bË
+(&
+¡ack_lim\99_h\99
+,
+ü0
+);
+
+661
+__
+
+Cm¶i
+(
+r3
+,
+O³¿nd
+(
+num_»gi¡\94s_
+ *
+kPo\9a\8brSize
+),
+r0
+);
+
+662
+__
+
+bge
+(&
+¡ack_ok
+);
+
+665
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+EXCEPTION
+));
+
+666
+__
+
+b
+(&
+»tuº_r3
+);
+
+668
+__
+
+b\9ad
+(&
+¡ack_lim\99_h\99
+);
+
+669
+C®lCheckS\8fckGu¬dS\8f\8b
+(
+r3
+);
+
+670
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+672
+__
+
+bÃ
+(&
+»tuº_r3
+);
+
+674
+__
+
+b\9ad
+(&
+¡ack_ok
+);
+
+677
+__
+
+Add
+(
+¥
+, sp, -
+num_»gi¡\94s_
+ *
+kPo\9a\8brSize
+,
+r0
+);
+
+679
+__
+
+LßdP
+(
+\92d_of_\9aput_add»ss
+(),
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kIÅutEnd
+));
+
+681
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kIÅutS\8f¹
+));
+
+683
+__
+
+sub
+(
+cu¼\92t_\9aput_off£t
+(),
+r3
+,
+\92d_of_\9aput_add»ss
+());
+
+686
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kS\8f¹Index
+));
+
+687
+__
+
+subi
+(
+r3
+,
+cu¼\92t_\9aput_off£t
+(),
+O³¿nd
+(
+ch¬_size
+()));
+
+688 ià(
+ gmode_
+ =ð
+UC16
+) {
+
+689
+__
+
+ShiáLeáImm
+(
+r0
+,
+r4
+,
+O³¿nd
+(1));
+
+690
+__
+
+sub
+(
+r3
+,\843,
+r0
+);
+
+692
+__
+
+sub
+(
+r3
+,\843,
+r4
+);
+
+696
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kIÅutS\8f¹M\9ausOÃ
+));
+
+699
+__
+
+mov
+(
+code_po\9a\8br
+(),
+O³¿nd
+(
+masm_
+->
+CodeObjeù
+()));
+
+701
+Lab\96
+
+ glßd_ch¬_¡¬t_»gexp
+,
+ g¡¬t_»gexp
+;
+
+703
+__
+
+cmpi
+(
+r4
+,
+O³¿nd
+::
+Z\94o
+());
+
+704
+__
+
+bÃ
+(&
+lßd_ch¬_¡¬t_»gexp
+);
+
+705
+__
+
+li
+(
+cu¼\92t_ch¬aù\94
+(),
+O³¿nd
+('\n'));
+
+706
+__
+
+b
+(&
+¡¬t_»gexp
+);
+
+709
+__
+
+b\9ad
+(&
+lßd_ch¬_¡¬t_»gexp
+);
+
+711
+LßdCu¼\92tCh¬aù\94Unchecked
+(-1, 1);
+
+712
+__
+
+b\9ad
+(&
+¡¬t_»gexp
+);
+
+715 ià(
+ gnum_§ved_»gi¡\94s_
+ > 0) {
+
+717 ià(
+ gnum_§ved_»gi¡\94s_
+ > 8) {
+
+719
+__
+
+addi
+(
+r4
+,
+äame_po\9a\8br
+(),
+O³¿nd
+(
+kRegi¡\94Z\94o
+ +
+kPo\9a\8brSize
+));
+
+720
+__
+
+li
+(
+r5
+,
+O³¿nd
+(
+num_§ved_»gi¡\94s_
+));
+
+721
+__
+
+mtùr
+(
+r5
+);
+
+722
+Lab\96
+
+ g\9a\99_loÝ
+;
+
+723
+__
+
+b\9ad
+(&
+\9a\99_loÝ
+);
+
+724
+__
+
+StÜePU
+(
+r3
+,
+MemO³¿nd
+(
+r4
+, -
+kPo\9a\8brSize
+));
+
+725
+__
+
+bdnz
+(&
+\9a\99_loÝ
+);
+
+727 \ f\12
+ gi
+ = 0; i <
+ gnum_§ved_»gi¡\94s_
+; i++) {
+
+728
+__
+
+StÜeP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+i
+),
+r0
+);
+
+734
+__
+
+LßdP
+(
+back\8cack_¡ackpo\9a\8br
+(),
+
+735
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kS\8fckHighEnd
+));
+
+737
+__
+
+b
+(&
+¡¬t_Ïb\96_
+);
+
+740 ià(
+ gsucûss_Ïb\96_
+.
+is_l\9aked
+()) {
+
+742
+__
+
+b\9ad
+(&
+sucûss_Ïb\96_
+);
+
+743 ià(
+ gnum_§ved_»gi¡\94s_
+ > 0) {
+
+745
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kIÅutS\8f¹
+));
+
+746
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kRegi¡\94Ou\8dut
+));
+
+747
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kS\8f¹Index
+));
+
+748
+__
+
+sub
+(
+r4
+,
+\92d_of_\9aput_add»ss
+(),\844);
+
+750 ià(
+ gmode_
+ =ð
+UC16
+) {
+
+751
+__
+
+ShiáRightImm
+(
+r4
+,\844,
+O³¿nd
+(1));
+
+754
+__
+
+add
+(
+r4
+,\844,
+r5
+);
+
+757
+DCHECK_EQ
+(0,
+num_§ved_»gi¡\94s_
+ % 2);
+
+761 \ f\12
+ gi
+ = 0; i <
+ gnum_§ved_»gi¡\94s_
+; i += 2) {
+
+762
+__
+
+LßdP
+(
+r5
+,
+»gi¡\94_loÿtiÚ
+(
+i
+),
+r0
+);
+
+763
+__
+
+LßdP
+(
+r6
+,
+»gi¡\94_loÿtiÚ
+(
+i
+ + 1),
+r0
+);
+
+764 ià(
+ gi
+ =ð0 &&
+glob®_w\99h_z\94o_Ëngth_check
+()) {
+
+766
+__
+
+mr
+(
+r25
+,
+r5
+);
+
+768 ià(
+ gmode_
+ =ð
+UC16
+) {
+
+769
+__
+
+ShiáRightAr\99hImm
+(
+r5
+,\845, 1);
+
+770
+__
+
+add
+(
+r5
+,
+r4
+,\845);
+
+771
+__
+
+ShiáRightAr\99hImm
+(
+r6
+,\846, 1);
+
+772
+__
+
+add
+(
+r6
+,
+r4
+,\846);
+
+774
+__
+
+add
+(
+r5
+,
+r4
+,\845);
+
+775
+__
+
+add
+(
+r6
+,
+r4
+,\846);
+
+777
+__
+
+¡w
+(
+r5
+,
+MemO³¿nd
+(
+r3
+));
+
+778
+__
+
+addi
+(
+r3
+,\843,
+O³¿nd
+(
+kIÁSize
+));
+
+779
+__
+
+¡w
+(
+r6
+,
+MemO³¿nd
+(
+r3
+));
+
+780
+__
+
+addi
+(
+r3
+,\843,
+O³¿nd
+(
+kIÁSize
+));
+
+784 ià(
+glob®
+()) {
+
+786
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kSucûssfulCtu»s
+));
+
+787
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kNumOu\8dutRegi¡\94s
+));
+
+788
+__
+
+LßdP
+(
+r5
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kRegi¡\94Ou\8dut
+));
+
+790
+__
+
+addi
+(
+r3
+,\843,
+O³¿nd
+(1));
+
+791
+__
+
+StÜeP
+(
+r3
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kSucûssfulCtu»s
+));
+
+794
+__
+
+subi
+(
+r4
+,\844,
+O³¿nd
+(
+num_§ved_»gi¡\94s_
+));
+
+796
+__
+
+cmpi
+(
+r4
+,
+O³¿nd
+(
+num_§ved_»gi¡\94s_
+));
+
+797
+__
+
+bÉ
+(&
+»tuº_r3
+);
+
+799
+__
+
+StÜeP
+(
+r4
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kNumOu\8dutRegi¡\94s
+));
+
+801
+__
+
+addi
+(
+r5
+,\845,
+O³¿nd
+(
+num_§ved_»gi¡\94s_
+ *
+kIÁSize
+));
+
+802
+__
+
+StÜeP
+(
+r5
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kRegi¡\94Ou\8dut
+));
+
+805
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kIÅutS\8f¹M\9ausOÃ
+));
+
+807 ià(
+glob®_w\99h_z\94o_Ëngth_check
+()) {
+
+810
+__
+
+cmp
+(
+cu¼\92t_\9aput_off£t
+(),
+r25
+);
+
+812
+__
+
+bÃ
+(&
+lßd_ch¬_¡¬t_»gexp
+);
+
+814
+__
+
+cmpi
+(
+cu¼\92t_\9aput_off£t
+(),
+O³¿nd
+::
+Z\94o
+());
+
+815
+__
+
+beq
+(&
+ex\99_Ïb\96_
+);
+
+817
+__
+
+addi
+(
+cu¼\92t_\9aput_off£t
+(), current_input_offset(),
+
+818
+O³¿nd
+((
+mode_
+ =ð
+UC16
+) ? 2 : 1));
+
+821
+__
+
+b
+(&
+lßd_ch¬_¡¬t_»gexp
+);
+
+823
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+SUCCESS
+));
+
+828
+__
+
+b\9ad
+(&
+ex\99_Ïb\96_
+);
+
+829 ià(
+glob®
+()) {
+
+830
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kSucûssfulCtu»s
+));
+
+833
+__
+
+b\9ad
+(&
+»tuº_r3
+);
+
+835
+__
+
+mr
+(
+¥
+,
+äame_po\9a\8br
+());
+
+837
+__
+
+MuÉiPÝ
+(
+»gi¡\94s_to_»\8f\9a
+);
+
+838
+__
+
+pÝ
+(
+r0
+);
+
+839
+__
+
+mtùr
+(
+r0
+);
+
+840
+__
+
+bùr
+();
+
+843 ià(
+ gback\8cack_Ïb\96_
+.
+is_l\9aked
+()) {
+
+844
+__
+
+b\9ad
+(&
+back\8cack_Ïb\96_
+);
+
+845
+Back\8cack
+();
+
+848
+Lab\96
+
+ gex\99_w\99h_exû±iÚ
+;
+
+851 ià(
+ gcheck_´\93m±_Ïb\96_
+.
+is_l\9aked
+()) {
+
+852
+SaãC®lT¬g\91
+(&
+check_´\93m±_Ïb\96_
+);
+
+854
+C®lCheckS\8fckGu¬dS\8f\8b
+(
+r3
+);
+
+855
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+858
+__
+
+bÃ
+(&
+»tuº_r3
+);
+
+861
+__
+
+LßdP
+(
+\92d_of_\9aput_add»ss
+(),
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kIÅutEnd
+));
+
+862
+SaãR\91uº
+();
+
+866 ià(
+ g¡ack_ov\94æow_Ïb\96_
+.
+is_l\9aked
+()) {
+
+867
+SaãC®lT¬g\91
+(&
+¡ack_ov\94æow_Ïb\96_
+);
+
+869
+Lab\96
+
+ ggrow_ç\9eed
+;
+
+872 \18cڡ \12
+ gnum_¬gum\92ts
+ = 3;
+
+873
+__
+
+P»·»C®lCFunùiÚ
+(
+num_¬gum\92ts
+,
+r3
+);
+
+874
+__
+
+mr
+(
+r3
+,
+back\8cack_¡ackpo\9a\8br
+());
+
+875
+__
+
+addi
+(
+r4
+,
+äame_po\9a\8br
+(),
+O³¿nd
+(
+kS\8fckHighEnd
+));
+
+876
+__
+
+mov
+(
+r5
+,
+O³¿nd
+(
+Ex\8bº®Reã»nû
+::
+isÞ©e_add»ss
+(
+isީe
+())));
+
+877
+Ex\8bº®Reã»nû
+
+ ggrow_¡ack
+ =
+
+878
+Ex\8bº®Reã»nû
+::
+»_grow_¡ack
+(
+isީe
+());
+
+879
+__
+
+C®lCFunùiÚ
+(
+grow_¡ack
+,
+num_¬gum\92ts
+);
+
+882
+__
+
+cmpi
+(
+r3
+,
+O³¿nd
+::
+Z\94o
+());
+
+883
+__
+
+beq
+(&
+ex\99_w\99h_exû±iÚ
+);
+
+885
+__
+
+mr
+(
+back\8cack_¡ackpo\9a\8br
+(),
+r3
+);
+
+887
+SaãR\91uº
+();
+
+890 ià(
+ gex\99_w\99h_exû±iÚ
+.
+is_l\9aked
+()) {
+
+892
+__
+
+b\9ad
+(&
+ex\99_w\99h_exû±iÚ
+);
+
+894
+__
+
+li
+(
+r3
+,
+O³¿nd
+(
+EXCEPTION
+));
+
+895
+__
+
+b
+(&
+»tuº_r3
+);
+
+899
+CodeDesc
+
+ gcode_desc
+;
+
+900
+ gmasm_
+->
+G\91Code
+(&
+code_desc
+);
+
+901
+ gHªdË
+<
+ gCode
+>
+ gcode
+ =
+isީe
+()->
+çùÜy
+()->
+NewCode
+(
+
+902
+code_desc
+,
+Code
+::
+Compu\8bFÏgs
+(Code::
+REGEXP
+),
+masm_
+->
+CodeObjeù
+());
+
+903
+PROFILE
+(
+masm_
+->
+isީe
+(),
+RegExpCodeC»©eEv\92t
+(*
+code
+, *
+sourû
+));
+
+904 \15
+ gHªdË
+<
+ gH\97pObjeù
+>::
+ÿ¡
+(
+code
+);
+
+908 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+GoTo
+(
+Lab\96
+*
+to
+è{
+B¿nchOrBack\8cack
+(
+®
+,\81o); }
+
+911 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+IfRegi¡\94GE
+(\12
+»g
+, \12
+com·¿nd
+,
+
+912
+Lab\96
+*
+if_ge
+) {
+
+913
+__
+
+LßdP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+»g
+),
+r0
+);
+
+914
+__
+
+Cmpi
+(
+r3
+,
+O³¿nd
+(
+com·¿nd
+),
+r0
+);
+
+915
+B¿nchOrBack\8cack
+(
+ge
+,
+if_ge
+);
+
+919 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+IfRegi¡\94LT
+(\12
+»g
+, \12
+com·¿nd
+,
+
+920
+Lab\96
+*
+if_É
+) {
+
+921
+__
+
+LßdP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+»g
+),
+r0
+);
+
+922
+__
+
+Cmpi
+(
+r3
+,
+O³¿nd
+(
+com·¿nd
+),
+r0
+);
+
+923
+B¿nchOrBack\8cack
+(
+É
+,
+if_É
+);
+
+927 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+IfRegi¡\94EqPos
+(\12
+»g
+,
+Lab\96
+*
+if_eq
+) {
+
+928
+__
+
+LßdP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+»g
+),
+r0
+);
+
+929
+__
+
+cmp
+(
+r3
+,
+cu¼\92t_\9aput_off£t
+());
+
+930
+B¿nchOrBack\8cack
+(
+eq
+,
+if_eq
+);
+
+934
+ gRegExpMaüoAs£mbËr
+::
+I¼egexpIm¶em\92\8ftiÚ
+
+
+935
+RegExpMaüoAs£mbËrPPC
+::
+Im¶em\92\8ftiÚ
+() {
+
+936 \15
+kPPCIm¶em\92\8ftiÚ
+;
+
+940 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+LßdCu¼\92tCh¬aù\94
+(\12
+ý_off£t
+,
+
+941
+Lab\96
+*
+Ú_\92d_of_\9aput
+,
+
+942
+boÞ
+
+check_bounds
+,
+
+943 \12
+ch¬aù\94s
+) {
+
+944
+DCHECK
+(
+ý_off£t
+ >= -1);
+
+945
+DCHECK
+(
+ý_off£t
+ < (1 << 30));
+
+946 ià(
+ gcheck_bounds
+) {
+
+947
+CheckPos\99iÚ
+(
+ý_off£t
+ +
+ch¬aù\94s
+ - 1,
+Ú_\92d_of_\9aput
+);
+
+949
+LßdCu¼\92tCh¬aù\94Unchecked
+(
+ý_off£t
+,
+ch¬aù\94s
+);
+
+953 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+PÝCu¼\92tPos\99iÚ
+() {
+
+954
+PÝ
+(
+cu¼\92t_\9aput_off£t
+());
+
+958 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+PÝRegi¡\94
+(\12
+»gi¡\94_\9adex
+) {
+
+959
+PÝ
+(
+r3
+);
+
+960
+__
+
+StÜeP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+»gi¡\94_\9adex
+),
+r0
+);
+
+964 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+PushBack\8cack
+(
+Lab\96
+*
+Ïb\96
+) {
+
+965
+__
+
+mov_Ïb\96_off£t
+(
+r3
+,
+Ïb\96
+);
+
+966
+Push
+(
+r3
+);
+
+967
+CheckS\8fckLim\99
+();
+
+971 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+PushCu¼\92tPos\99iÚ
+() {
+
+972
+Push
+(
+cu¼\92t_\9aput_off£t
+());
+
+976 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+PushRegi¡\94
+(\12
+»gi¡\94_\9adex
+,
+
+977
+S\8fckCheckFÏg
+
+check_¡ack_lim\99
+) {
+
+978
+__
+
+LßdP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+»gi¡\94_\9adex
+),
+r0
+);
+
+979
+Push
+(
+r3
+);
+
+980 ià(
+ gcheck_¡ack_lim\99
+è
+CheckS\8fckLim\99
+();
+
+984 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+R\97dCu¼\92tPos\99iÚFromRegi¡\94
+(\12
+»g
+) {
+
+985
+__
+
+LßdP
+(
+cu¼\92t_\9aput_off£t
+(),
+»gi¡\94_loÿtiÚ
+(
+»g
+),
+r0
+);
+
+989 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+R\97dS\8fckPo\9a\8brFromRegi¡\94
+(\12
+»g
+) {
+
+990
+__
+
+LßdP
+(
+back\8cack_¡ackpo\9a\8br
+(),
+»gi¡\94_loÿtiÚ
+(
+»g
+),
+r0
+);
+
+991
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kS\8fckHighEnd
+));
+
+992
+__
+
+add
+(
+back\8cack_¡ackpo\9a\8br
+(), back\8cack_¡ackpo\9a\8br(),
+r3
+);
+
+996 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+S\91Cu¼\92tPos\99iÚFromEnd
+(\12
+by
+) {
+
+997
+Lab\96
+
+aá\94_pos\99iÚ
+;
+
+998
+__
+
+Cmpi
+(
+cu¼\92t_\9aput_off£t
+(),
+O³¿nd
+(-
+by
+ *
+ch¬_size
+()),
+r0
+);
+
+999
+__
+
+bge
+(&
+aá\94_pos\99iÚ
+);
+
+1000
+__
+
+mov
+(
+cu¼\92t_\9aput_off£t
+(),
+O³¿nd
+(-
+by
+ *
+ch¬_size
+()));
+
+1004
+LßdCu¼\92tCh¬aù\94Unchecked
+(-1, 1);
+
+1005
+__
+
+b\9ad
+(&
+aá\94_pos\99iÚ
+);
+
+1009 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+S\91Regi¡\94
+(\12
+»gi¡\94_\9adex
+, \12
+to
+) {
+
+1010
+DCHECK
+(
+»gi¡\94_\9adex
+ >ð
+num_§ved_»gi¡\94s_
+);
+
+1011
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+to
+));
+
+1012
+__
+
+StÜeP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+»gi¡\94_\9adex
+),
+r0
+);
+
+1016
+boÞ
+
+ gRegExpMaüoAs£mbËrPPC
+::
+Sucûed
+() {
+
+1017
+__
+
+b
+(&
+sucûss_Ïb\96_
+);
+
+1018 \15
+glob®
+();
+
+1022 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+Wr\99eCu¼\92tPos\99iÚToRegi¡\94
+(\12
+»g
+,
+
+1023 \12
+ý_off£t
+) {
+
+1024 ià(
+ gý_off£t
+ == 0) {
+
+1025
+__
+
+StÜeP
+(
+cu¼\92t_\9aput_off£t
+(),
+»gi¡\94_loÿtiÚ
+(
+»g
+),
+r0
+);
+
+1027
+__
+
+mov
+(
+r0
+,
+O³¿nd
+(
+ý_off£t
+ *
+ch¬_size
+()));
+
+1028
+__
+
+add
+(
+r3
+,
+cu¼\92t_\9aput_off£t
+(),
+r0
+);
+
+1029
+__
+
+StÜeP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+»g
+),
+r0
+);
+
+1034 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CˬRegi¡\94s
+(\12
+»g_äom
+, \12
+»g_to
+) {
+
+1035
+DCHECK
+(
+»g_äom
+ <ð
+»g_to
+);
+
+1036
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kIÅutS\8f¹M\9ausOÃ
+));
+
+1037 \ f\12
+ g»g
+ =
+»g_äom
+;\84eg <ð
+»g_to
+;\84eg++) {
+
+1038
+__
+
+StÜeP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+»g
+),
+r0
+);
+
+1043 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+Wr\99eS\8fckPo\9a\8brToRegi¡\94
+(\12
+»g
+) {
+
+1044
+__
+
+LßdP
+(
+r4
+,
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+kS\8fckHighEnd
+));
+
+1045
+__
+
+sub
+(
+r3
+,
+back\8cack_¡ackpo\9a\8br
+(),
+r4
+);
+
+1046
+__
+
+StÜeP
+(
+r3
+,
+»gi¡\94_loÿtiÚ
+(
+»g
+),
+r0
+);
+
+1052 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+C®lCheckS\8fckGu¬dS\8f\8b
+(
+Regi¡\94
+
+sü©ch
+) {
+
+1053 \12
+äame_®ignm\92t
+ =
+masm_
+->
+Aùiv©iÚF¿meAlignm\92t
+();
+
+1054 \12
+ g¡ack_¥aû
+ =
+kNumRequ\9cedS\8fckF¿meSlÙs
+;
+
+1055 \12
+ g¡ack_·s£d_¬gum\92ts
+ = 1;
+
+1060 ià(
+ gäame_®ignm\92t
+ >
+ gkPo\9a\8brSize
+) {
+
+1063
+__
+
+mr
+(
+sü©ch
+,
+¥
+);
+
+1064
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(-(
+¡ack_·s£d_¬gum\92ts
+ + 1è*
+kPo\9a\8brSize
+));
+
+1065
+DCHECK
+(
+ba£
+::
+b\99s
+::
+IsPow\94OfTwo32
+(
+äame_®ignm\92t
+));
+
+1066
+__
+
+CˬRightImm
+(
+¥
+, sp,
+O³¿nd
+(
+WhichPow\94Of2
+(
+äame_®ignm\92t
+)));
+
+1067
+__
+
+StÜeP
+(
+sü©ch
+,
+MemO³¿nd
+(
+¥
+,
+¡ack_·s£d_¬gum\92ts
+ *
+kPo\9a\8brSize
+));
+
+1070
+ g¡ack_¥aû
+ +ð
+¡ack_·s£d_¬gum\92ts
+;
+
+1074
+__
+
+li
+(
+r0
+,
+O³¿nd
+::
+Z\94o
+());
+
+1075
+__
+
+StÜePU
+(
+r0
+,
+MemO³¿nd
+(
+¥
+, -
+¡ack_¥aû
+ *
+kPo\9a\8brSize
+));
+
+1078
+__
+
+mr
+(
+r5
+,
+äame_po\9a\8br
+());
+
+1080
+__
+
+mov
+(
+r4
+,
+O³¿nd
+(
+masm_
+->
+CodeObjeù
+()));
+
+1082
+__
+
+addi
+(
+r3
+,
+¥
+,
+O³¿nd
+(
+kS\8fckF¿meEx\8caP¬amSlÙ
+ *
+kPo\9a\8brSize
+));
+
+1084
+Ex\8bº®Reã»nû
+
+ g¡ack_gu¬d_check
+ =
+
+1085
+Ex\8bº®Reã»nû
+::
+»_check_¡ack_gu¬d_¡©e
+(
+isީe
+());
+
+1086
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+¡ack_gu¬d_check
+));
+
+1087
+D\9ceùCEÁryStub
+
+¡ub
+(
+isީe
+());
+
+1088
+ g¡ub
+.
+G\92\94©eC®l
+(
+masm_
+,
+\9d
+);
+
+1091
+ g¡ack_¥aû
+ =
+kNumRequ\9cedS\8fckF¿meSlÙs
+ +
+¡ack_·s£d_¬gum\92ts
+;
+
+1092 ià(
+ gäame_®ignm\92t
+ >
+ gkPo\9a\8brSize
+) {
+
+1093
+__
+
+LßdP
+(
+¥
+,
+MemO³¿nd
+(¥,
+¡ack_¥aû
+ *
+kPo\9a\8brSize
+));
+
+1095
+__
+
+addi
+(
+¥
+, sp,
+O³¿nd
+(
+¡ack_¥aû
+ *
+kPo\9a\8brSize
+));
+
+1098
+__
+
+mov
+(
+code_po\9a\8br
+(),
+O³¿nd
+(
+masm_
+->
+CodeObjeù
+()));
+
+1103
+ g\8bm¶©e
+ <
+ty³Çme
+
+ gT
+>
+
+1104 \18
+ gT
+&
+äame_\92\8cy
+(
+Add»ss
+
+»_äame
+, \12
+äame_off£t
+) {
+
+1105 \15
+ g»\9a\8b½»t_ÿ¡
+<
+ gT
+&>(
+ gMemÜy
+::
+\9at32_©
+(
+»_äame
+ +
+äame_off£t
+));
+
+1109 \12
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckS\8fckGu¬dS\8f\8b
+(
+Add»ss
+*
+»tuº_add»ss
+,
+
+1110
+Code
+*
+»_code
+,
+
+1111
+Add»ss
+
+»_äame
+) {
+
+1112
+Isީe
+*
+ gisީe
+ =
+äame_\92\8cy
+<Isީe*>(
+»_äame
+,
+ gkIsީe
+);
+
+1113
+S\8fckLim\99Check
+
+check
+(
+isީe
+);
+
+1114 ià(
+ gcheck
+.
+JsHasOv\94æowed
+()) {
+
+1115
+ gisީe
+->
+S\8fckOv\94æow
+();
+
+1116 \15
+ gEXCEPTION
+;
+
+1124 ià(
+ gäame_\92\8cy
+<\12>(
+ g»_äame
+,
+ gkD\9ceùC®l
+) == 1) {
+
+1125 \15
+RETRY
+;
+
+1129
+HªdËScÝe
+
+hªdËs
+(
+isީe
+);
+
+1130
+ gHªdË
+<
+ gCode
+>
+code_hªdË
+(
+»_code
+);
+
+1132
+ gHªdË
+<
+ gS\8c\9ag
+>
+subjeù
+(
+äame_\92\8cy
+<
+S\8c\9ag
+*>(
+»_äame
+,
+kIÅutS\8c\9ag
+));
+
+1135
+boÞ
+
+ gis_Úe_by\8b
+ =
+subjeù
+->
+IsOÃBy\8bR\95»£Á©iÚUnd\94éh
+();
+
+1137
+DCHECK
+(
+»_code
+->
+\9a¡ruùiÚ_¡¬t
+(è<ð*
+»tuº_add»ss
+);
+
+1138
+DCHECK
+(*
+»tuº_add»ss
+ <=
+
+1139
+»_code
+->
+\9a¡ruùiÚ_¡¬t
+(è+\84e_code->
+\9a¡ruùiÚ_size
+());
+
+1141
+Objeù
+*
+ g»suÉ
+ =
+isީe
+->
+¡ack_gu¬d
+()->
+HªdËIÁ\94ru±s
+();
+
+1143 ià(*
+ gcode_hªdË
+ !ð
+»_code
+) {
+
+1144
+\9a\8d\8c_t
+
+d\96\8f
+ =
+code_hªdË
+->
+add»ss
+(è-
+»_code
+->address();
+
+1146 *
+ g»tuº_add»ss
+ +ð
+d\96\8f
+;
+
+1149 ià(
+ g»suÉ
+->
+IsExû±iÚ
+()) {
+
+1150 \15
+ gEXCEPTION
+;
+
+1153
+ gHªdË
+<
+ gS\8c\9ag
+>
+ gsubjeù_tmp
+ =
+subjeù
+;
+
+1154 \12
+ g¦iû_off£t
+ = 0;
+
+1157 ià(
+S\8c\9agShe
+(*
+subjeù_tmp
+).
+IsCÚs
+()) {
+
+1158
+ gsubjeù_tmp
+ =
+HªdË
+<
+S\8c\9ag
+>(
+CÚsS\8c\9ag
+::
+ÿ¡
+(*
+subjeù_tmp
+)->
+f\9c¡
+());
+
+1159 } \vià(
+S\8c\9agShe
+(*
+subjeù_tmp
+).
+IsSliûd
+()) {
+
+1160
+SliûdS\8c\9ag
+*
+ g¦iû
+ = SliûdS\8c\9ag::
+ÿ¡
+(*
+subjeù_tmp
+);
+
+1161
+ gsubjeù_tmp
+ =
+HªdË
+<
+S\8c\9ag
+>(
+¦iû
+->
+·»Á
+());
+
+1162
+ g¦iû_off£t
+ =
+¦iû
+->
+off£t
+();
+
+1166 ià(
+ gsubjeù_tmp
+->
+IsOÃBy\8bR\95»£Á©iÚ
+(è!ð
+is_Úe_by\8b
+) {
+
+1170 \15
+RETRY
+;
+
+1177
+DCHECK
+(
+S\8c\9agShe
+(*
+subjeù_tmp
+).
+IsSequ\92t\9fl
+() ||
+
+1178
+S\8c\9agShe
+(*
+subjeù_tmp
+).
+IsEx\8bº®
+());
+
+1181 cڡ
+by\8b
+*
+ g¡¬t_add»ss
+ =
+äame_\92\8cy
+<cÚ¡ by\8b*>(
+»_äame
+,
+ gkIÅutS\8f¹
+);
+
+1185 \12
+ g¡¬t_\9adex
+ =
+äame_\92\8cy
+<
+\9a\8d\8c_t
+>(
+»_äame
+,
+ gkS\8f¹Index
+);
+
+1186 cڡ
+by\8b
+*
+ gÃw_add»ss
+ =
+
+1187
+S\8c\9agCh¬aù\94Pos\99iÚ
+(*
+subjeù_tmp
+,
+¡¬t_\9adex
+ +
+¦iû_off£t
+);
+
+1189 ià(
+ g¡¬t_add»ss
+ !ð
+Ãw_add»ss
+) {
+
+1192 cڡ
+by\8b
+*
+\92d_add»ss
+ =
+äame_\92\8cy
+<cÚ¡ by\8b*>(
+»_äame
+,
+ gkIÅutEnd
+);
+
+1193 \12
+ gby\8b_Ëngth
+ =
+¡©ic_ÿ¡
+<\12>(
+\92d_add»ss
+ -
+¡¬t_add»ss
+);
+
+1194
+ gäame_\92\8cy
+<cڡ
+ gS\8c\9ag
+*>(
+ g»_äame
+,
+ gkIÅutS\8c\9ag
+èð*
+subjeù
+;
+
+1195
+ gäame_\92\8cy
+<cڡ
+ gby\8b
+*>(
+ g»_äame
+,
+ gkIÅutS\8f¹
+èð
+Ãw_add»ss
+;
+
+1196
+ gäame_\92\8cy
+<cڡ
+ gby\8b
+*>(
+ g»_äame
+,
+ gkIÅutEnd
+èð
+Ãw_add»ss
+ +
+by\8b_Ëngth
+;
+
+1197 } \vià(
+ gäame_\92\8cy
+<cڡ
+ gS\8c\9ag
+*>(
+ g»_äame
+,
+ gkIÅutS\8c\9ag
+è!ð*
+subjeù
+) {
+
+1201
+äame_\92\8cy
+<cڡ
+S\8c\9ag
+*>(
+»_äame
+,
+kIÅutS\8c\9ag
+èð*
+subjeù
+;
+
+1208
+MemO³¿nd
+
+ gRegExpMaüoAs£mbËrPPC
+::
+»gi¡\94_loÿtiÚ
+(\12
+»gi¡\94_\9adex
+) {
+
+1209
+DCHECK
+(
+»gi¡\94_\9adex
+ < (1 << 30));
+
+1210 ià(
+ gnum_»gi¡\94s_
+ <ð
+»gi¡\94_\9adex
+) {
+
+1211
+num_»gi¡\94s_
+ =
+»gi¡\94_\9adex
+ + 1;
+
+1213 \15
+MemO³¿nd
+(
+äame_po\9a\8br
+(),
+
+1214
+kRegi¡\94Z\94o
+ -
+»gi¡\94_\9adex
+ *
+kPo\9a\8brSize
+);
+
+1218 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckPos\99iÚ
+(\12
+ý_off£t
+,
+
+1219
+Lab\96
+*
+Ú_outside_\9aput
+) {
+
+1220
+__
+
+Cmpi
+(
+cu¼\92t_\9aput_off£t
+(),
+O³¿nd
+(-
+ý_off£t
+ *
+ch¬_size
+()),
+r0
+);
+
+1221
+B¿nchOrBack\8cack
+(
+ge
+,
+Ú_outside_\9aput
+);
+
+1225 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+B¿nchOrBack\8cack
+(
+CÚd\99iÚ
+
+cÚd\99iÚ
+,
+Lab\96
+*
+to
+,
+
+1226
+CRegi¡\94
+
+ü
+) {
+
+1227 ià(
+ gcÚd\99iÚ
+ =ð
+®
+) {
+
+1228 ià(
+to
+ =ð
+NULL
+) {
+
+1229
+Back\8cack
+();
+
+1232
+__
+
+b
+(
+to
+);
+
+1235 ià(
+ gto
+ =ð
+NULL
+) {
+
+1236
+__
+
+b
+(
+cÚd\99iÚ
+, &
+back\8cack_Ïb\96_
+,
+ü
+);
+
+1239
+__
+
+b
+(
+cÚd\99iÚ
+,
+to
+,
+ü
+);
+
+1243 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+SaãC®l
+(
+Lab\96
+*
+to
+,
+CÚd\99iÚ
+
+cÚd
+,
+
+1244
+CRegi¡\94
+
+ü
+) {
+
+1245
+__
+
+b
+(
+cÚd
+,
+to
+,
+ü
+,
+S\91LK
+);
+
+1249 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+SaãR\91uº
+() {
+
+1250
+__
+
+pÝ
+(
+r0
+);
+
+1251
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+masm_
+->
+CodeObjeù
+()));
+
+1252
+__
+
+add
+(
+r0
+,\840,
+\9d
+);
+
+1253
+__
+
+m\8er
+(
+r0
+);
+
+1254
+__
+
+bÌ
+();
+
+1258 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+SaãC®lT¬g\91
+(
+Lab\96
+*
+Çme
+) {
+
+1259
+__
+
+b\9ad
+(
+Çme
+);
+
+1260
+__
+
+mær
+(
+r0
+);
+
+1261
+__
+
+mov
+(
+\9d
+,
+O³¿nd
+(
+masm_
+->
+CodeObjeù
+()));
+
+1262
+__
+
+sub
+(
+r0
+,\840,
+\9d
+);
+
+1263
+__
+
+push
+(
+r0
+);
+
+1267 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+Push
+(
+Regi¡\94
+
+sourû
+) {
+
+1268
+DCHECK
+(!
+sourû
+.
+is
+(
+back\8cack_¡ackpo\9a\8br
+()));
+
+1269
+__
+
+StÜePU
+(
+sourû
+,
+MemO³¿nd
+(
+back\8cack_¡ackpo\9a\8br
+(), -
+kPo\9a\8brSize
+));
+
+1273 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+PÝ
+(
+Regi¡\94
+
+\8frg\91
+) {
+
+1274
+DCHECK
+(!
+\8frg\91
+.
+is
+(
+back\8cack_¡ackpo\9a\8br
+()));
+
+1275
+__
+
+LßdP
+(
+\8frg\91
+,
+MemO³¿nd
+(
+back\8cack_¡ackpo\9a\8br
+()));
+
+1276
+__
+
+addi
+(
+back\8cack_¡ackpo\9a\8br
+(), backtrack_stackpointer(),
+
+1277
+O³¿nd
+(
+kPo\9a\8brSize
+));
+
+1281 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckP»em±iÚ
+() {
+
+1283
+Ex\8bº®Reã»nû
+
+¡ack_lim\99
+ =
+
+1284
+Ex\8bº®Reã»nû
+::
+add»ss_of_¡ack_lim\99
+(
+isީe
+());
+
+1285
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+¡ack_lim\99
+));
+
+1286
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(r3));
+
+1287
+__
+
+cm¶
+(
+¥
+,
+r3
+);
+
+1288
+SaãC®l
+(&
+check_´\93m±_Ïb\96_
+,
+Ë
+);
+
+1292 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+CheckS\8fckLim\99
+() {
+
+1293
+Ex\8bº®Reã»nû
+
+¡ack_lim\99
+ =
+
+1294
+Ex\8bº®Reã»nû
+::
+add»ss_of_»gexp_¡ack_lim\99
+(
+isީe
+());
+
+1295
+__
+
+mov
+(
+r3
+,
+O³¿nd
+(
+¡ack_lim\99
+));
+
+1296
+__
+
+LßdP
+(
+r3
+,
+MemO³¿nd
+(r3));
+
+1297
+__
+
+cm¶
+(
+back\8cack_¡ackpo\9a\8br
+(),
+r3
+);
+
+1298
+SaãC®l
+(&
+¡ack_ov\94æow_Ïb\96_
+,
+Ë
+);
+
+1302
+boÞ
+
+ gRegExpMaüoAs£mbËrPPC
+::
+CªR\97dUÇligÃd
+() {
+
+1303 \15
+CpuF\97tu»s
+::
+IsSuµÜ\8bd
+(
+UNALIGNED_ACCESSES
+è&& !
+¦ow_§ã
+();
+
+1307 \1e
+ gRegExpMaüoAs£mbËrPPC
+::
+LßdCu¼\92tCh¬aù\94Unchecked
+(\12
+ý_off£t
+,
+
+1308 \12
+ch¬aù\94s
+) {
+
+1309
+Regi¡\94
+
+ goff£t
+ =
+cu¼\92t_\9aput_off£t
+();
+
+1310 ià(
+ gý_off£t
+ != 0) {
+
+1312
+__
+
+addi
+(
+r25
+,
+cu¼\92t_\9aput_off£t
+(),
+O³¿nd
+(
+ý_off£t
+ *
+ch¬_size
+()));
+
+1313
+ goff£t
+ =
+r25
+;
+
+1320
+DCHECK
+(
+ch¬aù\94s
+ == 1);
+
+1321
+__
+
+add
+(
+cu¼\92t_ch¬aù\94
+(),
+\92d_of_\9aput_add»ss
+(),
+off£t
+);
+
+1322 ià(
+ gmode_
+ =ð
+LATIN1
+) {
+
+1323
+__
+
+lbz
+(
+cu¼\92t_ch¬aù\94
+(),
+MemO³¿nd
+(current_character()));
+
+1325
+DCHECK
+(
+mode_
+ =ð
+UC16
+);
+
+1326
+__
+
+lhz
+(
+cu¼\92t_ch¬aù\94
+(),
+MemO³¿nd
+(current_character()));
+
+1331 #undeà
+__
+
+
+ @regexp-macro-assembler-ppc.h
+
+5 #iâdeà
+V8_PPC_REGEXP_MACRO_ASSEMBLER_PPC_H_
+
+
+6 \ 1
+ #V8_PPC_REGEXP_MACRO_ASSEMBLER_PPC_H_
+
+
+ )
+
+8 \ 2
+ ~"¤c/maüo-as£mbËr.h
+"
+
+9 \ 2
+ ~"¤c/µc/as£mbËr-µc.h
+"
+
+10 \ 2
+ ~"¤c/µc/as£mbËr-µc-\9al.h
+"
+
+12
+Çme¥aû
+
+ gv8
+ {
+
+13
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+16 #iâdeà
+V8_INTERPRETED_REGEXP
+
+
+17 þas
+ cRegExpMaüoAs£mbËrPPC
+ :
+public
+
+N©iveRegExpMaüoAs£mbËr
+ {
+
+18
+public
+:
+
+19
+RegExpMaüoAs£mbËrPPC
+(
+Mode
+
+mode
+, \12
+»gi¡\94s_to_§ve
+,
+ZÚe
+*
+zÚe
+);
+
+20
+ gv\9ctu®
+ ~
+RegExpMaüoAs£mbËrPPC
+();
+
+21
+v\9ctu®
+ \12
+¡ack_lim\99_¦ack
+();
+
+22
+v\9ctu®
+ \1e
+AdvªûCu¼\92tPos\99iÚ
+(\12
+by
+);
+
+23
+v\9ctu®
+ \1e
+AdvªûRegi¡\94
+(\12
+»g
+, \12
+by
+);
+
+24
+v\9ctu®
+ \1e
+Back\8cack
+();
+
+25
+v\9ctu®
+ \1e
+B\9ad
+(
+Lab\96
+*
+Ïb\96
+);
+
+26
+v\9ctu®
+ \1e
+CheckAtS\8f¹
+(
+Lab\96
+*
+Ú_©_¡¬t
+);
+
+27
+v\9ctu®
+ \1e
+CheckCh¬aù\94
+(\1d
+c
+,
+Lab\96
+*
+Ú_equ®
+);
+
+28
+v\9ctu®
+ \1e
+CheckCh¬aù\94Aá\94And
+(\1d
+c
+, \1d
+mask
+,
+
+29
+Lab\96
+*
+Ú_equ®
+);
+
+30
+v\9ctu®
+ \1e
+CheckCh¬aù\94GT
+(
+uc16
+
+lim\99
+,
+Lab\96
+*
+Ú_g»©\94
+);
+
+31
+v\9ctu®
+ \1e
+CheckCh¬aù\94LT
+(
+uc16
+
+lim\99
+,
+Lab\96
+*
+Ú_Ëss
+);
+
+34
+v\9ctu®
+ \1e
+CheckG»edyLoÝ
+(
+Lab\96
+*
+Ú_tos_equ®s_cu¼\92t_pos\99iÚ
+);
+
+35
+v\9ctu®
+ \1e
+CheckNÙAtS\8f¹
+(
+Lab\96
+*
+Ú_nÙ_©_¡¬t
+);
+
+36
+v\9ctu®
+ \1e
+CheckNÙBackReã»nû
+(\12
+¡¬t_»g
+,
+Lab\96
+*
+Ú_no_m©ch
+);
+
+37
+v\9ctu®
+ \1e
+CheckNÙBackReã»nûIgnÜeCa£
+(\12
+¡¬t_»g
+,
+
+38
+Lab\96
+*
+Ú_no_m©ch
+);
+
+39
+v\9ctu®
+ \1e
+CheckNÙCh¬aù\94
+(\1d
+c
+,
+Lab\96
+*
+Ú_nÙ_equ®
+);
+
+40
+v\9ctu®
+ \1e
+CheckNÙCh¬aù\94Aá\94And
+(\1d
+c
+, \1d
+mask
+,
+
+41
+Lab\96
+*
+Ú_nÙ_equ®
+);
+
+42
+v\9ctu®
+ \1e
+CheckNÙCh¬aù\94Aá\94M\9ausAnd
+(
+uc16
+
+c
+, uc16
+m\9aus
+, uc16
+mask
+,
+
+43
+Lab\96
+*
+Ú_nÙ_equ®
+);
+
+44
+v\9ctu®
+ \1e
+CheckCh¬aù\94InRªge
+(
+uc16
+
+äom
+, uc16
+to
+,
+Lab\96
+*
+Ú_\9a_¿nge
+);
+
+45
+v\9ctu®
+ \1e
+CheckCh¬aù\94NÙInRªge
+(
+uc16
+
+äom
+, uc16
+to
+,
+
+46
+Lab\96
+*
+Ú_nÙ_\9a_¿nge
+);
+
+47
+v\9ctu®
+ \1e
+CheckB\99InTabË
+(
+HªdË
+<
+By\8bA¼ay
+>
+\8fbË
+,
+Lab\96
+*
+Ú_b\99_£t
+);
+
+51
+v\9ctu®
+ \1e
+CheckPos\99iÚ
+(\12
+ý_off£t
+,
+Lab\96
+*
+Ú_outside_\9aput
+);
+
+52
+v\9ctu®
+
+boÞ
+
+CheckS³c\9flCh¬aù\94CÏss
+(
+uc16
+
+ty³
+,
+Lab\96
+*
+Ú_no_m©ch
+);
+
+53
+v\9ctu®
+ \1e
+Fa\9e
+();
+
+54
+v\9ctu®
+
+ gHªdË
+<
+ gH\97pObjeù
+>
+G\91Code
+(
+HªdË
+<
+S\8c\9ag
+>
+sourû
+);
+
+55
+v\9ctu®
+ \1e
+GoTo
+(
+Lab\96
+*
+Ïb\96
+);
+
+56
+v\9ctu®
+ \1e
+IfRegi¡\94GE
+(\12
+»g
+, \12
+com·¿nd
+,
+Lab\96
+*
+if_ge
+);
+
+57
+v\9ctu®
+ \1e
+IfRegi¡\94LT
+(\12
+»g
+, \12
+com·¿nd
+,
+Lab\96
+*
+if_É
+);
+
+58
+v\9ctu®
+ \1e
+IfRegi¡\94EqPos
+(\12
+»g
+,
+Lab\96
+*
+if_eq
+);
+
+59
+v\9ctu®
+
+I¼egexpIm¶em\92\8ftiÚ
+
+Im¶em\92\8ftiÚ
+();
+
+60
+v\9ctu®
+ \1e
+LßdCu¼\92tCh¬aù\94
+(\12
+ý_off£t
+,
+Lab\96
+*
+Ú_\92d_of_\9aput
+,
+
+61
+boÞ
+
+check_bounds
+ =
+\8cue
+,
+
+62 \12
+ch¬aù\94s
+ = 1);
+
+63
+v\9ctu®
+ \1e
+PÝCu¼\92tPos\99iÚ
+();
+
+64
+v\9ctu®
+ \1e
+PÝRegi¡\94
+(\12
+»gi¡\94_\9adex
+);
+
+65
+v\9ctu®
+ \1e
+PushBack\8cack
+(
+Lab\96
+*
+Ïb\96
+);
+
+66
+v\9ctu®
+ \1e
+PushCu¼\92tPos\99iÚ
+();
+
+67
+v\9ctu®
+ \1e
+PushRegi¡\94
+(\12
+»gi¡\94_\9adex
+,
+
+68
+S\8fckCheckFÏg
+
+check_¡ack_lim\99
+);
+
+69
+v\9ctu®
+ \1e
+R\97dCu¼\92tPos\99iÚFromRegi¡\94
+(\12
+»g
+);
+
+70
+v\9ctu®
+ \1e
+R\97dS\8fckPo\9a\8brFromRegi¡\94
+(\12
+»g
+);
+
+71
+v\9ctu®
+ \1e
+S\91Cu¼\92tPos\99iÚFromEnd
+(\12
+by
+);
+
+72
+v\9ctu®
+ \1e
+S\91Regi¡\94
+(\12
+»gi¡\94_\9adex
+, \12
+to
+);
+
+73
+v\9ctu®
+
+boÞ
+
+Sucûed
+();
+
+74
+v\9ctu®
+ \1e
+Wr\99eCu¼\92tPos\99iÚToRegi¡\94
+(\12
+»g
+, \12
+ý_off£t
+);
+
+75
+v\9ctu®
+ \1e
+CˬRegi¡\94s
+(\12
+»g_äom
+, \12
+»g_to
+);
+
+76
+v\9ctu®
+ \1e
+Wr\99eS\8fckPo\9a\8brToRegi¡\94
+(\12
+»g
+);
+
+77
+v\9ctu®
+
+boÞ
+
+CªR\97dUÇligÃd
+();
+
+82 \18\12
+CheckS\8fckGu¬dS\8f\8b
+(
+Add»ss
+*
+»tuº_add»ss
+,
+Code
+*
+»_code
+,
+
+83
+Add»ss
+
+»_äame
+);
+
+85
+ g´iv©e
+:
+
+87 \18cڡ \12
+kF¿mePo\9a\8br
+ = 0;
+
+91 \18cڡ \12
+ gkStÜedRegi¡\94s
+ =
+kF¿mePo\9a\8br
+;
+
+93 \18cڡ \12
+ gkR\91uºAdd»ss
+ =
+kStÜedRegi¡\94s
+ + 7 *
+kPo\9a\8brSize
+;
+
+94 \18cڡ \12
+ gkC®ËrF¿me
+ =
+kR\91uºAdd»ss
+ +
+kPo\9a\8brSize
+;
+
+96 \18cڡ \12
+ gkSecÚd¬yR\91uºAdd»ss
+ =
+
+97
+kC®ËrF¿me
+ +
+kS\8fckF¿meEx\8caP¬amSlÙ
+ *
+kPo\9a\8brSize
+;
+
+98 \18cڡ \12
+ gkIsީe
+ =
+kSecÚd¬yR\91uºAdd»ss
+ +
+kPo\9a\8brSize
+;
+
+102 \18cڡ \12
+ gkD\9ceùC®l
+ =
+kF¿mePo\9a\8br
+ -
+kPo\9a\8brSize
+;
+
+103 \18cڡ \12
+ gkS\8fckHighEnd
+ =
+kD\9ceùC®l
+ -
+kPo\9a\8brSize
+;
+
+104 \18cڡ \12
+ gkNumOu\8dutRegi¡\94s
+ =
+kS\8fckHighEnd
+ -
+kPo\9a\8brSize
+;
+
+105 \18cڡ \12
+ gkRegi¡\94Ou\8dut
+ =
+kNumOu\8dutRegi¡\94s
+ -
+kPo\9a\8brSize
+;
+
+106 \18cڡ \12
+ gkIÅutEnd
+ =
+kRegi¡\94Ou\8dut
+ -
+kPo\9a\8brSize
+;
+
+107 \18cڡ \12
+ gkIÅutS\8f¹
+ =
+kIÅutEnd
+ -
+kPo\9a\8brSize
+;
+
+108 \18cڡ \12
+ gkS\8f¹Index
+ =
+kIÅutS\8f¹
+ -
+kPo\9a\8brSize
+;
+
+109 \18cڡ \12
+ gkIÅutS\8c\9ag
+ =
+kS\8f¹Index
+ -
+kPo\9a\8brSize
+;
+
+112 \18cڡ \12
+ gkSucûssfulCtu»s
+ =
+kIÅutS\8c\9ag
+ -
+kPo\9a\8brSize
+;
+
+113 \18cڡ \12
+ gkIÅutS\8f¹M\9ausOÃ
+ =
+kSucûssfulCtu»s
+ -
+kPo\9a\8brSize
+;
+
+115 \18cڡ \12
+ gkRegi¡\94Z\94o
+ =
+kIÅutS\8f¹M\9ausOÃ
+ -
+kPo\9a\8brSize
+;
+
+118 \18cڡ
+size_t
+
+ gkRegExpCodeSize
+ = 1024;
+
+122 \1e
+LßdCu¼\92tCh¬aù\94Unchecked
+(\12
+ý_off£t
+, \12
+ch¬aù\94_couÁ
+);
+
+125 \1e
+CheckP»em±iÚ
+();
+
+128 \1e
+CheckS\8fckLim\99
+();
+
+132 \1e
+C®lCheckS\8fckGu¬dS\8f\8b
+(
+Regi¡\94
+
+sü©ch
+);
+
+135
+MemO³¿nd
+
+»gi¡\94_loÿtiÚ
+(\12
+»gi¡\94_\9adex
+);
+
+139
+\9al\9ae
+
+Regi¡\94
+
+cu¼\92t_\9aput_off£t
+(è{ \15
+ gr27
+; }
+
+142
+\9al\9ae
+
+Regi¡\94
+
+cu¼\92t_ch¬aù\94
+(è{ \15
+ gr28
+; }
+
+145
+\9al\9ae
+
+Regi¡\94
+
+\92d_of_\9aput_add»ss
+(è{ \15
+ gr30
+; }
+
+149
+\9al\9ae
+
+Regi¡\94
+
+äame_po\9a\8br
+(è{ \15
+ gå
+; }
+
+153
+\9al\9ae
+
+Regi¡\94
+
+back\8cack_¡ackpo\9a\8br
+(è{ \15
+ gr29
+; }
+
+156
+\9al\9ae
+
+Regi¡\94
+
+code_po\9a\8br
+(è{ \15
+ gr26
+; }
+
+159
+\9al\9ae
+ \12
+ch¬_size
+(è{ \15
+ g¡©ic_ÿ¡
+<\12>(
+ gmode_
+); }
+
+163 \1e
+B¿nchOrBack\8cack
+(
+CÚd\99iÚ
+
+cÚd\99iÚ
+,
+Lab\96
+*
+to
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+167
+\9al\9ae
+ \1e
+SaãC®l
+(
+Lab\96
+*
+to
+,
+CÚd\99iÚ
+
+cÚd
+ =
+®
+,
+CRegi¡\94
+
+ü
+ =
+ü7
+);
+
+168
+\9al\9ae
+ \1e
+SaãR\91uº
+();
+
+169
+\9al\9ae
+ \1e
+SaãC®lT¬g\91
+(
+Lab\96
+*
+Çme
+);
+
+173
+\9al\9ae
+ \1e
+Push
+(
+Regi¡\94
+
+sourû
+);
+
+177
+\9al\9ae
+ \1e
+PÝ
+(
+Regi¡\94
+
+\8frg\91
+);
+
+179
+Isީe
+*
+isީe
+(ècÚ¡ { \15
+ gmasm_
+->isolate(); }
+
+181
+MaüoAs£mbËr
+*
+ gmasm_
+;
+
+184
+Mode
+
+ gmode_
+;
+
+187 \12
+ gnum_»gi¡\94s_
+;
+
+191 \12
+ gnum_§ved_»gi¡\94s_
+;
+
+194
+Lab\96
+
+ g\92\8cy_Ïb\96_
+;
+
+195
+Lab\96
+
+ g¡¬t_Ïb\96_
+;
+
+196
+Lab\96
+
+ gsucûss_Ïb\96_
+;
+
+197
+Lab\96
+
+ gback\8cack_Ïb\96_
+;
+
+198
+Lab\96
+
+ gex\99_Ïb\96_
+;
+
+199
+Lab\96
+
+ gcheck_´\93m±_Ïb\96_
+;
+
+200
+Lab\96
+
+ g¡ack_ov\94æow_Ïb\96_
+;
+
+201
+Lab\96
+
+ g\9a\8bº®_ç\9eu»_Ïb\96_
+;
+
+205 cڡ
+RegLi¡
+
+ gkRegExpC®ËeSaved
+ =
+
+ @simulator-ppc.cc
+
+5 \ 2
+ ~<¡d¬g.h
+>
+
+6 \ 2
+ ~<¡dlib.h
+>
+
+7 \ 2
+ ~<cm©h
+>
+
+9 \ 2
+ ~"¤c/v8.h
+"
+
+11 #ià
+V8_TARGET_ARCH_PPC
+
+
+13 \ 2
+ ~"¤c/as£mbËr.h
+"
+
+14 \ 2
+ ~"¤c/codeg\92.h
+"
+
+15 \ 2
+ ~"¤c/di§sm.h
+"
+
+16 \ 2
+ ~"¤c/µc/cÚ¡ªts-µc.h
+"
+
+17 \ 2
+ ~"¤c/µc/äames-µc.h
+"
+
+18 \ 2
+ ~"¤c/µc/simuÏtÜ-µc.h
+"
+
+20 #ià
+def\9aed
+(
+USE_SIMULATOR
+)
+
+23
+Çme¥aû
+
+ gv8
+ {
+
+24
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+30 \ 1
+ #SSÿnF
+
+ssÿnf
+
+
+31
+
+ )
+
+34 þas
+ cPPCDebugg\94
+ {
+
+35
+ gpublic
+:
+
+36
+ex¶ic\99
+
+PPCDebugg\94
+(
+SimuÏtÜ
+*
+sim
+è:
+sim_
+(sim) {}
+
+37 ~
+PPCDebugg\94
+();
+
+39 \1e
+StÝ
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+40 \1e
+Info
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+41 \1e
+Debug
+();
+
+43
+ g´iv©e
+:
+
+44 \18cڡ
+In¡r
+
+kB»akpo\9atIn¡r
+ = (
+TWI
+ | 0x1à*
+B21
+);
+
+45 \18cڡ
+In¡r
+
+ gkNÝIn¡r
+ = (
+ORI
+);
+
+47
+SimuÏtÜ
+*
+ gsim_
+;
+
+49
+\9a\8d\8c_t
+
+G\91Regi¡\94V®ue
+(\12
+»gnum
+);
+
+50 \b
+G\91Regi¡\94Pa\9cDoubËV®ue
+(\12
+»gnum
+);
+
+51 \b
+G\91FPDoubËRegi¡\94V®ue
+(\12
+»gnum
+);
+
+52
+boÞ
+
+G\91V®ue
+(cڡ \ 5*
+desc
+,
+\9a\8d\8c_t
+*
+v®ue
+);
+
+53
+boÞ
+
+G\91FPDoubËV®ue
+(cڡ \ 5*
+desc
+, \b*
+v®ue
+);
+
+56
+boÞ
+
+S\91B»akpo\9at
+(
+In¡ruùiÚ
+*
+b»ak_pc
+);
+
+57
+boÞ
+
+D\96\91eB»akpo\9at
+(
+In¡ruùiÚ
+*
+b»ak_pc
+);
+
+61 \1e
+UndoB»akpo\9ats
+();
+
+62 \1e
+RedoB»akpo\9ats
+();
+
+66
+ gPPCDebugg\94
+::~
+PPCDebugg\94
+() {}
+
+69 #ifdeà
+GENERATED_CODE_COVERAGE
+
+
+70 \18
+FILE
+*
+cov\94age_log
+ =
+NULL
+;
+
+73 \18\1e
+In\99\9flizeCov\94age
+() {
+
+74 \ 5*
+ gf\9ee_Çme
+ =
+g\91\92v
+("V8_GENERATED_CODE_COVERAGE_LOG");
+
+75 ià(
+ gf\9ee_Çme
+ !ð
+NULL
+) {
+
+76
+cov\94age_log
+ =
+fݒ
+(
+f\9ee_Çme
+, "aw+");
+
+81 \1e
+ gPPCDebugg\94
+::
+StÝ
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+83
+u\9at32_t
+
+code
+ =
+\9a¡r
+->
+SvcV®ue
+(è&
+kStÝCodeMask
+;
+
+85 \ 5**
+ gmsg_add»ss
+ =
+
+86
+»\9a\8b½»t_ÿ¡
+<\ 5**>(
+sim_
+->
+g\91_pc
+(è+
+In¡ruùiÚ
+::
+kIn¡rSize
+);
+
+87 \ 5*
+ gmsg
+ = *
+msg_add»ss
+;
+
+88
+DCHECK
+(
+msg
+ !ð
+NULL
+);
+
+91 ià(
+isW©chedStÝ
+(
+code
+è&& !
+ gw©ched_¡Ýs_
+[code].
+ gdesc
+) {
+
+92
+ gw©ched_¡Ýs_
+[
+code
+].
+ gdesc
+ =
+msg
+;
+
+95 ià(
+¡¾\92
+(
+msg
+) > 0) {
+
+96 ià(
+ gcov\94age_log
+ !ð
+NULL
+) {
+
+97
+år\9atf
+(
+cov\94age_log
+, "%s\n",
+msg
+);
+
+98
+fæush
+(
+cov\94age_log
+);
+
+101
+ g\9a¡r
+->
+S\91In¡ruùiÚB\99s
+(
+kNÝIn¡r
+);
+
+102
+ g»\9a\8b½»t_ÿ¡
+<
+ gIn¡ruùiÚ
+*>(
+ gmsg_add»ss
+)->
+S\91In¡ruùiÚB\99s
+(
+kNÝIn¡r
+);
+
+104
+ gsim_
+->
+£t_pc
+(
+sim_
+->
+g\91_pc
+(è+
+In¡ruùiÚ
+::
+kIn¡rSize
+ +
+kPo\9a\8brSize
+);
+
+109 \18\1e
+In\99\9flizeCov\94age
+() {}
+
+112 \1e
+ gPPCDebugg\94
+::
+StÝ
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+115
+u\9at32_t
+
+code
+ =
+\9a¡r
+->
+SvcV®ue
+(è&
+kStÝCodeMask
+;
+
+117 \ 5*
+ gmsg
+ =
+
+118 *
+»\9a\8b½»t_ÿ¡
+<\ 5**>(
+sim_
+->
+g\91_pc
+(è+
+In¡ruùiÚ
+::
+kIn¡rSize
+);
+
+120 ià(
+ gsim_
+->
+isW©chedStÝ
+(
+code
+è&& !sim_->
+ gw©ched_¡Ýs_
+[code].
+ gdesc
+) {
+
+121
+ gsim_
+->
+ gw©ched_¡Ýs_
+[
+code
+].
+ gdesc
+ =
+msg
+;
+
+124 ià(
+ gcode
+ !ð
+kMaxStÝCode
+) {
+
+125
+Pr\9atF
+("SimuÏtÜ h\99 stÝ %u: %s\n",
+code
+,
+msg
+);
+
+127
+Pr\9atF
+("SimuÏtÜ h\99 %s\n",
+msg
+);
+
+129
+ gsim_
+->
+£t_pc
+(
+sim_
+->
+g\91_pc
+(è+
+In¡ruùiÚ
+::
+kIn¡rSize
+ +
+kPo\9a\8brSize
+);
+
+130
+Debug
+();
+
+135 \1e
+ gPPCDebugg\94
+::
+Info
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+137 \ 5*
+msg
+ =
+
+138 *
+»\9a\8b½»t_ÿ¡
+<\ 5**>(
+sim_
+->
+g\91_pc
+(è+
+In¡ruùiÚ
+::
+kIn¡rSize
+);
+
+139
+Pr\9atF
+("SimuÏtÜ infØ%s\n",
+msg
+);
+
+140
+ gsim_
+->
+£t_pc
+(
+sim_
+->
+g\91_pc
+(è+
+In¡ruùiÚ
+::
+kIn¡rSize
+ +
+kPo\9a\8brSize
+);
+
+144
+\9a\8d\8c_t
+
+ gPPCDebugg\94
+::
+G\91Regi¡\94V®ue
+(\12
+»gnum
+) {
+
+145 \15
+sim_
+->
+g\91_»gi¡\94
+(
+»gnum
+);
+
+149 \b
+ gPPCDebugg\94
+::
+G\91Regi¡\94Pa\9cDoubËV®ue
+(\12
+»gnum
+) {
+
+150 \15
+sim_
+->
+g\91_doubË_äom_»gi¡\94_·\9c
+(
+»gnum
+);
+
+154 \b
+ gPPCDebugg\94
+::
+G\91FPDoubËRegi¡\94V®ue
+(\12
+»gnum
+) {
+
+155 \15
+sim_
+->
+g\91_doubË_äom_d_»gi¡\94
+(
+»gnum
+);
+
+159
+boÞ
+
+ gPPCDebugg\94
+::
+G\91V®ue
+(cڡ \ 5*
+desc
+,
+\9a\8d\8c_t
+*
+v®ue
+) {
+
+160 \12
+ g»gnum
+ =
+Regi¡\94s
+::
+Numb\94
+(
+desc
+);
+
+161 ià(
+ g»gnum
+ !ð
+kNoRegi¡\94
+) {
+
+162 *
+v®ue
+ =
+G\91Regi¡\94V®ue
+(
+»gnum
+);
+
+163 \15
+ g\8cue
+;
+
+165 ià(
+¡ºcmp
+(
+desc
+, "0x", 2) == 0) {
+
+166 \15
+SSÿnF
+(
+desc
+ + 2, "%"
+V8PRIxPTR
+,
+
+167
+»\9a\8b½»t_ÿ¡
+<
+u\9a\8d\8c_t
+*>(
+v®ue
+)) == 1;
+
+169 \15
+SSÿnF
+(
+desc
+, "%"
+V8PRIuPTR
+,
+»\9a\8b½»t_ÿ¡
+<
+u\9a\8d\8c_t
+*>(
+v®ue
+)) ==
+
+173 \15
+ gçl£
+;
+
+177
+boÞ
+
+ gPPCDebugg\94
+::
+G\91FPDoubËV®ue
+(cڡ \ 5*
+desc
+, \b*
+v®ue
+) {
+
+178 \12
+ g»gnum
+ =
+FPRegi¡\94s
+::
+Numb\94
+(
+desc
+);
+
+179 ià(
+ g»gnum
+ !ð
+kNoRegi¡\94
+) {
+
+180 *
+v®ue
+ =
+sim_
+->
+g\91_doubË_äom_d_»gi¡\94
+(
+»gnum
+);
+
+181 \15
+ g\8cue
+;
+
+183 \15
+ gçl£
+;
+
+187
+boÞ
+
+ gPPCDebugg\94
+::
+S\91B»akpo\9at
+(
+In¡ruùiÚ
+*
+b»ak_pc
+) {
+
+189 ià(
+sim_
+->
+b»ak_pc_
+ !ð
+NULL
+) {
+
+190 \15
+çl£
+;
+
+194
+ gsim_
+->
+ gb»ak_pc_
+ =
+b»ak_pc
+;
+
+195
+ gsim_
+->
+ gb»ak_\9a¡r_
+ =
+b»ak_pc
+->
+In¡ruùiÚB\99s
+();
+
+198 \15
+ g\8cue
+;
+
+202
+boÞ
+
+ gPPCDebugg\94
+::
+D\96\91eB»akpo\9at
+(
+In¡ruùiÚ
+*
+b»ak_pc
+) {
+
+203 ià(
+sim_
+->
+b»ak_pc_
+ !ð
+NULL
+) {
+
+204
+sim_
+->
+b»ak_pc_
+->
+S\91In¡ruùiÚB\99s
+(sim_->
+b»ak_\9a¡r_
+);
+
+207
+ gsim_
+->
+ gb»ak_pc_
+ =
+NULL
+;
+
+208
+ gsim_
+->
+ gb»ak_\9a¡r_
+ = 0;
+
+209 \15
+ g\8cue
+;
+
+213 \1e
+ gPPCDebugg\94
+::
+UndoB»akpo\9ats
+() {
+
+214 ià(
+sim_
+->
+b»ak_pc_
+ !ð
+NULL
+) {
+
+215
+sim_
+->
+b»ak_pc_
+->
+S\91In¡ruùiÚB\99s
+(sim_->
+b»ak_\9a¡r_
+);
+
+220 \1e
+ gPPCDebugg\94
+::
+RedoB»akpo\9ats
+() {
+
+221 ià(
+sim_
+->
+b»ak_pc_
+ !ð
+NULL
+) {
+
+222
+sim_
+->
+b»ak_pc_
+->
+S\91In¡ruùiÚB\99s
+(
+kB»akpo\9atIn¡r
+);
+
+227 \1e
+ gPPCDebugg\94
+::
+Debug
+() {
+
+228
+\9a\8d\8c_t
+
+ϡ_pc
+ = -1;
+
+229
+boÞ
+
+ gdÚe
+ =
+çl£
+;
+
+231 \ 1
+ #COMMAND_SIZE
+ 63
+
+ )
+
+232 \ 1
+ #ARG_SIZE
+ 255
+
+ )
+
+234 \ 1
+ #STR
+(
+a
+è#a
+
+ )
+
+235 \ 1
+ #XSTR
+(
+a
+è
+ `STR
+×)
+
+ )
+
+237 \ 5
+ gcmd
+[
+COMMAND_SIZE
+ + 1];
+
+238 \ 5
+ g¬g1
+[
+ARG_SIZE
+ + 1];
+
+239 \ 5
+ g¬g2
+[
+ARG_SIZE
+ + 1];
+
+240 \ 5*
+ g¬gv
+[3] = {
+cmd
+,
+¬g1
+,
+¬g2
+};
+
+243
+ gcmd
+[
+COMMAND_SIZE
+] = 0;
+
+244
+ g¬g1
+[
+ARG_SIZE
+] = 0;
+
+245
+ g¬g2
+[
+ARG_SIZE
+] = 0;
+
+249
+UndoB»akpo\9ats
+();
+
+251
+boÞ
+
+ g\8caû
+ = ::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+;
+
+252 ::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+ =
+çl£
+;
+
+254 \1f!
+ gdÚe
+ && !
+ gsim_
+->
+has_bad_pc
+()) {
+
+255 ià(
+ gϡ_pc
+ !ð
+sim_
+->
+g\91_pc
+()) {
+
+256
+di§sm
+::
+NameCÚv\94\8br
+
+cÚv\94\8br
+;
+
+257
+ gdi§sm
+::
+Di§s£mbËr
+
+dasm
+(
+cÚv\94\8br
+);
+
+259
+ gv8
+::
+\9a\8bº®
+::
+EmbeddedVeùÜ
+<\ 5, 256>
+ gbufãr
+;
+
+260
+ gdasm
+.
+In¡ruùiÚDecode
+(
+bufãr
+,
+»\9a\8b½»t_ÿ¡
+<
+by\8b
+*>(
+sim_
+->
+g\91_pc
+()));
+
+261
+Pr\9atF
+(" 0x%08"
+V8PRIxPTR
+ " %s\n",
+sim_
+->
+g\91_pc
+(),
+bufãr
+.
+¡¬t
+());
+
+262
+ gϡ_pc
+ =
+sim_
+->
+g\91_pc
+();
+
+264 \ 5*
+ gl\9ae
+ =
+R\97dL\9ae
+("sim> ");
+
+265 ià(
+ gl\9ae
+ =ð
+NULL
+) {
+
+268 \ 5*
+ gϡ_\9aput
+ =
+sim_
+->
+Ï¡_debugg\94_\9aput
+();
+
+269 ià(
+¡rcmp
+(
+l\9ae
+, "\n"è=ð0 &&
+Ï¡_\9aput
+ !ð
+NULL
+) {
+
+270
+l\9ae
+ =
+Ï¡_\9aput
+;
+
+273
+ gsim_
+->
+£t_Ï¡_debugg\94_\9aput
+(
+l\9ae
+);
+
+277 \12
+ g¬gc
+ =
+SSÿnF
+(
+l\9ae
+,
+
+278 "%"
+XSTR
+(
+COMMAND_SIZE
+) "s "
+
+279 "%"
+XSTR
+(
+ARG_SIZE
+) "s "
+
+280 "%"
+XSTR
+(
+ARG_SIZE
+) "s",
+
+281
+cmd
+,
+¬g1
+,
+¬g2
+);
+
+282 ià((
+¡rcmp
+(
+cmd
+, "si") == 0) || (strcmp(cmd, "stepi") == 0)) {
+
+283
+\9a\8d\8c_t
+
+v®ue
+;
+
+286 ià((
+ g»\9a\8b½»t_ÿ¡
+<
+ gIn¡ruùiÚ
+*>(
+ gsim_
+->
+g\91_pc
+()))
+
+287 ->
+In¡ruùiÚB\99s
+() == 0x7d821008) {
+
+288
+sim_
+->
+£t_pc
+(sim_->
+g\91_pc
+(è+
+In¡ruùiÚ
+::
+kIn¡rSize
+);
+
+290
+ gsim_
+->
+Execu\8bIn¡ruùiÚ
+(
+
+291
+»\9a\8b½»t_ÿ¡
+<
+In¡ruùiÚ
+*>(
+sim_
+->
+g\91_pc
+()));
+
+294 ià(
+ g¬gc
+ =ð2 &&
+ϡ_pc
+ !ð
+sim_
+->
+g\91_pc
+(è&&
+G\91V®ue
+(
+¬g1
+, &
+v®ue
+)) {
+
+295 \ f\12
+ gi
+ = 1; i <
+ gv®ue
+; i++) {
+
+296
+ gdi§sm
+::
+NameCÚv\94\8br
+
+cÚv\94\8br
+;
+
+297
+ gdi§sm
+::
+Di§s£mbËr
+
+dasm
+(
+cÚv\94\8br
+);
+
+299
+ gv8
+::
+\9a\8bº®
+::
+EmbeddedVeùÜ
+<\ 5, 256>
+ gbufãr
+;
+
+300
+ gdasm
+.
+In¡ruùiÚDecode
+(
+bufãr
+,
+
+301
+»\9a\8b½»t_ÿ¡
+<
+by\8b
+*>(
+sim_
+->
+g\91_pc
+()));
+
+302
+Pr\9atF
+(" 0x%08"
+V8PRIxPTR
+ " %s\n",
+sim_
+->
+g\91_pc
+(),
+
+303
+bufãr
+.
+¡¬t
+());
+
+304
+ gsim_
+->
+Execu\8bIn¡ruùiÚ
+(
+
+305
+»\9a\8b½»t_ÿ¡
+<
+In¡ruùiÚ
+*>(
+sim_
+->
+g\91_pc
+()));
+
+308 } \vià((
+¡rcmp
+(
+cmd
+, "c") == 0) || (strcmp(cmd, "cont") == 0)) {
+
+310 ià((
+»\9a\8b½»t_ÿ¡
+<
+In¡ruùiÚ
+*>(
+sim_
+->
+g\91_pc
+()))
+
+311 ->
+In¡ruùiÚB\99s
+() == 0x7d821008) {
+
+312
+sim_
+->
+£t_pc
+(sim_->
+g\91_pc
+(è+
+In¡ruùiÚ
+::
+kIn¡rSize
+);
+
+315
+ gsim_
+->
+Execu\8bIn¡ruùiÚ
+(
+
+316
+»\9a\8b½»t_ÿ¡
+<
+In¡ruùiÚ
+*>(
+sim_
+->
+g\91_pc
+()));
+
+319
+ gdÚe
+ =
+\8cue
+;
+
+320 } \vià((
+¡rcmp
+(
+cmd
+, "p") == 0) || (strcmp(cmd, "print") == 0)) {
+
+321 ià(
+¬gc
+ =ð2 || (¬gø=ð3 &&
+¡rcmp
+(
+¬g2
+, "fp") == 0)) {
+
+322
+\9a\8d\8c_t
+
+v®ue
+;
+
+323 \b
+ gdv®ue
+;
+
+324 ià(
+¡rcmp
+(
+¬g1
+, "all") == 0) {
+
+325 \ f\12
+i
+ = 0;
+ gi
+ <
+ gkNumRegi¡\94s
+; i++) {
+
+326
+ gv®ue
+ =
+G\91Regi¡\94V®ue
+(
+i
+);
+
+327
+Pr\9atF
+(" %3s: %08"
+V8PRIxPTR
+,
+Regi¡\94s
+::
+Name
+(
+i
+),
+v®ue
+);
+
+328 ià((
+ g¬gc
+ =ð3 &&
+¡rcmp
+(
+¬g2
+, "å"è=ð0è&&
+i
+ < 8 &&
+
+329 (
+i
+ % 2) == 0) {
+
+330
+dv®ue
+ =
+G\91Regi¡\94Pa\9cDoubËV®ue
+(
+i
+);
+
+331
+Pr\9atF
+(" (%f)\n",
+dv®ue
+);
+
+332 } \vià(
+ gi
+ !ð0 && !((
+i
+ + 1) & 3)) {
+
+333
+Pr\9atF
+("\n");
+
+336
+Pr\9atF
+("\85c: %08"
+V8PRIxPTR
+ "\86r: %08" V8PRIxPTR
+
+338 "ùr: %08"
+V8PRIxPTR
+ " xer: %08x cr: %08x\n",
+
+339
+sim_
+->
+¥ec\9fl_»g_pc_
+, sim_->
+¥ec\9fl_»g_Ì_
+,
+
+340
+sim_
+->
+¥ec\9fl_»g_ùr_
+, sim_->
+¥ec\9fl_»g_x\94_
+,
+
+341
+sim_
+->
+cÚd\99iÚ_»g_
+);
+
+342 } \vià(
+¡rcmp
+(
+¬g1
+, "alld") == 0) {
+
+343 \ f\12
+i
+ = 0;
+ gi
+ <
+ gkNumRegi¡\94s
+; i++) {
+
+344
+ gv®ue
+ =
+G\91Regi¡\94V®ue
+(
+i
+);
+
+345
+Pr\9atF
+(" %3s: %08"
+V8PRIxPTR
+ " %11"
+V8PRIdPTR
+,
+
+346
+Regi¡\94s
+::
+Name
+(
+i
+),
+v®ue
+, value);
+
+347 ià((
+ g¬gc
+ =ð3 &&
+¡rcmp
+(
+¬g2
+, "å"è=ð0è&&
+i
+ < 8 &&
+
+348 (
+i
+ % 2) == 0) {
+
+349
+dv®ue
+ =
+G\91Regi¡\94Pa\9cDoubËV®ue
+(
+i
+);
+
+350
+Pr\9atF
+(" (%f)\n",
+dv®ue
+);
+
+351 } \vià(!((
+ gi
+ + 1) % 2)) {
+
+352
+Pr\9atF
+("\n");
+
+355
+Pr\9atF
+("\85c: %08"
+V8PRIxPTR
+ "\86r: %08" V8PRIxPTR
+
+357 "ùr: %08"
+V8PRIxPTR
+ " xer: %08x cr: %08x\n",
+
+358
+sim_
+->
+¥ec\9fl_»g_pc_
+, sim_->
+¥ec\9fl_»g_Ì_
+,
+
+359
+sim_
+->
+¥ec\9fl_»g_ùr_
+, sim_->
+¥ec\9fl_»g_x\94_
+,
+
+360
+sim_
+->
+cÚd\99iÚ_»g_
+);
+
+361 } \vià(
+¡rcmp
+(
+¬g1
+, "allf") == 0) {
+
+362 \ f\12
+i
+ = 0;
+ gi
+ <
+ gDoubËRegi¡\94
+::
+kNumRegi¡\94s
+; i++) {
+
+363
+ gdv®ue
+ =
+G\91FPDoubËRegi¡\94V®ue
+(
+i
+);
+
+364
+u\9at64_t
+
+ gas_wÜds
+ =
+b\99_ÿ¡
+<u\9at64_t>(
+dv®ue
+);
+
+365
+Pr\9atF
+("%3s: %à0x%08x %08x\n",
+FPRegi¡\94s
+::
+Name
+(
+i
+),
+dv®ue
+,
+
+366
+¡©ic_ÿ¡
+<
+u\9at32_t
+>(
+as_wÜds
+ >> 32),
+
+367
+¡©ic_ÿ¡
+<
+u\9at32_t
+>(
+as_wÜds
+ & 0xffffffff));
+
+369 } \vià(
+ g¬g1
+[0] == 'r' &&
+
+370 (
+¬g1
+[1] >= '0' &&\87rg1[1] <= '9' &&
+
+371 (
+¬g1
+[2] == '\0' || (arg1[2] >= '0' &&\87rg1[2] <= '9' &&
+
+372
+¬g1
+[3] == '\0')))) {
+
+373 \12
+»gnum
+ =
+¡¹oul
+(&
+¬g1
+[1], 0, 10);
+
+374 ià(
+ g»gnum
+ !ð
+kNoRegi¡\94
+) {
+
+375
+v®ue
+ =
+G\91Regi¡\94V®ue
+(
+»gnum
+);
+
+376
+Pr\9atF
+("%s: 0x%08"
+V8PRIxPTR
+ " %"
+V8PRIdPTR
+ "\n",
+¬g1
+,
+v®ue
+,
+
+377
+v®ue
+);
+
+379
+Pr\9atF
+("% uÄecognized\n",
+¬g1
+);
+
+382 ià(
+G\91V®ue
+(
+¬g1
+, &
+v®ue
+)) {
+
+383
+Pr\9atF
+("%s: 0x%08"
+V8PRIxPTR
+ " %"
+V8PRIdPTR
+ "\n",
+¬g1
+,
+v®ue
+,
+
+384
+v®ue
+);
+
+385 } \vià(
+G\91FPDoubËV®ue
+(
+¬g1
+, &
+dv®ue
+)) {
+
+386
+u\9at64_t
+
+ gas_wÜds
+ =
+b\99_ÿ¡
+<u\9at64_t>(
+dv®ue
+);
+
+387
+Pr\9atF
+("%s: %à0x%08x %08x\n",
+¬g1
+,
+dv®ue
+,
+
+388
+¡©ic_ÿ¡
+<
+u\9at32_t
+>(
+as_wÜds
+ >> 32),
+
+389
+¡©ic_ÿ¡
+<
+u\9at32_t
+>(
+as_wÜds
+ & 0xffffffff));
+
+391
+Pr\9atF
+("% uÄecognized\n",
+¬g1
+);
+
+395
+Pr\9atF
+("print <register>\n");
+
+397 } \vià((
+¡rcmp
+(
+cmd
+, "po") == 0) ||
+
+398 (
+¡rcmp
+(
+cmd
+, "printobject") == 0)) {
+
+399 ià(
+¬gc
+ == 2) {
+
+400
+\9a\8d\8c_t
+
+v®ue
+;
+
+401
+OFS\8c\97m
+
+os
+(
+¡dout
+);
+
+402 ià(
+G\91V®ue
+(
+¬g1
+, &
+v®ue
+)) {
+
+403
+Objeù
+*
+ gobj
+ =
+»\9a\8b½»t_ÿ¡
+<Objeù*>(
+v®ue
+);
+
+404
+ gos
+ <<
+ g¬g1
+ << ": \n";
+
+405 #ifdeà
+DEBUG
+
+
+406
+ gobj
+->
+Pr\9at
+(
+os
+);
+
+407
+ gos
+ << "\n";
+
+409
+ gos
+ <<
+Br\9bf
+(
+obj
+) << "\n";
+
+412
+ gos
+ <<
+ g¬g1
+ << " unrecognized\n";
+
+415
+Pr\9atF
+("printobject <value>\n");
+
+417 } \vià(
+¡rcmp
+(
+cmd
+, "setpc") == 0) {
+
+418
+\9a\8d\8c_t
+
+v®ue
+;
+
+420 ià(!
+G\91V®ue
+(
+¬g1
+, &
+v®ue
+)) {
+
+421
+Pr\9atF
+("% uÄecognized\n",
+¬g1
+);
+
+424
+ gsim_
+->
+£t_pc
+(
+v®ue
+);
+
+425 } \vià(
+¡rcmp
+(
+cmd
+, "stack") == 0 || strcmp(cmd, "mem") == 0) {
+
+426
+\9a\8d\8c_t
+*
+cur
+ =
+NULL
+;
+
+427
+\9a\8d\8c_t
+*
+ g\92d
+ =
+NULL
+;
+
+428 \12
+ gÃxt_¬g
+ = 1;
+
+430 ià(
+¡rcmp
+(
+cmd
+, "stack") == 0) {
+
+431
+cur
+ =
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+*>(
+sim_
+->
+g\91_»gi¡\94
+(
+SimuÏtÜ
+::
+¥
+));
+
+433
+\9a\8d\8c_t
+
+ gv®ue
+;
+
+434 ià(!
+G\91V®ue
+(
+¬g1
+, &
+v®ue
+)) {
+
+435
+Pr\9atF
+("% uÄecognized\n",
+¬g1
+);
+
+438
+ gcur
+ =
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+*>(
+v®ue
+);
+
+439
+ gÃxt_¬g
+++;
+
+442
+\9a\8d\8c_t
+
+ gwÜds
+;
+
+443 ià(
+ g¬gc
+ =ð
+Ãxt_¬g
+) {
+
+444
+wÜds
+ = 10;
+
+446 ià(!
+G\91V®ue
+(
+¬gv
+[
+Ãxt_¬g
+], &
+wÜds
+)) {
+
+447
+ gwÜds
+ = 10;
+
+450
+ g\92d
+ =
+cur
+ +
+wÜds
+;
+
+452 \1f
+ gcur
+ <
+ g\92d
+) {
+
+453
+Pr\9atF
+(" 0x%08"
+V8PRIxPTR
+ ": 0x%08" V8PRIxPTR " %10"
+V8PRIdPTR
+,
+
+454
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+cur
+), *cur, *cur);
+
+455
+H\97pObjeù
+*
+ gobj
+ =
+»\9a\8b½»t_ÿ¡
+<H\97pObjeù*>(*
+cur
+);
+
+456
+\9a\8d\8c_t
+
+ gv®ue
+ = *
+cur
+;
+
+457
+H\97p
+*
+ gcu¼\92t_h\97p
+ =
+v8
+::
+\9a\8bº®
+::
+Isީe
+::
+Cu¼\92t
+()->
+h\97p
+();
+
+458 ià(((
+ gv®ue
+ & 1è=ð0è||
+cu¼\92t_h\97p
+->
+CÚ\8f\9as
+(
+obj
+)) {
+
+459
+Pr\9atF
+(" (");
+
+460 ià((
+ gv®ue
+ & 1) == 0) {
+
+461
+Pr\9atF
+("sm\98%d",
+PÏtfÜmSmiTagg\9ag
+::
+SmiToIÁ
+(
+obj
+));
+
+463
+ gobj
+->
+ShÜtPr\9at
+();
+
+465
+Pr\9atF
+(")");
+
+467
+Pr\9atF
+("\n");
+
+468
+ gcur
+++;
+
+470 } \vià(
+¡rcmp
+(
+cmd
+, "disasm") == 0 || strcmp(cmd, "di") == 0) {
+
+471
+di§sm
+::
+NameCÚv\94\8br
+
+cÚv\94\8br
+;
+
+472
+ gdi§sm
+::
+Di§s£mbËr
+
+dasm
+(
+cÚv\94\8br
+);
+
+474
+ gv8
+::
+\9a\8bº®
+::
+EmbeddedVeùÜ
+<\ 5, 256>
+ gbufãr
+;
+
+476
+by\8b
+*
+ g´ev
+ =
+NULL
+;
+
+477
+by\8b
+*
+ gcur
+ =
+NULL
+;
+
+478
+by\8b
+*
+ g\92d
+ =
+NULL
+;
+
+480 ià(
+ g¬gc
+ == 1) {
+
+481
+cur
+ =
+»\9a\8b½»t_ÿ¡
+<
+by\8b
+*>(
+sim_
+->
+g\91_pc
+());
+
+482
+ g\92d
+ =
+cur
+ + (10 *
+In¡ruùiÚ
+::
+kIn¡rSize
+);
+
+483 } \vià(
+ g¬gc
+ == 2) {
+
+484 \12
+»gnum
+ =
+Regi¡\94s
+::
+Numb\94
+(
+¬g1
+);
+
+485 ià(
+ g»gnum
+ !ð
+kNoRegi¡\94
+ ||
+¡ºcmp
+(
+¬g1
+, "0x", 2) == 0) {
+
+487
+\9a\8d\8c_t
+
+v®ue
+;
+
+488 ià(
+G\91V®ue
+(
+¬g1
+, &
+v®ue
+)) {
+
+489
+ gcur
+ =
+»\9a\8b½»t_ÿ¡
+<
+by\8b
+*>(
+v®ue
+);
+
+491
+ g\92d
+ =
+cur
+ + (10 *
+In¡ruùiÚ
+::
+kIn¡rSize
+);
+
+495
+\9a\8d\8c_t
+
+ gv®ue
+;
+
+496 ià(
+G\91V®ue
+(
+¬g1
+, &
+v®ue
+)) {
+
+497
+ gcur
+ =
+»\9a\8b½»t_ÿ¡
+<
+by\8b
+*>(
+sim_
+->
+g\91_pc
+());
+
+499
+ g\92d
+ =
+cur
+ + (
+v®ue
+ *
+In¡ruùiÚ
+::
+kIn¡rSize
+);
+
+503
+\9a\8d\8c_t
+
+ gv®ue1
+;
+
+504
+\9a\8d\8c_t
+
+ gv®ue2
+;
+
+505 ià(
+G\91V®ue
+(
+¬g1
+, &
+v®ue1
+è&& G\91V®ue(
+¬g2
+, &
+v®ue2
+)) {
+
+506
+ gcur
+ =
+»\9a\8b½»t_ÿ¡
+<
+by\8b
+*>(
+v®ue1
+);
+
+507
+ g\92d
+ =
+cur
+ + (
+v®ue2
+ *
+In¡ruùiÚ
+::
+kIn¡rSize
+);
+
+511 \1f
+ gcur
+ <
+ g\92d
+) {
+
+512
+ g´ev
+ =
+cur
+;
+
+513
+ gcur
+ +ð
+dasm
+.
+In¡ruùiÚDecode
+(
+bufãr
+,
+cur
+);
+
+514
+Pr\9atF
+(" 0x%08"
+V8PRIxPTR
+ " %s\n",
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+´ev
+),
+
+515
+bufãr
+.
+¡¬t
+());
+
+517 } \vià(
+¡rcmp
+(
+cmd
+, "gdb") == 0) {
+
+518
+Pr\9atF
+("relinquishing control\81o gdb\n");
+
+519
+ gv8
+::
+ba£
+::
+OS
+::
+DebugB»ak
+();
+
+520
+Pr\9atF
+("regaining control from gdb\n");
+
+521 } \vià(
+¡rcmp
+(
+cmd
+, "break") == 0) {
+
+522 ià(
+¬gc
+ == 2) {
+
+523
+\9a\8d\8c_t
+
+v®ue
+;
+
+524 ià(
+G\91V®ue
+(
+¬g1
+, &
+v®ue
+)) {
+
+525 ià(!
+S\91B»akpo\9at
+(
+»\9a\8b½»t_ÿ¡
+<
+In¡ruùiÚ
+*>(
+v®ue
+))) {
+
+526
+Pr\9atF
+("setting breakpoint failed\n");
+
+529
+Pr\9atF
+("% uÄecognized\n",
+¬g1
+);
+
+532
+Pr\9atF
+("break <address>\n");
+
+534 } \vià(
+¡rcmp
+(
+cmd
+, "del") == 0) {
+
+535 ià(!
+D\96\91eB»akpo\9at
+(
+NULL
+)) {
+
+536
+Pr\9atF
+("deleting breakpoint failed\n");
+
+538 } \vià(
+¡rcmp
+(
+cmd
+, "cr") == 0) {
+
+539
+Pr\9atF
+("CÚd\99iÚ\84eg: %08x\n",
+sim_
+->
+cÚd\99iÚ_»g_
+);
+
+540 } \vià(
+¡rcmp
+(
+cmd
+, "lr") == 0) {
+
+541
+Pr\9atF
+("L\9ak\84eg: %08"
+V8PRIxPTR
+ "\n",
+sim_
+->
+¥ec\9fl_»g_Ì_
+);
+
+542 } \vià(
+¡rcmp
+(
+cmd
+, "ctr") == 0) {
+
+543
+Pr\9atF
+("C\8c\84eg: %08"
+V8PRIxPTR
+ "\n",
+sim_
+->
+¥ec\9fl_»g_ùr_
+);
+
+544 } \vià(
+¡rcmp
+(
+cmd
+, "xer") == 0) {
+
+545
+Pr\9atF
+("XER: %08x\n",
+sim_
+->
+¥ec\9fl_»g_x\94_
+);
+
+546 } \vià(
+¡rcmp
+(
+cmd
+, "fpscr") == 0) {
+
+547
+Pr\9atF
+("FPSCR: %08x\n",
+sim_
+->
+å_cÚd\99iÚ_»g_
+);
+
+548 } \vià(
+¡rcmp
+(
+cmd
+, "stop") == 0) {
+
+549
+\9a\8d\8c_t
+
+v®ue
+;
+
+550
+\9a\8d\8c_t
+
+ g¡Ý_pc
+ =
+
+551
+sim_
+->
+g\91_pc
+(è- (
+In¡ruùiÚ
+::
+kIn¡rSize
+ +
+kPo\9a\8brSize
+);
+
+552
+In¡ruùiÚ
+*
+ g¡Ý_\9a¡r
+ =
+»\9a\8b½»t_ÿ¡
+<In¡ruùiÚ*>(
+¡Ý_pc
+);
+
+553
+In¡ruùiÚ
+*
+ gmsg_add»ss
+ =
+
+554
+»\9a\8b½»t_ÿ¡
+<
+In¡ruùiÚ
+*>(
+¡Ý_pc
+ + In¡ruùiÚ::
+kIn¡rSize
+);
+
+555 ià((
+ g¬gc
+ =ð2è&& (
+¡rcmp
+(
+¬g1
+, "unstop") == 0)) {
+
+557 ià(
+sim_
+->
+isStÝIn¡ruùiÚ
+(
+¡Ý_\9a¡r
+)) {
+
+558
+¡Ý_\9a¡r
+->
+S\91In¡ruùiÚB\99s
+(
+kNÝIn¡r
+);
+
+559
+ gmsg_add»ss
+->
+S\91In¡ruùiÚB\99s
+(
+kNÝIn¡r
+);
+
+561
+Pr\9atF
+("Not\87t debugger stop.\n");
+
+563 } \vià(
+ g¬gc
+ == 3) {
+
+565 ià(
+¡rcmp
+(
+¬g1
+, "info") == 0) {
+
+566 ià(
+¡rcmp
+(
+¬g2
+, "all") == 0) {
+
+567
+Pr\9atF
+("Stop information:\n");
+
+568 \ f
+u\9at32_t
+
+ gi
+ = 0; i <
+ gsim_
+->
+ gkNumOfW©chedStÝs
+; i++) {
+
+569
+ gsim_
+->
+Pr\9atStÝInfo
+(
+i
+);
+
+571 } \vià(
+G\91V®ue
+(
+¬g2
+, &
+v®ue
+)) {
+
+572
+ gsim_
+->
+Pr\9atStÝInfo
+(
+v®ue
+);
+
+574
+Pr\9atF
+("Unrecognized\87rgument.\n");
+
+576 } \vià(
+¡rcmp
+(
+¬g1
+, "enable") == 0) {
+
+578 ià(
+¡rcmp
+(
+¬g2
+, "all") == 0) {
+
+579 \ f
+u\9at32_t
+
+i
+ = 0;
+ gi
+ <
+ gsim_
+->
+ gkNumOfW©chedStÝs
+; i++) {
+
+580
+ gsim_
+->
+EÇbËStÝ
+(
+i
+);
+
+582 } \vià(
+G\91V®ue
+(
+¬g2
+, &
+v®ue
+)) {
+
+583
+ gsim_
+->
+EÇbËStÝ
+(
+v®ue
+);
+
+585
+Pr\9atF
+("Unrecognized\87rgument.\n");
+
+587 } \vià(
+¡rcmp
+(
+¬g1
+, "disable") == 0) {
+
+589 ià(
+¡rcmp
+(
+¬g2
+, "all") == 0) {
+
+590 \ f
+u\9at32_t
+
+i
+ = 0;
+ gi
+ <
+ gsim_
+->
+ gkNumOfW©chedStÝs
+; i++) {
+
+591
+ gsim_
+->
+Di§bËStÝ
+(
+i
+);
+
+593 } \vià(
+G\91V®ue
+(
+¬g2
+, &
+v®ue
+)) {
+
+594
+ gsim_
+->
+Di§bËStÝ
+(
+v®ue
+);
+
+596
+Pr\9atF
+("Unrecognized\87rgument.\n");
+
+600
+Pr\9atF
+("Wrong usage. Use help command for more information.\n");
+
+602 } \vià((
+¡rcmp
+(
+cmd
+, "t") == 0) || strcmp(cmd, "trace") == 0) {
+
+603 ::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+ = !::v8::internal::FLAG_trace_sim;
+
+604
+Pr\9atF
+("Trace of\83xecuted instructions is %s\n",
+
+605 ::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+ ? "on" : "off");
+
+606 } \vià((
+¡rcmp
+(
+cmd
+, "h") == 0) || (strcmp(cmd, "help") == 0)) {
+
+607
+Pr\9atF
+("cont\n");
+
+608
+Pr\9atF
+(" continue\83xecution (alias 'c')\n");
+
+609
+Pr\9atF
+("stepi [num instructions]\n");
+
+610
+Pr\9atF
+(" step one/num instruction(s) (alias 'si')\n");
+
+611
+Pr\9atF
+("print <register>\n");
+
+612
+Pr\9atF
+("\85rint\84egister content (alias 'p')\n");
+
+613
+Pr\9atF
+(" use\84egister\82ame 'all'\81o display\87ll integer\84egisters\n");
+
+614
+Pr\9atF
+(
+
+617
+Pr\9atF
+(" use\84egister\82ame 'rN'\81o display\84egister\82umber 'N'\n");
+
+618
+Pr\9atF
+("\87dd\87rgument 'fp'\81o\85rint\84egister\85air double values\n");
+
+619
+Pr\9atF
+(
+
+622
+Pr\9atF
+("printobject <register>\n");
+
+623
+Pr\9atF
+("\85rint\87n object from\87\84egister (alias 'po')\n");
+
+624
+Pr\9atF
+("cr\n");
+
+625
+Pr\9atF
+("\85rint condition\84egister\n");
+
+626
+Pr\9atF
+("lr\n");
+
+627
+Pr\9atF
+("\85rint\86ink\84egister\n");
+
+628
+Pr\9atF
+("ctr\n");
+
+629
+Pr\9atF
+("\85rint ctr\84egister\n");
+
+630
+Pr\9atF
+("xer\n");
+
+631
+Pr\9atF
+("\85rint XER\n");
+
+632
+Pr\9atF
+("fpscr\n");
+
+633
+Pr\9atF
+("\85rint FPSCR\n");
+
+634
+Pr\9atF
+("stack [<num words>]\n");
+
+635
+Pr\9atF
+(" dump stack content, default dump 10 words)\n");
+
+636
+Pr\9atF
+("mem <address> [<num words>]\n");
+
+637
+Pr\9atF
+(" dump memory content, default dump 10 words)\n");
+
+638
+Pr\9atF
+("disasm [<instructions>]\n");
+
+639
+Pr\9atF
+("disasm [<address/register>]\n");
+
+640
+Pr\9atF
+("disasm [[<address/register>] <instructions>]\n");
+
+641
+Pr\9atF
+(" disassemble code, default is 10 instructions\n");
+
+642
+Pr\9atF
+(" from\85c (alias 'di')\n");
+
+643
+Pr\9atF
+("gdb\n");
+
+644
+Pr\9atF
+("\83nter gdb\n");
+
+645
+Pr\9atF
+("break <address>\n");
+
+646
+Pr\9atF
+(" set\87 break\85oint on\81he\87ddress\n");
+
+647
+Pr\9atF
+("del\n");
+
+648
+Pr\9atF
+(" delete\81he breakpoint\n");
+
+649
+Pr\9atF
+("trace (alias 't')\n");
+
+650
+Pr\9atF
+("\81oogle\81he\81racing of\87ll\83xecuted statements\n");
+
+651
+Pr\9atF
+("stop feature:\n");
+
+652
+Pr\9atF
+(" Description:\n");
+
+653
+Pr\9atF
+(" Stops\87re debug instructions inserted by\n");
+
+654
+Pr\9atF
+("\81he Assembler::stop() function.\n");
+
+655
+Pr\9atF
+(" When hitting\87 stop,\81he Simulator will\n");
+
+656
+Pr\9atF
+(" stop\87nd\87nd give control\81o\81he PPCDebugger.\n");
+
+657
+Pr\9atF
+(" The first %d stop codes\87re watched:\n",
+
+658
+SimuÏtÜ
+::
+kNumOfW©chedStÝs
+);
+
+659
+Pr\9atF
+(" - They can be\83nabled / disabled:\81he Simulator\n");
+
+660
+Pr\9atF
+(" will / won't stop when hitting\81hem.\n");
+
+661
+Pr\9atF
+(" - The Simulator keeps\81rack of how many\81imes\81hey \n");
+
+662
+Pr\9atF
+("\87re met. (See\81he info command.) Going over\87\n");
+
+663
+Pr\9atF
+(" disabled stop still increases its counter. \n");
+
+664
+Pr\9atF
+(" Commands:\n");
+
+665
+Pr\9atF
+(" stop info\87ll/<code> :\85rint infos\87bout\82umber <code>\n");
+
+666
+Pr\9atF
+(" or\87ll stop(s).\n");
+
+667
+Pr\9atF
+(" stop\83nable/disable\87ll/<code> :\83nables / disables\n");
+
+668
+Pr\9atF
+("\87ll or\82umber <code> stop(s)\n");
+
+669
+Pr\9atF
+(" stop unstop\n");
+
+670
+Pr\9atF
+(" ignore\81he stop instruction\87t\81he current\86ocation\n");
+
+671
+Pr\9atF
+(" from\82ow on\n");
+
+673
+Pr\9atF
+("UnknowÀcommªd: %s\n",
+cmd
+);
+
+680
+RedoB»akpo\9ats
+();
+
+682 ::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+ =
+\8caû
+;
+
+684 #undeà
+COMMAND_SIZE
+
+
+685 #undeà
+ARG_SIZE
+
+
+687 #undeà
+STR
+
+
+688 #undeà
+XSTR
+
+
+692 \18
+boÞ
+
+ICacheM©ch
+(\1e*
+Úe
+, \1e*
+two
+) {
+
+693
+DCHECK
+((
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+Úe
+è&
+CachePage
+::
+kPageMask
+) == 0);
+
+694
+DCHECK
+((
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+two
+è&
+CachePage
+::
+kPageMask
+) == 0);
+
+695 \15
+ gÚe
+ =ð
+two
+;
+
+699 \18
+u\9at32_t
+
+ICacheHash
+(\1e*
+key
+) {
+
+700 \15
+ g¡©ic_ÿ¡
+<
+ gu\9at32_t
+>(
+ g»\9a\8b½»t_ÿ¡
+<
+ gu\9a\8d\8c_t
+>(
+ gkey
+)) >> 2;
+
+704 \18
+boÞ
+
+AÎOnOÃPage
+(
+u\9a\8d\8c_t
+
+¡¬t
+, \12
+size
+) {
+
+705
+\9a\8d\8c_t
+
+ g¡¬t_·ge
+ = (
+¡¬t
+ & ~
+CachePage
+::
+kPageMask
+);
+
+706
+\9a\8d\8c_t
+
+ g\92d_·ge
+ = ((
+¡¬t
+ +
+size
+è& ~
+CachePage
+::
+kPageMask
+);
+
+707 \15
+ g¡¬t_·ge
+ =ð
+\92d_·ge
+;
+
+711 \1e
+ gSimuÏtÜ
+::
+£t_Ï¡_debugg\94_\9aput
+(\ 5*
+\9aput
+) {
+
+712
+D\96\91eA¼ay
+(
+Ï¡_debugg\94_\9aput_
+);
+
+713
+ gϡ_debugg\94_\9aput_
+ =
+\9aput
+;
+
+717 \1e
+ gSimuÏtÜ
+::
+FlushICache
+(
+v8
+::
+\9a\8bº®
+::
+HashM
+*
+i_ÿche
+, \1e*
+¡¬t_addr
+,
+
+718
+size_t
+
+size
+) {
+
+719
+\9a\8d\8c_t
+
+ g¡¬t
+ =
+»\9a\8b½»t_ÿ¡
+<\9a\8d\8c_t>(
+¡¬t_addr
+);
+
+720 \12
+ g\9a\8ca_l\9ae
+ = (
+¡¬t
+ &
+CachePage
+::
+kL\9aeMask
+);
+
+721
+ g¡¬t
+ -ð
+\9a\8ca_l\9ae
+;
+
+722
+ gsize
+ +ð
+\9a\8ca_l\9ae
+;
+
+723
+ gsize
+ = ((
+size
+ - 1è|
+CachePage
+::
+kL\9aeMask
+) + 1;
+
+724 \12
+ goff£t
+ = (
+¡¬t
+ &
+CachePage
+::
+kPageMask
+);
+
+725 \1f!
+AÎOnOÃPage
+(
+¡¬t
+,
+size
+ - 1)) {
+
+726 \12
+ gby\8bs_to_æush
+ =
+CachePage
+::
+kPageSize
+ -
+off£t
+;
+
+727
+FlushOÃPage
+(
+i_ÿche
+,
+¡¬t
+,
+by\8bs_to_æush
+);
+
+728
+ g¡¬t
+ +ð
+by\8bs_to_æush
+;
+
+729
+ gsize
+ -ð
+by\8bs_to_æush
+;
+
+730
+DCHECK_EQ
+(0,
+¡©ic_ÿ¡
+<\12>(
+¡¬t
+ &
+CachePage
+::
+kPageMask
+));
+
+731
+ goff£t
+ = 0;
+
+733 ià(
+ gsize
+ != 0) {
+
+734
+FlushOÃPage
+(
+i_ÿche
+,
+¡¬t
+,
+size
+);
+
+739
+CachePage
+*
+ gSimuÏtÜ
+::
+G\91CachePage
+(
+v8
+::
+\9a\8bº®
+::
+HashM
+*
+i_ÿche
+, \1e*
+·ge
+) {
+
+740
+ gv8
+::
+\9a\8bº®
+::
+HashM
+::
+EÁry
+*
+\92\8cy
+ =
+
+741
+i_ÿche
+->
+Lookup
+(
+·ge
+,
+ICacheHash
+Õage),
+\8cue
+);
+
+742 ià(
+ g\92\8cy
+->
+ gv®ue
+ =ð
+NULL
+) {
+
+743
+CachePage
+*
+Ãw_·ge
+ =
+Ãw
+ CachePage();
+
+744
+ g\92\8cy
+->
+ gv®ue
+ =
+Ãw_·ge
+;
+
+746 \15
+ g»\9a\8b½»t_ÿ¡
+<
+ gCachePage
+*>(
+ g\92\8cy
+->
+ gv®ue
+);
+
+751 \1e
+ gSimuÏtÜ
+::
+FlushOÃPage
+(
+v8
+::
+\9a\8bº®
+::
+HashM
+*
+i_ÿche
+,
+\9a\8d\8c_t
+
+¡¬t
+,
+
+752 \12
+size
+) {
+
+753
+DCHECK
+(
+size
+ <ð
+CachePage
+::
+kPageSize
+);
+
+754
+DCHECK
+(
+AÎOnOÃPage
+(
+¡¬t
+,
+size
+ - 1));
+
+755
+DCHECK
+((
+¡¬t
+ &
+CachePage
+::
+kL\9aeMask
+) == 0);
+
+756
+DCHECK
+((
+size
+ &
+CachePage
+::
+kL\9aeMask
+) == 0);
+
+757 \1e*
+ g·ge
+ =
+»\9a\8b½»t_ÿ¡
+<\1e*>(
+¡¬t
+ & (~
+CachePage
+::
+kPageMask
+));
+
+758 \12
+ goff£t
+ = (
+¡¬t
+ &
+CachePage
+::
+kPageMask
+);
+
+759
+CachePage
+*
+ gÿche_·ge
+ =
+G\91CachePage
+(
+i_ÿche
+,
+·ge
+);
+
+760 \ 5*
+ gv®id_by\8bm
+ =
+ÿche_·ge
+->
+V®id\99yBy\8b
+(
+off£t
+);
+
+761
+mem£t
+(
+v®id_by\8bm
+,
+CachePage
+::
+LINE_INVALID
+,
+size
+ >> CachePage::
+kL\9aeShiá
+);
+
+765 \1e
+ gSimuÏtÜ
+::
+CheckICache
+(
+v8
+::
+\9a\8bº®
+::
+HashM
+*
+i_ÿche
+,
+
+766
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+767
+\9a\8d\8c_t
+
+ gadd»ss
+ =
+»\9a\8b½»t_ÿ¡
+<\9a\8d\8c_t>(
+\9a¡r
+);
+
+768 \1e*
+ g·ge
+ =
+»\9a\8b½»t_ÿ¡
+<\1e*>(
+add»ss
+ & (~
+CachePage
+::
+kPageMask
+));
+
+769 \1e*
+ gl\9ae
+ =
+»\9a\8b½»t_ÿ¡
+<\1e*>(
+add»ss
+ & (~
+CachePage
+::
+kL\9aeMask
+));
+
+770 \12
+ goff£t
+ = (
+add»ss
+ &
+CachePage
+::
+kPageMask
+);
+
+771
+CachePage
+*
+ gÿche_·ge
+ =
+G\91CachePage
+(
+i_ÿche
+,
+·ge
+);
+
+772 \ 5*
+ gÿche_v®id_by\8b
+ =
+ÿche_·ge
+->
+V®id\99yBy\8b
+(
+off£t
+);
+
+773
+boÞ
+
+ gÿche_h\99
+ = (*
+ÿche_v®id_by\8b
+ =ð
+CachePage
+::
+LINE_VALID
+);
+
+774 \ 5*
+ gÿched_l\9ae
+ =
+ÿche_·ge
+->
+CachedD©a
+(
+off£t
+ & ~
+CachePage
+::
+kL\9aeMask
+);
+
+775 ià(
+ gÿche_h\99
+) {
+
+777
+CHECK_EQ
+(0,
+
+778
+memcmp
+(
+»\9a\8b½»t_ÿ¡
+<\1e*>(
+\9a¡r
+),
+
+779
+ÿche_·ge
+->
+CachedD©a
+(
+off£t
+),
+In¡ruùiÚ
+::
+kIn¡rSize
+));
+
+782
+memýy
+(
+ÿched_l\9ae
+,
+l\9ae
+,
+CachePage
+::
+kL\9aeL\92gth
+);
+
+783 *
+ gÿche_v®id_by\8b
+ =
+CachePage
+::
+LINE_VALID
+;
+
+788 \1e
+ gSimuÏtÜ
+::
+In\99\9flize
+(
+Isީe
+*
+isީe
+) {
+
+789 ià(
+isީe
+->
+simuÏtÜ_\9a\99\9flized
+()) \15;
+
+790
+ gisީe
+->
+£t_simuÏtÜ_\9a\99\9flized
+(
+\8cue
+);
+
+791 ::
+v8
+::
+\9a\8bº®
+::
+Ex\8bº®Reã»nû
+::
+£t_»d\9ceùÜ
+(
+isީe
+,
+
+792 &
+Red\9ceùEx\8bº®Reã»nû
+);
+
+796
+ gSimuÏtÜ
+::
+SimuÏtÜ
+(
+Isީe
+*
+isީe
+è:
+isީe_
+(isolate) {
+
+797
+i_ÿche_
+ =
+isީe_
+->
+simuÏtÜ_i_ÿche
+();
+
+798 ià(
+ gi_ÿche_
+ =ð
+NULL
+) {
+
+799
+i_ÿche_
+ =
+Ãw
+
+v8
+::
+\9a\8bº®
+::
+HashM
+(&
+ICacheM©ch
+);
+
+800
+ gisީe_
+->
+£t_simuÏtÜ_i_ÿche
+(
+i_ÿche_
+);
+
+802
+In\99\9flize
+(
+isީe
+);
+
+805 #ià
+V8_TARGET_ARCH_PPC64
+
+
+806
+size_t
+
+ g¡ack_size
+ = 2 * 1024 * 1024;
+
+808
+size_t
+
+ g¡ack_size
+ = 1 * 1024 * 1024;
+
+810
+ g¡ack_
+ =
+»\9a\8b½»t_ÿ¡
+<\ 5*>(
+m®loc
+(
+¡ack_size
+));
+
+811
+ gpc_modif\9bd_
+ =
+çl£
+;
+
+812
+ gicouÁ_
+ = 0;
+
+813
+ gb»ak_pc_
+ =
+NULL
+;
+
+814
+ gb»ak_\9a¡r_
+ = 0;
+
+818 \ f\12
+ gi
+ = 0; i <
+ gkNumGPRs
+; i++) {
+
+819
+ g»gi¡\94s_
+[
+i
+] = 0;
+
+821
+ gcÚd\99iÚ_»g_
+ = 0;
+
+822
+ gå_cÚd\99iÚ_»g_
+ = 0;
+
+823
+ g¥ec\9fl_»g_pc_
+ = 0;
+
+824
+ g¥ec\9fl_»g_Ì_
+ = 0;
+
+825
+ g¥ec\9fl_»g_ùr_
+ = 0;
+
+828 \ f\12
+ gi
+ = 0; i <
+ gkNumFPRs
+; i++) {
+
+829
+ gå_»gi¡\94s_
+[
+i
+] = 0.0;
+
+835
+ g»gi¡\94s_
+[
+¥
+] =
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+¡ack_
+è+
+¡ack_size
+ - 64;
+
+836
+In\99\9flizeCov\94age
+();
+
+838
+ gϡ_debugg\94_\9aput_
+ =
+NULL
+;
+
+842
+ gSimuÏtÜ
+::~
+SimuÏtÜ
+() {}
+
+852 þas
+ cRed\9ceùiÚ
+ {
+
+853
+public
+:
+
+854
+Red\9ceùiÚ
+(\1e*
+ex\8bº®_funùiÚ
+,
+Ex\8bº®Reã»nû
+::
+Ty³
+
+ty³
+)
+
+855 :
+ex\8bº®_funùiÚ_
+(
+ex\8bº®_funùiÚ
+),
+
+856
+swi_\9a¡ruùiÚ_
+(
+¹C®lRed\9cIn¡r
+ |
+kC®lRtRed\9ceùed
+),
+
+857
+ty³_
+(
+ty³
+),
+
+858
+Ãxt_
+(
+NULL
+) {
+
+859
+Isީe
+*
+ gisީe
+ = Isީe::
+Cu¼\92t
+();
+
+860
+ gÃxt_
+ =
+isީe
+->
+simuÏtÜ_»d\9ceùiÚ
+();
+
+861
+ gSimuÏtÜ
+::
+cu¼\92t
+(
+isީe
+)->
+FlushICache
+(
+
+862
+isީe
+->
+simuÏtÜ_i_ÿche
+(),
+
+863
+»\9a\8b½»t_ÿ¡
+<\1e*>(&
+swi_\9a¡ruùiÚ_
+),
+In¡ruùiÚ
+::
+kIn¡rSize
+);
+
+864
+ gisީe
+->
+£t_simuÏtÜ_»d\9ceùiÚ
+(
+this
+);
+
+867 \1e*
+add»ss_of_swi_\9a¡ruùiÚ
+() {
+
+868 \15
+ g»\9a\8b½»t_ÿ¡
+<\1e*>(&
+ gswi_\9a¡ruùiÚ_
+);
+
+871 \1e*
+ex\8bº®_funùiÚ
+(è{ \15
+ gex\8bº®_funùiÚ_
+; }
+
+872
+ gEx\8bº®Reã»nû
+::
+Ty³
+
+ty³
+(è{ \15
+ty³_
+; }
+
+874 \18
+Red\9ceùiÚ
+*
+G\91
+(\1e*
+ex\8bº®_funùiÚ
+,
+
+875
+Ex\8bº®Reã»nû
+::
+Ty³
+
+ty³
+) {
+
+876
+Isީe
+*
+isީe
+ = Isީe::
+Cu¼\92t
+();
+
+877
+Red\9ceùiÚ
+*
+ gcu¼\92t
+ =
+isީe
+->
+simuÏtÜ_»d\9ceùiÚ
+();
+
+878 \ f;
+ gcu¼\92t
+ !ð
+NULL
+; cu¼\92\88ð
+cu¼\92t
+->
+Ãxt_
+) {
+
+879 ià(
+cu¼\92t
+->
+ex\8bº®_funùiÚ_
+ =ð
+ex\8bº®_funùiÚ
+) {
+
+880
+DCHECK_EQ
+(
+cu¼\92t
+->
+ty³
+(),\81ype);
+
+881 \15
+ gcu¼\92t
+;
+
+884 \15
+Ãw
+
+Red\9ceùiÚ
+(
+ex\8bº®_funùiÚ
+,
+ty³
+);
+
+887 \18
+Red\9ceùiÚ
+*
+FromSwiIn¡ruùiÚ
+(
+In¡ruùiÚ
+*
+swi_\9a¡ruùiÚ
+) {
+
+888 \ 5*
+ gaddr_of_swi
+ =
+»\9a\8b½»t_ÿ¡
+<\ 5*>(
+swi_\9a¡ruùiÚ
+);
+
+889 \ 5*
+ gaddr_of_»d\9ceùiÚ
+ =
+
+890
+addr_of_swi
+ -
+OFFSET_OF
+(
+Red\9ceùiÚ
+,
+swi_\9a¡ruùiÚ_
+);
+
+891 \15
+ g»\9a\8b½»t_ÿ¡
+<
+ gRed\9ceùiÚ
+*>(
+ gaddr_of_»d\9ceùiÚ
+);
+
+894 \18\1e*
+Rev\94£Red\9ceùiÚ
+(
+\9a\8d\8c_t
+
+»g
+) {
+
+895
+Red\9ceùiÚ
+*
+ g»d\9ceùiÚ
+ =
+FromSwiIn¡ruùiÚ
+(
+
+896
+»\9a\8b½»t_ÿ¡
+<
+In¡ruùiÚ
+*>Ôe\9a\8b½»t_ÿ¡<\1e*>(
+»g
+)));
+
+897 \15
+ g»d\9ceùiÚ
+->
+ex\8bº®_funùiÚ
+();
+
+900
+ g´iv©e
+:
+
+901 \1e*
+ex\8bº®_funùiÚ_
+;
+
+902
+u\9at32_t
+
+ gswi_\9a¡ruùiÚ_
+;
+
+903
+ gEx\8bº®Reã»nû
+::
+Ty³
+
+ty³_
+;
+
+904
+Red\9ceùiÚ
+*
+ gÃxt_
+;
+
+908 \1e*
+ gSimuÏtÜ
+::
+Red\9ceùEx\8bº®Reã»nû
+(\1e*
+ex\8bº®_funùiÚ
+,
+
+909
+Ex\8bº®Reã»nû
+::
+Ty³
+
+ty³
+) {
+
+910
+Red\9ceùiÚ
+*
+»d\9ceùiÚ
+ = Red\9ceùiÚ::
+G\91
+(
+ex\8bº®_funùiÚ
+,
+ty³
+);
+
+911 \15
+ g»d\9ceùiÚ
+->
+add»ss_of_swi_\9a¡ruùiÚ
+();
+
+916
+SimuÏtÜ
+*
+ gSimuÏtÜ
+::
+cu¼\92t
+(
+Isީe
+*
+isީe
+) {
+
+917
+v8
+::
+\9a\8bº®
+::
+Isީe
+::
+P\94IsÞ©eTh»adD©a
+*
+isÞ©e_d©a
+ =
+
+918
+isީe
+->
+F\9adOrAÎoÿ\8bP\94Th»adD©aFÜThisTh»ad
+();
+
+919
+DCHECK
+(
+isÞ©e_d©a
+ !ð
+NULL
+);
+
+921
+SimuÏtÜ
+*
+ gsim
+ =
+isÞ©e_d©a
+->
+simuÏtÜ
+();
+
+922 ià(
+ gsim
+ =ð
+NULL
+) {
+
+924
+sim
+ =
+Ãw
+
+SimuÏtÜ
+(
+isީe
+);
+
+925
+ gisÞ©e_d©a
+->
+£t_simuÏtÜ
+(
+sim
+);
+
+927 \15
+ gsim
+;
+
+932 \1e
+ gSimuÏtÜ
+::
+£t_»gi¡\94
+(\12
+»g
+,
+\9a\8d\8c_t
+
+v®ue
+) {
+
+933
+DCHECK
+((
+»g
+ >ð0è&& (»g <
+kNumGPRs
+));
+
+934
+ g»gi¡\94s_
+[
+»g
+] =
+v®ue
+;
+
+939
+\9a\8d\8c_t
+
+ gSimuÏtÜ
+::
+g\91_»gi¡\94
+(\12
+»g
+) const {
+
+940
+DCHECK
+((
+»g
+ >ð0è&& (»g <
+kNumGPRs
+));
+
+943 ià(
+ g»g
+ >ð
+kNumGPRs
+) \15 0;
+
+945 \15
+ g»gi¡\94s_
+[
+»g
+];
+
+949 \b
+ gSimuÏtÜ
+::
+g\91_doubË_äom_»gi¡\94_·\9c
+(\12
+»g
+) {
+
+950
+DCHECK
+((
+»g
+ >ð0è&& (»g <
+kNumGPRs
+) && ((reg % 2) == 0));
+
+952 \b
+ gdm_v®
+ = 0.0;
+
+953 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+956 \ 5
+ gbufãr
+[\17(
+å_»gi¡\94s_
+[0])];
+
+957
+memýy
+(
+bufãr
+, &
+»gi¡\94s_
+[
+»g
+], 2 * \17(registers_[0]));
+
+958
+memýy
+(&
+dm_v®
+,
+bufãr
+, 2 * \17(
+»gi¡\94s_
+[0]));
+
+960 \15 (
+ gdm_v®
+);
+
+965 \1e
+ gSimuÏtÜ
+::
+£t_pc
+(
+\9a\8d\8c_t
+
+v®ue
+) {
+
+966
+pc_modif\9bd_
+ =
+\8cue
+;
+
+967
+ g¥ec\9fl_»g_pc_
+ =
+v®ue
+;
+
+971
+boÞ
+
+ gSimuÏtÜ
+::
+has_bad_pc
+() const {
+
+972 \15 ((
+¥ec\9fl_»g_pc_
+ =ð
+bad_Ì
+è|| (¥ec\9fl_»g_pc_ =ð
+\92d_sim_pc
+));
+
+977
+\9a\8d\8c_t
+
+ gSimuÏtÜ
+::
+g\91_pc
+(ècÚ¡ { \15
+¥ec\9fl_»g_pc_
+; }
+
+984 \1e
+ gSimuÏtÜ
+::
+G\91FpArgs
+(\b*
+x
+, \b*
+y
+,
+\9a\8d\8c_t
+*
+z
+) {
+
+985 *
+ gx
+ =
+g\91_doubË_äom_d_»gi¡\94
+(1);
+
+986 *
+ gy
+ =
+g\91_doubË_äom_d_»gi¡\94
+(2);
+
+987 *
+ gz
+ =
+g\91_»gi¡\94
+(3);
+
+992 \1e
+ gSimuÏtÜ
+::
+S\91FpResuÉ
+(cڡ \b&
+»suÉ
+è{
+å_»gi¡\94s_
+[1] =\84esult; }
+
+995 \1e
+ gSimuÏtÜ
+::
+T¿shC®ËrSaveRegi¡\94s
+() {
+
+998
+»gi¡\94s_
+[2] = 0x50Bad4U;
+
+999
+ g»gi¡\94s_
+[3] = 0x50Bad4U;
+
+1000
+ g»gi¡\94s_
+[12] = 0x50Bad4U;
+
+1005
+u\9at32_t
+
+ gSimuÏtÜ
+::
+R\97dWU
+(
+\9a\8d\8c_t
+
+addr
+,
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1006
+u\9at32_t
+*
+ g±r
+ =
+»\9a\8b½»t_ÿ¡
+<u\9at32_t*>(
+addr
+);
+
+1007 \15 *
+ g±r
+;
+
+1011
+\9at32_t
+
+ gSimuÏtÜ
+::
+R\97dW
+(
+\9a\8d\8c_t
+
+addr
+,
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1012
+\9at32_t
+*
+ g±r
+ =
+»\9a\8b½»t_ÿ¡
+<\9at32_t*>(
+addr
+);
+
+1013 \15 *
+ g±r
+;
+
+1017 \1e
+ gSimuÏtÜ
+::
+Wr\99eW
+(
+\9a\8d\8c_t
+
+addr
+,
+u\9at32_t
+
+v®ue
+,
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1018
+u\9at32_t
+*
+ g±r
+ =
+»\9a\8b½»t_ÿ¡
+<u\9at32_t*>(
+addr
+);
+
+1019 *
+ g±r
+ =
+v®ue
+;
+
+1024 \1e
+ gSimuÏtÜ
+::
+Wr\99eW
+(
+\9a\8d\8c_t
+
+addr
+,
+\9at32_t
+
+v®ue
+,
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1025
+\9at32_t
+*
+ g±r
+ =
+»\9a\8b½»t_ÿ¡
+<\9at32_t*>(
+addr
+);
+
+1026 *
+ g±r
+ =
+v®ue
+;
+
+1031
+u\9at16_t
+
+ gSimuÏtÜ
+::
+R\97dHU
+(
+\9a\8d\8c_t
+
+addr
+,
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1032
+u\9at16_t
+*
+ g±r
+ =
+»\9a\8b½»t_ÿ¡
+<u\9at16_t*>(
+addr
+);
+
+1033 \15 *
+ g±r
+;
+
+1037
+\9at16_t
+
+ gSimuÏtÜ
+::
+R\97dH
+(
+\9a\8d\8c_t
+
+addr
+,
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1038
+\9at16_t
+*
+ g±r
+ =
+»\9a\8b½»t_ÿ¡
+<\9at16_t*>(
+addr
+);
+
+1039 \15 *
+ g±r
+;
+
+1043 \1e
+ gSimuÏtÜ
+::
+Wr\99eH
+(
+\9a\8d\8c_t
+
+addr
+,
+u\9at16_t
+
+v®ue
+,
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1044
+u\9at16_t
+*
+ g±r
+ =
+»\9a\8b½»t_ÿ¡
+<u\9at16_t*>(
+addr
+);
+
+1045 *
+ g±r
+ =
+v®ue
+;
+
+1050 \1e
+ gSimuÏtÜ
+::
+Wr\99eH
+(
+\9a\8d\8c_t
+
+addr
+,
+\9at16_t
+
+v®ue
+,
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1051
+\9at16_t
+*
+ g±r
+ =
+»\9a\8b½»t_ÿ¡
+<\9at16_t*>(
+addr
+);
+
+1052 *
+ g±r
+ =
+v®ue
+;
+
+1057
+u\9at8_t
+
+ gSimuÏtÜ
+::
+R\97dBU
+(
+\9a\8d\8c_t
+
+addr
+) {
+
+1058
+u\9at8_t
+*
+±r
+ =
+»\9a\8b½»t_ÿ¡
+<u\9at8_t*>(
+addr
+);
+
+1059 \15 *
+ g±r
+;
+
+1063
+\9at8_t
+
+ gSimuÏtÜ
+::
+R\97dB
+(
+\9a\8d\8c_t
+
+addr
+) {
+
+1064
+\9at8_t
+*
+±r
+ =
+»\9a\8b½»t_ÿ¡
+<\9at8_t*>(
+addr
+);
+
+1065 \15 *
+ g±r
+;
+
+1069 \1e
+ gSimuÏtÜ
+::
+Wr\99eB
+(
+\9a\8d\8c_t
+
+addr
+,
+u\9at8_t
+
+v®ue
+) {
+
+1070
+u\9at8_t
+*
+ g±r
+ =
+»\9a\8b½»t_ÿ¡
+<u\9at8_t*>(
+addr
+);
+
+1071 *
+ g±r
+ =
+v®ue
+;
+
+1075 \1e
+ gSimuÏtÜ
+::
+Wr\99eB
+(
+\9a\8d\8c_t
+
+addr
+,
+\9at8_t
+
+v®ue
+) {
+
+1076
+\9at8_t
+*
+ g±r
+ =
+»\9a\8b½»t_ÿ¡
+<\9at8_t*>(
+addr
+);
+
+1077 *
+ g±r
+ =
+v®ue
+;
+
+1081
+\9a\8d\8c_t
+*
+ gSimuÏtÜ
+::
+R\97dDW
+(\9a\8d\8c_\88
+addr
+) {
+
+1082
+\9a\8d\8c_t
+*
+±r
+ =
+»\9a\8b½»t_ÿ¡
+<\9a\8d\8c_t*>(
+addr
+);
+
+1083 \15
+ g±r
+;
+
+1087 \1e
+ gSimuÏtÜ
+::
+Wr\99eDW
+(
+\9a\8d\8c_t
+
+addr
+,
+\9at64_t
+
+v®ue
+) {
+
+1088
+\9at64_t
+*
+ g±r
+ =
+»\9a\8b½»t_ÿ¡
+<\9at64_t*>(
+addr
+);
+
+1089 *
+ g±r
+ =
+v®ue
+;
+
+1095
+u\9a\8d\8c_t
+
+ gSimuÏtÜ
+::
+S\8fckLim\99
+() const {
+
+1098 \15
+»\9a\8b½»t_ÿ¡
+<
+u\9a\8d\8c_t
+>(
+¡ack_
+) + 1024;
+
+1103 \1e
+ gSimuÏtÜ
+::
+FÜm©
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+fÜm©
+) {
+
+1104
+Pr\9atF
+("SimuÏtÜ found unsuµÜ\8bd in¡ruùiÚ:\À0x%08"
+V8PRIxPTR
+ ": %s\n",
+
+1105
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+\9a¡r
+),
+fÜm©
+);
+
+1106
+UNIMPLEMENTED
+();
+
+1111
+boÞ
+
+ gSimuÏtÜ
+::
+C¬ryFrom
+(
+\9at32_t
+
+Ëá
+, iÁ32_\88
+right
+, iÁ32_\88
+ÿ¼y
+) {
+
+1112
+u\9at32_t
+
+ guËá
+ =
+¡©ic_ÿ¡
+<u\9at32_t>(
+Ëá
+);
+
+1113
+u\9at32_t
+
+ guright
+ =
+¡©ic_ÿ¡
+<u\9at32_t>(
+right
+);
+
+1114
+u\9at32_t
+
+ gu»¡
+ = 0xffffffffU -
+uËá
+;
+
+1116 \15 (
+ guright
+ >
+ gu»¡
+) ||
+
+1117 (
+ gÿ¼y
+ && (((
+ guright
+ + 1è>
+ gu»¡
+) || (uright > (urest - 1))));
+
+1122
+boÞ
+
+ gSimuÏtÜ
+::
+BÜrowFrom
+(
+\9at32_t
+
+Ëá
+, iÁ32_\88
+right
+) {
+
+1123
+u\9at32_t
+
+ guËá
+ =
+¡©ic_ÿ¡
+<u\9at32_t>(
+Ëá
+);
+
+1124
+u\9at32_t
+
+ guright
+ =
+¡©ic_ÿ¡
+<u\9at32_t>(
+right
+);
+
+1126 \15 (
+ guright
+ >
+ guËá
+);
+
+1131
+boÞ
+
+ gSimuÏtÜ
+::
+Ov\94æowFrom
+(
+\9at32_t
+
+®u_out
+, iÁ32_\88
+Ëá
+, iÁ32_\88
+right
+,
+
+1132
+boÞ
+
+add\99iÚ
+) {
+
+1133
+boÞ
+
+ gov\94æow
+;
+
+1134 ià(
+ gadd\99iÚ
+) {
+
+1136
+ gov\94æow
+ = ((
+Ëá
+ >ð0 &&
+right
+ >= 0) || (left < 0 &&\84ight < 0))
+
+1139 ((
+Ëá
+ < 0 &&
+®u_out
+ >= 0) || (left >= 0 &&\87lu_out < 0));
+
+1142
+ gov\94æow
+ = ((
+Ëá
+ < 0 &&
+right
+ >= 0) || (left >= 0 &&\84ight < 0))
+
+1145 ((
+Ëá
+ < 0 &&
+®u_out
+ >= 0) || (left >= 0 &&\87lu_out < 0));
+
+1147 \15
+ gov\94æow
+;
+
+1151 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+1158 \e
+\9at64_t
+ (*
+ tSimuÏtÜRuÁimeC®l
+)(
+ t\9a\8d\8c_t
+
+ t¬g0
+, iÁ±r_\88
+ t¬g1
+,
+
+1159
+ t\9a\8d\8c_t
+
+ t¬g2
+, iÁ±r_\88
+ t¬g3
+,
+
+1160
+ t\9a\8d\8c_t
+
+ t¬g4
+, iÁ±r_\88
+ t¬g5
+);
+
+1163 \e
+\9a\8d\8c_t
+ (*
+ tSimuÏtÜRuÁimeC®l
+)(
+ t\9a\8d\8c_t
+
+ t¬g0
+, iÁ±r_\88
+ t¬g1
+,
+
+1164
+ t\9a\8d\8c_t
+
+ t¬g2
+, iÁ±r_\88
+ t¬g3
+,
+
+1165
+ t\9a\8d\8c_t
+
+ t¬g4
+, iÁ±r_\88
+ t¬g5
+);
+
+1166 \19
+ sObjeùPa\9c
+ {
+
+1167
+\9a\8d\8c_t
+
+ gx
+;
+
+1168
+\9a\8d\8c_t
+
+ gy
+;
+
+1171 \e\19
+ObjeùPa\9c
+ (*
+ tSimuÏtÜRuÁimeObjeùPa\9cC®l
+)(
+
+1172
+ t\9a\8d\8c_t
+
+ t¬g0
+, iÁ±r_\88
+ t¬g1
+, iÁ±r_\88
+ t¬g2
+, iÁ±r_\88
+ t¬g3
+, iÁ±r_\88
+ t¬g4
+,
+
+1173
+ t\9a\8d\8c_t
+
+ t¬g5
+);
+
+1177 \e\12(*
+ gSimuÏtÜRuÁimeCom·»C®l
+)(\b
+ td¬g0
+, \b
+ td¬g1
+);
+
+1178 \e\b(*
+ gSimuÏtÜRuÁimeFPFPC®l
+)(\b
+ td¬g0
+, \b
+ td¬g1
+);
+
+1179 \e\b(*
+ gSimuÏtÜRuÁimeFPC®l
+)(\b
+ td¬g0
+);
+
+1180 \e\b(*
+ gSimuÏtÜRuÁimeFPIÁC®l
+)(\b
+ td¬g0
+,
+ t\9a\8d\8c_t
+
+ t¬g0
+);
+
+1184 \e\1e(*
+ gSimuÏtÜRuÁimeD\9ceùApiC®l
+)(
+ t\9a\8d\8c_t
+
+ t¬g0
+);
+
+1185 \e\1e(*
+ gSimuÏtÜRuÁimeProf\9e\9agApiC®l
+)(
+ t\9a\8d\8c_t
+
+ t¬g0
+, \1e*
+ t¬g1
+);
+
+1188 \e\1e(*
+ gSimuÏtÜRuÁimeD\9ceùG\91\8brC®l
+)(
+ t\9a\8d\8c_t
+
+ t¬g0
+, iÁ±r_\88
+ t¬g1
+);
+
+1189 \e\1e(*
+ gSimuÏtÜRuÁimeProf\9e\9agG\91\8brC®l
+)(
+ t\9a\8d\8c_t
+
+ t¬g0
+,
+
+1190
+ t\9a\8d\8c_t
+
+ t¬g1
+, \1e*
+ t¬g2
+);
+
+1194 \1e
+ gSimuÏtÜ
+::
+Soáw¬eIÁ\94ru±
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1195 \12
+svc
+ =
+\9a¡r
+->
+SvcV®ue
+();
+
+1196 \1a
+ gsvc
+) {
+
+1197 \ 4
+ gkC®lRtRed\9ceùed
+: {
+
+1200
+boÞ
+
+¡ack_®igÃd
+ =
+
+1201 (
+g\91_»gi¡\94
+(
+¥
+è& (::
+v8
+::
+\9a\8bº®
+::
+FLAG_sim_¡ack_®ignm\92t
+ - 1)) ==
+
+1203
+Red\9ceùiÚ
+*
+ g»d\9ceùiÚ
+ = Red\9ceùiÚ::
+FromSwiIn¡ruùiÚ
+(
+\9a¡r
+);
+
+1204 cڡ \12
+ gkArgCouÁ
+ = 6;
+
+1205 \12
+ g¬g0_»gnum
+ = 3;
+
+1206 #ià
+V8_TARGET_ARCH_PPC64
+ && !
+ABI_RETURNS_OBJECT_PAIRS_IN_REGS
+
+
+1207
+\9a\8d\8c_t
+
+ g»suÉ_bufãr
+ = 0;
+
+1208 ià(
+ g»d\9ceùiÚ
+->
+ty³
+(è=ð
+Ex\8bº®Reã»nû
+::
+BUILTIN_OBJECTPAIR_CALL
+) {
+
+1209
+»suÉ_bufãr
+ =
+g\91_»gi¡\94
+(
+r3
+);
+
+1210
+ g¬g0_»gnum
+++;
+
+1213
+\9a\8d\8c_t
+
+ g¬g
+[
+kArgCouÁ
+];
+
+1214 \ f\12
+ gi
+ = 0; i <
+ gkArgCouÁ
+; i++) {
+
+1215
+ g¬g
+[
+i
+] =
+g\91_»gi¡\94
+(
+¬g0_»gnum
+ + i);
+
+1217
+boÞ
+
+ gå_ÿÎ
+ =
+
+1218 (
+»d\9ceùiÚ
+->
+ty³
+(è=ð
+Ex\8bº®Reã»nû
+::
+BUILTIN_FP_FP_CALL
+) ||
+
+1219 (
+»d\9ceùiÚ
+->
+ty³
+(è=ð
+Ex\8bº®Reã»nû
+::
+BUILTIN_COMPARE_CALL
+) ||
+
+1220 (
+»d\9ceùiÚ
+->
+ty³
+(è=ð
+Ex\8bº®Reã»nû
+::
+BUILTIN_FP_CALL
+) ||
+
+1221 (
+»d\9ceùiÚ
+->
+ty³
+(è=ð
+Ex\8bº®Reã»nû
+::
+BUILTIN_FP_INT_CALL
+);
+
+1224
+\9a\8d\8c_t
+
+ g§ved_Ì
+ =
+¥ec\9fl_»g_Ì_
+;
+
+1225
+\9a\8d\8c_t
+
+ gex\8bº®
+ =
+
+1226
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+»d\9ceùiÚ
+->
+ex\8bº®_funùiÚ
+());
+
+1227 ià(
+ gå_ÿÎ
+) {
+
+1228 \b
+ gdv®0
+,
+ gdv®1
+;
+
+1229
+\9a\8d\8c_t
+
+ giv®
+;
+
+1230 \12
+ g\9cesuÉ
+ = 0;
+
+1231 \b
+ gd»suÉ
+ = 0;
+
+1232
+G\91FpArgs
+(&
+dv®0
+, &
+dv®1
+, &
+iv®
+);
+
+1233 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+ || !
+¡ack_®igÃd
+) {
+
+1234
+SimuÏtÜRuÁimeC®l
+
+g\92\94ic_\8frg\91
+ =
+
+1235
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeC®l
+>(
+ex\8bº®
+);
+
+1236 \1a
+ g»d\9ceùiÚ
+->
+ty³
+()) {
+
+1237 \ 4
+ gEx\8bº®Reã»nû
+::
+BUILTIN_FP_FP_CALL
+:
+
+1238 \ 4
+Ex\8bº®Reã»nû
+::
+BUILTIN_COMPARE_CALL
+:
+
+1239
+Pr\9atF
+("Call\81o host function\87t %p with\87rgs %f, %f",
+
+1240
+FUNCTION_ADDR
+(
+g\92\94ic_\8frg\91
+),
+dv®0
+,
+dv®1
+);
+
+1242 \ 4
+ gEx\8bº®Reã»nû
+::
+BUILTIN_FP_CALL
+:
+
+1243
+Pr\9atF
+("Call\81o host function\87t %p with\87rg %f",
+
+1244
+FUNCTION_ADDR
+(
+g\92\94ic_\8frg\91
+),
+dv®0
+);
+
+1246 \ 4
+ gEx\8bº®Reã»nû
+::
+BUILTIN_FP_INT_CALL
+:
+
+1247
+Pr\9atF
+("C®ÈtØho¡ funùiÚ\87\88%°w\99h\87rg %f, %"
+V8PRIdPTR
+,
+
+1248
+FUNCTION_ADDR
+(
+g\92\94ic_\8frg\91
+),
+dv®0
+,
+iv®
+);
+
+1251
+UNREACHABLE
+();
+
+1254 ià(!
+ g¡ack_®igÃd
+) {
+
+1255
+Pr\9atF
+(" w\99h uÇligÃd s\8fck %08"
+V8PRIxPTR
+ "\n",
+
+1256
+g\91_»gi¡\94
+(
+¥
+));
+
+1258
+Pr\9atF
+("\n");
+
+1260
+CHECK
+(
+¡ack_®igÃd
+);
+
+1261 \1a
+ g»d\9ceùiÚ
+->
+ty³
+()) {
+
+1262 \ 4
+ gEx\8bº®Reã»nû
+::
+BUILTIN_COMPARE_CALL
+: {
+
+1263
+SimuÏtÜRuÁimeCom·»C®l
+
+\8frg\91
+ =
+
+1264
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeCom·»C®l
+>(
+ex\8bº®
+);
+
+1265
+ g\9cesuÉ
+ =
+\8frg\91
+(
+dv®0
+,
+dv®1
+);
+
+1266
+£t_»gi¡\94
+(
+r3
+,
+\9cesuÉ
+);
+
+1269 \ 4
+ gEx\8bº®Reã»nû
+::
+BUILTIN_FP_FP_CALL
+: {
+
+1270
+SimuÏtÜRuÁimeFPFPC®l
+
+\8frg\91
+ =
+
+1271
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeFPFPC®l
+>(
+ex\8bº®
+);
+
+1272
+ gd»suÉ
+ =
+\8frg\91
+(
+dv®0
+,
+dv®1
+);
+
+1273
+S\91FpResuÉ
+(
+d»suÉ
+);
+
+1276 \ 4
+ gEx\8bº®Reã»nû
+::
+BUILTIN_FP_CALL
+: {
+
+1277
+SimuÏtÜRuÁimeFPC®l
+
+\8frg\91
+ =
+
+1278
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeFPC®l
+>(
+ex\8bº®
+);
+
+1279
+ gd»suÉ
+ =
+\8frg\91
+(
+dv®0
+);
+
+1280
+S\91FpResuÉ
+(
+d»suÉ
+);
+
+1283 \ 4
+ gEx\8bº®Reã»nû
+::
+BUILTIN_FP_INT_CALL
+: {
+
+1284
+SimuÏtÜRuÁimeFPIÁC®l
+
+\8frg\91
+ =
+
+1285
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeFPIÁC®l
+>(
+ex\8bº®
+);
+
+1286
+ gd»suÉ
+ =
+\8frg\91
+(
+dv®0
+,
+iv®
+);
+
+1287
+S\91FpResuÉ
+(
+d»suÉ
+);
+
+1291
+UNREACHABLE
+();
+
+1294 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+ || !
+¡ack_®igÃd
+) {
+
+1295 \1a
+»d\9ceùiÚ
+->
+ty³
+()) {
+
+1296 \ 4
+Ex\8bº®Reã»nû
+::
+BUILTIN_COMPARE_CALL
+:
+
+1297
+Pr\9atF
+("R\91uºed %08x\n",
+\9cesuÉ
+);
+
+1299 \ 4
+ gEx\8bº®Reã»nû
+::
+BUILTIN_FP_FP_CALL
+:
+
+1300 \ 4
+Ex\8bº®Reã»nû
+::
+BUILTIN_FP_CALL
+:
+
+1301 \ 4
+Ex\8bº®Reã»nû
+::
+BUILTIN_FP_INT_CALL
+:
+
+1302
+Pr\9atF
+("R\91uºed %f\n",
+d»suÉ
+);
+
+1305
+UNREACHABLE
+();
+
+1309 } \vià(
+ g»d\9ceùiÚ
+->
+ty³
+(è=ð
+Ex\8bº®Reã»nû
+::
+DIRECT_API_CALL
+) {
+
+1312 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+ || !
+¡ack_®igÃd
+) {
+
+1313
+Pr\9atF
+("C®ÈtØho¡ funùiÚ\87\88%°¬g %08"
+V8PRIxPTR
+,
+
+1314
+»\9a\8b½»t_ÿ¡
+<\1e*>(
+ex\8bº®
+),
+¬g
+[0]);
+
+1315 ià(!
+ g¡ack_®igÃd
+) {
+
+1316
+Pr\9atF
+(" w\99h uÇligÃd s\8fck %08"
+V8PRIxPTR
+ "\n",
+
+1317
+g\91_»gi¡\94
+(
+¥
+));
+
+1319
+Pr\9atF
+("\n");
+
+1321
+CHECK
+(
+¡ack_®igÃd
+);
+
+1322
+SimuÏtÜRuÁimeD\9ceùApiC®l
+
+ g\8frg\91
+ =
+
+1323
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeD\9ceùApiC®l
+>(
+ex\8bº®
+);
+
+1324
+\8frg\91
+(
+¬g
+[0]);
+
+1325 } \vià(
+ g»d\9ceùiÚ
+->
+ty³
+(è=ð
+Ex\8bº®Reã»nû
+::
+PROFILING_API_CALL
+) {
+
+1328 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+ || !
+¡ack_®igÃd
+) {
+
+1329
+Pr\9atF
+("C®ÈtØho¡ funùiÚ\87\88%°¬g %08"
+V8PRIxPTR
+
+
+1330 " %08"
+V8PRIxPTR
+,
+
+1331
+»\9a\8b½»t_ÿ¡
+<\1e*>(
+ex\8bº®
+),
+¬g
+[0],\87rg[1]);
+
+1332 ià(!
+ g¡ack_®igÃd
+) {
+
+1333
+Pr\9atF
+(" w\99h uÇligÃd s\8fck %08"
+V8PRIxPTR
+ "\n",
+
+1334
+g\91_»gi¡\94
+(
+¥
+));
+
+1336
+Pr\9atF
+("\n");
+
+1338
+CHECK
+(
+¡ack_®igÃd
+);
+
+1339
+SimuÏtÜRuÁimeProf\9e\9agApiC®l
+
+ g\8frg\91
+ =
+
+1340
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeProf\9e\9agApiC®l
+>(
+ex\8bº®
+);
+
+1341
+\8frg\91
+(
+¬g
+[0],
+Red\9ceùiÚ
+::
+Rev\94£Red\9ceùiÚ
+(arg[1]));
+
+1342 } \vià(
+ g»d\9ceùiÚ
+->
+ty³
+(è=ð
+Ex\8bº®Reã»nû
+::
+DIRECT_GETTER_CALL
+) {
+
+1345 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+ || !
+¡ack_®igÃd
+) {
+
+1346
+Pr\9atF
+("C®ÈtØho¡ funùiÚ\87\88%°¬g %08"
+V8PRIxPTR
+
+
+1347 " %08"
+V8PRIxPTR
+,
+
+1348
+»\9a\8b½»t_ÿ¡
+<\1e*>(
+ex\8bº®
+),
+¬g
+[0],\87rg[1]);
+
+1349 ià(!
+ g¡ack_®igÃd
+) {
+
+1350
+Pr\9atF
+(" w\99h uÇligÃd s\8fck %08"
+V8PRIxPTR
+ "\n",
+
+1351
+g\91_»gi¡\94
+(
+¥
+));
+
+1353
+Pr\9atF
+("\n");
+
+1355
+CHECK
+(
+¡ack_®igÃd
+);
+
+1356
+SimuÏtÜRuÁimeD\9ceùG\91\8brC®l
+
+ g\8frg\91
+ =
+
+1357
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeD\9ceùG\91\8brC®l
+>(
+ex\8bº®
+);
+
+1358 #ià!
+ABI_PASSES_HANDLES_IN_REGS
+
+
+1359
+ g¬g
+[0] = *(
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+*>(
+¬g
+[0]));
+
+1361
+\8frg\91
+(
+¬g
+[0],\87rg[1]);
+
+1362 } \vià(
+ g»d\9ceùiÚ
+->
+ty³
+() ==
+
+1363
+Ex\8bº®Reã»nû
+::
+PROFILING_GETTER_CALL
+) {
+
+1364 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+ || !
+¡ack_®igÃd
+) {
+
+1365
+Pr\9atF
+("C®ÈtØho¡ funùiÚ\87\88%°¬g %08"
+V8PRIxPTR
+
+
+1366 " %08"
+V8PRIxPTR
+ " %08" V8PRIxPTR,
+
+1367
+»\9a\8b½»t_ÿ¡
+<\1e*>(
+ex\8bº®
+),
+¬g
+[0],\87rg[1],\87rg[2]);
+
+1368 ià(!
+ g¡ack_®igÃd
+) {
+
+1369
+Pr\9atF
+(" w\99h uÇligÃd s\8fck %08"
+V8PRIxPTR
+ "\n",
+
+1370
+g\91_»gi¡\94
+(
+¥
+));
+
+1372
+Pr\9atF
+("\n");
+
+1374
+CHECK
+(
+¡ack_®igÃd
+);
+
+1375
+SimuÏtÜRuÁimeProf\9e\9agG\91\8brC®l
+
+ g\8frg\91
+ =
+
+1376
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeProf\9e\9agG\91\8brC®l
+>(
+ex\8bº®
+);
+
+1377 #ià!
+ABI_PASSES_HANDLES_IN_REGS
+
+
+1378
+ g¬g
+[0] = *(
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+*>(
+¬g
+[0]));
+
+1380
+\8frg\91
+(
+¬g
+[0],\87rg[1],
+Red\9ceùiÚ
+::
+Rev\94£Red\9ceùiÚ
+(arg[2]));
+
+1383 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+ || !
+¡ack_®igÃd
+) {
+
+1384
+SimuÏtÜRuÁimeC®l
+
+\8frg\91
+ =
+
+1385
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeC®l
+>(
+ex\8bº®
+);
+
+1386
+Pr\9atF
+(
+
+1388 "\t\t\t\\8frg %08"
+V8PRIxPTR
+ ", %08" V8PRIxPTR ", %08" V8PRIxPTR
+
+1389 ", %08"
+V8PRIxPTR
+ ", %08" V8PRIxPTR ", %08" V8PRIxPTR,
+
+1390
+FUNCTION_ADDR
+(
+\8frg\91
+),
+¬g
+[0],\87rg[1],\87rg[2],\87rg[3],\87rg[4],
+
+1391
+¬g
+[5]);
+
+1392 ià(!
+ g¡ack_®igÃd
+) {
+
+1393
+Pr\9atF
+(" w\99h uÇligÃd s\8fck %08"
+V8PRIxPTR
+ "\n",
+
+1394
+g\91_»gi¡\94
+(
+¥
+));
+
+1396
+Pr\9atF
+("\n");
+
+1398
+CHECK
+(
+¡ack_®igÃd
+);
+
+1399 #ià!
+V8_TARGET_ARCH_PPC64
+
+
+1400
+DCHECK
+(
+»d\9ceùiÚ
+->
+ty³
+(è=ð
+Ex\8bº®Reã»nû
+::
+BUILTIN_CALL
+);
+
+1401
+SimuÏtÜRuÁimeC®l
+
+ g\8frg\91
+ =
+
+1402
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeC®l
+>(
+ex\8bº®
+);
+
+1403
+\9at64_t
+
+ g»suÉ
+ =
+\8frg\91
+(
+¬g
+[0],\87rg[1],\87rg[2],\87rg[3],\87rg[4],\87rg[5]);
+
+1404
+\9at32_t
+
+ glo_»s
+ =
+¡©ic_ÿ¡
+<\9at32_t>(
+»suÉ
+);
+
+1405
+\9at32_t
+
+ ghi_»s
+ =
+¡©ic_ÿ¡
+<\9at32_t>(
+»suÉ
+ >> 32);
+
+1406 #ià
+V8_TARGET_BIG_ENDIAN
+
+
+1407 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+) {
+
+1408
+Pr\9atF
+("R\91uºed %08x\n",
+hi_»s
+);
+
+1410
+£t_»gi¡\94
+(
+r3
+,
+hi_»s
+);
+
+1411
+£t_»gi¡\94
+(
+r4
+,
+lo_»s
+);
+
+1413 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+) {
+
+1414
+Pr\9atF
+("R\91uºed %08x\n",
+lo_»s
+);
+
+1416
+£t_»gi¡\94
+(
+r3
+,
+lo_»s
+);
+
+1417
+£t_»gi¡\94
+(
+r4
+,
+hi_»s
+);
+
+1420 ià(
+ g»d\9ceùiÚ
+->
+ty³
+(è=ð
+Ex\8bº®Reã»nû
+::
+BUILTIN_CALL
+) {
+
+1421
+SimuÏtÜRuÁimeC®l
+
+\8frg\91
+ =
+
+1422
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeC®l
+>(
+ex\8bº®
+);
+
+1423
+\9a\8d\8c_t
+
+ g»suÉ
+ =
+
+1424
+\8frg\91
+(
+¬g
+[0],\87rg[1],\87rg[2],\87rg[3],\87rg[4],\87rg[5]);
+
+1425 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+) {
+
+1426
+Pr\9atF
+("R\91uºed %08"
+V8PRIxPTR
+ "\n",
+»suÉ
+);
+
+1428
+£t_»gi¡\94
+(
+r3
+,
+»suÉ
+);
+
+1430
+DCHECK
+(
+»d\9ceùiÚ
+->
+ty³
+() ==
+
+1431
+Ex\8bº®Reã»nû
+::
+BUILTIN_OBJECTPAIR_CALL
+);
+
+1432
+SimuÏtÜRuÁimeObjeùPa\9cC®l
+
+ g\8frg\91
+ =
+
+1433
+»\9a\8b½»t_ÿ¡
+<
+SimuÏtÜRuÁimeObjeùPa\9cC®l
+>(
+ex\8bº®
+);
+
+1434 \19
+ObjeùPa\9c
+
+ g»suÉ
+ =
+
+1435
+\8frg\91
+(
+¬g
+[0],\87rg[1],\87rg[2],\87rg[3],\87rg[4],\87rg[5]);
+
+1436 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+) {
+
+1437
+Pr\9atF
+("R\91uºed %08"
+V8PRIxPTR
+ ", %08" V8PRIxPTR "\n",
+»suÉ
+.
+x
+,
+
+1438
+»suÉ
+.
+y
+);
+
+1440 #ià
+ABI_RETURNS_OBJECT_PAIRS_IN_REGS
+
+
+1441
+£t_»gi¡\94
+(
+r3
+,
+»suÉ
+.
+x
+);
+
+1442
+£t_»gi¡\94
+(
+r4
+,
+»suÉ
+.
+y
+);
+
+1444
+memýy
+(
+»\9a\8b½»t_ÿ¡
+<\1e*>(
+»suÉ_bufãr
+), &
+»suÉ
+,
+
+1445 \17(\19
+ObjeùPa\9c
+));
+
+1450
+£t_pc
+(
+§ved_Ì
+);
+
+1453 \ 4
+ gkB»akpo\9at
+: {
+
+1454
+PPCDebugg\94
+
+dbg
+(
+this
+);
+
+1455
+ gdbg
+.
+Debug
+();
+
+1458 \ 4
+ gkInfo
+: {
+
+1459
+PPCDebugg\94
+
+dbg
+(
+this
+);
+
+1460
+ gdbg
+.
+Info
+(
+\9a¡r
+);
+
+1465 ià(
+svc
+ >= (1 << 23)) {
+
+1466
+u\9at32_t
+
+code
+ =
+svc
+ &
+kStÝCodeMask
+;
+
+1467 ià(
+isW©chedStÝ
+(
+code
+)) {
+
+1468
+Inü\97£StÝCouÁ\94
+(
+code
+);
+
+1472 ià(
+isEÇbËdStÝ
+(
+code
+)) {
+
+1473
+PPCDebugg\94
+
+dbg
+(
+this
+);
+
+1474
+ gdbg
+.
+StÝ
+(
+\9a¡r
+);
+
+1476
+£t_pc
+(
+g\91_pc
+(è+
+In¡ruùiÚ
+::
+kIn¡rSize
+ +
+kPo\9a\8brSize
+);
+
+1480
+UNREACHABLE
+();
+
+1489
+boÞ
+
+ gSimuÏtÜ
+::
+isStÝIn¡ruùiÚ
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1490 \15 (
+\9a¡r
+->
+B\99s
+(27, 24è=ð0xFè&& (\9a¡r->
+SvcV®ue
+(è>ð
+kStÝCode
+);
+
+1494
+boÞ
+
+ gSimuÏtÜ
+::
+isW©chedStÝ
+(
+u\9at32_t
+
+code
+) {
+
+1495
+DCHECK
+(
+code
+ <ð
+kMaxStÝCode
+);
+
+1496 \15
+ gcode
+ <
+ gkNumOfW©chedStÝs
+;
+
+1500
+boÞ
+
+ gSimuÏtÜ
+::
+isEÇbËdStÝ
+(
+u\9at32_t
+
+code
+) {
+
+1501
+DCHECK
+(
+code
+ <ð
+kMaxStÝCode
+);
+
+1503 \15 !
+isW©chedStÝ
+(
+code
+) ||
+
+1504 !(
+ gw©ched_¡Ýs_
+[
+code
+].
+ gcouÁ
+ &
+ gkStÝDi§bËdB\99
+);
+
+1508 \1e
+ gSimuÏtÜ
+::
+EÇbËStÝ
+(
+u\9at32_t
+
+code
+) {
+
+1509
+DCHECK
+(
+isW©chedStÝ
+(
+code
+));
+
+1510 ià(!
+isEÇbËdStÝ
+(
+code
+)) {
+
+1511
+ gw©ched_¡Ýs_
+[
+code
+].
+ gcouÁ
+ &ð~
+kStÝDi§bËdB\99
+;
+
+1516 \1e
+ gSimuÏtÜ
+::
+Di§bËStÝ
+(
+u\9at32_t
+
+code
+) {
+
+1517
+DCHECK
+(
+isW©chedStÝ
+(
+code
+));
+
+1518 ià(
+isEÇbËdStÝ
+(
+code
+)) {
+
+1519
+ gw©ched_¡Ýs_
+[
+code
+].
+ gcouÁ
+ |ð
+kStÝDi§bËdB\99
+;
+
+1524 \1e
+ gSimuÏtÜ
+::
+Inü\97£StÝCouÁ\94
+(
+u\9at32_t
+
+code
+) {
+
+1525
+DCHECK
+(
+code
+ <ð
+kMaxStÝCode
+);
+
+1526
+DCHECK
+(
+isW©chedStÝ
+(
+code
+));
+
+1527 ià((
+ gw©ched_¡Ýs_
+[
+code
+].
+ gcouÁ
+ & ~(1 << 31)) == 0x7fffffff) {
+
+1528
+Pr\9atF
+(
+
+1531
+code
+);
+
+1532
+ gw©ched_¡Ýs_
+[
+code
+].
+ gcouÁ
+ = 0;
+
+1533
+EÇbËStÝ
+(
+code
+);
+
+1535
+ gw©ched_¡Ýs_
+[
+code
+].
+ gcouÁ
+++;
+
+1541 \1e
+ gSimuÏtÜ
+::
+Pr\9atStÝInfo
+(
+u\9at32_t
+
+code
+) {
+
+1542
+DCHECK
+(
+code
+ <ð
+kMaxStÝCode
+);
+
+1543 ià(!
+isW©chedStÝ
+(
+code
+)) {
+
+1544
+Pr\9atF
+("Stop\82ot watched.");
+
+1546 cڡ \ 5*
+ g¡©e
+ =
+isEÇbËdStÝ
+(
+code
+) ? "Enabled" : "Disabled";
+
+1547
+\9at32_t
+
+ gcouÁ
+ =
+w©ched_¡Ýs_
+[
+code
+].
+couÁ
+ & ~
+kStÝDi§bËdB\99
+;
+
+1549 ià(
+ gcouÁ
+ != 0) {
+
+1550 ià(
+w©ched_¡Ýs_
+[
+code
+].
+desc
+) {
+
+1551
+Pr\9atF
+("¡Ý %\98- 0x%x: \t%s, \tcouÁ\94 = %i, \t%s\n",
+code
+, code,
+
+1552
+¡©e
+,
+couÁ
+,
+w©ched_¡Ýs_
+[
+code
+].
+desc
+);
+
+1554
+Pr\9atF
+("¡Ý %\98- 0x%x: \t%s, \tcouÁ\94 = %i\n",
+code
+, code,
+¡©e
+,
+
+1555
+couÁ
+);
+
+1562 \1e
+ gSimuÏtÜ
+::
+S\91CR0
+(
+\9a\8d\8c_t
+
+»suÉ
+,
+boÞ
+
+£tSO
+) {
+
+1563 \12
+ gbf
+ = 0;
+
+1564 ià(
+ g»suÉ
+ < 0) {
+
+1565
+ gbf
+ |= 0x80000000;
+
+1567 ià(
+ g»suÉ
+ > 0) {
+
+1568
+ gbf
+ |= 0x40000000;
+
+1570 ià(
+ g»suÉ
+ == 0) {
+
+1571
+bf
+ |= 0x20000000;
+
+1573 ià(
+ g£tSO
+) {
+
+1574
+ gbf
+ |= 0x10000000;
+
+1576
+ gcÚd\99iÚ_»g_
+ = (
+cÚd\99iÚ_»g_
+ & ~0xF0000000è|
+bf
+;
+
+1580 \1e
+ gSimuÏtÜ
+::
+Execu\8bB¿nchCÚd\99iÚ®
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1581 \12
+bo
+ =
+\9a¡r
+->
+B\99s
+(25, 21) << 21;
+
+1582 \12
+ goff£t
+ = (
+\9a¡r
+->
+B\99s
+(15, 2) << 18) >> 16;
+
+1583 \12
+ gcÚd\99iÚ_b\99
+ =
+\9a¡r
+->
+B\99s
+(20, 16);
+
+1584 \12
+ gcÚd\99iÚ_mask
+ = 0x80000000 >>
+cÚd\99iÚ_b\99
+;
+
+1585 \1a
+ gbo
+) {
+
+1586 \ 4
+ gDCBNZF
+:
+
+1587 \ 4
+DCBEZF
+:
+
+1588
+UNIMPLEMENTED
+();
+
+1589 \ 4
+ gBF
+: {
+
+1590 ià(!(
+cÚd\99iÚ_»g_
+ &
+cÚd\99iÚ_mask
+)) {
+
+1591 ià(
+\9a¡r
+->
+B\99
+(0) == 1) {
+
+1592
+¥ec\9fl_»g_Ì_
+ =
+g\91_pc
+() + 4;
+
+1594
+£t_pc
+(
+g\91_pc
+(è+
+off£t
+);
+
+1598 \ 4
+ gDCBNZT
+:
+
+1599 \ 4
+DCBEZT
+:
+
+1600
+UNIMPLEMENTED
+();
+
+1601 \ 4
+ gBT
+: {
+
+1602 ià(
+cÚd\99iÚ_»g_
+ &
+cÚd\99iÚ_mask
+) {
+
+1603 ià(
+\9a¡r
+->
+B\99
+(0) == 1) {
+
+1604
+¥ec\9fl_»g_Ì_
+ =
+g\91_pc
+() + 4;
+
+1606
+£t_pc
+(
+g\91_pc
+(è+
+off£t
+);
+
+1610 \ 4
+ gDCBNZ
+:
+
+1611 \ 4
+DCBEZ
+:
+
+1612
+¥ec\9fl_»g_ùr_
+ -= 1;
+
+1613 ià((
+ g¥ec\9fl_»g_ùr_
+ =ð0è=ð(
+bo
+ =ð
+DCBEZ
+)) {
+
+1614 ià(
+\9a¡r
+->
+B\99
+(0) == 1) {
+
+1615
+¥ec\9fl_»g_Ì_
+ =
+g\91_pc
+() + 4;
+
+1617
+£t_pc
+(
+g\91_pc
+(è+
+off£t
+);
+
+1620 \ 4
+ gBA
+: {
+
+1621 ià(
+\9a¡r
+->
+B\99
+(0) == 1) {
+
+1622
+¥ec\9fl_»g_Ì_
+ =
+g\91_pc
+() + 4;
+
+1624
+£t_pc
+(
+g\91_pc
+(è+
+off£t
+);
+
+1628
+UNIMPLEMENTED
+();
+
+1634 \1e
+ gSimuÏtÜ
+::
+Execu\8bExt1
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1635 \1a
+\9a¡r
+->
+B\99s
+(10, 1) << 1) {
+
+1636 \ 4
+ gMCRF
+:
+
+1637
+UNIMPLEMENTED
+();
+
+1638 \ 4
+ gBCLRX
+: {
+
+1640
+\9a\8d\8c_t
+
+Þd_pc
+ =
+g\91_pc
+();
+
+1641
+£t_pc
+(
+¥ec\9fl_»g_Ì_
+);
+
+1642 ià(
+ g\9a¡r
+->
+B\99
+(0) == 1) {
+
+1643
+¥ec\9fl_»g_Ì_
+ =
+Þd_pc
+ + 4;
+
+1647 \ 4
+ gBCCTRX
+: {
+
+1649
+\9a\8d\8c_t
+
+Þd_pc
+ =
+g\91_pc
+();
+
+1650
+£t_pc
+(
+¥ec\9fl_»g_ùr_
+);
+
+1651 ià(
+ g\9a¡r
+->
+B\99
+(0) == 1) {
+
+1652
+¥ec\9fl_»g_Ì_
+ =
+Þd_pc
+ + 4;
+
+1656 \ 4
+ gCRNOR
+:
+
+1657 \ 4
+RFI
+:
+
+1658 \ 4
+CRANDC
+:
+
+1659
+UNIMPLEMENTED
+();
+
+1660 \ 4
+ gISYNC
+: {
+
+1664 \ 4
+ gCRXOR
+: {
+
+1665 \12
+bt
+ =
+\9a¡r
+->
+B\99s
+(25, 21);
+
+1666 \12
+ gba
+ =
+\9a¡r
+->
+B\99s
+(20, 16);
+
+1667 \12
+ gbb
+ =
+\9a¡r
+->
+B\99s
+(15, 11);
+
+1668 \12
+ gba_v®
+ = ((0x80000000 >>
+ba
+è&
+cÚd\99iÚ_»g_
+) == 0 ? 0 : 1;
+
+1669 \12
+ gbb_v®
+ = ((0x80000000 >>
+bb
+è&
+cÚd\99iÚ_»g_
+) == 0 ? 0 : 1;
+
+1670 \12
+ gbt_v®
+ =
+ba_v®
+ ^
+bb_v®
+;
+
+1671
+ gbt_v®
+ =
+bt_v®
+ << (31 -
+bt
+);
+
+1672
+ gcÚd\99iÚ_»g_
+ &ð~(0x80000000 >>
+bt
+);
+
+1673
+ gcÚd\99iÚ_»g_
+ |ð
+bt_v®
+;
+
+1676 \ 4
+ gCREQV
+: {
+
+1677 \12
+bt
+ =
+\9a¡r
+->
+B\99s
+(25, 21);
+
+1678 \12
+ gba
+ =
+\9a¡r
+->
+B\99s
+(20, 16);
+
+1679 \12
+ gbb
+ =
+\9a¡r
+->
+B\99s
+(15, 11);
+
+1680 \12
+ gba_v®
+ = ((0x80000000 >>
+ba
+è&
+cÚd\99iÚ_»g_
+) == 0 ? 0 : 1;
+
+1681 \12
+ gbb_v®
+ = ((0x80000000 >>
+bb
+è&
+cÚd\99iÚ_»g_
+) == 0 ? 0 : 1;
+
+1682 \12
+ gbt_v®
+ = 1 - (
+ba_v®
+ ^
+bb_v®
+);
+
+1683
+ gbt_v®
+ =
+bt_v®
+ << (31 -
+bt
+);
+
+1684
+ gcÚd\99iÚ_»g_
+ &ð~(0x80000000 >>
+bt
+);
+
+1685
+ gcÚd\99iÚ_»g_
+ |ð
+bt_v®
+;
+
+1688 \ 4
+ gCRNAND
+:
+
+1689 \ 4
+CRAND
+:
+
+1690 \ 4
+CRORC
+:
+
+1691 \ 4
+CROR
+:
+
+1693
+UNIMPLEMENTED
+();
+
+1699
+boÞ
+
+ gSimuÏtÜ
+::
+Execu\8bExt2_10b\99
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1700
+boÞ
+
+found
+ =
+\8cue
+;
+
+1702 \12
+ gÝcode
+ =
+\9a¡r
+->
+B\99s
+(10, 1) << 1;
+
+1703 \1a
+ gÝcode
+) {
+
+1704 \ 4
+ gSRWX
+: {
+
+1705 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+1706 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1707 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+1708
+u\9at32_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+1709
+u\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+1710
+\9a\8d\8c_t
+
+ g»suÉ
+ =
+rs_v®
+ >> (
+rb_v®
+ & 0x3f);
+
+1711
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+1712 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+1713
+S\91CR0
+(
+»suÉ
+);
+
+1717 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1718 \ 4
+ gSRDX
+: {
+
+1719 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+1720 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1721 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+1722
+u\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+1723
+u\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+1724
+\9a\8d\8c_t
+
+ g»suÉ
+ =
+rs_v®
+ >> (
+rb_v®
+ & 0x7f);
+
+1725
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+1726 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+1727
+S\91CR0
+(
+»suÉ
+);
+
+1732 \ 4
+ gSRAW
+: {
+
+1733 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+1734 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1735 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+1736
+\9at32_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+1737
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+1738
+\9a\8d\8c_t
+
+ g»suÉ
+ =
+rs_v®
+ >> (
+rb_v®
+ & 0x3f);
+
+1739
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+1740 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+1741
+S\91CR0
+(
+»suÉ
+);
+
+1745 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1746 \ 4
+ gSRAD
+: {
+
+1747 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+1748 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1749 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+1750
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+1751
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+1752
+\9a\8d\8c_t
+
+ g»suÉ
+ =
+rs_v®
+ >> (
+rb_v®
+ & 0x7f);
+
+1753
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+1754 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+1755
+S\91CR0
+(
+»suÉ
+);
+
+1760 \ 4
+ gSRAWIX
+: {
+
+1761 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1762 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+1763 \12
+ gsh
+ =
+\9a¡r
+->
+B\99s
+(15, 11);
+
+1764
+\9at32_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+1765
+\9a\8d\8c_t
+
+ g»suÉ
+ =
+rs_v®
+ >>
+sh
+;
+
+1766
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+1767 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+1768
+S\91CR0
+(
+»suÉ
+);
+
+1772 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1773 \ 4
+ gEXTSW
+: {
+
+1774 cڡ \12
+shiá
+ =
+kB\99sP\94Po\9a\8br
+ - 32;
+
+1775 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1776 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+1777
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+1778
+\9a\8d\8c_t
+
+ g¿_v®
+ = (
+rs_v®
+ <<
+shiá
+) >> shift;
+
+1779
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+);
+
+1780 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+1781
+S\91CR0
+(
+¿_v®
+);
+
+1786 \ 4
+ gEXTSH
+: {
+
+1787 cڡ \12
+shiá
+ =
+kB\99sP\94Po\9a\8br
+ - 16;
+
+1788 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1789 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+1790
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+1791
+\9a\8d\8c_t
+
+ g¿_v®
+ = (
+rs_v®
+ <<
+shiá
+) >> shift;
+
+1792
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+);
+
+1793 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+1794
+S\91CR0
+(
+¿_v®
+);
+
+1798 \ 4
+ gEXTSB
+: {
+
+1799 cڡ \12
+shiá
+ =
+kB\99sP\94Po\9a\8br
+ - 8;
+
+1800 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1801 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+1802
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+1803
+\9a\8d\8c_t
+
+ g¿_v®
+ = (
+rs_v®
+ <<
+shiá
+) >> shift;
+
+1804
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+);
+
+1805 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+1806
+S\91CR0
+(
+¿_v®
+);
+
+1810 \ 4
+ gLFSUX
+:
+
+1811 \ 4
+LFSX
+: {
+
+1812 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+1813 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1814 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+1815
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+1816
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+1817
+\9at32_t
+
+ gv®
+ =
+R\97dW
+(
+¿_v®
+ +
+rb_v®
+,
+\9a¡r
+);
+
+1818 \ e*
+ gå\8c
+ =
+»\9a\8b½»t_ÿ¡
+<\ e*>(&
+v®
+);
+
+1819
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+¡©ic_ÿ¡
+<\b>(*
+å\8c
+));
+
+1820 ià(
+ gÝcode
+ =ð
+LFSUX
+) {
+
+1821
+DCHECK
+(
+¿
+ != 0);
+
+1822
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+rb_v®
+);
+
+1826 \ 4
+ gLFDUX
+:
+
+1827 \ 4
+LFDX
+: {
+
+1828 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+1829 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1830 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+1831
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+1832
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+1833 \b*
+ gd±r
+ =
+»\9a\8b½»t_ÿ¡
+<\b*>(
+R\97dDW
+(
+¿_v®
+ +
+rb_v®
+));
+
+1834
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+, *
+d±r
+);
+
+1835 ià(
+ gÝcode
+ =ð
+LFDUX
+) {
+
+1836
+DCHECK
+(
+¿
+ != 0);
+
+1837
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+rb_v®
+);
+
+1841 \ 4
+ gSTFSUX
+: {
+
+1842 \ 4
+STFSX
+:
+
+1843 \12
+äs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+1844 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1845 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+1846
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+1847
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+1848 \ e
+ gäs_v®
+ =
+¡©ic_ÿ¡
+<\ e>(
+g\91_doubË_äom_d_»gi¡\94
+(
+äs
+));
+
+1849
+\9at32_t
+*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\9at32_t*>(&
+äs_v®
+);
+
+1850
+Wr\99eW
+(
+¿_v®
+ +
+rb_v®
+, *
+p
+,
+\9a¡r
+);
+
+1851 ià(
+ gÝcode
+ =ð
+STFSUX
+) {
+
+1852
+DCHECK
+(
+¿
+ != 0);
+
+1853
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+rb_v®
+);
+
+1857 \ 4
+ gSTFDUX
+: {
+
+1858 \ 4
+STFDX
+:
+
+1859 \12
+äs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+1860 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1861 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+1862
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+1863
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+1864 \b
+ gäs_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äs
+);
+
+1865
+\9at64_t
+*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\9at64_t*>(&
+äs_v®
+);
+
+1866
+Wr\99eDW
+(
+¿_v®
+ +
+rb_v®
+, *
+p
+);
+
+1867 ià(
+ gÝcode
+ =ð
+STFDUX
+) {
+
+1868
+DCHECK
+(
+¿
+ != 0);
+
+1869
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+rb_v®
+);
+
+1873 \ 4
+ gSYNC
+: {
+
+1877 \ 4
+ gICBI
+: {
+
+1882
+found
+ =
+çl£
+;
+
+1887 ià(
+ gfound
+) \15 found;
+
+1889
+ gfound
+ =
+\8cue
+;
+
+1890
+ gÝcode
+ =
+\9a¡r
+->
+B\99s
+(10, 2) << 2;
+
+1891 \1a
+ gÝcode
+) {
+
+1892 \ 4
+ gSRADIX
+: {
+
+1893 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1894 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+1895 \12
+ gsh
+ = (
+\9a¡r
+->
+B\99s
+(15, 11è| (
+ g\9a¡r
+->
+B\99
+(1) << 5));
+
+1896
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+1897
+\9a\8d\8c_t
+
+ g»suÉ
+ =
+rs_v®
+ >>
+sh
+;
+
+1898
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+1899 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+1900
+S\91CR0
+(
+»suÉ
+);
+
+1905
+found
+ =
+çl£
+;
+
+1910 \15
+ gfound
+;
+
+1914
+boÞ
+
+ gSimuÏtÜ
+::
+Execu\8bExt2_9b\99_·¹1
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+1915
+boÞ
+
+found
+ =
+\8cue
+;
+
+1917 \12
+ gÝcode
+ =
+\9a¡r
+->
+B\99s
+(9, 1) << 1;
+
+1918 \1a
+ gÝcode
+) {
+
+1919 \ 4
+ gTW
+: {
+
+1921
+Soáw¬eIÁ\94ru±
+(
+\9a¡r
+);
+
+1924 \ 4
+ gCMP
+: {
+
+1925 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1926 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+1927 \12
+ gü
+ =
+\9a¡r
+->
+B\99s
+(25, 23);
+
+1928
+u\9at32_t
+
+ gbf
+ = 0;
+
+1929 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1930 \12
+ gL
+ =
+\9a¡r
+->
+B\99
+(21);
+
+1931 ià(
+ gL
+) {
+
+1933
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+1934
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+1935 ià(
+ g¿_v®
+ <
+ grb_v®
+) {
+
+1936
+ gbf
+ |= 0x80000000;
+
+1938 ià(
+ g¿_v®
+ >
+ grb_v®
+) {
+
+1939
+ gbf
+ |= 0x40000000;
+
+1941 ià(
+ g¿_v®
+ =ð
+rb_v®
+) {
+
+1942
+bf
+ |= 0x20000000;
+
+1944 #ià
+V8_TARGET_ARCH_PPC64
+
+
+1946
+\9at32_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+1947
+\9at32_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+1948 ià(
+ g¿_v®
+ <
+ grb_v®
+) {
+
+1949
+ gbf
+ |= 0x80000000;
+
+1951 ià(
+ g¿_v®
+ >
+ grb_v®
+) {
+
+1952
+ gbf
+ |= 0x40000000;
+
+1954 ià(
+ g¿_v®
+ =ð
+rb_v®
+) {
+
+1955
+bf
+ |= 0x20000000;
+
+1959
+u\9at32_t
+
+ gcÚd\99iÚ_mask
+ = 0xF0000000U >> (
+ü
+ * 4);
+
+1960
+u\9at32_t
+
+ gcÚd\99iÚ
+ =
+bf
+ >> (
+ü
+ * 4);
+
+1961
+ gcÚd\99iÚ_»g_
+ = (
+cÚd\99iÚ_»g_
+ & ~
+cÚd\99iÚ_mask
+è|
+cÚd\99iÚ
+;
+
+1964 \ 4
+ gSUBFCX
+: {
+
+1965 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+1966 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1967 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+1969
+u\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+1970
+u\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+1971
+u\9a\8d\8c_t
+
+ g®u_out
+ = ~
+¿_v®
+ +
+rb_v®
+ + 1;
+
+1972
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+1974 ià((
+ g®u_out
+ ^
+ grb_v®
+) & 0x80000000) {
+
+1975
+ g¥ec\9fl_»g_x\94_
+ &= ~0xF0000000;
+
+1977
+ g¥ec\9fl_»g_x\94_
+ = (
+¥ec\9fl_»g_x\94_
+ & ~0xF0000000) | 0x20000000;
+
+1979 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+1980
+S\91CR0
+(
+®u_out
+);
+
+1985 \ 4
+ gADDCX
+: {
+
+1986 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+1987 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+1988 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+1990
+u\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+1991
+u\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+1992
+u\9a\8d\8c_t
+
+ g®u_out
+ =
+¿_v®
+ +
+rb_v®
+;
+
+1994 ià(~
+ g¿_v®
+ <
+ grb_v®
+) {
+
+1995
+ g¥ec\9fl_»g_x\94_
+ = (
+¥ec\9fl_»g_x\94_
+ & ~0xF0000000) | 0x20000000;
+
+1997
+ g¥ec\9fl_»g_x\94_
+ &= ~0xF0000000;
+
+1999
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+2000 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2001
+S\91CR0
+(
+¡©ic_ÿ¡
+<
+\9a\8d\8c_t
+>(
+®u_out
+));
+
+2006 \ 4
+ gMULHWX
+: {
+
+2007 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2008 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2009 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2010
+\9at32_t
+
+ g¿_v®
+ = (
+g\91_»gi¡\94
+(
+¿
+) & 0xFFFFFFFF);
+
+2011
+\9at32_t
+
+ grb_v®
+ = (
+g\91_»gi¡\94
+(
+rb
+) & 0xFFFFFFFF);
+
+2012
+\9at64_t
+
+ g®u_out
+ = (\9at64_t)
+¿_v®
+ * (\9at64_t)
+rb_v®
+;
+
+2013
+ g®u_out
+ >>= 32;
+
+2014
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+2015 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2016
+S\91CR0
+(
+¡©ic_ÿ¡
+<
+\9a\8d\8c_t
+>(
+®u_out
+));
+
+2021 \ 4
+ gNEGX
+: {
+
+2022 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2023 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2024
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+2025
+\9a\8d\8c_t
+
+ g®u_out
+ = 1 + ~
+¿_v®
+;
+
+2026 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2027
+\9a\8d\8c_t
+
+ gÚe
+ = 1;
+
+2028
+\9a\8d\8c_t
+
+ gkOv\94æowV®
+ = (
+Úe
+ << 63);
+
+2030
+\9a\8d\8c_t
+
+ gkOv\94æowV®
+ =
+kM\9aIÁ
+;
+
+2032
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+2033 ià(
+ g\9a¡r
+->
+B\99
+(10)) {
+
+2034 ià(
+ g¿_v®
+ =ð
+kOv\94æowV®
+) {
+
+2035
+¥ec\9fl_»g_x\94_
+ |= 0xC0000000;
+
+2037
+ g¥ec\9fl_»g_x\94_
+ &= ~0x40000000;
+
+2040 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2041
+boÞ
+
+ g£tSO
+ = (
+¥ec\9fl_»g_x\94_
+ & 0x80000000);
+
+2042
+S\91CR0
+(
+®u_out
+,
+£tSO
+);
+
+2046 \ 4
+ gSLWX
+: {
+
+2047 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2048 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2049 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2050
+u\9at32_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2051
+u\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2052
+u\9at32_t
+
+ g»suÉ
+ =
+rs_v®
+ << (
+rb_v®
+ & 0x3f);
+
+2053
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+2054 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2055
+S\91CR0
+(
+»suÉ
+);
+
+2059 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2060 \ 4
+ gSLDX
+: {
+
+2061 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2062 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2063 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2064
+u\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2065
+u\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2066
+u\9a\8d\8c_t
+
+ g»suÉ
+ =
+rs_v®
+ << (
+rb_v®
+ & 0x7f);
+
+2067
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+2068 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2069
+S\91CR0
+(
+»suÉ
+);
+
+2073 \ 4
+ gMFVSRD
+: {
+
+2074
+DCHECK
+(!
+\9a¡r
+->
+B\99
+(0));
+
+2075 \12
+ gät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2076 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2077 \b
+ gät_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+ät
+);
+
+2078
+\9at64_t
+*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\9at64_t*>(&
+ät_v®
+);
+
+2079
+£t_»gi¡\94
+(
+¿
+, *
+p
+);
+
+2082 \ 4
+ gMFVSRWZ
+: {
+
+2083
+DCHECK
+(!
+\9a¡r
+->
+B\99
+(0));
+
+2084 \12
+ gät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2085 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2086 \b
+ gät_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+ät
+);
+
+2087
+\9at64_t
+*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\9at64_t*>(&
+ät_v®
+);
+
+2088
+£t_»gi¡\94
+(
+¿
+,
+¡©ic_ÿ¡
+<
+u\9at32_t
+>(*
+p
+));
+
+2091 \ 4
+ gMTVSRD
+: {
+
+2092
+DCHECK
+(!
+\9a¡r
+->
+B\99
+(0));
+
+2093 \12
+ gät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2094 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2095
+\9at64_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+2096 \b*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\b*>(&
+¿_v®
+);
+
+2097
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+, *
+p
+);
+
+2100 \ 4
+ gMTVSRWA
+: {
+
+2101
+DCHECK
+(!
+\9a¡r
+->
+B\99
+(0));
+
+2102 \12
+ gät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2103 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2104
+\9at64_t
+
+ g¿_v®
+ =
+¡©ic_ÿ¡
+<
+\9at32_t
+>(
+g\91_»gi¡\94
+(
+¿
+));
+
+2105 \b*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\b*>(&
+¿_v®
+);
+
+2106
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+, *
+p
+);
+
+2109 \ 4
+ gMTVSRWZ
+: {
+
+2110
+DCHECK
+(!
+\9a¡r
+->
+B\99
+(0));
+
+2111 \12
+ gät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2112 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2113
+u\9at64_t
+
+ g¿_v®
+ =
+¡©ic_ÿ¡
+<
+u\9at32_t
+>(
+g\91_»gi¡\94
+(
+¿
+));
+
+2114 \b*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\b*>(&
+¿_v®
+);
+
+2115
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+, *
+p
+);
+
+2120
+found
+ =
+çl£
+;
+
+2125 \15
+ gfound
+;
+
+2129 \1e
+ gSimuÏtÜ
+::
+Execu\8bExt2_9b\99_·¹2
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+2130 \12
+Ýcode
+ =
+\9a¡r
+->
+B\99s
+(9, 1) << 1;
+
+2131 \1a
+ gÝcode
+) {
+
+2132 \ 4
+ gCNTLZWX
+: {
+
+2133 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2134 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2135
+u\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2136
+u\9a\8d\8c_t
+
+ gcouÁ
+ = 0;
+
+2137 \12
+ gn
+ = 0;
+
+2138
+u\9a\8d\8c_t
+
+ gb\99
+ = 0x80000000;
+
+2139 \ f;
+ gn
+ < 32;\82++) {
+
+2140 ià(
+ gb\99
+ &
+ grs_v®
+) \ 3;
+
+2141
+ gcouÁ
+++;
+
+2142
+ gb\99
+ >>= 1;
+
+2144
+£t_»gi¡\94
+(
+¿
+,
+couÁ
+);
+
+2145 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2146 \12
+ gbf
+ = 0;
+
+2147 ià(
+ gcouÁ
+ > 0) {
+
+2148
+ gbf
+ |= 0x40000000;
+
+2150 ià(
+ gcouÁ
+ == 0) {
+
+2151
+bf
+ |= 0x20000000;
+
+2153
+ gcÚd\99iÚ_»g_
+ = (
+cÚd\99iÚ_»g_
+ & ~0xF0000000è|
+bf
+;
+
+2157 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2158 \ 4
+ gCNTLZDX
+: {
+
+2159 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2160 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2161
+u\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2162
+u\9a\8d\8c_t
+
+ gcouÁ
+ = 0;
+
+2163 \12
+ gn
+ = 0;
+
+2164
+u\9a\8d\8c_t
+
+ gb\99
+ = 0x8000000000000000UL;
+
+2165 \ f;
+ gn
+ < 64;\82++) {
+
+2166 ià(
+ gb\99
+ &
+ grs_v®
+) \ 3;
+
+2167
+ gcouÁ
+++;
+
+2168
+ gb\99
+ >>= 1;
+
+2170
+£t_»gi¡\94
+(
+¿
+,
+couÁ
+);
+
+2171 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2172 \12
+ gbf
+ = 0;
+
+2173 ià(
+ gcouÁ
+ > 0) {
+
+2174
+ gbf
+ |= 0x40000000;
+
+2176 ià(
+ gcouÁ
+ == 0) {
+
+2177
+bf
+ |= 0x20000000;
+
+2179
+ gcÚd\99iÚ_»g_
+ = (
+cÚd\99iÚ_»g_
+ & ~0xF0000000è|
+bf
+;
+
+2184 \ 4
+ gANDX
+: {
+
+2185 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2186 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2187 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2188
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2189
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2190
+\9a\8d\8c_t
+
+ g®u_out
+ =
+rs_v®
+ &
+rb_v®
+;
+
+2191
+£t_»gi¡\94
+(
+¿
+,
+®u_out
+);
+
+2192 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2193
+S\91CR0
+(
+®u_out
+);
+
+2197 \ 4
+ gANDCX
+: {
+
+2198 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2199 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2200 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2201
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2202
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2203
+\9a\8d\8c_t
+
+ g®u_out
+ =
+rs_v®
+ & ~
+rb_v®
+;
+
+2204
+£t_»gi¡\94
+(
+¿
+,
+®u_out
+);
+
+2205 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2206
+S\91CR0
+(
+®u_out
+);
+
+2210 \ 4
+ gCMPL
+: {
+
+2211 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2212 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2213 \12
+ gü
+ =
+\9a¡r
+->
+B\99s
+(25, 23);
+
+2214
+u\9at32_t
+
+ gbf
+ = 0;
+
+2215 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2216 \12
+ gL
+ =
+\9a¡r
+->
+B\99
+(21);
+
+2217 ià(
+ gL
+) {
+
+2219
+u\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+2220
+u\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2221 ià(
+ g¿_v®
+ <
+ grb_v®
+) {
+
+2222
+ gbf
+ |= 0x80000000;
+
+2224 ià(
+ g¿_v®
+ >
+ grb_v®
+) {
+
+2225
+ gbf
+ |= 0x40000000;
+
+2227 ià(
+ g¿_v®
+ =ð
+rb_v®
+) {
+
+2228
+bf
+ |= 0x20000000;
+
+2230 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2232
+u\9at32_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+2233
+u\9at32_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2234 ià(
+ g¿_v®
+ <
+ grb_v®
+) {
+
+2235
+ gbf
+ |= 0x80000000;
+
+2237 ià(
+ g¿_v®
+ >
+ grb_v®
+) {
+
+2238
+ gbf
+ |= 0x40000000;
+
+2240 ià(
+ g¿_v®
+ =ð
+rb_v®
+) {
+
+2241
+bf
+ |= 0x20000000;
+
+2245
+u\9at32_t
+
+ gcÚd\99iÚ_mask
+ = 0xF0000000U >> (
+ü
+ * 4);
+
+2246
+u\9at32_t
+
+ gcÚd\99iÚ
+ =
+bf
+ >> (
+ü
+ * 4);
+
+2247
+ gcÚd\99iÚ_»g_
+ = (
+cÚd\99iÚ_»g_
+ & ~
+cÚd\99iÚ_mask
+è|
+cÚd\99iÚ
+;
+
+2250 \ 4
+ gSUBFX
+: {
+
+2251 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2252 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2253 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2255
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+2256
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2257
+\9a\8d\8c_t
+
+ g®u_out
+ =
+rb_v®
+ -
+¿_v®
+;
+
+2259
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+2260 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2261
+S\91CR0
+(
+®u_out
+);
+
+2266 \ 4
+ gADDZEX
+: {
+
+2267 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2268 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2269
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+2270 ià(
+ g¥ec\9fl_»g_x\94_
+ & 0x20000000) {
+
+2271
+ g¿_v®
+ += 1;
+
+2273
+£t_»gi¡\94
+(
+¹
+,
+¿_v®
+);
+
+2274 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2275
+S\91CR0
+(
+¿_v®
+);
+
+2280 \ 4
+ gNORX
+: {
+
+2281 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2282 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2283 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2284
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2285
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2286
+\9a\8d\8c_t
+
+ g®u_out
+ = ~(
+rs_v®
+ |
+rb_v®
+);
+
+2287
+£t_»gi¡\94
+(
+¿
+,
+®u_out
+);
+
+2288 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2289
+S\91CR0
+(
+®u_out
+);
+
+2293 \ 4
+ gMULLW
+: {
+
+2294 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2295 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2296 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2297
+\9at32_t
+
+ g¿_v®
+ = (
+g\91_»gi¡\94
+(
+¿
+) & 0xFFFFFFFF);
+
+2298
+\9at32_t
+
+ grb_v®
+ = (
+g\91_»gi¡\94
+(
+rb
+) & 0xFFFFFFFF);
+
+2299
+\9at32_t
+
+ g®u_out
+ =
+¿_v®
+ *
+rb_v®
+;
+
+2300
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+2301 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2302
+S\91CR0
+(
+®u_out
+);
+
+2307 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2308 \ 4
+ gMULLD
+: {
+
+2309 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2310 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2311 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2312
+\9at64_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+2313
+\9at64_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2314
+\9at64_t
+
+ g®u_out
+ =
+¿_v®
+ *
+rb_v®
+;
+
+2315
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+2316 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2317
+S\91CR0
+(
+®u_out
+);
+
+2323 \ 4
+ gDIVW
+: {
+
+2324 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2325 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2326 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2327
+\9at32_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+2328
+\9at32_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2329
+boÞ
+
+ gov\94æow
+ = (
+¿_v®
+ =ð
+kM\9aIÁ
+ &&
+rb_v®
+ == -1);
+
+2332
+\9at32_t
+
+ g®u_out
+ = (
+rb_v®
+ =ð0 ||
+ov\94æow
+è? -1 :
+¿_v®
+ /\84b_val;
+
+2333
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+2334 ià(
+ g\9a¡r
+->
+B\99
+(10)) {
+
+2335 ià(
+ gov\94æow
+) {
+
+2336
+ g¥ec\9fl_»g_x\94_
+ |= 0xC0000000;
+
+2338
+ g¥ec\9fl_»g_x\94_
+ &= ~0x40000000;
+
+2341 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2342
+boÞ
+
+ g£tSO
+ = (
+¥ec\9fl_»g_x\94_
+ & 0x80000000);
+
+2343
+S\91CR0
+(
+®u_out
+,
+£tSO
+);
+
+2347 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2348 \ 4
+ gDIVD
+: {
+
+2349 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2350 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2351 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2352
+\9at64_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+2353
+\9at64_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2354
+\9at64_t
+
+ gÚe
+ = 1;
+
+2355
+\9at64_t
+
+ gkM\9aLÚgLÚg
+ = (
+Úe
+ << 63);
+
+2358
+\9at64_t
+
+ g®u_out
+ =
+
+2359 (
+rb_v®
+ =ð0 || (
+¿_v®
+ =ð
+kM\9aLÚgLÚg
+ &&\84b_val == -1))
+
+2361 :
+¿_v®
+ /
+rb_v®
+;
+
+2362
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+2363 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2364
+S\91CR0
+(
+®u_out
+);
+
+2370 \ 4
+ gADDX
+: {
+
+2371 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2372 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2373 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2375
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+2376
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2377
+\9a\8d\8c_t
+
+ g®u_out
+ =
+¿_v®
+ +
+rb_v®
+;
+
+2378
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+2379 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2380
+S\91CR0
+(
+®u_out
+);
+
+2385 \ 4
+ gXORX
+: {
+
+2386 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2387 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2388 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2389
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2390
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2391
+\9a\8d\8c_t
+
+ g®u_out
+ =
+rs_v®
+ ^
+rb_v®
+;
+
+2392
+£t_»gi¡\94
+(
+¿
+,
+®u_out
+);
+
+2393 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2394
+S\91CR0
+(
+®u_out
+);
+
+2398 \ 4
+ gORX
+: {
+
+2399 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2400 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2401 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2402
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2403
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2404
+\9a\8d\8c_t
+
+ g®u_out
+ =
+rs_v®
+ |
+rb_v®
+;
+
+2405
+£t_»gi¡\94
+(
+¿
+,
+®u_out
+);
+
+2406 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2407
+S\91CR0
+(
+®u_out
+);
+
+2411 \ 4
+ gMFSPR
+: {
+
+2412 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2413 \12
+ g¥r
+ =
+\9a¡r
+->
+B\99s
+(20, 11);
+
+2414 ià(
+ g¥r
+ != 256) {
+
+2415
+UNIMPLEMENTED
+();
+
+2417
+£t_»gi¡\94
+(
+¹
+,
+¥ec\9fl_»g_Ì_
+);
+
+2420 \ 4
+ gMTSPR
+: {
+
+2421 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2422
+\9a\8d\8c_t
+
+ g¹_v®
+ =
+g\91_»gi¡\94
+(
+¹
+);
+
+2423 \12
+ g¥r
+ =
+\9a¡r
+->
+B\99s
+(20, 11);
+
+2424 ià(
+ g¥r
+ == 256) {
+
+2425
+¥ec\9fl_»g_Ì_
+ =
+¹_v®
+;
+
+2426 } \vià(
+ g¥r
+ == 288) {
+
+2427
+¥ec\9fl_»g_ùr_
+ =
+¹_v®
+;
+
+2428 } \vià(
+ g¥r
+ == 32) {
+
+2429
+¥ec\9fl_»g_x\94_
+ =
+¹_v®
+;
+
+2431
+UNIMPLEMENTED
+();
+
+2435 \ 4
+ gMFCR
+: {
+
+2436 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2437
+£t_»gi¡\94
+(
+¹
+,
+cÚd\99iÚ_»g_
+);
+
+2440 \ 4
+ gSTWUX
+:
+
+2441 \ 4
+STWX
+: {
+
+2442 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2443 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2444 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2445
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+2446
+\9at32_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2447
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2448
+Wr\99eW
+(
+¿_v®
+ +
+rb_v®
+,
+rs_v®
+,
+\9a¡r
+);
+
+2449 ià(
+ gÝcode
+ =ð
+STWUX
+) {
+
+2450
+DCHECK
+(
+¿
+ != 0);
+
+2451
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+rb_v®
+);
+
+2455 \ 4
+ gSTBUX
+:
+
+2456 \ 4
+STBX
+: {
+
+2457 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2458 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2459 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2460
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+2461
+\9at8_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2462
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2463
+Wr\99eB
+(
+¿_v®
+ +
+rb_v®
+,
+rs_v®
+);
+
+2464 ià(
+ gÝcode
+ =ð
+STBUX
+) {
+
+2465
+DCHECK
+(
+¿
+ != 0);
+
+2466
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+rb_v®
+);
+
+2470 \ 4
+ gSTHUX
+:
+
+2471 \ 4
+STHX
+: {
+
+2472 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2473 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2474 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2475
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+2476
+\9at16_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2477
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2478
+Wr\99eH
+(
+¿_v®
+ +
+rb_v®
+,
+rs_v®
+,
+\9a¡r
+);
+
+2479 ià(
+ gÝcode
+ =ð
+STHUX
+) {
+
+2480
+DCHECK
+(
+¿
+ != 0);
+
+2481
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+rb_v®
+);
+
+2485 \ 4
+ gLWZX
+:
+
+2486 \ 4
+LWZUX
+: {
+
+2487 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2488 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2489 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2490
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+2491
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2492
+£t_»gi¡\94
+(
+¹
+,
+R\97dWU
+(
+¿_v®
+ +
+rb_v®
+,
+\9a¡r
+));
+
+2493 ià(
+ gÝcode
+ =ð
+LWZUX
+) {
+
+2494
+DCHECK
+(
+¿
+ !ð0 &&\84¨!ð
+¹
+);
+
+2495
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+rb_v®
+);
+
+2499 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2500 \ 4
+ gLDX
+:
+
+2501 \ 4
+LDUX
+: {
+
+2502 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2503 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2504 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2505
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+2506
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2507
+\9a\8d\8c_t
+*
+ g»suÉ
+ =
+R\97dDW
+(
+¿_v®
+ +
+rb_v®
+);
+
+2508
+£t_»gi¡\94
+(
+¹
+, *
+»suÉ
+);
+
+2509 ià(
+ gÝcode
+ =ð
+LDUX
+) {
+
+2510
+DCHECK
+(
+¿
+ !ð0 &&\84¨!ð
+¹
+);
+
+2511
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+rb_v®
+);
+
+2515 \ 4
+ gSTDX
+:
+
+2516 \ 4
+STDUX
+: {
+
+2517 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2518 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2519 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2520
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+2521
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2522
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2523
+Wr\99eDW
+(
+¿_v®
+ +
+rb_v®
+,
+rs_v®
+);
+
+2524 ià(
+ gÝcode
+ =ð
+STDUX
+) {
+
+2525
+DCHECK
+(
+¿
+ != 0);
+
+2526
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+rb_v®
+);
+
+2531 \ 4
+ gLBZX
+:
+
+2532 \ 4
+LBZUX
+: {
+
+2533 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2534 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2535 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2536
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+2537
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2538
+£t_»gi¡\94
+(
+¹
+,
+R\97dBU
+(
+¿_v®
+ +
+rb_v®
+) & 0xFF);
+
+2539 ià(
+ gÝcode
+ =ð
+LBZUX
+) {
+
+2540
+DCHECK
+(
+¿
+ !ð0 &&\84¨!ð
+¹
+);
+
+2541
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+rb_v®
+);
+
+2545 \ 4
+ gLHZX
+:
+
+2546 \ 4
+LHZUX
+: {
+
+2547 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2548 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2549 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2550
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+2551
+\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2552
+£t_»gi¡\94
+(
+¹
+,
+R\97dHU
+(
+¿_v®
+ +
+rb_v®
+,
+\9a¡r
+) & 0xFFFF);
+
+2553 ià(
+ gÝcode
+ =ð
+LHZUX
+) {
+
+2554
+DCHECK
+(
+¿
+ !ð0 &&\84¨!ð
+¹
+);
+
+2555
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+rb_v®
+);
+
+2559 \ 4
+ gDCBF
+: {
+
+2564
+Pr\9atF
+("Unim¶em\92\8bd: %08x\n",
+\9a¡r
+->
+In¡ruùiÚB\99s
+());
+
+2565
+UNIMPLEMENTED
+();
+
+2571 \1e
+ gSimuÏtÜ
+::
+Execu\8bExt2
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+2573 ià(
+Execu\8bExt2_10b\99
+(
+\9a¡r
+)) \15;
+
+2575 ià(
+Execu\8bExt2_9b\99_·¹1
+(
+\9a¡r
+)) \15;
+
+2576
+Execu\8bExt2_9b\99_·¹2
+(
+\9a¡r
+);
+
+2580 \1e
+ gSimuÏtÜ
+::
+Execu\8bExt4
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+2581 \1a
+\9a¡r
+->
+B\99s
+(5, 1) << 1) {
+
+2582 \ 4
+ gFDIV
+: {
+
+2583 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2584 \12
+ gäa
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2585 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2586 \b
+ gäa_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äa
+);
+
+2587 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2588 \b
+ gät_v®
+ =
+äa_v®
+ /
+äb_v®
+;
+
+2589
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2592 \ 4
+ gFSUB
+: {
+
+2593 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2594 \12
+ gäa
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2595 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2596 \b
+ gäa_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äa
+);
+
+2597 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2598 \b
+ gät_v®
+ =
+äa_v®
+ -
+äb_v®
+;
+
+2599
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2602 \ 4
+ gFADD
+: {
+
+2603 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2604 \12
+ gäa
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2605 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2606 \b
+ gäa_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äa
+);
+
+2607 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2608 \b
+ gät_v®
+ =
+äa_v®
+ +
+äb_v®
+;
+
+2609
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2612 \ 4
+ gFSQRT
+: {
+
+2613 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2614 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2615 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2616 \b
+ gät_v®
+ =
+¡d
+::
+sq¹
+(
+äb_v®
+);
+
+2617
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2620 \ 4
+ gFSEL
+: {
+
+2621 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2622 \12
+ gäa
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2623 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2624 \12
+ gäc
+ =
+\9a¡r
+->
+RCV®ue
+();
+
+2625 \b
+ gäa_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äa
+);
+
+2626 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2627 \b
+ gäc_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äc
+);
+
+2628 \b
+ gät_v®
+ = ((
+äa_v®
+ >ð0.0è?
+äc_v®
+ :
+äb_v®
+);
+
+2629
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2632 \ 4
+ gFMUL
+: {
+
+2633 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2634 \12
+ gäa
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2635 \12
+ gäc
+ =
+\9a¡r
+->
+RCV®ue
+();
+
+2636 \b
+ gäa_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äa
+);
+
+2637 \b
+ gäc_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äc
+);
+
+2638 \b
+ gät_v®
+ =
+äa_v®
+ *
+äc_v®
+;
+
+2639
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2642 \ 4
+ gFMSUB
+: {
+
+2643 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2644 \12
+ gäa
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2645 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2646 \12
+ gäc
+ =
+\9a¡r
+->
+RCV®ue
+();
+
+2647 \b
+ gäa_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äa
+);
+
+2648 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2649 \b
+ gäc_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äc
+);
+
+2650 \b
+ gät_v®
+ = (
+äa_v®
+ *
+äc_v®
+è-
+äb_v®
+;
+
+2651
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2654 \ 4
+ gFMADD
+: {
+
+2655 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2656 \12
+ gäa
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2657 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2658 \12
+ gäc
+ =
+\9a¡r
+->
+RCV®ue
+();
+
+2659 \b
+ gäa_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äa
+);
+
+2660 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2661 \b
+ gäc_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äc
+);
+
+2662 \b
+ gät_v®
+ = (
+äa_v®
+ *
+äc_v®
+è+
+äb_v®
+;
+
+2663
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2667 \12
+ gÝcode
+ =
+\9a¡r
+->
+B\99s
+(10, 1) << 1;
+
+2668 \1a
+ gÝcode
+) {
+
+2669 \ 4
+ gFCMPU
+: {
+
+2670 \12
+äa
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2671 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2672 \b
+ gäa_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äa
+);
+
+2673 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2674 \12
+ gü
+ =
+\9a¡r
+->
+B\99s
+(25, 23);
+
+2675 \12
+ gbf
+ = 0;
+
+2676 ià(
+ gäa_v®
+ <
+ gäb_v®
+) {
+
+2677
+ gbf
+ |= 0x80000000;
+
+2679 ià(
+ gäa_v®
+ >
+ gäb_v®
+) {
+
+2680
+ gbf
+ |= 0x40000000;
+
+2682 ià(
+ gäa_v®
+ =ð
+äb_v®
+) {
+
+2683
+bf
+ |= 0x20000000;
+
+2685 ià(
+ g¡d
+::
+isunÜd\94ed
+(
+äa_v®
+,
+äb_v®
+)) {
+
+2686
+ gbf
+ |= 0x10000000;
+
+2688 \12
+ gcÚd\99iÚ_mask
+ = 0xF0000000 >> (
+ü
+ * 4);
+
+2689 \12
+ gcÚd\99iÚ
+ =
+bf
+ >> (
+ü
+ * 4);
+
+2690
+ gcÚd\99iÚ_»g_
+ = (
+cÚd\99iÚ_»g_
+ & ~
+cÚd\99iÚ_mask
+è|
+cÚd\99iÚ
+;
+
+2693 \ 4
+ gFRSP
+: {
+
+2694 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2695 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2696 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2699
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+äb_v®
+);
+
+2700 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2705 \ 4
+ gFCFID
+: {
+
+2706 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2707 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2708 \b
+ gt_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2709
+\9at64_t
+*
+ gäb_v®_p
+ =
+»\9a\8b½»t_ÿ¡
+<\9at64_t*>(&
+t_v®
+);
+
+2710 \b
+ gät_v®
+ =
+¡©ic_ÿ¡
+<\b>(*
+äb_v®_p
+);
+
+2711
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2714 \ 4
+ gFCTID
+: {
+
+2715 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2716 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2717 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2718
+\9at64_t
+
+ gät_v®
+;
+
+2719
+\9at64_t
+
+ gÚe
+ = 1;
+
+2720
+\9at64_t
+
+ gkM\9aLÚgLÚg
+ = (
+Úe
+ << 63);
+
+2721
+\9at64_t
+
+ gkMaxLÚgLÚg
+ =
+kM\9aLÚgLÚg
+ - 1;
+
+2723 ià(
+ gäb_v®
+ >
+ gkMaxLÚgLÚg
+) {
+
+2724
+ gät_v®
+ =
+kMaxLÚgLÚg
+;
+
+2725 } \vià(
+ gäb_v®
+ <
+ gkM\9aLÚgLÚg
+) {
+
+2726
+ gät_v®
+ =
+kM\9aLÚgLÚg
+;
+
+2728 \1a
+ gå_cÚd\99iÚ_»g_
+ &
+ gkFPRound\9agModeMask
+) {
+
+2729 \ 4
+ gkRoundToZ\94o
+:
+
+2730
+ät_v®
+ = (
+\9at64_t
+)
+äb_v®
+;
+
+2732 \ 4
+ gkRoundToPlusInf
+:
+
+2733
+ät_v®
+ = (
+\9at64_t
+)
+¡d
+::
+û\9e
+(
+äb_v®
+);
+
+2735 \ 4
+ gkRoundToM\9ausInf
+:
+
+2736
+ät_v®
+ = (
+\9at64_t
+)
+¡d
+::
+æoÜ
+(
+äb_v®
+);
+
+2739
+ät_v®
+ = (
+\9at64_t
+)
+äb_v®
+;
+
+2740
+UNIMPLEMENTED
+();
+
+2744 \b*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\b*>(&
+ät_v®
+);
+
+2745
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+, *
+p
+);
+
+2748 \ 4
+ gFCTIDZ
+: {
+
+2749 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2750 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2751 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2752
+\9at64_t
+
+ gät_v®
+;
+
+2753
+\9at64_t
+
+ gÚe
+ = 1;
+
+2754
+\9at64_t
+
+ gkM\9aLÚgLÚg
+ = (
+Úe
+ << 63);
+
+2755
+\9at64_t
+
+ gkMaxLÚgLÚg
+ =
+kM\9aLÚgLÚg
+ - 1;
+
+2757 ià(
+ gäb_v®
+ >
+ gkMaxLÚgLÚg
+) {
+
+2758
+ gät_v®
+ =
+kMaxLÚgLÚg
+;
+
+2759 } \vià(
+ gäb_v®
+ <
+ gkM\9aLÚgLÚg
+) {
+
+2760
+ gät_v®
+ =
+kM\9aLÚgLÚg
+;
+
+2762
+ gät_v®
+ = (
+\9at64_t
+)
+äb_v®
+;
+
+2764 \b*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\b*>(&
+ät_v®
+);
+
+2765
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+, *
+p
+);
+
+2768 \ 4
+ gFCTIW
+:
+
+2769 \ 4
+FCTIWZ
+: {
+
+2770 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2771 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2772 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2773
+\9at64_t
+
+ gät_v®
+;
+
+2774 ià(
+ gäb_v®
+ >
+ gkMaxIÁ
+) {
+
+2775
+ gät_v®
+ =
+kMaxIÁ
+;
+
+2776 } \vià(
+ gäb_v®
+ <
+ gkM\9aIÁ
+) {
+
+2777
+ gät_v®
+ =
+kM\9aIÁ
+;
+
+2779 ià(
+ gÝcode
+ =ð
+FCTIWZ
+) {
+
+2780
+ät_v®
+ = (
+\9at64_t
+)
+äb_v®
+;
+
+2782 \1a
+ gå_cÚd\99iÚ_»g_
+ &
+ gkFPRound\9agModeMask
+) {
+
+2783 \ 4
+ gkRoundToZ\94o
+:
+
+2784
+ät_v®
+ = (
+\9at64_t
+)
+äb_v®
+;
+
+2786 \ 4
+ gkRoundToPlusInf
+:
+
+2787
+ät_v®
+ = (
+\9at64_t
+)
+¡d
+::
+û\9e
+(
+äb_v®
+);
+
+2789 \ 4
+ gkRoundToM\9ausInf
+:
+
+2790
+ät_v®
+ = (
+\9at64_t
+)
+¡d
+::
+æoÜ
+(
+äb_v®
+);
+
+2792 \ 4
+ gkRoundToN\97»¡
+:
+
+2793
+ät_v®
+ = (
+\9at64_t
+)
+Ìound
+(
+äb_v®
+);
+
+2796 ià(
+ g¡d
+::
+çbs
+(
+¡©ic_ÿ¡
+<\b>(
+ät_v®
+è-
+äb_v®
+) == 0.5 &&
+
+2797 (
+ät_v®
+ % 2)) {
+
+2798
+ät_v®
+ += ((frt_val > 0) ? -1 : 1);
+
+2803
+DCHECK
+(
+çl£
+);
+
+2804
+ gät_v®
+ = (
+\9at64_t
+)
+äb_v®
+;
+
+2809 \b*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\b*>(&
+ät_v®
+);
+
+2810
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+, *
+p
+);
+
+2813 \ 4
+ gFNEG
+: {
+
+2814 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2815 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2816 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2817 \b
+ gät_v®
+ = -
+äb_v®
+;
+
+2818
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2821 \ 4
+ gFMR
+: {
+
+2822 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2823 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2824 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2825 \b
+ gät_v®
+ =
+äb_v®
+;
+
+2826
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2829 \ 4
+ gMTFSFI
+: {
+
+2830 \12
+bf
+ =
+\9a¡r
+->
+B\99s
+(25, 23);
+
+2831 \12
+ gimm
+ =
+\9a¡r
+->
+B\99s
+(15, 12);
+
+2832 \12
+ gå_cÚd\99iÚ_mask
+ = 0xF0000000 >> (
+bf
+ * 4);
+
+2833
+ gå_cÚd\99iÚ_»g_
+ &ð~
+å_cÚd\99iÚ_mask
+;
+
+2834
+ gå_cÚd\99iÚ_»g_
+ |ð(
+imm
+ << (28 - (
+bf
+ * 4)));
+
+2835 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2836
+ gcÚd\99iÚ_»g_
+ &= 0xF0FFFFFF;
+
+2837
+ gcÚd\99iÚ_»g_
+ |ð(
+imm
+ << 23);
+
+2841 \ 4
+ gMTFSF
+: {
+
+2842 \12
+äb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2843 \b
+ gäb_dv®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2844
+\9at64_t
+*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\9at64_t*>(&
+äb_dv®
+);
+
+2845
+\9at32_t
+
+ gäb_iv®
+ =
+¡©ic_ÿ¡
+<\9at32_t>((*
+p
+) & 0xffffffff);
+
+2846 \12
+ gl
+ =
+\9a¡r
+->
+B\99s
+(25, 25);
+
+2847 ià(
+ gl
+ == 1) {
+
+2848
+å_cÚd\99iÚ_»g_
+ =
+äb_iv®
+;
+
+2850
+UNIMPLEMENTED
+();
+
+2852 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2853
+UNIMPLEMENTED
+();
+
+2859 \ 4
+ gMFFS
+: {
+
+2860 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2861
+\9at64_t
+
+ glv®
+ =
+¡©ic_ÿ¡
+<\9at64_t>(
+å_cÚd\99iÚ_»g_
+);
+
+2862 \b*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\b*>(&
+lv®
+);
+
+2863
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+, *
+p
+);
+
+2866 \ 4
+ gFABS
+: {
+
+2867 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2868 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2869 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2870 \b
+ gät_v®
+ =
+¡d
+::
+çbs
+(
+äb_v®
+);
+
+2871
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2874 \ 4
+ gFRIM
+: {
+
+2875 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+2876 \12
+ gäb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2877 \b
+ gäb_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äb
+);
+
+2878
+\9at64_t
+
+ gæoÜ_v®
+ = (\9at64_t)
+äb_v®
+;
+
+2879 ià(
+ gæoÜ_v®
+ >
+ gäb_v®
+) floor_val--;
+
+2880 \b
+ gät_v®
+ =
+¡©ic_ÿ¡
+<\b>(
+æoÜ_v®
+);
+
+2881
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+ät_v®
+);
+
+2885
+UNIMPLEMENTED
+();
+
+2888 #ià
+V8_TARGET_ARCH_PPC64
+
+
+2889 \1e
+ gSimuÏtÜ
+::
+Execu\8bExt5
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+2890 \1a
+\9a¡r
+->
+B\99s
+(4, 2) << 2) {
+
+2891 \ 4
+ gRLDICL
+: {
+
+2892 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2893 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2894
+u\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2895 \12
+ gsh
+ = (
+\9a¡r
+->
+B\99s
+(15, 11è| (
+ g\9a¡r
+->
+B\99
+(1) << 5));
+
+2896 \12
+ gmb
+ = (
+\9a¡r
+->
+B\99s
+(10, 6è| (
+ g\9a¡r
+->
+B\99
+(5) << 5));
+
+2897
+DCHECK
+(
+sh
+ >= 0 && sh <= 63);
+
+2898
+DCHECK
+(
+mb
+ >= 0 && mb <= 63);
+
+2900
+u\9a\8d\8c_t
+
+ g»suÉ
+ = (
+rs_v®
+ <<
+sh
+) | (rs_val >> (64 - sh));
+
+2901
+u\9a\8d\8c_t
+
+ gmask
+ = 0xfffffffffffffffà>>
+mb
+;
+
+2902
+ g»suÉ
+ &ð
+mask
+;
+
+2903
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+2904 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2905
+S\91CR0
+(
+»suÉ
+);
+
+2909 \ 4
+ gRLDICR
+: {
+
+2910 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2911 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2912
+u\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2913 \12
+ gsh
+ = (
+\9a¡r
+->
+B\99s
+(15, 11è| (
+ g\9a¡r
+->
+B\99
+(1) << 5));
+
+2914 \12
+ gme
+ = (
+\9a¡r
+->
+B\99s
+(10, 6è| (
+ g\9a¡r
+->
+B\99
+(5) << 5));
+
+2915
+DCHECK
+(
+sh
+ >= 0 && sh <= 63);
+
+2916
+DCHECK
+(
+me
+ >= 0 && me <= 63);
+
+2918
+u\9a\8d\8c_t
+
+ g»suÉ
+ = (
+rs_v®
+ <<
+sh
+) | (rs_val >> (64 - sh));
+
+2919
+u\9a\8d\8c_t
+
+ gmask
+ = 0xfffffffffffffffà<< (63 -
+me
+);
+
+2920
+ g»suÉ
+ &ð
+mask
+;
+
+2921
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+2922 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2923
+S\91CR0
+(
+»suÉ
+);
+
+2927 \ 4
+ gRLDIC
+: {
+
+2928 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2929 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2930
+u\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2931 \12
+ gsh
+ = (
+\9a¡r
+->
+B\99s
+(15, 11è| (
+ g\9a¡r
+->
+B\99
+(1) << 5));
+
+2932 \12
+ gmb
+ = (
+\9a¡r
+->
+B\99s
+(10, 6è| (
+ g\9a¡r
+->
+B\99
+(5) << 5));
+
+2933
+DCHECK
+(
+sh
+ >= 0 && sh <= 63);
+
+2934
+DCHECK
+(
+mb
+ >= 0 && mb <= 63);
+
+2936
+u\9a\8d\8c_t
+
+ g»suÉ
+ = (
+rs_v®
+ <<
+sh
+) | (rs_val >> (64 - sh));
+
+2937
+u\9a\8d\8c_t
+
+ gmask
+ = (0xfffffffffffffffà>>
+mb
+è& (0xfffffffffffffffà<<
+sh
+);
+
+2938
+ g»suÉ
+ &ð
+mask
+;
+
+2939
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+2940 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2941
+S\91CR0
+(
+»suÉ
+);
+
+2945 \ 4
+ gRLDIMI
+: {
+
+2946 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2947 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2948
+u\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2949
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+2950 \12
+ gsh
+ = (
+\9a¡r
+->
+B\99s
+(15, 11è| (
+ g\9a¡r
+->
+B\99
+(1) << 5));
+
+2951 \12
+ gmb
+ = (
+\9a¡r
+->
+B\99s
+(10, 6è| (
+ g\9a¡r
+->
+B\99
+(5) << 5));
+
+2952 \12
+ gme
+ = 63 -
+sh
+;
+
+2954
+u\9a\8d\8c_t
+
+ g»suÉ
+ = (
+rs_v®
+ <<
+sh
+) | (rs_val >> (64 - sh));
+
+2955
+u\9a\8d\8c_t
+
+ gmask
+ = 0;
+
+2956 ià(
+ gmb
+ <
+ gme
+ + 1) {
+
+2957
+u\9a\8d\8c_t
+
+ gb\99
+ = 0x8000000000000000 >>
+mb
+;
+
+2958 \ f;
+ gmb
+ <ð
+me
+; mb++) {
+
+2959
+ gmask
+ |ð
+b\99
+;
+
+2960
+ gb\99
+ >>= 1;
+
+2962 } \vià(
+ gmb
+ =ð
+me
+ + 1) {
+
+2963
+mask
+ = 0xffffffffffffffff;
+
+2965
+u\9a\8d\8c_t
+
+ gb\99
+ = 0x8000000000000000 >> (
+me
+ + 1);
+
+2966
+ gmask
+ = 0xffffffffffffffff;
+
+2967 \ f;
+ gme
+ <
+ gmb
+; me++) {
+
+2968
+ gmask
+ ^ð
+b\99
+;
+
+2969
+ gb\99
+ >>= 1;
+
+2972
+ g»suÉ
+ &ð
+mask
+;
+
+2973
+ g¿_v®
+ &ð~
+mask
+;
+
+2974
+ g»suÉ
+ |ð
+¿_v®
+;
+
+2975
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+2976 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2977
+S\91CR0
+(
+»suÉ
+);
+
+2982 \1a
+ g\9a¡r
+->
+B\99s
+(4, 1) << 1) {
+
+2983 \ 4
+ gRLDCL
+: {
+
+2984 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+2985 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+2986 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+2987
+u\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+2988
+u\9a\8d\8c_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+2989 \12
+ gsh
+ = (
+rb_v®
+ & 0x3f);
+
+2990 \12
+ gmb
+ = (
+\9a¡r
+->
+B\99s
+(10, 6è| (
+ g\9a¡r
+->
+B\99
+(5) << 5));
+
+2991
+DCHECK
+(
+sh
+ >= 0 && sh <= 63);
+
+2992
+DCHECK
+(
+mb
+ >= 0 && mb <= 63);
+
+2994
+u\9a\8d\8c_t
+
+ g»suÉ
+ = (
+rs_v®
+ <<
+sh
+) | (rs_val >> (64 - sh));
+
+2995
+u\9a\8d\8c_t
+
+ gmask
+ = 0xfffffffffffffffà>>
+mb
+;
+
+2996
+ g»suÉ
+ &ð
+mask
+;
+
+2997
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+2998 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+2999
+S\91CR0
+(
+»suÉ
+);
+
+3004
+UNIMPLEMENTED
+();
+
+3009 \1e
+ gSimuÏtÜ
+::
+Execu\8bG\92\94ic
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+3010 \12
+Ýcode
+ =
+\9a¡r
+->
+OpcodeV®ue
+() << 26;
+
+3011 \1a
+ gÝcode
+) {
+
+3012 \ 4
+ gSUBFIC
+: {
+
+3013 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+3014 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3015
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+3016
+\9at32_t
+
+ gim_v®
+ =
+\9a¡r
+->
+B\99s
+(15, 0);
+
+3017
+ gim_v®
+ =
+SIGN_EXT_IMM16
+(
+im_v®
+);
+
+3018
+\9a\8d\8c_t
+
+ g®u_out
+ =
+im_v®
+ -
+¿_v®
+;
+
+3019
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+3023 \ 4
+ gCMPLI
+: {
+
+3024 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3025
+u\9at32_t
+
+ gim_v®
+ =
+\9a¡r
+->
+B\99s
+(15, 0);
+
+3026 \12
+ gü
+ =
+\9a¡r
+->
+B\99s
+(25, 23);
+
+3027
+u\9at32_t
+
+ gbf
+ = 0;
+
+3028 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3029 \12
+ gL
+ =
+\9a¡r
+->
+B\99
+(21);
+
+3030 ià(
+ gL
+) {
+
+3032
+u\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+3033 ià(
+ g¿_v®
+ <
+ gim_v®
+) {
+
+3034
+ gbf
+ |= 0x80000000;
+
+3036 ià(
+ g¿_v®
+ >
+ gim_v®
+) {
+
+3037
+ gbf
+ |= 0x40000000;
+
+3039 ià(
+ g¿_v®
+ =ð
+im_v®
+) {
+
+3040
+bf
+ |= 0x20000000;
+
+3042 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3044
+u\9at32_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+3045 ià(
+ g¿_v®
+ <
+ gim_v®
+) {
+
+3046
+ gbf
+ |= 0x80000000;
+
+3048 ià(
+ g¿_v®
+ >
+ gim_v®
+) {
+
+3049
+ gbf
+ |= 0x40000000;
+
+3051 ià(
+ g¿_v®
+ =ð
+im_v®
+) {
+
+3052
+bf
+ |= 0x20000000;
+
+3056
+u\9at32_t
+
+ gcÚd\99iÚ_mask
+ = 0xF0000000U >> (
+ü
+ * 4);
+
+3057
+u\9at32_t
+
+ gcÚd\99iÚ
+ =
+bf
+ >> (
+ü
+ * 4);
+
+3058
+ gcÚd\99iÚ_»g_
+ = (
+cÚd\99iÚ_»g_
+ & ~
+cÚd\99iÚ_mask
+è|
+cÚd\99iÚ
+;
+
+3061 \ 4
+ gCMPI
+: {
+
+3062 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3063
+\9at32_t
+
+ gim_v®
+ =
+\9a¡r
+->
+B\99s
+(15, 0);
+
+3064
+ gim_v®
+ =
+SIGN_EXT_IMM16
+(
+im_v®
+);
+
+3065 \12
+ gü
+ =
+\9a¡r
+->
+B\99s
+(25, 23);
+
+3066
+u\9at32_t
+
+ gbf
+ = 0;
+
+3067 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3068 \12
+ gL
+ =
+\9a¡r
+->
+B\99
+(21);
+
+3069 ià(
+ gL
+) {
+
+3071
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+3072 ià(
+ g¿_v®
+ <
+ gim_v®
+) {
+
+3073
+ gbf
+ |= 0x80000000;
+
+3075 ià(
+ g¿_v®
+ >
+ gim_v®
+) {
+
+3076
+ gbf
+ |= 0x40000000;
+
+3078 ià(
+ g¿_v®
+ =ð
+im_v®
+) {
+
+3079
+bf
+ |= 0x20000000;
+
+3081 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3083
+\9at32_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+3084 ià(
+ g¿_v®
+ <
+ gim_v®
+) {
+
+3085
+ gbf
+ |= 0x80000000;
+
+3087 ià(
+ g¿_v®
+ >
+ gim_v®
+) {
+
+3088
+ gbf
+ |= 0x40000000;
+
+3090 ià(
+ g¿_v®
+ =ð
+im_v®
+) {
+
+3091
+bf
+ |= 0x20000000;
+
+3095
+u\9at32_t
+
+ gcÚd\99iÚ_mask
+ = 0xF0000000U >> (
+ü
+ * 4);
+
+3096
+u\9at32_t
+
+ gcÚd\99iÚ
+ =
+bf
+ >> (
+ü
+ * 4);
+
+3097
+ gcÚd\99iÚ_»g_
+ = (
+cÚd\99iÚ_»g_
+ & ~
+cÚd\99iÚ_mask
+è|
+cÚd\99iÚ
+;
+
+3100 \ 4
+ gADDIC
+: {
+
+3101 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+3102 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3103
+u\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+3104
+u\9a\8d\8c_t
+
+ gim_v®
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0));
+
+3105
+u\9a\8d\8c_t
+
+ g®u_out
+ =
+¿_v®
+ +
+im_v®
+;
+
+3107 ià(~
+ g¿_v®
+ <
+ gim_v®
+) {
+
+3108
+ g¥ec\9fl_»g_x\94_
+ = (
+¥ec\9fl_»g_x\94_
+ & ~0xF0000000) | 0x20000000;
+
+3110
+ g¥ec\9fl_»g_x\94_
+ &= ~0xF0000000;
+
+3112
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+3115 \ 4
+ gADDI
+: {
+
+3116 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+3117 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3118
+\9at32_t
+
+ gim_v®
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0));
+
+3119
+\9a\8d\8c_t
+
+ g®u_out
+;
+
+3120 ià(
+ g¿
+ == 0) {
+
+3121
+®u_out
+ =
+im_v®
+;
+
+3123
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+3124
+ g®u_out
+ =
+¿_v®
+ +
+im_v®
+;
+
+3126
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+3130 \ 4
+ gADDIS
+: {
+
+3131 \12
+¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+3132 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3133
+\9at32_t
+
+ gim_v®
+ = (
+\9a¡r
+->
+B\99s
+(15, 0) << 16);
+
+3134
+\9a\8d\8c_t
+
+ g®u_out
+;
+
+3135 ià(
+ g¿
+ == 0) {
+
+3136
+®u_out
+ =
+im_v®
+;
+
+3138
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+3139
+ g®u_out
+ =
+¿_v®
+ +
+im_v®
+;
+
+3141
+£t_»gi¡\94
+(
+¹
+,
+®u_out
+);
+
+3144 \ 4
+ gBCX
+: {
+
+3145
+Execu\8bB¿nchCÚd\99iÚ®
+(
+\9a¡r
+);
+
+3148 \ 4
+ gBX
+: {
+
+3149 \12
+off£t
+ = (
+\9a¡r
+->
+B\99s
+(25, 2) << 8) >> 6;
+
+3150 ià(
+ g\9a¡r
+->
+B\99
+(0) == 1) {
+
+3151
+¥ec\9fl_»g_Ì_
+ =
+g\91_pc
+() + 4;
+
+3153
+£t_pc
+(
+g\91_pc
+(è+
+off£t
+);
+
+3157 \ 4
+ gEXT1
+: {
+
+3158
+Execu\8bExt1
+(
+\9a¡r
+);
+
+3161 \ 4
+ gRLWIMIX
+: {
+
+3162 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3163 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3164
+u\9at32_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+3165
+\9at32_t
+
+ g¿_v®
+ =
+g\91_»gi¡\94
+(
+¿
+);
+
+3166 \12
+ gsh
+ =
+\9a¡r
+->
+B\99s
+(15, 11);
+
+3167 \12
+ gmb
+ =
+\9a¡r
+->
+B\99s
+(10, 6);
+
+3168 \12
+ gme
+ =
+\9a¡r
+->
+B\99s
+(5, 1);
+
+3170
+u\9at32_t
+
+ g»suÉ
+ = (
+rs_v®
+ <<
+sh
+) | (rs_val >> (32 - sh));
+
+3171 \12
+ gmask
+ = 0;
+
+3172 ià(
+ gmb
+ <
+ gme
+ + 1) {
+
+3173 \12
+ gb\99
+ = 0x80000000 >>
+mb
+;
+
+3174 \ f;
+ gmb
+ <ð
+me
+; mb++) {
+
+3175
+ gmask
+ |ð
+b\99
+;
+
+3176
+ gb\99
+ >>= 1;
+
+3178 } \vià(
+ gmb
+ =ð
+me
+ + 1) {
+
+3179
+mask
+ = 0xffffffff;
+
+3181 \12
+ gb\99
+ = 0x80000000 >> (
+me
+ + 1);
+
+3182
+ gmask
+ = 0xffffffff;
+
+3183 \ f;
+ gme
+ <
+ gmb
+; me++) {
+
+3184
+ gmask
+ ^ð
+b\99
+;
+
+3185
+ gb\99
+ >>= 1;
+
+3188
+ g»suÉ
+ &ð
+mask
+;
+
+3189
+ g¿_v®
+ &ð~
+mask
+;
+
+3190
+ g»suÉ
+ |ð
+¿_v®
+;
+
+3191
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+3192 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+3193
+S\91CR0
+(
+»suÉ
+);
+
+3197 \ 4
+ gRLWINMX
+:
+
+3198 \ 4
+RLWNMX
+: {
+
+3199 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3200 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3201
+u\9at32_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+3202 \12
+ gsh
+ = 0;
+
+3203 ià(
+ gÝcode
+ =ð
+RLWINMX
+) {
+
+3204
+sh
+ =
+\9a¡r
+->
+B\99s
+(15, 11);
+
+3206 \12
+ grb
+ =
+\9a¡r
+->
+RBV®ue
+();
+
+3207
+u\9at32_t
+
+ grb_v®
+ =
+g\91_»gi¡\94
+(
+rb
+);
+
+3208
+ gsh
+ = (
+rb_v®
+ & 0x1f);
+
+3210 \12
+ gmb
+ =
+\9a¡r
+->
+B\99s
+(10, 6);
+
+3211 \12
+ gme
+ =
+\9a¡r
+->
+B\99s
+(5, 1);
+
+3213
+u\9at32_t
+
+ g»suÉ
+ = (
+rs_v®
+ <<
+sh
+) | (rs_val >> (32 - sh));
+
+3214 \12
+ gmask
+ = 0;
+
+3215 ià(
+ gmb
+ <
+ gme
+ + 1) {
+
+3216 \12
+ gb\99
+ = 0x80000000 >>
+mb
+;
+
+3217 \ f;
+ gmb
+ <ð
+me
+; mb++) {
+
+3218
+ gmask
+ |ð
+b\99
+;
+
+3219
+ gb\99
+ >>= 1;
+
+3221 } \vià(
+ gmb
+ =ð
+me
+ + 1) {
+
+3222
+mask
+ = 0xffffffff;
+
+3224 \12
+ gb\99
+ = 0x80000000 >> (
+me
+ + 1);
+
+3225
+ gmask
+ = 0xffffffff;
+
+3226 \ f;
+ gme
+ <
+ gmb
+; me++) {
+
+3227
+ gmask
+ ^ð
+b\99
+;
+
+3228
+ gb\99
+ >>= 1;
+
+3231
+ g»suÉ
+ &ð
+mask
+;
+
+3232
+£t_»gi¡\94
+(
+¿
+,
+»suÉ
+);
+
+3233 ià(
+ g\9a¡r
+->
+B\99
+(0)) {
+
+3234
+S\91CR0
+(
+»suÉ
+);
+
+3238 \ 4
+ gORI
+: {
+
+3239 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3240 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3241
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+3242
+u\9at32_t
+
+ gim_v®
+ =
+\9a¡r
+->
+B\99s
+(15, 0);
+
+3243
+\9a\8d\8c_t
+
+ g®u_out
+ =
+rs_v®
+ |
+im_v®
+;
+
+3244
+£t_»gi¡\94
+(
+¿
+,
+®u_out
+);
+
+3247 \ 4
+ gORIS
+: {
+
+3248 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3249 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3250
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+3251
+u\9at32_t
+
+ gim_v®
+ =
+\9a¡r
+->
+B\99s
+(15, 0);
+
+3252
+\9a\8d\8c_t
+
+ g®u_out
+ =
+rs_v®
+ | (
+im_v®
+ << 16);
+
+3253
+£t_»gi¡\94
+(
+¿
+,
+®u_out
+);
+
+3256 \ 4
+ gXORI
+: {
+
+3257 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3258 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3259
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+3260
+u\9at32_t
+
+ gim_v®
+ =
+\9a¡r
+->
+B\99s
+(15, 0);
+
+3261
+\9a\8d\8c_t
+
+ g®u_out
+ =
+rs_v®
+ ^
+im_v®
+;
+
+3262
+£t_»gi¡\94
+(
+¿
+,
+®u_out
+);
+
+3266 \ 4
+ gXORIS
+: {
+
+3267 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3268 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3269
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+3270
+u\9at32_t
+
+ gim_v®
+ =
+\9a¡r
+->
+B\99s
+(15, 0);
+
+3271
+\9a\8d\8c_t
+
+ g®u_out
+ =
+rs_v®
+ ^ (
+im_v®
+ << 16);
+
+3272
+£t_»gi¡\94
+(
+¿
+,
+®u_out
+);
+
+3275 \ 4
+ gANDIx
+: {
+
+3276 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3277 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3278
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+3279
+u\9at32_t
+
+ gim_v®
+ =
+\9a¡r
+->
+B\99s
+(15, 0);
+
+3280
+\9a\8d\8c_t
+
+ g®u_out
+ =
+rs_v®
+ &
+im_v®
+;
+
+3281
+£t_»gi¡\94
+(
+¿
+,
+®u_out
+);
+
+3282
+S\91CR0
+(
+®u_out
+);
+
+3285 \ 4
+ gANDISx
+: {
+
+3286 \12
+rs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3287 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3288
+\9a\8d\8c_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+3289
+u\9at32_t
+
+ gim_v®
+ =
+\9a¡r
+->
+B\99s
+(15, 0);
+
+3290
+\9a\8d\8c_t
+
+ g®u_out
+ =
+rs_v®
+ & (
+im_v®
+ << 16);
+
+3291
+£t_»gi¡\94
+(
+¿
+,
+®u_out
+);
+
+3292
+S\91CR0
+(
+®u_out
+);
+
+3295 \ 4
+ gEXT2
+: {
+
+3296
+Execu\8bExt2
+(
+\9a¡r
+);
+
+3300 \ 4
+ gLWZU
+:
+
+3301 \ 4
+LWZ
+: {
+
+3302 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3303 \12
+ g¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+3304
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+3305 \12
+ goff£t
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0));
+
+3306
+£t_»gi¡\94
+(
+¹
+,
+R\97dWU
+(
+¿_v®
+ +
+off£t
+,
+\9a¡r
+));
+
+3307 ià(
+ gÝcode
+ =ð
+LWZU
+) {
+
+3308
+DCHECK
+(
+¿
+ != 0);
+
+3309
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+off£t
+);
+
+3314 \ 4
+ gLBZU
+:
+
+3315 \ 4
+LBZ
+: {
+
+3316 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3317 \12
+ g¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+3318
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+3319 \12
+ goff£t
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0));
+
+3320
+£t_»gi¡\94
+(
+¹
+,
+R\97dB
+(
+¿_v®
+ +
+off£t
+) & 0xFF);
+
+3321 ià(
+ gÝcode
+ =ð
+LBZU
+) {
+
+3322
+DCHECK
+(
+¿
+ != 0);
+
+3323
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+off£t
+);
+
+3328 \ 4
+ gSTWU
+:
+
+3329 \ 4
+STW
+: {
+
+3330 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3331 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3332
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+3333
+\9at32_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+3334 \12
+ goff£t
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0));
+
+3335
+Wr\99eW
+(
+¿_v®
+ +
+off£t
+,
+rs_v®
+,
+\9a¡r
+);
+
+3336 ià(
+ gÝcode
+ =ð
+STWU
+) {
+
+3337
+DCHECK
+(
+¿
+ != 0);
+
+3338
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+off£t
+);
+
+3344 \ 4
+ gSTBU
+:
+
+3345 \ 4
+STB
+: {
+
+3346 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3347 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3348
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+3349
+\9at8_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+3350 \12
+ goff£t
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0));
+
+3351
+Wr\99eB
+(
+¿_v®
+ +
+off£t
+,
+rs_v®
+);
+
+3352 ià(
+ gÝcode
+ =ð
+STBU
+) {
+
+3353
+DCHECK
+(
+¿
+ != 0);
+
+3354
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+off£t
+);
+
+3359 \ 4
+ gLHZU
+:
+
+3360 \ 4
+LHZ
+: {
+
+3361 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3362 \12
+ g¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+3363
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+3364 \12
+ goff£t
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0));
+
+3365
+u\9a\8d\8c_t
+
+ g»suÉ
+ =
+R\97dHU
+(
+¿_v®
+ +
+off£t
+,
+\9a¡r
+) & 0xffff;
+
+3366
+£t_»gi¡\94
+(
+¹
+,
+»suÉ
+);
+
+3367 ià(
+ gÝcode
+ =ð
+LHZU
+) {
+
+3368
+DCHECK
+(
+¿
+ != 0);
+
+3369
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+off£t
+);
+
+3374 \ 4
+ gLHA
+:
+
+3375 \ 4
+LHAU
+: {
+
+3376
+UNIMPLEMENTED
+();
+
+3380 \ 4
+ gSTHU
+:
+
+3381 \ 4
+STH
+: {
+
+3382 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3383 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3384
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+3385
+\9at16_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+3386 \12
+ goff£t
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0));
+
+3387
+Wr\99eH
+(
+¿_v®
+ +
+off£t
+,
+rs_v®
+,
+\9a¡r
+);
+
+3388 ià(
+ gÝcode
+ =ð
+STHU
+) {
+
+3389
+DCHECK
+(
+¿
+ != 0);
+
+3390
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+off£t
+);
+
+3395 \ 4
+ gLMW
+:
+
+3396 \ 4
+STMW
+: {
+
+3397
+UNIMPLEMENTED
+();
+
+3401 \ 4
+ gLFSU
+:
+
+3402 \ 4
+LFS
+: {
+
+3403 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+3404 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3405
+\9at32_t
+
+ goff£t
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0));
+
+3406
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+3407
+\9at32_t
+
+ gv®
+ =
+R\97dW
+(
+¿_v®
+ +
+off£t
+,
+\9a¡r
+);
+
+3408 \ e*
+ gå\8c
+ =
+»\9a\8b½»t_ÿ¡
+<\ e*>(&
+v®
+);
+
+3409
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+,
+¡©ic_ÿ¡
+<\b>(*
+å\8c
+));
+
+3410 ià(
+ gÝcode
+ =ð
+LFSU
+) {
+
+3411
+DCHECK
+(
+¿
+ != 0);
+
+3412
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+off£t
+);
+
+3417 \ 4
+ gLFDU
+:
+
+3418 \ 4
+LFD
+: {
+
+3419 \12
+ät
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+3420 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3421
+\9at32_t
+
+ goff£t
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0));
+
+3422
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+3423 \b*
+ gd±r
+ =
+»\9a\8b½»t_ÿ¡
+<\b*>(
+R\97dDW
+(
+¿_v®
+ +
+off£t
+));
+
+3424
+£t_d_»gi¡\94_äom_doubË
+(
+ät
+, *
+d±r
+);
+
+3425 ià(
+ gÝcode
+ =ð
+LFDU
+) {
+
+3426
+DCHECK
+(
+¿
+ != 0);
+
+3427
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+off£t
+);
+
+3432 \ 4
+ gSTFSU
+: {
+
+3433 \ 4
+STFS
+:
+
+3434 \12
+äs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3435 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3436
+\9at32_t
+
+ goff£t
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0));
+
+3437
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+3438 \ e
+ gäs_v®
+ =
+¡©ic_ÿ¡
+<\ e>(
+g\91_doubË_äom_d_»gi¡\94
+(
+äs
+));
+
+3439
+\9at32_t
+*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\9at32_t*>(&
+äs_v®
+);
+
+3440
+Wr\99eW
+(
+¿_v®
+ +
+off£t
+, *
+p
+,
+\9a¡r
+);
+
+3441 ià(
+ gÝcode
+ =ð
+STFSU
+) {
+
+3442
+DCHECK
+(
+¿
+ != 0);
+
+3443
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+off£t
+);
+
+3448 \ 4
+ gSTFDU
+:
+
+3449 \ 4
+STFD
+: {
+
+3450 \12
+äs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3451 \12
+ g¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3452
+\9at32_t
+
+ goff£t
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0));
+
+3453
+\9a\8d\8c_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+3454 \b
+ gäs_v®
+ =
+g\91_doubË_äom_d_»gi¡\94
+(
+äs
+);
+
+3455
+\9at64_t
+*
+ gp
+ =
+»\9a\8b½»t_ÿ¡
+<\9at64_t*>(&
+äs_v®
+);
+
+3456
+Wr\99eDW
+(
+¿_v®
+ +
+off£t
+, *
+p
+);
+
+3457 ià(
+ gÝcode
+ =ð
+STFDU
+) {
+
+3458
+DCHECK
+(
+¿
+ != 0);
+
+3459
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+off£t
+);
+
+3464 \ 4
+ gEXT3
+:
+
+3465
+UNIMPLEMENTED
+();
+
+3466 \ 4
+ gEXT4
+: {
+
+3467
+Execu\8bExt4
+(
+\9a¡r
+);
+
+3471 #ià
+V8_TARGET_ARCH_PPC64
+
+
+3472 \ 4
+ gEXT5
+: {
+
+3473
+Execu\8bExt5
+(
+\9a¡r
+);
+
+3476 \ 4
+ gLD
+: {
+
+3477 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3478 \12
+ g¹
+ =
+\9a¡r
+->
+RTV®ue
+();
+
+3479
+\9at64_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+3480 \12
+ goff£t
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0) & ~3);
+
+3481 \1a
+ g\9a¡r
+->
+B\99s
+(1, 0)) {
+
+3483
+\9a\8d\8c_t
+*
+»suÉ
+ =
+R\97dDW
+(
+¿_v®
+ +
+off£t
+);
+
+3484
+£t_»gi¡\94
+(
+¹
+, *
+»suÉ
+);
+
+3488
+\9a\8d\8c_t
+*
+»suÉ
+ =
+R\97dDW
+(
+¿_v®
+ +
+off£t
+);
+
+3489
+£t_»gi¡\94
+(
+¹
+, *
+»suÉ
+);
+
+3490
+DCHECK
+(
+¿
+ != 0);
+
+3491
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+off£t
+);
+
+3495
+\9a\8d\8c_t
+
+»suÉ
+ =
+R\97dW
+(
+¿_v®
+ +
+off£t
+,
+\9a¡r
+);
+
+3496
+£t_»gi¡\94
+(
+¹
+,
+»suÉ
+);
+
+3503 \ 4
+ gSTD
+: {
+
+3504 \12
+¿
+ =
+\9a¡r
+->
+RAV®ue
+();
+
+3505 \12
+ grs
+ =
+\9a¡r
+->
+RSV®ue
+();
+
+3506
+\9at64_t
+
+ g¿_v®
+ =
+¿
+ =ð0 ? 0 :
+g\91_»gi¡\94
+(ra);
+
+3507
+\9at64_t
+
+ grs_v®
+ =
+g\91_»gi¡\94
+(
+rs
+);
+
+3508 \12
+ goff£t
+ =
+SIGN_EXT_IMM16
+(
+\9a¡r
+->
+B\99s
+(15, 0) & ~3);
+
+3509
+Wr\99eDW
+(
+¿_v®
+ +
+off£t
+,
+rs_v®
+);
+
+3510 ià(
+ g\9a¡r
+->
+B\99
+(0) == 1) {
+
+3511
+DCHECK
+(
+¿
+ != 0);
+
+3512
+£t_»gi¡\94
+(
+¿
+,
+¿_v®
+ +
+off£t
+);
+
+3518 \ 4
+ gFAKE_OPCODE
+: {
+
+3519 ià(
+\9a¡r
+->
+B\99s
+(
+MARKER_SUBOPCODE_BIT
+, MARKER_SUBOPCODE_BIT) == 1) {
+
+3520 \12
+m¬k\94_code
+ =
+\9a¡r
+->
+B\99s
+(
+STUB_MARKER_HIGH_BIT
+, 0);
+
+3521
+DCHECK
+(
+m¬k\94_code
+ <
+F_NEXT_AVAILABLE_STUB_MARKER
+);
+
+3522
+Pr\9atF
+("H\99 stub-m¬k\94: %d (EMIT_STUB_MARKER)\n",
+m¬k\94_code
+);
+
+3524 \12
+ gçke_Ýcode
+ =
+\9a¡r
+->
+B\99s
+(
+FAKE_OPCODE_HIGH_BIT
+, 0);
+
+3525 ià(
+ gçke_Ýcode
+ =ð
+fBKPT
+) {
+
+3526
+PPCDebugg\94
+
+dbg
+(
+this
+);
+
+3527
+Pr\9atF
+("Simulator hit BKPT.\n");
+
+3528
+ gdbg
+.
+Debug
+();
+
+3530
+DCHECK
+(
+çke_Ýcode
+ <
+fLa¡Fak\94
+);
+
+3531
+Pr\9atF
+("Hit ARM opcode: %d(FAKE_OPCODE defined in constant-ppc.h)\n",
+
+3532
+çke_Ýcode
+);
+
+3533
+UNIMPLEMENTED
+();
+
+3540
+UNIMPLEMENTED
+();
+
+3547 \1e
+ gSimuÏtÜ
+::
+T¿û
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+3548
+di§sm
+::
+NameCÚv\94\8br
+
+cÚv\94\8br
+;
+
+3549
+ gdi§sm
+::
+Di§s£mbËr
+
+dasm
+(
+cÚv\94\8br
+);
+
+3551
+ gv8
+::
+\9a\8bº®
+::
+EmbeddedVeùÜ
+<\ 5, 256>
+ gbufãr
+;
+
+3552
+ gdasm
+.
+In¡ruùiÚDecode
+(
+bufãr
+,
+»\9a\8b½»t_ÿ¡
+<
+by\8b
+*>(
+\9a¡r
+));
+
+3553
+Pr\9atF
+("%05d %08"
+V8PRIxPTR
+ " %s\n",
+icouÁ_
+,
+
+3554
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+\9a¡r
+),
+bufãr
+.
+¡¬t
+());
+
+3559 \1e
+ gSimuÏtÜ
+::
+Execu\8bIn¡ruùiÚ
+(
+In¡ruùiÚ
+*
+\9a¡r
+) {
+
+3560 ià(
+v8
+::
+\9a\8bº®
+::
+FLAG_check_iÿche
+) {
+
+3561
+CheckICache
+(
+isީe_
+->
+simuÏtÜ_i_ÿche
+(),
+\9a¡r
+);
+
+3563
+ gpc_modif\9bd_
+ =
+çl£
+;
+
+3564 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_\8caû_sim
+) {
+
+3565
+T¿û
+(
+\9a¡r
+);
+
+3567 \12
+ gÝcode
+ =
+\9a¡r
+->
+OpcodeV®ue
+() << 26;
+
+3568 ià(
+ gÝcode
+ =ð
+TWI
+) {
+
+3569
+Soáw¬eIÁ\94ru±
+(
+\9a¡r
+);
+
+3571
+Execu\8bG\92\94ic
+(
+\9a¡r
+);
+
+3573 ià(!
+ gpc_modif\9bd_
+) {
+
+3574
+£t_pc
+(
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+\9a¡r
+è+
+In¡ruùiÚ
+::
+kIn¡rSize
+);
+
+3579 \1e
+ gSimuÏtÜ
+::
+Execu\8b
+() {
+
+3582
+\9a\8d\8c_t
+
+´og¿m_couÁ\94
+ =
+g\91_pc
+();
+
+3584 ià(::
+v8
+::
+\9a\8bº®
+::
+FLAG_¡Ý_sim_©
+ == 0) {
+
+3587 \1f
+´og¿m_couÁ\94
+ !ð
+\92d_sim_pc
+) {
+
+3588
+In¡ruùiÚ
+*
+\9a¡r
+ =
+»\9a\8b½»t_ÿ¡
+<In¡ruùiÚ*>(
+´og¿m_couÁ\94
+);
+
+3589
+ gicouÁ_
+++;
+
+3590
+Execu\8bIn¡ruùiÚ
+(
+\9a¡r
+);
+
+3591
+ g´og¿m_couÁ\94
+ =
+g\91_pc
+();
+
+3596 \1f
+ g´og¿m_couÁ\94
+ !ð
+\92d_sim_pc
+) {
+
+3597
+In¡ruùiÚ
+*
+\9a¡r
+ =
+»\9a\8b½»t_ÿ¡
+<In¡ruùiÚ*>(
+´og¿m_couÁ\94
+);
+
+3598
+ gicouÁ_
+++;
+
+3599 ià(
+ gicouÁ_
+ =ð::
+v8
+::
+\9a\8bº®
+::
+FLAG_¡Ý_sim_©
+) {
+
+3600
+PPCDebugg\94
+
+dbg
+(
+this
+);
+
+3601
+ gdbg
+.
+Debug
+();
+
+3603
+Execu\8bIn¡ruùiÚ
+(
+\9a¡r
+);
+
+3605
+ g´og¿m_couÁ\94
+ =
+g\91_pc
+();
+
+3611 \1e
+ gSimuÏtÜ
+::
+C®lIÁ\94Çl
+(
+by\8b
+*
+\92\8cy
+) {
+
+3613 #ià
+ABI_USES_FUNCTION_DESCRIPTORS
+
+
+3615
+£t_pc
+(*(
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+*>(
+\92\8cy
+)));
+
+3618
+£t_pc
+(
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+>(
+\92\8cy
+));
+
+3624
+ g¥ec\9fl_»g_Ì_
+ =
+\92d_sim_pc
+;
+
+3627
+\9a\8d\8c_t
+
+ gr2_v®
+ =
+g\91_»gi¡\94
+(
+r2
+);
+
+3628
+\9a\8d\8c_t
+
+ gr13_v®
+ =
+g\91_»gi¡\94
+(
+r13
+);
+
+3629
+\9a\8d\8c_t
+
+ gr14_v®
+ =
+g\91_»gi¡\94
+(
+r14
+);
+
+3630
+\9a\8d\8c_t
+
+ gr15_v®
+ =
+g\91_»gi¡\94
+(
+r15
+);
+
+3631
+\9a\8d\8c_t
+
+ gr16_v®
+ =
+g\91_»gi¡\94
+(
+r16
+);
+
+3632
+\9a\8d\8c_t
+
+ gr17_v®
+ =
+g\91_»gi¡\94
+(
+r17
+);
+
+3633
+\9a\8d\8c_t
+
+ gr18_v®
+ =
+g\91_»gi¡\94
+(
+r18
+);
+
+3634
+\9a\8d\8c_t
+
+ gr19_v®
+ =
+g\91_»gi¡\94
+(
+r19
+);
+
+3635
+\9a\8d\8c_t
+
+ gr20_v®
+ =
+g\91_»gi¡\94
+(
+r20
+);
+
+3636
+\9a\8d\8c_t
+
+ gr21_v®
+ =
+g\91_»gi¡\94
+(
+r21
+);
+
+3637
+\9a\8d\8c_t
+
+ gr22_v®
+ =
+g\91_»gi¡\94
+(
+r22
+);
+
+3638
+\9a\8d\8c_t
+
+ gr23_v®
+ =
+g\91_»gi¡\94
+(
+r23
+);
+
+3639
+\9a\8d\8c_t
+
+ gr24_v®
+ =
+g\91_»gi¡\94
+(
+r24
+);
+
+3640
+\9a\8d\8c_t
+
+ gr25_v®
+ =
+g\91_»gi¡\94
+(
+r25
+);
+
+3641
+\9a\8d\8c_t
+
+ gr26_v®
+ =
+g\91_»gi¡\94
+(
+r26
+);
+
+3642
+\9a\8d\8c_t
+
+ gr27_v®
+ =
+g\91_»gi¡\94
+(
+r27
+);
+
+3643
+\9a\8d\8c_t
+
+ gr28_v®
+ =
+g\91_»gi¡\94
+(
+r28
+);
+
+3644
+\9a\8d\8c_t
+
+ gr29_v®
+ =
+g\91_»gi¡\94
+(
+r29
+);
+
+3645
+\9a\8d\8c_t
+
+ gr30_v®
+ =
+g\91_»gi¡\94
+(
+r30
+);
+
+3646
+\9a\8d\8c_t
+
+ gr31_v®
+ =
+g\91_»gi¡\94
+(
+å
+);
+
+3650
+\9a\8d\8c_t
+
+ gÿÎ\93_§ved_v®ue
+ =
+icouÁ_
+;
+
+3651
+£t_»gi¡\94
+(
+r2
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3652
+£t_»gi¡\94
+(
+r13
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3653
+£t_»gi¡\94
+(
+r14
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3654
+£t_»gi¡\94
+(
+r15
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3655
+£t_»gi¡\94
+(
+r16
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3656
+£t_»gi¡\94
+(
+r17
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3657
+£t_»gi¡\94
+(
+r18
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3658
+£t_»gi¡\94
+(
+r19
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3659
+£t_»gi¡\94
+(
+r20
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3660
+£t_»gi¡\94
+(
+r21
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3661
+£t_»gi¡\94
+(
+r22
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3662
+£t_»gi¡\94
+(
+r23
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3663
+£t_»gi¡\94
+(
+r24
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3664
+£t_»gi¡\94
+(
+r25
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3665
+£t_»gi¡\94
+(
+r26
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3666
+£t_»gi¡\94
+(
+r27
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3667
+£t_»gi¡\94
+(
+r28
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3668
+£t_»gi¡\94
+(
+r29
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3669
+£t_»gi¡\94
+(
+r30
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3670
+£t_»gi¡\94
+(
+å
+,
+ÿÎ\93_§ved_v®ue
+);
+
+3673
+Execu\8b
+();
+
+3676
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r2
+));
+
+3677
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r13
+));
+
+3678
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r14
+));
+
+3679
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r15
+));
+
+3680
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r16
+));
+
+3681
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r17
+));
+
+3682
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r18
+));
+
+3683
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r19
+));
+
+3684
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r20
+));
+
+3685
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r21
+));
+
+3686
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r22
+));
+
+3687
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r23
+));
+
+3688
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r24
+));
+
+3689
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r25
+));
+
+3690
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r26
+));
+
+3691
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r27
+));
+
+3692
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r28
+));
+
+3693
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r29
+));
+
+3694
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+r30
+));
+
+3695
+CHECK_EQ
+(
+ÿÎ\93_§ved_v®ue
+,
+g\91_»gi¡\94
+(
+å
+));
+
+3698
+£t_»gi¡\94
+(
+r2
+,
+r2_v®
+);
+
+3699
+£t_»gi¡\94
+(
+r13
+,
+r13_v®
+);
+
+3700
+£t_»gi¡\94
+(
+r14
+,
+r14_v®
+);
+
+3701
+£t_»gi¡\94
+(
+r15
+,
+r15_v®
+);
+
+3702
+£t_»gi¡\94
+(
+r16
+,
+r16_v®
+);
+
+3703
+£t_»gi¡\94
+(
+r17
+,
+r17_v®
+);
+
+3704
+£t_»gi¡\94
+(
+r18
+,
+r18_v®
+);
+
+3705
+£t_»gi¡\94
+(
+r19
+,
+r19_v®
+);
+
+3706
+£t_»gi¡\94
+(
+r20
+,
+r20_v®
+);
+
+3707
+£t_»gi¡\94
+(
+r21
+,
+r21_v®
+);
+
+3708
+£t_»gi¡\94
+(
+r22
+,
+r22_v®
+);
+
+3709
+£t_»gi¡\94
+(
+r23
+,
+r23_v®
+);
+
+3710
+£t_»gi¡\94
+(
+r24
+,
+r24_v®
+);
+
+3711
+£t_»gi¡\94
+(
+r25
+,
+r25_v®
+);
+
+3712
+£t_»gi¡\94
+(
+r26
+,
+r26_v®
+);
+
+3713
+£t_»gi¡\94
+(
+r27
+,
+r27_v®
+);
+
+3714
+£t_»gi¡\94
+(
+r28
+,
+r28_v®
+);
+
+3715
+£t_»gi¡\94
+(
+r29
+,
+r29_v®
+);
+
+3716
+£t_»gi¡\94
+(
+r30
+,
+r30_v®
+);
+
+3717
+£t_»gi¡\94
+(
+å
+,
+r31_v®
+);
+
+3721
+\9a\8d\8c_t
+
+ gSimuÏtÜ
+::
+C®l
+(
+by\8b
+*
+\92\8cy
+, \12
+¬gum\92t_couÁ
+, ...) {
+
+3722
+va_li¡
+
+ g·¿m\91\94s
+;
+
+3723
+va_¡¬t
+(
+·¿m\91\94s
+,
+¬gum\92t_couÁ
+);
+
+3727 \12
+ g»g_¬g_couÁ
+ = (
+¬gum\92t_couÁ
+ > 8) ? 8 :\87rgument_count;
+
+3728 \12
+ g¡ack_¬g_couÁ
+ =
+¬gum\92t_couÁ
+ -
+»g_¬g_couÁ
+;
+
+3729 \ f\12
+ gi
+ = 0; i <
+ g»g_¬g_couÁ
+; i++) {
+
+3730
+£t_»gi¡\94
+(
+i
+ + 3,
+va_¬g
+(
+·¿m\91\94s
+,
+\9a\8d\8c_t
+));
+
+3734
+\9a\8d\8c_t
+
+ gÜig\9a®_¡ack
+ =
+g\91_»gi¡\94
+(
+¥
+);
+
+3736
+\9a\8d\8c_t
+
+ g\92\8cy_¡ack
+ =
+
+3737 (
+Üig\9a®_¡ack
+ -
+
+3738 (
+kNumRequ\9cedS\8fckF¿meSlÙs
+ +
+¡ack_¬g_couÁ
+è* \17(
+\9a\8d\8c_t
+));
+
+3739 ià(
+ gba£
+::
+OS
+::
+Aùiv©iÚF¿meAlignm\92t
+() != 0) {
+
+3740
+\92\8cy_¡ack
+ &ð-
+ba£
+::
+OS
+::
+Aùiv©iÚF¿meAlignm\92t
+();
+
+3744
+\9a\8d\8c_t
+*
+ g¡ack_¬gum\92t
+ =
+
+3745
+»\9a\8b½»t_ÿ¡
+<
+\9a\8d\8c_t
+*>(
+\92\8cy_¡ack
+è+
+kS\8fckF¿meEx\8caP¬amSlÙ
+;
+
+3746 \ f\12
+ gi
+ = 0; i <
+ g¡ack_¬g_couÁ
+; i++) {
+
+3747
+ g¡ack_¬gum\92t
+[
+i
+] =
+va_¬g
+(
+·¿m\91\94s
+,
+\9a\8d\8c_t
+);
+
+3749
+va_\92d
+(
+·¿m\91\94s
+);
+
+3750
+£t_»gi¡\94
+(
+¥
+,
+\92\8cy_¡ack
+);
+
+3752
+C®lIÁ\94Çl
+(
+\92\8cy
+);
+
+3755
+CHECK_EQ
+(
+\92\8cy_¡ack
+,
+g\91_»gi¡\94
+(
+¥
+));
+
+3756
+£t_»gi¡\94
+(
+¥
+,
+Üig\9a®_¡ack
+);
+
+3758
+\9a\8d\8c_t
+
+ g»suÉ
+ =
+g\91_»gi¡\94
+(
+r3
+);
+
+3759 \15
+ g»suÉ
+;
+
+3763 \1e
+ gSimuÏtÜ
+::
+C®lFP
+(
+by\8b
+*
+\92\8cy
+, \b
+d0
+, \b
+d1
+) {
+
+3764
+£t_d_»gi¡\94_äom_doubË
+(1,
+d0
+);
+
+3765
+£t_d_»gi¡\94_äom_doubË
+(2,
+d1
+);
+
+3766
+C®lIÁ\94Çl
+(
+\92\8cy
+);
+
+3770
+\9at32_t
+
+ gSimuÏtÜ
+::
+C®lFPR\91uºsIÁ
+(
+by\8b
+*
+\92\8cy
+, \b
+d0
+, \b
+d1
+) {
+
+3771
+C®lFP
+(
+\92\8cy
+,
+d0
+,
+d1
+);
+
+3772
+\9at32_t
+
+ g»suÉ
+ =
+g\91_»gi¡\94
+(
+r3
+);
+
+3773 \15
+ g»suÉ
+;
+
+3777 \b
+ gSimuÏtÜ
+::
+C®lFPR\91uºsDoubË
+(
+by\8b
+*
+\92\8cy
+, \b
+d0
+, \b
+d1
+) {
+
+3778
+C®lFP
+(
+\92\8cy
+,
+d0
+,
+d1
+);
+
+3779 \15
+g\91_doubË_äom_d_»gi¡\94
+(1);
+
+3783
+u\9a\8d\8c_t
+
+ gSimuÏtÜ
+::
+PushAdd»ss
+(u\9a\8d\8c_\88
+add»ss
+) {
+
+3784
+u\9a\8d\8c_t
+
+Ãw_¥
+ =
+g\91_»gi¡\94
+(
+¥
+) - \17(uintptr_t);
+
+3785
+u\9a\8d\8c_t
+*
+ g¡ack_¦Ù
+ =
+»\9a\8b½»t_ÿ¡
+<u\9a\8d\8c_t*>(
+Ãw_¥
+);
+
+3786 *
+ g¡ack_¦Ù
+ =
+add»ss
+;
+
+3787
+£t_»gi¡\94
+(
+¥
+,
+Ãw_¥
+);
+
+3788 \15
+ gÃw_¥
+;
+
+3792
+u\9a\8d\8c_t
+
+ gSimuÏtÜ
+::
+PÝAdd»ss
+() {
+
+3793
+u\9a\8d\8c_t
+
+cu¼\92t_¥
+ =
+g\91_»gi¡\94
+(
+¥
+);
+
+3794
+u\9a\8d\8c_t
+*
+ g¡ack_¦Ù
+ =
+»\9a\8b½»t_ÿ¡
+<u\9a\8d\8c_t*>(
+cu¼\92t_¥
+);
+
+3795
+u\9a\8d\8c_t
+
+ gadd»ss
+ = *
+¡ack_¦Ù
+;
+
+3796
+£t_»gi¡\94
+(
+¥
+,
+cu¼\92t_¥
+ + \17(
+u\9a\8d\8c_t
+));
+
+3797 \15
+ gadd»ss
+;
+
+ @simulator-ppc.h
+
+13 #iâdeà
+V8_PPC_SIMULATOR_PPC_H_
+
+
+14 \ 1
+ #V8_PPC_SIMULATOR_PPC_H_
+
+
+ )
+
+16 \ 2
+ ~"¤c/®loÿtiÚ.h
+"
+
+18 #ià!
+def\9aed
+(
+USE_SIMULATOR
+)
+
+21
+Çme¥aû
+
+ gv8
+ {
+
+22
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+25 \ 1
+ #CALL_GENERATED_CODE
+(
+\92\8cy
+,
+p0
+,
+p1
+,
+p2
+,
+p3
+,
+p4
+) \
+
+26 (
+ `\92\8cy
+(
+p0
+,
+p1
+,
+p2
+,
+p3
+,
+p4
+))
+
+ )
+
+28 \e\12(*
+ gµc_»gexp_m©ch\94
+)(
+ tS\8c\9ag
+*, \12, cڡ
+ tby\8b
+*, const byte*, \12*,
+
+29 \12,
+ tAdd»ss
+, \12, \1e*,
+ tIsީe
+*);
+
+36 \ 1
+ #CALL_GENERATED_REGEXP_CODE
+(
+\92\8cy
+,
+p0
+,
+p1
+,
+p2
+,
+p3
+,
+p4
+,
+p5
+,
+p6
+,
+p7
+,
+p8
+) \
+
+37 (
+FUNCTION_CAST
+<
+µc_»gexp_m©ch\94
+>(
+\92\8cy
+)(
+p0
+,
+p1
+,
+p2
+,
+p3
+,
+p4
+,
+p5
+,
+p6
+,
+p7
+, \
+
+38
+NULL
+,
+p8
+))
+
+ )
+
+43 þas
+ cSimuÏtÜS\8fck
+ :
+public
+
+v8
+::
+\9a\8bº®
+::
+AÎS\8ftic
+ {
+
+44
+public
+:
+
+45 \18
+\9al\9ae
+
+u\9a\8d\8c_t
+
+JsLim\99FromCLim\99
+(
+v8
+::
+\9a\8bº®
+::
+Isީe
+*
+isީe
+,
+
+46
+u\9a\8d\8c_t
+
+c_lim\99
+) {
+
+47
+USE
+(
+isީe
+);
+
+48 \15
+ gc_lim\99
+;
+
+51 \18
+\9al\9ae
+
+u\9a\8d\8c_t
+
+Regi¡\94CTryC©ch
+(u\9a\8d\8c_\88
+\8cy_ÿtch_add»ss
+) {
+
+52 \15
+ g\8cy_ÿtch_add»ss
+;
+
+55 \18
+\9al\9ae
+ \1e
+UÄegi¡\94CTryC©ch
+() {}
+
+63 \ 2
+ ~"¤c/as£mbËr.h
+"
+
+64 \ 2
+ ~"¤c/hashm.h
+"
+
+65 \ 2
+ ~"¤c/µc/cÚ¡ªts-µc.h
+"
+
+67
+Çme¥aû
+
+ gv8
+ {
+
+68
+Çme¥aû
+
+ g\9a\8bº®
+ {
+
+70 þas
+ cCachePage
+ {
+
+71
+ gpublic
+:
+
+72 \18cڡ \12
+LINE_VALID
+ = 0;
+
+73 \18cڡ \12
+ gLINE_INVALID
+ = 1;
+
+75 \18cڡ \12
+ gkPageShiá
+ = 12;
+
+76 \18cڡ \12
+ gkPageSize
+ = 1 <<
+kPageShiá
+;
+
+77 \18cڡ \12
+ gkPageMask
+ =
+kPageSize
+ - 1;
+
+78 \18cڡ \12
+ gkL\9aeShiá
+ = 2;
+
+79 \18cڡ \12
+ gkL\9aeL\92gth
+ = 1 <<
+kL\9aeShiá
+;
+
+80 \18cڡ \12
+ gkL\9aeMask
+ =
+kL\9aeL\92gth
+ - 1;
+
+82
+CachePage
+(è{
+mem£t
+(&
+v®id\99y_m_
+,
+LINE_INVALID
+, \17(validity_map_)); }
+
+84 \ 5*
+V®id\99yBy\8b
+(\12
+off£t
+) {
+
+85 \15 &
+ gv®id\99y_m_
+[
+off£t
+ >>
+kL\9aeShiá
+];
+
+88 \ 5*
+CachedD©a
+(\12
+off£t
+è{ \15 &
+ gd©a_
+[offset]; }
+
+90
+ g´iv©e
+:
+
+91 \ 5
+d©a_
+[
+kPageSize
+];
+
+92 \18cڡ \12
+ gkV®id\99yMSize
+ =
+kPageSize
+ >>
+kL\9aeShiá
+;
+
+93 \ 5
+ gv®id\99y_m_
+[
+kV®id\99yMSize
+];
+
+97 þas
+ cSimuÏtÜ
+ {
+
+98
+ gpublic
+:
+
+99
+ä\9bnd
+
+þass
+
+PPCDebugg\94
+;
+
+100 \f
+ eRegi¡\94
+ {
+
+101
+ gno_»g
+ = -1,
+
+102
+ gr0
+ = 0,
+
+103
+ g¥
+,
+
+104
+ gr2
+,
+
+105
+ gr3
+,
+
+106
+ gr4
+,
+
+107
+ gr5
+,
+
+108
+ gr6
+,
+
+109
+ gr7
+,
+
+110
+ gr8
+,
+
+111
+ gr9
+,
+
+112
+ gr10
+,
+
+113
+ gr11
+,
+
+114
+ gr12
+,
+
+115
+ gr13
+,
+
+116
+ gr14
+,
+
+117
+ gr15
+,
+
+118
+ gr16
+,
+
+119
+ gr17
+,
+
+120
+ gr18
+,
+
+121
+ gr19
+,
+
+122
+ gr20
+,
+
+123
+ gr21
+,
+
+124
+ gr22
+,
+
+125
+ gr23
+,
+
+126
+ gr24
+,
+
+127
+ gr25
+,
+
+128
+ gr26
+,
+
+129
+ gr27
+,
+
+130
+ gr28
+,
+
+131
+ gr29
+,
+
+132
+ gr30
+,
+
+133
+ gå
+,
+
+134
+ gkNumGPRs
+ = 32,
+
+135
+ gd0
+ = 0,
+
+136
+ gd1
+,
+
+137
+ gd2
+,
+
+138
+ gd3
+,
+
+139
+ gd4
+,
+
+140
+ gd5
+,
+
+141
+ gd6
+,
+
+142
+ gd7
+,
+
+143
+ gd8
+,
+
+144
+ gd9
+,
+
+145
+ gd10
+,
+
+146
+ gd11
+,
+
+147
+ gd12
+,
+
+148
+ gd13
+,
+
+149
+ gd14
+,
+
+150
+ gd15
+,
+
+151
+ gd16
+,
+
+152
+ gd17
+,
+
+153
+ gd18
+,
+
+154
+ gd19
+,
+
+155
+ gd20
+,
+
+156
+ gd21
+,
+
+157
+ gd22
+,
+
+158
+ gd23
+,
+
+159
+ gd24
+,
+
+160
+ gd25
+,
+
+161
+ gd26
+,
+
+162
+ gd27
+,
+
+163
+ gd28
+,
+
+164
+ gd29
+,
+
+165
+ gd30
+,
+
+166
+ gd31
+,
+
+167
+ gkNumFPRs
+ = 32
+
+170
+ex¶ic\99
+
+SimuÏtÜ
+(
+Isީe
+*
+isީe
+);
+
+171 ~
+SimuÏtÜ
+();
+
+175 \18
+SimuÏtÜ
+*
+cu¼\92t
+(
+v8
+::
+\9a\8bº®
+::
+Isީe
+*
+isީe
+);
+
+178 \1e
+£t_»gi¡\94
+(\12
+»g
+,
+\9a\8d\8c_t
+
+v®ue
+);
+
+179
+\9a\8d\8c_t
+
+g\91_»gi¡\94
+(\12
+»g
+) const;
+
+180 \b
+g\91_doubË_äom_»gi¡\94_·\9c
+(\12
+»g
+);
+
+181 \1e
+£t_d_»gi¡\94_äom_doubË
+(\12
+d»g
+, cڡ \b
+dbl
+) {
+
+182
+DCHECK
+(
+d»g
+ >ð0 && d»g <
+kNumFPRs
+);
+
+183
+ gå_»gi¡\94s_
+[
+d»g
+] =
+dbl
+;
+
+185 \b
+g\91_doubË_äom_d_»gi¡\94
+(\12
+d»g
+è{ \15
+ gå_»gi¡\94s_
+[dreg]; }
+
+188 \1e
+£t_pc
+(
+\9a\8d\8c_t
+
+v®ue
+);
+
+189
+\9a\8d\8c_t
+
+g\91_pc
+() const;
+
+191
+Add»ss
+
+g\91_¥
+() {
+
+192 \15
+ g»\9a\8b½»t_ÿ¡
+<
+ gAdd»ss
+>(
+ g¡©ic_ÿ¡
+<
+ g\9a\8d\8c_t
+>(
+g\91_»gi¡\94
+(
+¥
+)));
+
+196
+u\9a\8d\8c_t
+
+S\8fckLim\99
+() const;
+
+199 \1e
+Execu\8b
+();
+
+202 \18\1e
+In\99\9flize
+(
+Isީe
+*
+isީe
+);
+
+207
+\9a\8d\8c_t
+
+C®l
+(
+by\8b
+*
+\92\8cy
+, \12
+¬gum\92t_couÁ
+, ...);
+
+209 \1e
+C®lFP
+(
+by\8b
+*
+\92\8cy
+, \b
+d0
+, \b
+d1
+);
+
+210
+\9at32_t
+
+C®lFPR\91uºsIÁ
+(
+by\8b
+*
+\92\8cy
+, \b
+d0
+, \b
+d1
+);
+
+211 \b
+C®lFPR\91uºsDoubË
+(
+by\8b
+*
+\92\8cy
+, \b
+d0
+, \b
+d1
+);
+
+214
+u\9a\8d\8c_t
+
+PushAdd»ss
+(u\9a\8d\8c_\88
+add»ss
+);
+
+217
+u\9a\8d\8c_t
+
+PÝAdd»ss
+();
+
+220 \1e
+£t_Ï¡_debugg\94_\9aput
+(\ 5*
+\9aput
+);
+
+221 \ 5*
+Ï¡_debugg\94_\9aput
+(è{ \15
+ gϡ_debugg\94_\9aput_
+; }
+
+224 \18\1e
+FlushICache
+(
+v8
+::
+\9a\8bº®
+::
+HashM
+*
+i_ÿche
+, \1e*
+¡¬t
+,
+
+225
+size_t
+
+size
+);
+
+229
+boÞ
+
+has_bad_pc
+() const;
+
+231
+ g´iv©e
+:
+
+232 \f
+ e¥ec\9fl_v®ues
+ {
+
+235
+bad_Ì
+ = -1,
+
+240
+ g\92d_sim_pc
+ = -2
+
+244 \1e
+FÜm©
+(
+In¡ruùiÚ
+*
+\9a¡r
+, cڡ \ 5*
+fÜm©
+);
+
+247
+boÞ
+
+C¬ryFrom
+(
+\9at32_t
+
+Ëá
+, iÁ32_\88
+right
+, iÁ32_\88
+ÿ¼y
+ = 0);
+
+248
+boÞ
+
+BÜrowFrom
+(
+\9at32_t
+
+Ëá
+, iÁ32_\88
+right
+);
+
+249
+boÞ
+
+Ov\94æowFrom
+(
+\9at32_t
+
+®u_out
+, iÁ32_\88
+Ëá
+, iÁ32_\88
+right
+,
+
+250
+boÞ
+
+add\99iÚ
+);
+
+253
+\9at32_t
+
+G\91ShiáRm
+(
+In¡ruùiÚ
+*
+\9a¡r
+,
+boÞ
+*
+ÿ¼y_out
+);
+
+254
+\9at32_t
+
+G\91Imm
+(
+In¡ruùiÚ
+*
+\9a¡r
+,
+boÞ
+*
+ÿ¼y_out
+);
+
+255 \1e
+ProûssPUW
+(
+In¡ruùiÚ
+*
+\9a¡r
+, \12
+num_»gs
+, \12
+Ý\94ªd_size
+,
+
+256
+\9a\8d\8c_t
+*
+¡¬t_add»ss
+, iÁ±r_t*
+\92d_add»ss
+);
+
+257 \1e
+HªdËRLi¡
+(
+In¡ruùiÚ
+*
+\9a¡r
+,
+boÞ
+
+lßd
+);
+
+258 \1e
+HªdËVLi¡
+(
+In¡ruùiÚ
+*
+\9a¡
+);
+
+259 \1e
+Soáw¬eIÁ\94ru±
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+262
+\9al\9ae
+
+boÞ
+
+isStÝIn¡ruùiÚ
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+263
+\9al\9ae
+
+boÞ
+
+isW©chedStÝ
+(
+u\9at32_t
+
+bk±_code
+);
+
+264
+\9al\9ae
+
+boÞ
+
+isEÇbËdStÝ
+(
+u\9at32_t
+
+bk±_code
+);
+
+265
+\9al\9ae
+ \1e
+EÇbËStÝ
+(
+u\9at32_t
+
+bk±_code
+);
+
+266
+\9al\9ae
+ \1e
+Di§bËStÝ
+(
+u\9at32_t
+
+bk±_code
+);
+
+267
+\9al\9ae
+ \1e
+Inü\97£StÝCouÁ\94
+(
+u\9at32_t
+
+bk±_code
+);
+
+268 \1e
+Pr\9atStÝInfo
+(
+u\9at32_t
+
+code
+);
+
+271
+\9al\9ae
+
+u\9at8_t
+
+R\97dBU
+(
+\9a\8d\8c_t
+
+addr
+);
+
+272
+\9al\9ae
+
+\9at8_t
+
+R\97dB
+(
+\9a\8d\8c_t
+
+addr
+);
+
+273
+\9al\9ae
+ \1e
+Wr\99eB
+(
+\9a\8d\8c_t
+
+addr
+,
+u\9at8_t
+
+v®ue
+);
+
+274
+\9al\9ae
+ \1e
+Wr\99eB
+(
+\9a\8d\8c_t
+
+addr
+,
+\9at8_t
+
+v®ue
+);
+
+276
+\9al\9ae
+
+u\9at16_t
+
+R\97dHU
+(
+\9a\8d\8c_t
+
+addr
+,
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+277
+\9al\9ae
+
+\9at16_t
+
+R\97dH
+(
+\9a\8d\8c_t
+
+addr
+,
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+279
+\9al\9ae
+ \1e
+Wr\99eH
+(
+\9a\8d\8c_t
+
+addr
+,
+u\9at16_t
+
+v®ue
+,
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+280
+\9al\9ae
+ \1e
+Wr\99eH
+(
+\9a\8d\8c_t
+
+addr
+,
+\9at16_t
+
+v®ue
+,
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+282
+\9al\9ae
+
+u\9at32_t
+
+R\97dWU
+(
+\9a\8d\8c_t
+
+addr
+,
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+283
+\9al\9ae
+
+\9at32_t
+
+R\97dW
+(
+\9a\8d\8c_t
+
+addr
+,
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+284
+\9al\9ae
+ \1e
+Wr\99eW
+(
+\9a\8d\8c_t
+
+addr
+,
+u\9at32_t
+
+v®ue
+,
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+285
+\9al\9ae
+ \1e
+Wr\99eW
+(
+\9a\8d\8c_t
+
+addr
+,
+\9at32_t
+
+v®ue
+,
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+287
+\9a\8d\8c_t
+*
+R\97dDW
+(\9a\8d\8c_\88
+addr
+);
+
+288 \1e
+Wr\99eDW
+(
+\9a\8d\8c_t
+
+addr
+,
+\9at64_t
+
+v®ue
+);
+
+290 \1e
+T¿û
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+291 \1e
+S\91CR0
+(
+\9a\8d\8c_t
+
+»suÉ
+,
+boÞ
+
+£tSO
+ =
+çl£
+);
+
+292 \1e
+Execu\8bB¿nchCÚd\99iÚ®
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+293 \1e
+Execu\8bExt1
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+294
+boÞ
+
+Execu\8bExt2_10b\99
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+295
+boÞ
+
+Execu\8bExt2_9b\99_·¹1
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+296 \1e
+Execu\8bExt2_9b\99_·¹2
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+297 \1e
+Execu\8bExt2
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+298 \1e
+Execu\8bExt4
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+299 #ià
+V8_TARGET_ARCH_PPC64
+
+
+300 \1e
+Execu\8bExt5
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+302 \1e
+Execu\8bG\92\94ic
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+305 \1e
+Execu\8bIn¡ruùiÚ
+(
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+308 \18\1e
+CheckICache
+(
+v8
+::
+\9a\8bº®
+::
+HashM
+*
+i_ÿche
+,
+In¡ruùiÚ
+*
+\9a¡r
+);
+
+309 \18\1e
+FlushOÃPage
+(
+v8
+::
+\9a\8bº®
+::
+HashM
+*
+i_ÿche
+,
+\9a\8d\8c_t
+
+¡¬t
+,
+
+310 \12
+size
+);
+
+311 \18
+CachePage
+*
+G\91CachePage
+(
+v8
+::
+\9a\8bº®
+::
+HashM
+*
+i_ÿche
+, \1e*
+·ge
+);
+
+314 \18\1e*
+Red\9ceùEx\8bº®Reã»nû
+(
+
+315 \1e*
+ex\8bº®_funùiÚ
+,
+v8
+::
+\9a\8bº®
+::
+Ex\8bº®Reã»nû
+::
+Ty³
+
+ty³
+);
+
+318 \1e
+G\91FpArgs
+(\b*
+x
+, \b*
+y
+,
+\9a\8d\8c_t
+*
+z
+);
+
+319 \1e
+S\91FpResuÉ
+(cڡ \b&
+»suÉ
+);
+
+320 \1e
+T¿shC®ËrSaveRegi¡\94s
+();
+
+322 \1e
+C®lIÁ\94Çl
+(
+by\8b
+*
+\92\8cy
+);
+
+328
+\9a\8d\8c_t
+
+ g»gi¡\94s_
+[
+kNumGPRs
+];
+
+329
+\9at32_t
+
+ gcÚd\99iÚ_»g_
+;
+
+330
+\9at32_t
+
+ gå_cÚd\99iÚ_»g_
+;
+
+331
+\9a\8d\8c_t
+
+ g¥ec\9fl_»g_Ì_
+;
+
+332
+\9a\8d\8c_t
+
+ g¥ec\9fl_»g_pc_
+;
+
+333
+\9a\8d\8c_t
+
+ g¥ec\9fl_»g_ùr_
+;
+
+334
+\9at32_t
+
+ g¥ec\9fl_»g_x\94_
+;
+
+336 \b
+ gå_»gi¡\94s_
+[
+kNumFPRs
+];
+
+339 \ 5*
+ g¡ack_
+;
+
+340
+boÞ
+
+ gpc_modif\9bd_
+;
+
+341 \12
+ gicouÁ_
+;
+
+344 \ 5*
+ gϡ_debugg\94_\9aput_
+;
+
+347
+ gv8
+::
+\9a\8bº®
+::
+HashM
+*
+i_ÿche_
+;
+
+350
+In¡ruùiÚ
+*
+ gb»ak_pc_
+;
+
+351
+In¡r
+
+ gb»ak_\9a¡r_
+;
+
+353
+ gv8
+::
+\9a\8bº®
+::
+Isީe
+*
+isީe_
+;
+
+357 \18cڡ
+u\9at32_t
+
+ gkNumOfW©chedStÝs
+ = 256;
+
+360 \18cڡ
+u\9at32_t
+
+ gkStÝDi§bËdB\99
+ = 1 << 31;
+
+366 \19
+ sStÝCouÁAndDesc
+ {
+
+367
+u\9at32_t
+
+ gcouÁ
+;
+
+368 \ 5*
+ gdesc
+;
+
+370
+StÝCouÁAndDesc
+
+ gw©ched_¡Ýs_
+[
+kNumOfW©chedStÝs
+];
+
+376 \ 1
+ #CALL_GENERATED_CODE
+(
+\92\8cy
+,
+p0
+,
+p1
+,
+p2
+,
+p3
+,
+p4
+) \
+
+377
+»\9a\8b½»t_ÿ¡
+<
+Objeù
+*>(
+SimuÏtÜ
+::
+ `cu¼\92t
+(
+Isީe
+::
+ `Cu¼\92t
+())->
+ `C®l
+( \
+
+378
+ `FUNCTION_ADDR
+(
+\92\8cy
+), 5, (
+\9a\8d\8c_t
+)
+p0
+, (\9a\8d\8c_t)
+p1
+, (\9a\8d\8c_t)
+p2
+, \
+
+379 (
+\9a\8d\8c_t
+)
+p3
+, (\9a\8d\8c_t)
+p4
+))
+
+ )
+
+381 \ 1
+ #CALL_GENERATED_REGEXP_CODE
+(
+\92\8cy
+,
+p0
+,
+p1
+,
+p2
+,
+p3
+,
+p4
+,
+p5
+,
+p6
+,
+p7
+,
+p8
+) \
+
+382
+SimuÏtÜ
+::
+ `cu¼\92t
+(
+Isީe
+::
+ `Cu¼\92t
+()) \
+
+383 ->
+ `C®l
+(
+\92\8cy
+, 10, (
+\9a\8d\8c_t
+)
+p0
+, (\9a\8d\8c_t)
+p1
+, (\9a\8d\8c_t)
+p2
+, \
+
+384 (
+\9a\8d\8c_t
+)
+p3
+, (\9a\8d\8c_t)
+p4
+, (\9a\8d\8c_t)
+p5
+, (\9a\8d\8c_t)
+p6
+, \
+
+385 (
+\9a\8d\8c_t
+)
+p7
+, (\9a\8d\8c_t)
+NULL
+, (\9a\8d\8c_t)
+p8
+)
+
+ )
+
+393 þas
+ cSimuÏtÜS\8fck
+ :
+public
+
+v8
+::
+\9a\8bº®
+::
+AÎS\8ftic
+ {
+
+394
+public
+:
+
+395 \18
+\9al\9ae
+
+u\9a\8d\8c_t
+
+JsLim\99FromCLim\99
+(
+v8
+::
+\9a\8bº®
+::
+Isީe
+*
+isީe
+,
+
+396
+u\9a\8d\8c_t
+
+c_lim\99
+) {
+
+397 \15
+ gSimuÏtÜ
+::
+cu¼\92t
+(
+isީe
+)->
+S\8fckLim\99
+();
+
+400 \18
+\9al\9ae
+
+u\9a\8d\8c_t
+
+Regi¡\94CTryC©ch
+(u\9a\8d\8c_\88
+\8cy_ÿtch_add»ss
+) {
+
+401
+SimuÏtÜ
+*
+ gsim
+ = SimuÏtÜ::
+cu¼\92t
+(
+Isީe
+::
+Cu¼\92t
+());
+
+402 \15
+ gsim
+->
+PushAdd»ss
+(
+\8cy_ÿtch_add»ss
+);
+
+405 \18
+\9al\9ae
+ \1e
+UÄegi¡\94CTryC©ch
+() {
+
+406
+ gSimuÏtÜ
+::
+cu¼\92t
+(
+Isީe
+::
+Cu¼\92t
+())->
+PÝAdd»ss
+();
+
+ @/usr/include/assert.h
+
+24 #ifdef
+_ASSERT_H
+
+
+26 #undeà
+_ASSERT_H
+
+
+27 #undeà
+as£¹
+
+
+28 #undeà
+__ASSERT_VOID_CAST
+
+
+30 #ifdef
+__USE_GNU
+
+
+31 #undeà
+as£¹_³¼Ü
+
+
+36 \ 1
+ #_ASSERT_H
+ 1
+
+ )
+
+37 \ 2
+ ~<ã©u»s.h
+>
+
+39 #ià
+def\9aed
+
+__ýlu¥lus
+ &&
+__GNUC_PREREQ
+ (2,95)
+
+40 \ 1
+ #__ASSERT_VOID_CAST
+
+¡©ic_ÿ¡
+<\1e>
+
+ )
+
+42 \ 1
+ #__ASSERT_VOID_CAST
+ (\1e)
+
+ )
+
+50 #ifdef
+NDEBUG
+
+
+52 \ 1
+ #as£¹
+(
+ex´
+è(
+ `__ASSERT_VOID_CAST
+ (0))
+
+ )
+
+60 #ifdef
+__USE_GNU
+
+
+61 \ 1
+ #as£¹_³¼Ü
+(
+\94ºum
+è(
+ `__ASSERT_VOID_CAST
+ (0))
+
+ )
+
+66 #iâdeà
+_ASSERT_H_DECLS
+
+
+67 \ 1
+ #_ASSERT_H_DECLS
+
+
+ )
+
+68
+__BEGIN_DECLS
+
+
+71 \r\1e
+ $__as£¹_ç\9e
+ (
+__cڡ
+ \ 5*
+__as£¹iÚ
+, __cڡ \ 5*
+__f\9ee
+,
+
+72 \1d\12
+__l\9ae
+,
+__cڡ
+ \ 5*
+__funùiÚ
+)
+
+73
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__nÜ\91uº__
+));
+
+76 \r\1e
+ $__as£¹_³¼Ü_ç\9e
+ (\12
+__\94ºum
+,
+__cڡ
+ \ 5*
+__f\9ee
+,
+
+77 \1d\12
+__l\9ae
+,
+
+78
+__cڡ
+ \ 5*
+__funùiÚ
+)
+
+79
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__nÜ\91uº__
+));
+
+84 \r\1e
+ $__as£¹
+ (cڡ \ 5*
+__as£¹iÚ
+, cڡ \ 5*
+__f\9ee
+, \12
+__l\9ae
+)
+
+85
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__nÜ\91uº__
+));
+
+88
+__END_DECLS
+
+
+91 \ 1
+ #as£¹
+(
+ex´
+) \
+
+92 ((
+ex´
+) \
+
+93 ?
+ `__ASSERT_VOID_CAST
+ (0) \
+
+94 :
+ `__as£¹_ç\9e
+ (
+ `__STRING
+(
+ex´
+),
+__FILE__
+,
+__LINE__
+,
+__ASSERT_FUNCTION
+))
+
+ )
+
+96 #ifdef
+__USE_GNU
+
+
+97 \ 1
+ #as£¹_³¼Ü
+(
+\94ºum
+) \
+
+98 (!(
+\94ºum
+) \
+
+99 ?
+ `__ASSERT_VOID_CAST
+ (0) \
+
+100 :
+ `__as£¹_³¼Ü_ç\9e
+ ((
+\94ºum
+),
+__FILE__
+,
+__LINE__
+,
+__ASSERT_FUNCTION
+))
+
+ )
+
+108 #ià
+def\9aed
+
+__ýlu¥lus
+ ?
+ `__GNUC_PREREQ
+ (2, 6) : __GNUC_PREREQ (2, 4)
+
+109 \ 1
+ #__ASSERT_FUNCTION
+
+__PRETTY_FUNCTION__
+
+
+ )
+
+111 #ià
+def\9aed
+
+__STDC_VERSION__
+ && __STDC_VERSION__ >= 199901L
+
+112 \ 1
+ #__ASSERT_FUNCTION
+
+__func__
+
+
+ )
+
+114 \ 1
+ #__ASSERT_FUNCTION
+ ((
+__cڡ
+ \ 5*è0)
+
+ )
+
+ @/usr/include/limits.h
+
+24 #iâdeà
+_LIBC_LIMITS_H_
+
+
+25 \ 1
+ #_LIBC_LIMITS_H_
+ 1
+
+ )
+
+27 \ 2
+ ~<ã©u»s.h
+>
+
+33 \ 1
+ #MB_LEN_MAX
+ 16
+
+ )
+
+38 #ià!
+def\9aed
+
+__GNUC__
+ || __GNUC__ < 2
+
+43 #iâdeà
+_LIMITS_H
+
+
+44 \ 1
+ #_LIMITS_H
+ 1
+
+ )
+
+46 \ 2
+ ~<b\99s/wÜdsize.h
+>
+
+55 \ 1
+ #CHAR_BIT
+ 8
+
+ )
+
+58 \ 1
+ #SCHAR_MIN
+ (-128)
+
+ )
+
+59 \ 1
+ #SCHAR_MAX
+ 127
+
+ )
+
+62 \ 1
+ #UCHAR_MAX
+ 255
+
+ )
+
+65 #ifdeà
+__CHAR_UNSIGNED__
+
+
+66 \ 1
+ #CHAR_MIN
+ 0
+
+ )
+
+67 \ 1
+ #CHAR_MAX
+
+UCHAR_MAX
+
+
+ )
+
+69 \ 1
+ #CHAR_MIN
+
+SCHAR_MIN
+
+
+ )
+
+70 \ 1
+ #CHAR_MAX
+
+SCHAR_MAX
+
+
+ )
+
+74 \ 1
+ #SHRT_MIN
+ (-32768)
+
+ )
+
+75 \ 1
+ #SHRT_MAX
+ 32767
+
+ )
+
+78 \ 1
+ #USHRT_MAX
+ 65535
+
+ )
+
+81 \ 1
+ #INT_MIN
+ (-
+INT_MAX
+ - 1)
+
+ )
+
+82 \ 1
+ #INT_MAX
+ 2147483647
+
+ )
+
+85 \ 1
+ #UINT_MAX
+ 4294967295U
+
+ )
+
+88 #ià
+__WORDSIZE
+ == 64
+
+89 \ 1
+ #LONG_MAX
+ 9223372036854775807L
+
+ )
+
+91 \ 1
+ #LONG_MAX
+ 2147483647L
+
+ )
+
+93 \ 1
+ #LONG_MIN
+ (-
+LONG_MAX
+ - 1L)
+
+ )
+
+96 #ià
+__WORDSIZE
+ == 64
+
+97 \ 1
+ #ULONG_MAX
+ 18446744073709551615UL
+
+ )
+
+99 \ 1
+ #ULONG_MAX
+ 4294967295UL
+
+ )
+
+102 #ifdeà
+__USE_ISOC99
+
+
+105 \ 1
+ #LLONG_MAX
+ 9223372036854775807LL
+
+ )
+
+106 \ 1
+ #LLONG_MIN
+ (-
+LLONG_MAX
+ - 1LL)
+
+ )
+
+109 \ 1
+ #ULLONG_MAX
+ 18446744073709551615ULL
+
+ )
+
+123 #ià
+def\9aed
+
+__GNUC__
+ && !def\9aed
+_GCC_LIMITS_H_
+
+
+125 #\9aþude_Ãx\88<
+lim\99s
+.
+h
+>
+
+131 #ià
+def\9aed
+
+__USE_ISOC99
+ && def\9aed
+__GNUC__
+
+
+132 #iâdeà
+LLONG_MIN
+
+
+133 \ 1
+ #LLONG_MIN
+ (-
+LLONG_MAX
+-1)
+
+ )
+
+135 #iâdeà
+LLONG_MAX
+
+
+136 \ 1
+ #LLONG_MAX
+
+__LONG_LONG_MAX__
+
+
+ )
+
+138 #iâdeà
+ULLONG_MAX
+
+
+139 \ 1
+ #ULLONG_MAX
+ (
+LLONG_MAX
+ * 2ULL + 1)
+
+ )
+
+143 #ifdef
+__USE_POSIX
+
+
+145 \ 2
+ ~<b\99s/posix1_lim.h
+>
+
+148 #ifdef
+__USE_POSIX2
+
+
+149 \ 2
+ ~<b\99s/posix2_lim.h
+>
+
+152 #ifdef
+__USE_XOPEN
+
+
+153 \ 2
+ ~<b\99s/xÝ\92_lim.h
+>
+
+ @/usr/include/stdio.h
+
+24 #iâdeà
+_STDIO_H
+
+
+26 #ià!
+def\9aed
+
+__Ãed_FILE
+ && !def\9aed
+__Ãed___FILE
+
+
+27 \ 1
+ #_STDIO_H
+ 1
+
+ )
+
+28 \ 2
+ ~<ã©u»s.h
+>
+
+30
+ g__BEGIN_DECLS
+
+
+32 \ 1
+ #__Ãed_size_t
+
+
+ )
+
+33 \ 1
+ #__Ãed_NULL
+
+
+ )
+
+34 \ 2
+ ~<¡ddef.h
+>
+
+36 \ 2
+ ~<b\99s/ty³s.h
+>
+
+37 \ 1
+ #__Ãed_FILE
+
+
+ )
+
+38 \ 1
+ #__Ãed___FILE
+
+
+ )
+
+42 #ià!
+def\9aed
+
+__FILE_def\9aed
+ && def\9aed
+__Ãed_FILE
+
+
+45 \19
+ g_IO_FILE
+;
+
+47
+__BEGIN_NAMESPACE_STD
+
+
+49 \e\19
+_IO_FILE
+
+ tFILE
+;
+
+50
+ g__END_NAMESPACE_STD
+
+
+51 #ià
+def\9aed
+
+__USE_LARGEFILE64
+ || def\9aed
+__USE_SVID
+ || def\9aed
+__USE_POSIX
+ \
+
+52 ||
+def\9aed
+
+ g__USE_BSD
+ || def\9aed
+ g__USE_ISOC99
+ || def\9aed
+ g__USE_XOPEN
+ \
+
+53 ||
+def\9aed
+
+__USE_POSIX2
+
+
+54
+ $__USING_NAMESPACE_STD
+(
+FILE
+)
+
+57 \ 1
+ #__FILE_def\9aed
+ 1
+
+ )
+
+59 #undeà
+__Ãed_FILE
+
+
+62 #ià!
+def\9aed
+
+____FILE_def\9aed
+ && def\9aed
+__Ãed___FILE
+
+
+65 \e\19
+_IO_FILE
+
+ t__FILE
+;
+
+67 \ 1
+ #____FILE_def\9aed
+ 1
+
+ )
+
+69 #undeà
+__Ãed___FILE
+
+
+72 #ifdef
+_STDIO_H
+
+
+73 \ 1
+ #_STDIO_USES_IOSTREAM
+
+
+ )
+
+75 \ 2
+ ~<libio.h
+>
+
+77 #ià
+def\9aed
+
+__USE_XOPEN
+ || def\9aed
+__USE_XOPEN2K8
+
+
+78 #ifdeà
+__GNUC__
+
+
+79 #iâdeà
+_VA_LIST_DEFINED
+
+
+80 \e
+_G_va_li¡
+
+ tva_li¡
+;
+
+81 \ 1
+ #_VA_LIST_DEFINED
+
+
+ )
+
+84 \ 2
+ ~<¡d¬g.h
+>
+
+88 #ifdeà
+__USE_XOPEN2K8
+
+
+89 #iâdeà
+__off_t_def\9aed
+
+
+90 #iâdeà
+__USE_FILE_OFFSET64
+
+
+91 \e
+__off_t
+
+ toff_t
+;
+
+93 \e
+__off64_t
+
+ toff_t
+;
+
+95 \ 1
+ #__off_t_def\9aed
+
+
+ )
+
+97 #ià
+def\9aed
+
+__USE_LARGEFILE64
+ && !def\9aed
+__off64_t_def\9aed
+
+
+98 \e
+__off64_t
+
+ toff64_t
+;
+
+99 \ 1
+ #__off64_t_def\9aed
+
+
+ )
+
+102 #iâdeà
+__ssize_t_def\9aed
+
+
+103 \e
+__ssize_t
+
+ tssize_t
+;
+
+104 \ 1
+ #__ssize_t_def\9aed
+
+
+ )
+
+109
+__BEGIN_NAMESPACE_STD
+
+
+110 #iâdeà
+__USE_FILE_OFFSET64
+
+
+111 \e
+_G_åos_t
+
+ tåos_t
+;
+
+113 \e
+_G_åos64_t
+
+ tåos_t
+;
+
+115
+__END_NAMESPACE_STD
+
+
+116 #ifdeà
+__USE_LARGEFILE64
+
+
+117 \e
+_G_åos64_t
+
+ tåos64_t
+;
+
+121 \ 1
+ #_IOFBF
+ 0
+
+ )
+
+122 \ 1
+ #_IOLBF
+ 1
+
+ )
+
+123 \ 1
+ #_IONBF
+ 2
+
+ )
+
+127 #iâdeà
+BUFSIZ
+
+
+128 \ 1
+ #BUFSIZ
+
+_IO_BUFSIZ
+
+
+ )
+
+134 #iâdeà
+EOF
+
+
+135 \ 1
+ #EOF
+ (-1)
+
+ )
+
+141 \ 1
+ #SEEK_SET
+ 0
+
+ )
+
+142 \ 1
+ #SEEK_CUR
+ 1
+
+ )
+
+143 \ 1
+ #SEEK_END
+ 2
+
+ )
+
+144 #ifdeà
+__USE_GNU
+
+
+145 \ 1
+ #SEEK_DATA
+ 3
+
+ )
+
+146 \ 1
+ #SEEK_HOLE
+ 4
+
+ )
+
+150 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_XOPEN
+
+
+152 \ 1
+ #P_tmpd\9c
+ "/tmp"
+
+ )
+
+165 \ 2
+ ~<b\99s/¡dio_lim.h
+>
+
+169 \r\19
+_IO_FILE
+ *
+¡d\9a
+;
+
+170 \r\19
+_IO_FILE
+ *
+¡dout
+;
+
+171 \r\19
+_IO_FILE
+ *
+¡d\94r
+;
+
+173 \ 1
+ #¡d\9a
+
+¡d\9a
+
+
+ )
+
+174 \ 1
+ #¡dout
+
+¡dout
+
+
+ )
+
+175 \ 1
+ #¡d\94r
+
+¡d\94r
+
+
+ )
+
+177
+__BEGIN_NAMESPACE_STD
+
+
+179 \r\12
+ $»move
+ (
+__cڡ
+ \ 5*
+__f\9e\92ame
+è
+__THROW
+;
+
+181 \r\12
+ $Ȃme
+ (
+__cڡ
+ \ 5*
+__Þd
+, __cڡ \ 5*
+__Ãw
+è
+__THROW
+;
+
+182
+__END_NAMESPACE_STD
+
+
+184 #ifdeà
+__USE_ATFILE
+
+
+186 \r\12
+ $Ȃm\97t
+ (\12
+__Þdfd
+,
+__cڡ
+ \ 5*
+__Þd
+, \12
+__Ãwfd
+,
+
+187
+__cڡ
+ \ 5*
+__Ãw
+è
+__THROW
+;
+
+190
+__BEGIN_NAMESPACE_STD
+
+
+195 #iâdeà
+__USE_FILE_OFFSET64
+
+
+196 \r
+FILE
+ *
+ $tmpf\9ee
+ (\1eè
+__wur
+;
+
+198 #ifdeà
+__REDIRECT
+
+
+199 \r
+FILE
+ *
+ `__REDIRECT
+ (
+tmpf\9ee
+, (\1e),
+tmpf\9ee64
+è
+__wur
+;
+
+201 \ 1
+ #tmpf\9ee
+
+tmpf\9ee64
+
+
+ )
+
+205 #ifdeà
+__USE_LARGEFILE64
+
+
+206 \r
+FILE
+ *
+ $tmpf\9ee64
+ (\1eè
+__wur
+;
+
+210 \r\ 5*
+ $tm²am
+ (\ 5*
+__s
+è
+__THROW
+
+__wur
+;
+
+211
+__END_NAMESPACE_STD
+
+
+213 #ifdeà
+__USE_MISC
+
+
+216 \r\ 5*
+ $tm²am_r
+ (\ 5*
+__s
+è
+__THROW
+
+__wur
+;
+
+220 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_XOPEN
+
+
+228 \r\ 5*
+ $\8bm²am
+ (
+__cڡ
+ \ 5*
+__d\9c
+, __cڡ \ 5*
+__pfx
+)
+
+229
+__THROW
+
+__©\8cibu\8b_m®loc__
+
+__wur
+;
+
+233
+__BEGIN_NAMESPACE_STD
+
+
+238 \r\12
+ `fþo£
+ (
+FILE
+ *
+__¡»am
+);
+
+243 \r\12
+ `fæush
+ (
+FILE
+ *
+__¡»am
+);
+
+244
+__END_NAMESPACE_STD
+
+
+246 #ifdeà
+__USE_MISC
+
+
+253 \r\12
+ `fæush_uÆocked
+ (
+FILE
+ *
+__¡»am
+);
+
+256 #ifdeà
+__USE_GNU
+
+
+263 \r\12
+ `fþo£®l
+ (\1e);
+
+267
+__BEGIN_NAMESPACE_STD
+
+
+268 #iâdeà
+__USE_FILE_OFFSET64
+
+
+273 \r
+FILE
+ *
+ $fݒ
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__f\9e\92ame
+,
+
+274
+__cڡ
+ \ 5*
+__»¡riù
+
+__modes
+è
+__wur
+;
+
+279 \r
+FILE
+ *
+ $äeÝ\92
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__f\9e\92ame
+,
+
+280
+__cڡ
+ \ 5*
+__»¡riù
+
+__modes
+,
+
+281
+FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+283 #ifdeà
+__REDIRECT
+
+
+284 \r
+FILE
+ *
+ `__REDIRECT
+ (
+fݒ
+, (
+__cڡ
+ \ 5*
+__»¡riù
+
+__f\9e\92ame
+,
+
+285
+__cڡ
+ \ 5*
+__»¡riù
+
+__modes
+),
+fݒ64
+)
+
+286
+__wur
+;
+
+287 \r
+FILE
+ *
+ `__REDIRECT
+ (
+äeÝ\92
+, (
+__cڡ
+ \ 5*
+__»¡riù
+
+__f\9e\92ame
+,
+
+288
+__cڡ
+ \ 5*
+__»¡riù
+
+__modes
+,
+
+289
+FILE
+ *
+__»¡riù
+
+__¡»am
+),
+äeÝ\9264
+)
+
+290
+__wur
+;
+
+292 \ 1
+ #fݒ
+
+fݒ64
+
+
+ )
+
+293 \ 1
+ #äeÝ\92
+
+äeÝ\9264
+
+
+ )
+
+296
+__END_NAMESPACE_STD
+
+
+297 #ifdeà
+__USE_LARGEFILE64
+
+
+298 \r
+FILE
+ *
+ $fݒ64
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__f\9e\92ame
+,
+
+299
+__cڡ
+ \ 5*
+__»¡riù
+
+__modes
+è
+__wur
+;
+
+300 \r
+FILE
+ *
+ $äeÝ\9264
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__f\9e\92ame
+,
+
+301
+__cڡ
+ \ 5*
+__»¡riù
+
+__modes
+,
+
+302
+FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+305 #ifdef
+__USE_POSIX
+
+
+307 \r
+FILE
+ *
+ $fdݒ
+ (\12
+__fd
+,
+__cڡ
+ \ 5*
+__modes
+è
+__THROW
+
+__wur
+;
+
+310 #ifdef
+__USE_GNU
+
+
+313 \r
+FILE
+ *
+ $fÝ\92cook\9b
+ (\1e*
+__»¡riù
+
+__magic_cook\9b
+,
+
+314
+__cڡ
+ \ 5*
+__»¡riù
+
+__modes
+,
+
+315
+_IO_cook\9b_io_funùiÚs_t
+
+__io_funcs
+è
+__THROW
+
+__wur
+;
+
+318 #ifdeà
+__USE_XOPEN2K8
+
+
+320 \r
+FILE
+ *
+ $fmemݒ
+ (\1e*
+__s
+,
+size_t
+
+__Ën
+,
+__cڡ
+ \ 5*
+__modes
+)
+
+321
+__THROW
+
+__wur
+;
+
+326 \r
+FILE
+ *
+ $Ý\92_mem¡»am
+ (\ 5**
+__buæoc
+,
+size_t
+ *
+__siz\96oc
+è
+__THROW
+
+__wur
+;
+
+330
+__BEGIN_NAMESPACE_STD
+
+
+333 \r\1e
+ $£tbuf
+ (
+FILE
+ *
+__»¡riù
+
+__¡»am
+, \ 5*__»¡riù
+__buf
+è
+__THROW
+;
+
+337 \r\12
+ $£tvbuf
+ (
+FILE
+ *
+__»¡riù
+
+__¡»am
+, \ 5*__»¡riù
+__buf
+,
+
+338 \12
+__modes
+,
+size_t
+
+__n
+è
+__THROW
+;
+
+339
+__END_NAMESPACE_STD
+
+
+341 #ifdef
+__USE_BSD
+
+
+344 \r\1e
+ $£tbufãr
+ (
+FILE
+ *
+__»¡riù
+
+__¡»am
+, \ 5*__»¡riù
+__buf
+,
+
+345
+size_t
+
+__size
+è
+__THROW
+;
+
+348 \r\1e
+ $£\8e\9aebuf
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+;
+
+352
+__BEGIN_NAMESPACE_STD
+
+
+357 \r\12
+ `år\9atf
+ (
+FILE
+ *
+__»¡riù
+
+__¡»am
+,
+
+358
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...);
+
+363 \r\12
+ `´\9atf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...);
+
+365 \r\12
+ $¥r\9atf
+ (\ 5*
+__»¡riù
+
+__s
+,
+
+366
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...è
+__THROWNL
+;
+
+372 \r\12
+ `vår\9atf
+ (
+FILE
+ *
+__»¡riù
+
+__s
+,
+__cڡ
+ \ 5*__»¡riù
+__fÜm©
+,
+
+373
+_G_va_li¡
+
+__¬g
+);
+
+378 \r\12
+ `v´\9atf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+_G_va_li¡
+
+__¬g
+);
+
+380 \r\12
+ $v¥r\9atf
+ (\ 5*
+__»¡riù
+
+__s
+,
+__cڡ
+ \ 5*__»¡riù
+__fÜm©
+,
+
+381
+_G_va_li¡
+
+__¬g
+è
+__THROWNL
+;
+
+382
+__END_NAMESPACE_STD
+
+
+384 #ià
+def\9aed
+
+__USE_BSD
+ || def\9aed
+__USE_ISOC99
+ || def\9aed
+__USE_UNIX98
+
+
+385
+__BEGIN_NAMESPACE_C99
+
+
+387 \r\12
+ $¢´\9atf
+ (\ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__maxËn
+,
+
+388
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...)
+
+389
+__THROWNL
+
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__´\9atf__
+, 3, 4)));
+
+391 \r\12
+ $v¢´\9atf
+ (\ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__maxËn
+,
+
+392
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+_G_va_li¡
+
+__¬g
+)
+
+393
+__THROWNL
+
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__´\9atf__
+, 3, 0)));
+
+394
+__END_NAMESPACE_C99
+
+
+397 #ifdeà
+__USE_GNU
+
+
+400 \r\12
+ $va¥r\9atf
+ (\ 5**
+__»¡riù
+
+__±r
+,
+__cڡ
+ \ 5*__»¡riù
+__f
+,
+
+401
+_G_va_li¡
+
+__¬g
+)
+
+402
+__THROWNL
+
+ `__©\8cibu\8b__
+ ((
+ $__fÜm©__
+ (
+__´\9atf__
+, 2, 0))è
+__wur
+;
+
+403 \r\12
+ $__a¥r\9atf
+ (\ 5**
+__»¡riù
+
+__±r
+,
+
+404
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+, ...)
+
+405
+__THROWNL
+
+ `__©\8cibu\8b__
+ ((
+ $__fÜm©__
+ (
+__´\9atf__
+, 2, 3))è
+__wur
+;
+
+406 \r\12
+ $a¥r\9atf
+ (\ 5**
+__»¡riù
+
+__±r
+,
+
+407
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+, ...)
+
+408
+__THROWNL
+
+ `__©\8cibu\8b__
+ ((
+ $__fÜm©__
+ (
+__´\9atf__
+, 2, 3))è
+__wur
+;
+
+411 #ifdeà
+__USE_XOPEN2K8
+
+
+418 \r\12
+ $vd´\9atf
+ (\12
+__fd
+,
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+,
+
+419
+_G_va_li¡
+
+__¬g
+)
+
+420
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__´\9atf__
+, 2, 0)));
+
+421 \r\12
+ $d´\9atf
+ (\12
+__fd
+,
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+, ...)
+
+422
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__´\9atf__
+, 2, 3)));
+
+426
+__BEGIN_NAMESPACE_STD
+
+
+431 \r\12
+ $fsÿnf
+ (
+FILE
+ *
+__»¡riù
+
+__¡»am
+,
+
+432
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...è
+__wur
+;
+
+437 \r\12
+ $sÿnf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...è
+__wur
+;
+
+439 \r\12
+ $ssÿnf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+
+440
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...è
+__THROW
+;
+
+442 #ià
+def\9aed
+
+__USE_ISOC99
+ && !def\9aed
+__USE_GNU
+ \
+
+443 && (!
+def\9aed
+
+__LDBL_COMPAT
+ || !def\9aed
+__REDIRECT
+) \
+
+444 && (
+def\9aed
+
+__STRICT_ANSI__
+ || def\9aed
+__USE_XOPEN2K
+)
+
+445 #ifdeà
+__REDIRECT
+
+
+449 \r\12
+ `__REDIRECT
+ (
+fsÿnf
+, (
+FILE
+ *
+__»¡riù
+
+__¡»am
+,
+
+450
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...),
+
+451
+__isoc99_fsÿnf
+è
+__wur
+;
+
+452 \r\12
+ `__REDIRECT
+ (
+sÿnf
+, (
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...),
+
+453
+__isoc99_sÿnf
+è
+__wur
+;
+
+454 \r\12
+ `__REDIRECT_NTH
+ (
+ssÿnf
+, (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+
+455
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...),
+
+456
+__isoc99_ssÿnf
+);
+
+458 \r\12
+ $__isoc99_fsÿnf
+ (
+FILE
+ *
+__»¡riù
+
+__¡»am
+,
+
+459
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...è
+__wur
+;
+
+460 \r\12
+ $__isoc99_sÿnf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...è
+__wur
+;
+
+461 \r\12
+ $__isoc99_ssÿnf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+
+462
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...è
+__THROW
+;
+
+463 \ 1
+ #fsÿnf
+
+__isoc99_fsÿnf
+
+
+ )
+
+464 \ 1
+ #sÿnf
+
+__isoc99_sÿnf
+
+
+ )
+
+465 \ 1
+ #ssÿnf
+
+__isoc99_ssÿnf
+
+
+ )
+
+469
+__END_NAMESPACE_STD
+
+
+471 #ifdef
+__USE_ISOC99
+
+
+472
+__BEGIN_NAMESPACE_C99
+
+
+477 \r\12
+ $vfsÿnf
+ (
+FILE
+ *
+__»¡riù
+
+__s
+,
+__cڡ
+ \ 5*__»¡riù
+__fÜm©
+,
+
+478
+_G_va_li¡
+
+__¬g
+)
+
+479
+ `__©\8cibu\8b__
+ ((
+ $__fÜm©__
+ (
+__sÿnf__
+, 2, 0))è
+__wur
+;
+
+485 \r\12
+ $vsÿnf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+_G_va_li¡
+
+__¬g
+)
+
+486
+ `__©\8cibu\8b__
+ ((
+ $__fÜm©__
+ (
+__sÿnf__
+, 1, 0))è
+__wur
+;
+
+489 \r\12
+ $vssÿnf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+
+490
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+_G_va_li¡
+
+__¬g
+)
+
+491
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__sÿnf__
+, 2, 0)));
+
+493 #ià!
+def\9aed
+
+__USE_GNU
+ \
+
+494 && (!
+def\9aed
+
+__LDBL_COMPAT
+ || !def\9aed
+__REDIRECT
+) \
+
+495 && (
+def\9aed
+
+__STRICT_ANSI__
+ || def\9aed
+__USE_XOPEN2K
+)
+
+496 #ifdeà
+__REDIRECT
+
+
+500 \r\12
+ `__REDIRECT
+ (
+vfsÿnf
+,
+
+501 (
+FILE
+ *
+__»¡riù
+
+__s
+,
+
+502
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+_G_va_li¡
+
+__¬g
+),
+
+503
+__isoc99_vfsÿnf
+)
+
+504
+ `__©\8cibu\8b__
+ ((
+ $__fÜm©__
+ (
+__sÿnf__
+, 2, 0))è
+__wur
+;
+
+505 \r\12
+ `__REDIRECT
+ (
+vsÿnf
+, (
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+506
+_G_va_li¡
+
+__¬g
+),
+__isoc99_vsÿnf
+)
+
+507
+ `__©\8cibu\8b__
+ ((
+ $__fÜm©__
+ (
+__sÿnf__
+, 1, 0))è
+__wur
+;
+
+508 \r\12
+ `__REDIRECT_NTH
+ (
+vssÿnf
+,
+
+509 (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+
+510
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+511
+_G_va_li¡
+
+__¬g
+),
+__isoc99_vssÿnf
+)
+
+512
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__sÿnf__
+, 2, 0)));
+
+514 \r\12
+ $__isoc99_vfsÿnf
+ (
+FILE
+ *
+__»¡riù
+
+__s
+,
+
+515
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+516
+_G_va_li¡
+
+__¬g
+è
+__wur
+;
+
+517 \r\12
+ $__isoc99_vsÿnf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+518
+_G_va_li¡
+
+__¬g
+è
+__wur
+;
+
+519 \r\12
+ $__isoc99_vssÿnf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+
+520
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+521
+_G_va_li¡
+
+__¬g
+è
+__THROW
+;
+
+522 \ 1
+ #vfsÿnf
+
+__isoc99_vfsÿnf
+
+
+ )
+
+523 \ 1
+ #vsÿnf
+
+__isoc99_vsÿnf
+
+
+ )
+
+524 \ 1
+ #vssÿnf
+
+__isoc99_vssÿnf
+
+
+ )
+
+528
+__END_NAMESPACE_C99
+
+
+532
+__BEGIN_NAMESPACE_STD
+
+
+537 \r\12
+ `fg\91c
+ (
+FILE
+ *
+__¡»am
+);
+
+538 \r\12
+ `g\91c
+ (
+FILE
+ *
+__¡»am
+);
+
+544 \r\12
+ `g\91ch¬
+ (\1e);
+
+545
+__END_NAMESPACE_STD
+
+
+549 \ 1
+ #g\91c
+(
+_å
+è
+ `_IO_g\91c
+ (_å)
+
+ )
+
+551 #ià
+def\9aed
+
+__USE_POSIX
+ || def\9aed
+__USE_MISC
+
+
+556 \r\12
+ `g\91c_uÆocked
+ (
+FILE
+ *
+__¡»am
+);
+
+557 \r\12
+ `g\91ch¬_uÆocked
+ (\1e);
+
+560 #ifdeà
+__USE_MISC
+
+
+567 \r\12
+ `fg\91c_uÆocked
+ (
+FILE
+ *
+__¡»am
+);
+
+571
+__BEGIN_NAMESPACE_STD
+
+
+579 \r\12
+ `åutc
+ (\12
+__c
+,
+FILE
+ *
+__¡»am
+);
+
+580 \r\12
+ `putc
+ (\12
+__c
+,
+FILE
+ *
+__¡»am
+);
+
+586 \r\12
+ `putch¬
+ (\12
+__c
+);
+
+587
+__END_NAMESPACE_STD
+
+
+591 \ 1
+ #putc
+(
+_ch
+,
+_å
+è
+ `_IO_putc
+ (_ch, _å)
+
+ )
+
+593 #ifdeà
+__USE_MISC
+
+
+600 \r\12
+ `åutc_uÆocked
+ (\12
+__c
+,
+FILE
+ *
+__¡»am
+);
+
+603 #ià
+def\9aed
+
+__USE_POSIX
+ || def\9aed
+__USE_MISC
+
+
+608 \r\12
+ `putc_uÆocked
+ (\12
+__c
+,
+FILE
+ *
+__¡»am
+);
+
+609 \r\12
+ `putch¬_uÆocked
+ (\12
+__c
+);
+
+613 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_MISC
+ \
+
+614 || (
+def\9aed
+
+__USE_XOPEN
+ && !def\9aed
+__USE_XOPEN2K
+)
+
+616 \r\12
+ `g\91w
+ (
+FILE
+ *
+__¡»am
+);
+
+619 \r\12
+ `putw
+ (\12
+__w
+,
+FILE
+ *
+__¡»am
+);
+
+623
+__BEGIN_NAMESPACE_STD
+
+
+628 \r\ 5*
+ $fg\91s
+ (\ 5*
+__»¡riù
+
+__s
+, \12
+__n
+,
+FILE
+ *__»¡riù
+__¡»am
+)
+
+629
+__wur
+;
+
+636 \r\ 5*
+ $g\91s
+ (\ 5*
+__s
+è
+__wur
+;
+
+637
+__END_NAMESPACE_STD
+
+
+639 #ifdeà
+__USE_GNU
+
+
+646 \r\ 5*
+ $fg\91s_uÆocked
+ (\ 5*
+__»¡riù
+
+__s
+, \12
+__n
+,
+
+647
+FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+651 #ifdef
+__USE_XOPEN2K8
+
+
+662 \r
+_IO_ssize_t
+
+ $__g\91d\96im
+ (\ 5**
+__»¡riù
+
+__l\9a\95\8c
+,
+
+663
+size_t
+ *
+__»¡riù
+
+__n
+, \12
+__d\96im\99\94
+,
+
+664
+FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+665 \r
+_IO_ssize_t
+
+ $g\91d\96im
+ (\ 5**
+__»¡riù
+
+__l\9a\95\8c
+,
+
+666
+size_t
+ *
+__»¡riù
+
+__n
+, \12
+__d\96im\99\94
+,
+
+667
+FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+675 \r
+_IO_ssize_t
+
+ $g\91l\9ae
+ (\ 5**
+__»¡riù
+
+__l\9a\95\8c
+,
+
+676
+size_t
+ *
+__»¡riù
+
+__n
+,
+
+677
+FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+681
+__BEGIN_NAMESPACE_STD
+
+
+686 \r\12
+ `åuts
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+FILE
+ *__»¡riù
+__¡»am
+);
+
+692 \r\12
+ `puts
+ (
+__cڡ
+ \ 5*
+__s
+);
+
+699 \r\12
+ `ung\91c
+ (\12
+__c
+,
+FILE
+ *
+__¡»am
+);
+
+706 \r
+size_t
+
+ $ä\97d
+ (\1e*
+__»¡riù
+
+__±r
+,
+size_t
+
+__size
+,
+
+707
+size_t
+
+__n
+,
+FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+712 \r
+size_t
+
+ `fwr\99e
+ (
+__cڡ
+ \1e*
+__»¡riù
+
+__±r
+, size_\88
+__size
+,
+
+713
+size_t
+
+__n
+,
+FILE
+ *
+__»¡riù
+
+__s
+);
+
+714
+__END_NAMESPACE_STD
+
+
+716 #ifdeà
+__USE_GNU
+
+
+723 \r\12
+ `åuts_uÆocked
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+
+724
+FILE
+ *
+__»¡riù
+
+__¡»am
+);
+
+727 #ifdeà
+__USE_MISC
+
+
+734 \r
+size_t
+
+ $ä\97d_uÆocked
+ (\1e*
+__»¡riù
+
+__±r
+,
+size_t
+
+__size
+,
+
+735
+size_t
+
+__n
+,
+FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+736 \r
+size_t
+
+ `fwr\99e_uÆocked
+ (
+__cڡ
+ \1e*
+__»¡riù
+
+__±r
+, size_\88
+__size
+,
+
+737
+size_t
+
+__n
+,
+FILE
+ *
+__»¡riù
+
+__¡»am
+);
+
+741
+__BEGIN_NAMESPACE_STD
+
+
+746 \r\12
+ `f£ek
+ (
+FILE
+ *
+__¡»am
+, \13\12
+__off
+, \12
+__wh\92û
+);
+
+751 \r\13\12
+ $á\96l
+ (
+FILE
+ *
+__¡»am
+è
+__wur
+;
+
+756 \r\1e
+ `»w\9ad
+ (
+FILE
+ *
+__¡»am
+);
+
+757
+__END_NAMESPACE_STD
+
+
+764 #ià
+def\9aed
+
+__USE_LARGEFILE
+ || def\9aed
+__USE_XOPEN2K
+
+
+765 #iâdeà
+__USE_FILE_OFFSET64
+
+
+770 \r\12
+ `f£eko
+ (
+FILE
+ *
+__¡»am
+,
+__off_t
+
+__off
+, \12
+__wh\92û
+);
+
+775 \r
+__off_t
+
+ $á\96lo
+ (
+FILE
+ *
+__¡»am
+è
+__wur
+;
+
+777 #ifdeà
+__REDIRECT
+
+
+778 \r\12
+ `__REDIRECT
+ (
+f£eko
+,
+
+779 (
+FILE
+ *
+__¡»am
+,
+__off64_t
+
+__off
+, \12
+__wh\92û
+),
+
+780
+f£eko64
+);
+
+781 \r
+__off64_t
+
+ `__REDIRECT
+ (
+á\96lo
+, (
+FILE
+ *
+__¡»am
+),
+á\96lo64
+);
+
+783 \ 1
+ #f£eko
+
+f£eko64
+
+
+ )
+
+784 \ 1
+ #á\96lo
+
+á\96lo64
+
+
+ )
+
+789
+__BEGIN_NAMESPACE_STD
+
+
+790 #iâdeà
+__USE_FILE_OFFSET64
+
+
+795 \r\12
+ `fg\91pos
+ (
+FILE
+ *
+__»¡riù
+
+__¡»am
+,
+åos_t
+ *__»¡riù
+__pos
+);
+
+800 \r\12
+ `f£\8dos
+ (
+FILE
+ *
+__¡»am
+,
+__cڡ
+
+åos_t
+ *
+__pos
+);
+
+802 #ifdeà
+__REDIRECT
+
+
+803 \r\12
+ `__REDIRECT
+ (
+fg\91pos
+, (
+FILE
+ *
+__»¡riù
+
+__¡»am
+,
+
+804
+åos_t
+ *
+__»¡riù
+
+__pos
+),
+fg\91pos64
+);
+
+805 \r\12
+ `__REDIRECT
+ (
+f£\8dos
+,
+
+806 (
+FILE
+ *
+__¡»am
+,
+__cڡ
+
+åos_t
+ *
+__pos
+),
+f£\8dos64
+);
+
+808 \ 1
+ #fg\91pos
+
+fg\91pos64
+
+
+ )
+
+809 \ 1
+ #f£\8dos
+
+f£\8dos64
+
+
+ )
+
+812
+__END_NAMESPACE_STD
+
+
+814 #ifdeà
+__USE_LARGEFILE64
+
+
+815 \r\12
+ `f£eko64
+ (
+FILE
+ *
+__¡»am
+,
+__off64_t
+
+__off
+, \12
+__wh\92û
+);
+
+816 \r
+__off64_t
+
+ $á\96lo64
+ (
+FILE
+ *
+__¡»am
+è
+__wur
+;
+
+817 \r\12
+ `fg\91pos64
+ (
+FILE
+ *
+__»¡riù
+
+__¡»am
+,
+åos64_t
+ *__»¡riù
+__pos
+);
+
+818 \r\12
+ `f£\8dos64
+ (
+FILE
+ *
+__¡»am
+,
+__cڡ
+
+åos64_t
+ *
+__pos
+);
+
+821
+__BEGIN_NAMESPACE_STD
+
+
+823 \r\1e
+ $þ\97»¼
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+;
+
+825 \r\12
+ $ãof
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+
+__wur
+;
+
+827 \r\12
+ $ã¼Ü
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+
+__wur
+;
+
+828
+__END_NAMESPACE_STD
+
+
+830 #ifdeà
+__USE_MISC
+
+
+832 \r\1e
+ $þ\97»¼_uÆocked
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+;
+
+833 \r\12
+ $ãof_uÆocked
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+
+__wur
+;
+
+834 \r\12
+ $ã¼Ü_uÆocked
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+
+__wur
+;
+
+838
+__BEGIN_NAMESPACE_STD
+
+
+843 \r\1e
+ `³¼Ü
+ (
+__cڡ
+ \ 5*
+__s
+);
+
+844
+__END_NAMESPACE_STD
+
+
+850 \ 2
+ ~<b\99s/sys_\94¾i¡.h
+>
+
+853 #ifdef
+__USE_POSIX
+
+
+855 \r\12
+ $f\9e\92o
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+
+__wur
+;
+
+858 #ifdeà
+__USE_MISC
+
+
+860 \r\12
+ $f\9e\92o_uÆocked
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+
+__wur
+;
+
+864 #ià(
+def\9aed
+
+__USE_POSIX2
+ || def\9aed
+__USE_SVID
+ || def\9aed
+__USE_BSD
+ || \
+
+865
+def\9aed
+
+__USE_MISC
+)
+
+870 \r
+FILE
+ *
+ $pݒ
+ (
+__cڡ
+ \ 5*
+__commªd
+, __cڡ \ 5*
+__modes
+è
+__wur
+;
+
+876 \r\12
+ `pþo£
+ (
+FILE
+ *
+__¡»am
+);
+
+880 #ifdef
+__USE_POSIX
+
+
+882 \r\ 5*
+ $ù\94mid
+ (\ 5*
+__s
+è
+__THROW
+;
+
+886 #ifdeà
+__USE_XOPEN
+
+
+888 \r\ 5*
+ `cu£rid
+ (\ 5*
+__s
+);
+
+892 #ifdef
+__USE_GNU
+
+
+893 \19
+ob¡ack
+;
+
+896 \r\12
+ $ob¡ack_´\9atf
+ (\19
+ob¡ack
+ *
+__»¡riù
+
+__ob¡ack
+,
+
+897
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...)
+
+898
+__THROWNL
+
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__´\9atf__
+, 2, 3)));
+
+899 \r\12
+ $ob¡ack_v´\9atf
+ (\19
+ob¡ack
+ *
+__»¡riù
+
+__ob¡ack
+,
+
+900
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+901
+_G_va_li¡
+
+__¬gs
+)
+
+902
+__THROWNL
+
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__´\9atf__
+, 2, 0)));
+
+906 #ià
+def\9aed
+
+__USE_POSIX
+ || def\9aed
+__USE_MISC
+
+
+910 \r\1e
+ $æockf\9ee
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+;
+
+914 \r\12
+ $árylockf\9ee
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+
+__wur
+;
+
+917 \r\1e
+ $fuÆockf\9ee
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+;
+
+920 #ià
+def\9aed
+
+__USE_XOPEN
+ && !def\9aed
+__USE_XOPEN2K
+ && !def\9aed
+__USE_GNU
+
+
+924 \ 1
+ #__Ãed_g\91Ýt
+
+
+ )
+
+925 \ 2
+ ~<g\91Ýt.h
+>
+
+930 #ifdeà
+__USE_EXTERN_INLINES
+
+
+931 \ 2
+ ~<b\99s/¡dio.h
+>
+
+933 #ià
+__USE_FORTIFY_LEVEL
+ > 0 &&
+def\9aed
+
+__ex\8bº_®ways_\9al\9ae
+
+
+934 \ 2
+ ~<b\99s/¡dio2.h
+>
+
+936 #ifdeà
+__LDBL_COMPAT
+
+
+937 \ 2
+ ~<b\99s/¡dio-ldbl.h
+>
+
+940
+__END_DECLS
+
+
+ @/usr/include/stdlib.h
+
+23 #iâdef
+_STDLIB_H
+
+
+25 \ 2
+ ~<ã©u»s.h
+>
+
+28 \ 1
+ #__Ãed_size_t
+
+
+ )
+
+29 #iâdeà
+__Ãed_m®loc_ªd_ÿÎoc
+
+
+30 \ 1
+ #__Ãed_wch¬_t
+
+
+ )
+
+31 \ 1
+ #__Ãed_NULL
+
+
+ )
+
+33 \ 2
+ ~<¡ddef.h
+>
+
+35
+ g__BEGIN_DECLS
+
+
+37 #iâdeà
+__Ãed_m®loc_ªd_ÿÎoc
+
+
+38 \ 1
+ #_STDLIB_H
+ 1
+
+ )
+
+40 #ià(
+def\9aed
+
+__USE_XOPEN
+ || def\9aed
+__USE_XOPEN2K8
+è&& !def\9aed
+_SYS_WAIT_H
+
+
+42 \ 2
+ ~<b\99s/wa\99æags.h
+>
+
+43 \ 2
+ ~<b\99s/wa\99¡©us.h
+>
+
+45 #ifdeà
+__USE_BSD
+
+
+50 #ià
+def\9aed
+
+__GNUC__
+ && !def\9aed
+__ýlu¥lus
+
+
+51 \ 1
+ #__WAIT_INT
+(
+¡©us
+) \
+
+52 (
+ `__ex\8bnsiÚ__
+ (((uniÚ {
+ `__ty³of
+(
+¡©us
+è
+__\9a
+; \12
+__i
+; }) \
+
+53 { .
+__\9a
+ = (
+¡©us
+è}).
+__i
+))
+
+ )
+
+55 \ 1
+ #__WAIT_INT
+(
+¡©us
+è(*(\12*è&(¡©us))
+
+ )
+
+63 #ià!
+def\9aed
+
+__GNUC__
+ || __GNUC__ < 2 || def\9aed
+__ýlu¥lus
+
+
+64 \ 1
+ #__WAIT_STATUS
+ \1e*
+
+ )
+
+65 \ 1
+ #__WAIT_STATUS_DEFN
+ \1e*
+
+ )
+
+70 \1c
+wa\99
+ *
+ m__u±r
+;
+
+71 \12*
+ m__\9d\8c
+;
+
+72 }
+ t__WAIT_STATUS
+
+ t__©\8cibu\8b__
+ ((
+ t__\8cª¥¬\92t_uniÚ__
+));
+
+73 \ 1
+ #__WAIT_STATUS_DEFN
+ \12*
+
+ )
+
+78 \ 1
+ #__WAIT_INT
+(
+¡©us
+è(¡©us)
+
+ )
+
+79 \ 1
+ #__WAIT_STATUS
+ \12*
+
+ )
+
+80 \ 1
+ #__WAIT_STATUS_DEFN
+ \12*
+
+ )
+
+85 \ 1
+ #WEXITSTATUS
+(
+¡©us
+è
+ `__WEXITSTATUS
+ (
+ `__WAIT_INT
+ (¡©us))
+
+ )
+
+86 \ 1
+ #WTERMSIG
+(
+¡©us
+è
+ `__WTERMSIG
+ (
+ `__WAIT_INT
+ (¡©us))
+
+ )
+
+87 \ 1
+ #WSTOPSIG
+(
+¡©us
+è
+ `__WSTOPSIG
+ (
+ `__WAIT_INT
+ (¡©us))
+
+ )
+
+88 \ 1
+ #WIFEXITED
+(
+¡©us
+è
+ `__WIFEXITED
+ (
+ `__WAIT_INT
+ (¡©us))
+
+ )
+
+89 \ 1
+ #WIFSIGNALED
+(
+¡©us
+è
+ `__WIFSIGNALED
+ (
+ `__WAIT_INT
+ (¡©us))
+
+ )
+
+90 \ 1
+ #WIFSTOPPED
+(
+¡©us
+è
+ `__WIFSTOPPED
+ (
+ `__WAIT_INT
+ (¡©us))
+
+ )
+
+91 #ifdeà
+__WIFCONTINUED
+
+
+92 \ 1
+ #WIFCONTINUED
+(
+¡©us
+è
+ `__WIFCONTINUED
+ (
+ `__WAIT_INT
+ (¡©us))
+
+ )
+
+96
+__BEGIN_NAMESPACE_STD
+
+
+100 \12
+ mquÙ
+;
+
+101 \12
+ m»m
+;
+
+102 }
+ tdiv_t
+;
+
+105 #iâdeà
+__ldiv_t_def\9aed
+
+
+108 \13\12
+ mquÙ
+;
+
+109 \13\12
+ m»m
+;
+
+110 }
+ tldiv_t
+;
+
+111 \ 1
+ #__ldiv_t_def\9aed
+ 1
+
+ )
+
+113
+ g__END_NAMESPACE_STD
+
+
+115 #ià
+def\9aed
+
+__USE_ISOC99
+ && !def\9aed
+__Îdiv_t_def\9aed
+
+
+116
+__BEGIN_NAMESPACE_C99
+
+
+118
+__ex\8bnsiÚ__
+ \estruct
+
+120 \13\13\12
+ mquÙ
+;
+
+121 \13\13\12
+ m»m
+;
+
+122 }
+ tÎdiv_t
+;
+
+123 \ 1
+ #__Îdiv_t_def\9aed
+ 1
+
+ )
+
+124
+ g__END_NAMESPACE_C99
+
+
+129 \ 1
+ #RAND_MAX
+ 2147483647
+
+ )
+
+134 \ 1
+ #EXIT_FAILURE
+ 1
+
+ )
+
+135 \ 1
+ #EXIT_SUCCESS
+ 0
+
+ )
+
+139 \ 1
+ #MB_CUR_MAX
+ (
+ `__ùy³_g\91_mb_cur_max
+ ())
+
+ )
+
+140 \r
+size_t
+
+ $__ùy³_g\91_mb_cur_max
+ (\1eè
+__THROW
+
+__wur
+;
+
+143
+__BEGIN_NAMESPACE_STD
+
+
+145 \r\b
+ $©of
+ (
+__cڡ
+ \ 5*
+__Ō
+)
+
+146
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+148 \r\12
+ $©oi
+ (
+__cڡ
+ \ 5*
+__Ō
+)
+
+149
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+151 \r\13\12
+ $©Þ
+ (
+__cڡ
+ \ 5*
+__Ō
+)
+
+152
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+153
+__END_NAMESPACE_STD
+
+
+155 #ià
+def\9aed
+
+__USE_ISOC99
+ || (def\9aed
+__GLIBC_HAVE_LONG_LONG
+ && def\9aed
+__USE_MISC
+)
+
+156
+__BEGIN_NAMESPACE_C99
+
+
+158
+__ex\8bnsiÚ__
+ \r\13\13\12
+ $©Þl
+ (
+__cڡ
+ \ 5*
+__Ō
+)
+
+159
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+160
+__END_NAMESPACE_C99
+
+
+163
+__BEGIN_NAMESPACE_STD
+
+
+165 \r\b
+ $¡¹od
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+166 \ 5**
+__»¡riù
+
+__\92d±r
+)
+
+167
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+168
+__END_NAMESPACE_STD
+
+
+170 #ifdef
+__USE_ISOC99
+
+
+171
+__BEGIN_NAMESPACE_C99
+
+
+173 \r\ e
+ $¡¹of
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+174 \ 5**
+__»¡riù
+
+__\92d±r
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+176 \r\13\b
+ $¡¹Þd
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+177 \ 5**
+__»¡riù
+
+__\92d±r
+)
+
+178
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+179
+__END_NAMESPACE_C99
+
+
+182
+__BEGIN_NAMESPACE_STD
+
+
+184 \r\13\12
+ $¡¹Þ
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+185 \ 5**
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+)
+
+186
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+188 \r\1d\13\12
+ $¡¹oul
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+189 \ 5**
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+)
+
+190
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+191
+__END_NAMESPACE_STD
+
+
+193 #ià
+def\9aed
+
+__GLIBC_HAVE_LONG_LONG
+ && def\9aed
+__USE_BSD
+
+
+195
+__ex\8bnsiÚ__
+
+
+196 \r\13\13\12
+ $¡¹oq
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+197 \ 5**
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+)
+
+198
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+200
+__ex\8bnsiÚ__
+
+
+201 \r\1d\13\13\12
+ $¡¹ouq
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+202 \ 5**
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+)
+
+203
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+206 #ià
+def\9aed
+
+__USE_ISOC99
+ || (def\9aed
+__GLIBC_HAVE_LONG_LONG
+ && def\9aed
+__USE_MISC
+)
+
+207
+__BEGIN_NAMESPACE_C99
+
+
+209
+__ex\8bnsiÚ__
+
+
+210 \r\13\13\12
+ $¡¹Þl
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+211 \ 5**
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+)
+
+212
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+214
+__ex\8bnsiÚ__
+
+
+215 \r\1d\13\13\12
+ $¡¹ouÎ
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+216 \ 5**
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+)
+
+217
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+218
+__END_NAMESPACE_C99
+
+
+222 #ifdeà
+__USE_GNU
+
+
+236 \ 2
+ ~<xloÿË.h
+>
+
+240 \r\13\12
+ $¡¹Þ_l
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+241 \ 5**
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+,
+
+242
+__loÿË_t
+
+__loc
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1, 4)è
+__wur
+;
+
+244 \r\1d\13\12
+ $¡¹oul_l
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+245 \ 5**
+__»¡riù
+
+__\92d±r
+,
+
+246 \12
+__ba£
+,
+__loÿË_t
+
+__loc
+)
+
+247
+__THROW
+
+ `__nÚnuÎ
+ ((1, 4)è
+__wur
+;
+
+249
+__ex\8bnsiÚ__
+
+
+250 \r\13\13\12
+ $¡¹Þl_l
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+251 \ 5**
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+,
+
+252
+__loÿË_t
+
+__loc
+)
+
+253
+__THROW
+
+ `__nÚnuÎ
+ ((1, 4)è
+__wur
+;
+
+255
+__ex\8bnsiÚ__
+
+
+256 \r\1d\13\13\12
+ $¡¹ouÎ_l
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+257 \ 5**
+__»¡riù
+
+__\92d±r
+,
+
+258 \12
+__ba£
+,
+__loÿË_t
+
+__loc
+)
+
+259
+__THROW
+
+ `__nÚnuÎ
+ ((1, 4)è
+__wur
+;
+
+261 \r\b
+ $¡¹od_l
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+262 \ 5**
+__»¡riù
+
+__\92d±r
+,
+__loÿË_t
+
+__loc
+)
+
+263
+__THROW
+
+ `__nÚnuÎ
+ ((1, 3)è
+__wur
+;
+
+265 \r\ e
+ $¡¹of_l
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+266 \ 5**
+__»¡riù
+
+__\92d±r
+,
+__loÿË_t
+
+__loc
+)
+
+267
+__THROW
+
+ `__nÚnuÎ
+ ((1, 3)è
+__wur
+;
+
+269 \r\13\b
+ $¡¹Þd_l
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Ō
+,
+
+270 \ 5**
+__»¡riù
+
+__\92d±r
+,
+
+271
+__loÿË_t
+
+__loc
+)
+
+272
+__THROW
+
+ `__nÚnuÎ
+ ((1, 3)è
+__wur
+;
+
+276 #ifdeà
+__USE_EXTERN_INLINES
+
+
+277
+__BEGIN_NAMESPACE_STD
+
+
+278
+__ex\8bº_\9al\9ae
+ \b
+
+279
+ `__NTH
+ (
+ $©of
+ (
+__cڡ
+ \ 5*
+__Ō
+))
+
+281 \15
+ `¡¹od
+ (
+__Ō
+, (\ 5**è
+NULL
+);
+
+282
+ }
+}
+
+283
+__ex\8bº_\9al\9ae
+ \12
+
+284
+__NTH
+ (
+ $©oi
+ (
+__cڡ
+ \ 5*
+__Ō
+))
+
+286 \15 (\12è
+ `¡¹Þ
+ (
+__Ō
+, (\ 5**è
+NULL
+, 10);
+
+287
+ }
+}
+
+288
+__ex\8bº_\9al\9ae
+ \13\12
+
+289
+__NTH
+ (
+ $©Þ
+ (
+__cڡ
+ \ 5*
+__Ō
+))
+
+291 \15
+ `¡¹Þ
+ (
+__Ō
+, (\ 5**è
+NULL
+, 10);
+
+292
+ }
+}
+
+293
+ g__END_NAMESPACE_STD
+
+
+295 #ià
+def\9aed
+
+__USE_MISC
+ || def\9aed
+__USE_ISOC99
+
+
+296
+__BEGIN_NAMESPACE_C99
+
+
+297
+__ex\8bnsiÚ__
+
+__ex\8bº_\9al\9ae
+ \13\13\12
+
+298
+__NTH
+ (
+ $©Þl
+ (
+__cڡ
+ \ 5*
+__Ō
+))
+
+300 \15
+ `¡¹Þl
+ (
+__Ō
+, (\ 5**è
+NULL
+, 10);
+
+301
+ }
+}
+
+302
+ g__END_NAMESPACE_C99
+
+
+307 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_XOPEN_EXTENDED
+
+
+311 \r\ 5*
+ $l64a
+ (\13\12
+__n
+è
+__THROW
+
+__wur
+;
+
+314 \r\13\12
+ $a64l
+ (
+__cڡ
+ \ 5*
+__s
+)
+
+315
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+319 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_XOPEN_EXTENDED
+ || def\9aed
+__USE_BSD
+
+
+320 \ 2
+ ~<sys/ty³s.h
+>
+
+327 \r\13\12
+ $¿ndom
+ (\1eè
+__THROW
+;
+
+330 \r\1e
+ $¤ªdom
+ (\1d\12
+__£ed
+è
+__THROW
+;
+
+336 \r\ 5*
+ $\9a\99¡©e
+ (\1d\12
+__£ed
+, \ 5*
+__¡©ebuf
+,
+
+337
+size_t
+
+__¡©\96\92
+è
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+341 \r\ 5*
+ $£t¡©e
+ (\ 5*
+__¡©ebuf
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+344 #ifdeà
+__USE_MISC
+
+
+349 \19
+ s¿ndom_d©a
+
+
+351
+\9at32_t
+ *
+å\8c
+;
+
+352
+\9at32_t
+ *
+½\8c
+;
+
+353
+\9at32_t
+ *
+¡©e
+;
+
+354 \12
+¿nd_ty³
+;
+
+355 \12
+¿nd_deg
+;
+
+356 \12
+¿nd_£p
+;
+
+357
+\9at32_t
+ *
+\92d_±r
+;
+
+360 \r\12
+ $¿ndom_r
+ (\19
+¿ndom_d©a
+ *
+__»¡riù
+
+__buf
+,
+
+361
+\9at32_t
+ *
+__»¡riù
+
+__»suÉ
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+363 \r\12
+ $¤ªdom_r
+ (\1d\12
+__£ed
+, \19
+¿ndom_d©a
+ *
+__buf
+)
+
+364
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+366 \r\12
+ $\9a\99¡©e_r
+ (\1d\12
+__£ed
+, \ 5*
+__»¡riù
+
+__¡©ebuf
+,
+
+367
+size_t
+
+__¡©\96\92
+,
+
+368 \19
+¿ndom_d©a
+ *
+__»¡riù
+
+__buf
+)
+
+369
+__THROW
+
+ `__nÚnuÎ
+ ((2, 4));
+
+371 \r\12
+ $£t¡©e_r
+ (\ 5*
+__»¡riù
+
+__¡©ebuf
+,
+
+372 \19
+¿ndom_d©a
+ *
+__»¡riù
+
+__buf
+)
+
+373
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+378
+__BEGIN_NAMESPACE_STD
+
+
+380 \r\12
+ $¿nd
+ (\1eè
+__THROW
+;
+
+382 \r\1e
+ $¤ªd
+ (\1d\12
+__£ed
+è
+__THROW
+;
+
+383
+__END_NAMESPACE_STD
+
+
+385 #ifdeà
+__USE_POSIX
+
+
+387 \r\12
+ $¿nd_r
+ (\1d\12*
+__£ed
+è
+__THROW
+;
+
+391 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_XOPEN
+
+
+395 \r\b
+ $d¿nd48
+ (\1eè
+__THROW
+;
+
+396 \r\b
+ $\94ªd48
+ (\1d\16\12
+__xsubi
+[3]è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+399 \r\13\12
+ $̪d48
+ (\1eè
+__THROW
+;
+
+400 \r\13\12
+ $Īd48
+ (\1d\16\12
+__xsubi
+[3])
+
+401
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+404 \r\13\12
+ $m¿nd48
+ (\1eè
+__THROW
+;
+
+405 \r\13\12
+ $j¿nd48
+ (\1d\16\12
+__xsubi
+[3])
+
+406
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+409 \r\1e
+ $¤ªd48
+ (\13\12
+__£edv®
+è
+__THROW
+;
+
+410 \r\1d\16\12*
+ $£ed48
+ (\1d\16\12
+__£ed16v
+[3])
+
+411
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+412 \r\1e
+ $lcÚg48
+ (\1d\16\12
+__·¿m
+[7]è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+414 #ifdeà
+__USE_MISC
+
+
+418 \19
+ sd¿nd48_d©a
+
+
+420 \1d\16\12
+__x
+[3];
+
+421 \1d\16\12
+__Þd_x
+[3];
+
+422 \1d\16\12
+__c
+;
+
+423 \1d\16\12
+__\9a\99
+;
+
+424 \1d\13\13\12
+__a
+;
+
+428 \r\12
+ $d¿nd48_r
+ (\19
+d¿nd48_d©a
+ *
+__»¡riù
+
+__bufãr
+,
+
+429 \b*
+__»¡riù
+
+__»suÉ
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+430 \r\12
+ $\94ªd48_r
+ (\1d\16\12
+__xsubi
+[3],
+
+431 \19
+d¿nd48_d©a
+ *
+__»¡riù
+
+__bufãr
+,
+
+432 \b*
+__»¡riù
+
+__»suÉ
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+435 \r\12
+ $̪d48_r
+ (\19
+d¿nd48_d©a
+ *
+__»¡riù
+
+__bufãr
+,
+
+436 \13\12*
+__»¡riù
+
+__»suÉ
+)
+
+437
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+438 \r\12
+ $Īd48_r
+ (\1d\16\12
+__xsubi
+[3],
+
+439 \19
+d¿nd48_d©a
+ *
+__»¡riù
+
+__bufãr
+,
+
+440 \13\12*
+__»¡riù
+
+__»suÉ
+)
+
+441
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+444 \r\12
+ $m¿nd48_r
+ (\19
+d¿nd48_d©a
+ *
+__»¡riù
+
+__bufãr
+,
+
+445 \13\12*
+__»¡riù
+
+__»suÉ
+)
+
+446
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+447 \r\12
+ $j¿nd48_r
+ (\1d\16\12
+__xsubi
+[3],
+
+448 \19
+d¿nd48_d©a
+ *
+__»¡riù
+
+__bufãr
+,
+
+449 \13\12*
+__»¡riù
+
+__»suÉ
+)
+
+450
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+453 \r\12
+ $¤ªd48_r
+ (\13\12
+__£edv®
+, \19
+d¿nd48_d©a
+ *
+__bufãr
+)
+
+454
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+456 \r\12
+ $£ed48_r
+ (\1d\16\12
+__£ed16v
+[3],
+
+457 \19
+d¿nd48_d©a
+ *
+__bufãr
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+459 \r\12
+ $lcÚg48_r
+ (\1d\16\12
+__·¿m
+[7],
+
+460 \19
+d¿nd48_d©a
+ *
+__bufãr
+)
+
+461
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+467 #iâdeà
+__m®loc_ªd_ÿÎoc_def\9aed
+
+
+468 \ 1
+ #__m®loc_ªd_ÿÎoc_def\9aed
+
+
+ )
+
+469
+__BEGIN_NAMESPACE_STD
+
+
+471 \r\1e*
+ $m®loc
+ (
+size_t
+
+__size
+è
+__THROW
+
+__©\8cibu\8b_m®loc__
+
+__wur
+;
+
+473 \r\1e*
+ $ÿÎoc
+ (
+size_t
+
+__nmemb
+, size_\88
+__size
+)
+
+474
+__THROW
+
+__©\8cibu\8b_m®loc__
+
+__wur
+;
+
+475
+__END_NAMESPACE_STD
+
+
+478 #iâdeà
+__Ãed_m®loc_ªd_ÿÎoc
+
+
+479
+__BEGIN_NAMESPACE_STD
+
+
+485 \r\1e*
+ $»®loc
+ (\1e*
+__±r
+,
+size_t
+
+__size
+)
+
+486
+__THROW
+
+__©\8cibu\8b_w¬n_unu£d_»suÉ__
+;
+
+488 \r\1e
+ $ä\93
+ (\1e*
+__±r
+è
+__THROW
+;
+
+489
+__END_NAMESPACE_STD
+
+
+491 #ifdef
+__USE_MISC
+
+
+493 \r\1e
+ $cä\93
+ (\1e*
+__±r
+è
+__THROW
+;
+
+496 #ià
+def\9aed
+
+__USE_GNU
+ || def\9aed
+__USE_BSD
+ || def\9aed
+__USE_MISC
+
+
+497 \ 2
+ ~<®loÿ.h
+>
+
+500 #ià(
+def\9aed
+
+__USE_XOPEN_EXTENDED
+ && !def\9aed
+__USE_XOPEN2K
+) \
+
+501 ||
+def\9aed
+
+__USE_BSD
+
+
+503 \r\1e*
+ $v®loc
+ (
+size_t
+
+__size
+è
+__THROW
+
+__©\8cibu\8b_m®loc__
+
+__wur
+;
+
+506 #ifdeà
+__USE_XOPEN2K
+
+
+508 \r\12
+ $posix_mem®ign
+ (\1e**
+__mem±r
+,
+size_t
+
+__®ignm\92t
+, size_\88
+__size
+)
+
+509
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+512
+__BEGIN_NAMESPACE_STD
+
+
+514 \r\1e
+ $abÜt
+ (\1eè
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__nÜ\91uº__
+));
+
+518 \r\12
+ `©ex\99
+ (\1e(*
+__func
+è(\1e)è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+520 #ifdeà
+__USE_GNU
+
+
+524 #ifdeà
+__ýlu¥lus
+
+
+525 \r"C++" \12
+ `©_quick_ex\99
+ (\1e(*
+__func
+) (\1e))
+
+526
+__THROW
+
+ `__asm
+ ("©_quick_ex\99"è
+ `__nÚnuÎ
+ ((1));
+
+528 \r\12
+ `©_quick_ex\99
+ (\1e(*
+__func
+è(\1e)è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+531
+__END_NAMESPACE_STD
+
+
+533 #ifdef
+__USE_MISC
+
+
+536 \r\12
+ `Ú_ex\99
+ (\1e(*
+__func
+è(\12
+__¡©us
+, \1e*
+__¬g
+), \1e*__arg)
+
+537
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+540
+__BEGIN_NAMESPACE_STD
+
+
+544 \r\1e
+ $ex\99
+ (\12
+__¡©us
+è
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__nÜ\91uº__
+));
+
+546 #ifdeà
+__USE_GNU
+
+
+552 \r\1e
+ $quick_ex\99
+ (\12
+__¡©us
+è
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__nÜ\91uº__
+));
+
+554
+__END_NAMESPACE_STD
+
+
+556 #ifdeà
+__USE_ISOC99
+
+
+557
+__BEGIN_NAMESPACE_C99
+
+
+560 \r\1e
+ $_Ex\99
+ (\12
+__¡©us
+è
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__nÜ\91uº__
+));
+
+561
+__END_NAMESPACE_C99
+
+
+565
+__BEGIN_NAMESPACE_STD
+
+
+567 \r\ 5*
+ $g\91\92v
+ (
+__cڡ
+ \ 5*
+__Çme
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+568
+__END_NAMESPACE_STD
+
+
+572 \r\ 5*
+ $__£cu»_g\91\92v
+ (
+__cڡ
+ \ 5*
+__Çme
+)
+
+573
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+575 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_XOPEN
+
+
+579 \r\12
+ $pu\8bnv
+ (\ 5*
+__¡r\9ag
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+582 #ià
+def\9aed
+
+__USE_BSD
+ || def\9aed
+__USE_XOPEN2K
+
+
+585 \r\12
+ $£\8bnv
+ (
+__cڡ
+ \ 5*
+__Çme
+, __cڡ \ 5*
+__v®ue
+, \12
+__»¶aû
+)
+
+586
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+589 \r\12
+ $un£\8bnv
+ (
+__cڡ
+ \ 5*
+__Çme
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+592 #ifdef
+__USE_MISC
+
+
+596 \r\12
+ $þ\97»nv
+ (\1eè
+__THROW
+;
+
+600 #ià
+def\9aed
+
+__USE_MISC
+ \
+
+601 || (
+def\9aed
+
+__USE_XOPEN_EXTENDED
+ && !def\9aed
+__USE_XOPEN2K
+)
+
+606 \r\ 5*
+ $mk\8bmp
+ (\ 5*
+__\8bm¶©e
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+609 #ià
+def\9aed
+
+__USE_MISC
+ || def\9aed
+__USE_XOPEN_EXTENDED
+ \
+
+610 ||
+def\9aed
+
+__USE_XOPEN2K8
+
+
+619 #iâdeà
+__USE_FILE_OFFSET64
+
+
+620 \r\12
+ $mk¡emp
+ (\ 5*
+__\8bm¶©e
+è
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+622 #ifdeà
+__REDIRECT
+
+
+623 \r\12
+ `__REDIRECT
+ (
+mk¡emp
+, (\ 5*
+__\8bm¶©e
+),
+mk¡emp64
+)
+
+624
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+626 \ 1
+ #mk¡emp
+
+mk¡emp64
+
+
+ )
+
+629 #ifdeà
+__USE_LARGEFILE64
+
+
+630 \r\12
+ $mk¡emp64
+ (\ 5*
+__\8bm¶©e
+è
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+634 #ifdeà
+__USE_MISC
+
+
+641 #iâdeà
+__USE_FILE_OFFSET64
+
+
+642 \r\12
+ $mk¡emps
+ (\ 5*
+__\8bm¶©e
+, \12
+__suffixËn
+è
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+644 #ifdeà
+__REDIRECT
+
+
+645 \r\12
+ `__REDIRECT
+ (
+mk¡emps
+, (\ 5*
+__\8bm¶©e
+, \12
+__suffixËn
+),
+
+646
+mk¡emps64
+è
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+648 \ 1
+ #mk¡emps
+
+mk¡emps64
+
+
+ )
+
+651 #ifdeà
+__USE_LARGEFILE64
+
+
+652 \r\12
+ $mk¡emps64
+ (\ 5*
+__\8bm¶©e
+, \12
+__suffixËn
+)
+
+653
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+657 #ià
+def\9aed
+
+__USE_BSD
+ || def\9aed
+__USE_XOPEN2K8
+
+
+663 \r\ 5*
+ $mkd\8bmp
+ (\ 5*
+__\8bm¶©e
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+666 #ifdeà
+__USE_GNU
+
+
+673 #iâdeà
+__USE_FILE_OFFSET64
+
+
+674 \r\12
+ $mko¡emp
+ (\ 5*
+__\8bm¶©e
+, \12
+__æags
+è
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+676 #ifdeà
+__REDIRECT
+
+
+677 \r\12
+ `__REDIRECT
+ (
+mko¡emp
+, (\ 5*
+__\8bm¶©e
+, \12
+__æags
+),
+mko¡emp64
+)
+
+678
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+680 \ 1
+ #mko¡emp
+
+mko¡emp64
+
+
+ )
+
+683 #ifdeà
+__USE_LARGEFILE64
+
+
+684 \r\12
+ $mko¡emp64
+ (\ 5*
+__\8bm¶©e
+, \12
+__æags
+è
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+693 #iâdeà
+__USE_FILE_OFFSET64
+
+
+694 \r\12
+ $mko¡emps
+ (\ 5*
+__\8bm¶©e
+, \12
+__suffixËn
+, \12
+__æags
+)
+
+695
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+697 #ifdeà
+__REDIRECT
+
+
+698 \r\12
+ `__REDIRECT
+ (
+mko¡emps
+, (\ 5*
+__\8bm¶©e
+, \12
+__suffixËn
+,
+
+699 \12
+__æags
+),
+mko¡emps64
+)
+
+700
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+702 \ 1
+ #mko¡emps
+
+mko¡emps64
+
+
+ )
+
+705 #ifdeà
+__USE_LARGEFILE64
+
+
+706 \r\12
+ $mko¡emps64
+ (\ 5*
+__\8bm¶©e
+, \12
+__suffixËn
+, \12
+__æags
+)
+
+707
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+712
+__BEGIN_NAMESPACE_STD
+
+
+717 \r\12
+ $sy¡em
+ (
+__cڡ
+ \ 5*
+__commªd
+è
+__wur
+;
+
+718
+__END_NAMESPACE_STD
+
+
+721 #ifdef
+__USE_GNU
+
+
+724 \r\ 5*
+ $ÿnÚiÿlize_f\9ee_Çme
+ (
+__cڡ
+ \ 5*
+__Çme
+)
+
+725
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+728 #ià
+def\9aed
+
+__USE_BSD
+ || def\9aed
+__USE_XOPEN_EXTENDED
+
+
+734 \r\ 5*
+ $»®·th
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Çme
+,
+
+735 \ 5*
+__»¡riù
+
+__»sÞved
+è
+__THROW
+
+__wur
+;
+
+740 #iâdeà
+__COMPAR_FN_T
+
+
+741 \ 1
+ #__COMPAR_FN_T
+
+
+ )
+
+742 \e\12(*
+ t__com·r_â_t
+è(
+ t__cڡ
+ \1e*, __const \1e*);
+
+744 #ifdef
+__USE_GNU
+
+
+745 \e
+__com·r_â_t
+
+ tcom·risÚ_â_t
+;
+
+748 #ifdeà
+__USE_GNU
+
+
+749 \e\12(*
+ t__com·r_d_â_t
+è(
+ t__cڡ
+ \1e*, __const \1e*, \1e*);
+
+752
+__BEGIN_NAMESPACE_STD
+
+
+755 \r\1e*
+ $b£¬ch
+ (
+__cڡ
+ \1e*
+__key
+, __cڡ \1e*
+__ba£
+,
+
+756
+size_t
+
+__nmemb
+, size_\88
+__size
+,
+__com·r_â_t
+
+__com·r
+)
+
+757
+ `__nÚnuÎ
+ ((1, 2, 5)è
+__wur
+;
+
+761 \r\1e
+ $qsÜt
+ (\1e*
+__ba£
+,
+size_t
+
+__nmemb
+, size_\88
+__size
+,
+
+762
+__com·r_â_t
+
+__com·r
+è
+ `__nÚnuÎ
+ ((1, 4));
+
+763 #ifdeà
+__USE_GNU
+
+
+764 \r\1e
+ $qsÜt_r
+ (\1e*
+__ba£
+,
+size_t
+
+__nmemb
+, size_\88
+__size
+,
+
+765
+__com·r_d_â_t
+
+__com·r
+, \1e*
+__¬g
+)
+
+766
+ `__nÚnuÎ
+ ((1, 4));
+
+771 \r\12
+ $abs
+ (\12
+__x
+è
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+)è
+__wur
+;
+
+772 \r\13\12
+ $Ïbs
+ (\13\12
+__x
+è
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+)è
+__wur
+;
+
+773
+__END_NAMESPACE_STD
+
+
+775 #ifdeà
+__USE_ISOC99
+
+
+776
+__ex\8bnsiÚ__
+ \r\13\13\12
+ $Îabs
+ (\13\13\12
+__x
+)
+
+777
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+)è
+__wur
+;
+
+781
+__BEGIN_NAMESPACE_STD
+
+
+785 \r
+div_t
+
+ $div
+ (\12
+__num\94
+, \12
+__d\92om
+)
+
+786
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+)è
+__wur
+;
+
+787 \r
+ldiv_t
+
+ $ldiv
+ (\13\12
+__num\94
+, \13\12
+__d\92om
+)
+
+788
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+)è
+__wur
+;
+
+789
+__END_NAMESPACE_STD
+
+
+791 #ifdeà
+__USE_ISOC99
+
+
+792
+__BEGIN_NAMESPACE_C99
+
+
+793
+__ex\8bnsiÚ__
+ \r
+Îdiv_t
+
+ $Îdiv
+ (\13\13\12
+__num\94
+,
+
+794 \13\13\12
+__d\92om
+)
+
+795
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+)è
+__wur
+;
+
+796
+__END_NAMESPACE_C99
+
+
+800 #ià(
+def\9aed
+
+__USE_XOPEN_EXTENDED
+ && !def\9aed
+__USE_XOPEN2K
+) \
+
+801 ||
+def\9aed
+
+__USE_SVID
+
+
+808 \r\ 5*
+ $ecvt
+ (\b
+__v®ue
+, \12
+__ndig\99
+, \12*
+__»¡riù
+
+__deýt
+,
+
+809 \12*
+__»¡riù
+
+__sign
+è
+__THROW
+
+ `__nÚnuÎ
+ ((3, 4)è
+__wur
+;
+
+814 \r\ 5*
+ $fcvt
+ (\b
+__v®ue
+, \12
+__ndig\99
+, \12*
+__»¡riù
+
+__deýt
+,
+
+815 \12*
+__»¡riù
+
+__sign
+è
+__THROW
+
+ `__nÚnuÎ
+ ((3, 4)è
+__wur
+;
+
+820 \r\ 5*
+ $gcvt
+ (\b
+__v®ue
+, \12
+__ndig\99
+, \ 5*
+__buf
+)
+
+821
+__THROW
+
+ `__nÚnuÎ
+ ((3)è
+__wur
+;
+
+824 #ifdeà
+__USE_MISC
+
+
+826 \r\ 5*
+ $qecvt
+ (\13\b
+__v®ue
+, \12
+__ndig\99
+,
+
+827 \12*
+__»¡riù
+
+__deýt
+, \12*__»¡riù
+__sign
+)
+
+828
+__THROW
+
+ `__nÚnuÎ
+ ((3, 4)è
+__wur
+;
+
+829 \r\ 5*
+ $qfcvt
+ (\13\b
+__v®ue
+, \12
+__ndig\99
+,
+
+830 \12*
+__»¡riù
+
+__deýt
+, \12*__»¡riù
+__sign
+)
+
+831
+__THROW
+
+ `__nÚnuÎ
+ ((3, 4)è
+__wur
+;
+
+832 \r\ 5*
+ $qgcvt
+ (\13\b
+__v®ue
+, \12
+__ndig\99
+, \ 5*
+__buf
+)
+
+833
+__THROW
+
+ `__nÚnuÎ
+ ((3)è
+__wur
+;
+
+838 \r\12
+ $ecvt_r
+ (\b
+__v®ue
+, \12
+__ndig\99
+, \12*
+__»¡riù
+
+__deýt
+,
+
+839 \12*
+__»¡riù
+
+__sign
+, \ 5*__»¡riù
+__buf
+,
+
+840
+size_t
+
+__Ën
+è
+__THROW
+
+ `__nÚnuÎ
+ ((3, 4, 5));
+
+841 \r\12
+ $fcvt_r
+ (\b
+__v®ue
+, \12
+__ndig\99
+, \12*
+__»¡riù
+
+__deýt
+,
+
+842 \12*
+__»¡riù
+
+__sign
+, \ 5*__»¡riù
+__buf
+,
+
+843
+size_t
+
+__Ën
+è
+__THROW
+
+ `__nÚnuÎ
+ ((3, 4, 5));
+
+845 \r\12
+ $qecvt_r
+ (\13\b
+__v®ue
+, \12
+__ndig\99
+,
+
+846 \12*
+__»¡riù
+
+__deýt
+, \12*__»¡riù
+__sign
+,
+
+847 \ 5*
+__»¡riù
+
+__buf
+,
+size_t
+
+__Ën
+)
+
+848
+__THROW
+
+ `__nÚnuÎ
+ ((3, 4, 5));
+
+849 \r\12
+ $qfcvt_r
+ (\13\b
+__v®ue
+, \12
+__ndig\99
+,
+
+850 \12*
+__»¡riù
+
+__deýt
+, \12*__»¡riù
+__sign
+,
+
+851 \ 5*
+__»¡riù
+
+__buf
+,
+size_t
+
+__Ën
+)
+
+852
+__THROW
+
+ `__nÚnuÎ
+ ((3, 4, 5));
+
+857
+__BEGIN_NAMESPACE_STD
+
+
+860 \r\12
+ $mbËn
+ (
+__cڡ
+ \ 5*
+__s
+,
+size_t
+
+__n
+è
+__THROW
+
+__wur
+;
+
+863 \r\12
+ $mbtowc
+ (
+wch¬_t
+ *
+__»¡riù
+
+__pwc
+,
+
+864
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+è
+__THROW
+
+__wur
+;
+
+867 \r\12
+ $wùomb
+ (\ 5*
+__s
+,
+wch¬_t
+
+__wch¬
+è
+__THROW
+
+__wur
+;
+
+871 \r
+size_t
+
+ $mb¡owcs
+ (
+wch¬_t
+ *
+__»¡riù
+
+__pwcs
+,
+
+872
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+è
+__THROW
+;
+
+874 \r
+size_t
+
+ $wc¡ombs
+ (\ 5*
+__»¡riù
+
+__s
+,
+
+875
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__pwcs
+,
+size_t
+
+__n
+)
+
+876
+__THROW
+;
+
+877
+__END_NAMESPACE_STD
+
+
+880 #ifdeà
+__USE_SVID
+
+
+885 \r\12
+ $½m©ch
+ (
+__cڡ
+ \ 5*
+__»¥Ú£
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__wur
+;
+
+889 #ià
+def\9aed
+
+__USE_XOPEN_EXTENDED
+ || def\9aed
+__USE_XOPEN2K8
+
+
+896 \r\12
+ $g\91subÝt
+ (\ 5**
+__»¡riù
+
+__ÝtiÚp
+,
+
+897 \ 5*
+__cڡ
+ *
+__»¡riù
+
+__tok\92s
+,
+
+898 \ 5**
+__»¡riù
+
+__v®u\95
+)
+
+899
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2, 3)è
+__wur
+;
+
+903 #ifdeà
+__USE_XOPEN
+
+
+905 \r\1e
+ $£tkey
+ (
+__cڡ
+ \ 5*
+__key
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+911 #ifdeà
+__USE_XOPEN2KXSI
+
+
+913 \r\12
+ $posix_Ý\92±
+ (\12
+__oæag
+è
+__wur
+;
+
+916 #ifdeà
+__USE_XOPEN
+
+
+921 \r\12
+ $g¿Á±
+ (\12
+__fd
+è
+__THROW
+;
+
+925 \r\12
+ $uÆock±
+ (\12
+__fd
+è
+__THROW
+;
+
+930 \r\ 5*
+ $±¢ame
+ (\12
+__fd
+è
+__THROW
+
+__wur
+;
+
+933 #ifdeà
+__USE_GNU
+
+
+937 \r\12
+ $±¢ame_r
+ (\12
+__fd
+, \ 5*
+__buf
+,
+size_t
+
+__buæ\92
+)
+
+938
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+941 \r\12
+ `g\91±
+ (\1e);
+
+944 #ifdeà
+__USE_BSD
+
+
+948 \r\12
+ $g\91lßdavg
+ (\b
+__lßdavg
+[], \12
+__ÃËm
+)
+
+949
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+954 #ià
+__USE_FORTIFY_LEVEL
+ > 0 &&
+def\9aed
+
+__ex\8bº_®ways_\9al\9ae
+
+
+955 \ 2
+ ~<b\99s/¡dlib.h
+>
+
+957 #ifdeà
+__LDBL_COMPAT
+
+
+958 \ 2
+ ~<b\99s/¡dlib-ldbl.h
+>
+
+962 #undeà
+__Ãed_m®loc_ªd_ÿÎoc
+
+
+964
+__END_DECLS
+
+
+ @/usr/include/string.h
+
+24 #iâdef
+_STRING_H
+
+
+25 \ 1
+ #_STRING_H
+ 1
+
+ )
+
+27 \ 2
+ ~<ã©u»s.h
+>
+
+29
+ g__BEGIN_DECLS
+
+
+32 \ 1
+ #__Ãed_size_t
+
+
+ )
+
+33 \ 1
+ #__Ãed_NULL
+
+
+ )
+
+34 \ 2
+ ~<¡ddef.h
+>
+
+37 #ià
+def\9aed
+
+__ýlu¥lus
+ &&
+__GNUC_PREREQ
+ (4, 4)
+
+38 \ 1
+ #__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+ )
+
+42
+__BEGIN_NAMESPACE_STD
+
+
+44 \r\1e*
+ $memýy
+ (\1e*
+__»¡riù
+
+__de¡
+,
+
+45
+__cڡ
+ \1e*
+__»¡riù
+
+__¤c
+,
+size_t
+
+__n
+)
+
+46
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+49 \r\1e*
+ $memmove
+ (\1e*
+__de¡
+,
+__cڡ
+ \1e*
+__¤c
+,
+size_t
+
+__n
+)
+
+50
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+51
+__END_NAMESPACE_STD
+
+
+56 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_BSD
+ || def\9aed
+__USE_XOPEN
+
+
+57 \r\1e*
+ $memcýy
+ (\1e*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \1e*__»¡riù
+__¤c
+,
+
+58 \12
+__c
+,
+size_t
+
+__n
+)
+
+59
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+63
+__BEGIN_NAMESPACE_STD
+
+
+65 \r\1e*
+ $mem£t
+ (\1e*
+__s
+, \12
+__c
+,
+size_t
+
+__n
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+68 \r\12
+ $memcmp
+ (
+__cڡ
+ \1e*
+__s1
+, __cڡ \1e*
+__s2
+,
+size_t
+
+__n
+)
+
+69
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+72 #ifdeà
+__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+75 \r\1e*
+ `memchr
+ (\1e*
+__s
+, \12
+__c
+,
+size_t
+
+__n
+)
+
+76
+__THROW
+
+ `__asm
+ ("memchr"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+77 \r
+__cڡ
+ \1e*
+ `memchr
+ (__cڡ \1e*
+__s
+, \12
+__c
+,
+size_t
+
+__n
+)
+
+78
+__THROW
+
+ `__asm
+ ("memchr"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+80 #ifdeà
+__OPTIMIZE__
+
+
+81
+__ex\8bº_®ways_\9al\9ae
+ \1e*
+
+82
+ `memchr
+ (\1e*
+__s
+, \12
+__c
+,
+size_t
+
+__n
+è
+__THROW
+
+
+84 \15
+ `__bu\9et\9a_memchr
+ (
+__s
+,
+__c
+,
+__n
+);
+
+87
+__ex\8bº_®ways_\9al\9ae
+
+__cڡ
+ \1e*
+
+88
+ `memchr
+ (
+__cڡ
+ \1e*
+__s
+, \12
+__c
+,
+size_t
+
+__n
+è
+__THROW
+
+
+90 \15
+ `__bu\9et\9a_memchr
+ (
+__s
+,
+__c
+,
+__n
+);
+
+93
+ }
+}
+
+95 \r\1e*
+ $memchr
+ (
+__cڡ
+ \1e*
+__s
+, \12
+__c
+,
+size_t
+
+__n
+)
+
+96
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+98
+__END_NAMESPACE_STD
+
+
+100 #ifdeà
+__USE_GNU
+
+
+103 #ifdeà
+__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+104 \r"C++" \1e*
+ $¿wmemchr
+ (\1e*
+__s
+, \12
+__c
+)
+
+105
+__THROW
+
+ `__asm
+ ("¿wmemchr"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+106 \r"C++"
+__cڡ
+ \1e*
+ $¿wmemchr
+ (
+__cڡ
+ \1e*
+__s
+, \12
+__c
+)
+
+107
+__THROW
+
+ `__asm
+ ("¿wmemchr"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+109 \r\1e*
+ $¿wmemchr
+ (
+__cڡ
+ \1e*
+__s
+, \12
+__c
+)
+
+110
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+114 #ifdeà
+__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+115 \r"C++" \1e*
+ $memrchr
+ (\1e*
+__s
+, \12
+__c
+,
+size_t
+
+__n
+)
+
+116
+__THROW
+
+ `__asm
+ ("memrchr"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+117 \r"C++"
+__cڡ
+ \1e*
+ $memrchr
+ (
+__cڡ
+ \1e*
+__s
+, \12
+__c
+,
+size_t
+
+__n
+)
+
+118
+__THROW
+
+ `__asm
+ ("memrchr"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+120 \r\1e*
+ $memrchr
+ (
+__cڡ
+ \1e*
+__s
+, \12
+__c
+,
+size_t
+
+__n
+)
+
+121
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+126
+__BEGIN_NAMESPACE_STD
+
+
+128 \r\ 5*
+ $¡rýy
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \ 5*__»¡riù
+__¤c
+)
+
+129
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+131 \r\ 5*
+ $¡ºýy
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+
+132
+__cڡ
+ \ 5*
+__»¡riù
+
+__¤c
+,
+size_t
+
+__n
+)
+
+133
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+136 \r\ 5*
+ $¡rÿt
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \ 5*__»¡riù
+__¤c
+)
+
+137
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+139 \r\ 5*
+ $¡ºÿt
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \ 5*__»¡riù
+__¤c
+,
+
+140
+size_t
+
+__n
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+143 \r\12
+ $¡rcmp
+ (
+__cڡ
+ \ 5*
+__s1
+, __cڡ \ 5*
+__s2
+)
+
+144
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+146 \r\12
+ $¡ºcmp
+ (
+__cڡ
+ \ 5*
+__s1
+, __cڡ \ 5*
+__s2
+,
+size_t
+
+__n
+)
+
+147
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+150 \r\12
+ $¡rcÞl
+ (
+__cڡ
+ \ 5*
+__s1
+, __cڡ \ 5*
+__s2
+)
+
+151
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+153 \r
+size_t
+
+ $¡rxäm
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+
+154
+__cڡ
+ \ 5*
+__»¡riù
+
+__¤c
+,
+size_t
+
+__n
+)
+
+155
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+156
+__END_NAMESPACE_STD
+
+
+158 #ifdeà
+__USE_XOPEN2K8
+
+
+162 \ 2
+ ~<xloÿË.h
+>
+
+165 \r\12
+ $¡rcÞl_l
+ (
+__cڡ
+ \ 5*
+__s1
+, __cڡ \ 5*
+__s2
+,
+__loÿË_t
+
+__l
+)
+
+166
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2, 3));
+
+168 \r
+size_t
+
+ $¡rxäm_l
+ (\ 5*
+__de¡
+,
+__cڡ
+ \ 5*
+__¤c
+,
+size_t
+
+__n
+,
+
+169
+__loÿË_t
+
+__l
+è
+__THROW
+
+ `__nÚnuÎ
+ ((2, 4));
+
+172 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_BSD
+ || def\9aed
+__USE_XOPEN_EXTENDED
+ \
+
+173 ||
+def\9aed
+
+__USE_XOPEN2K8
+
+
+175 \r\ 5*
+ $¡rdup
+ (
+__cڡ
+ \ 5*
+__s
+)
+
+176
+__THROW
+
+__©\8cibu\8b_m®loc__
+
+ `__nÚnuÎ
+ ((1));
+
+182 #ià
+def\9aed
+
+__USE_XOPEN2K8
+
+
+183 \r\ 5*
+ $¡ºdup
+ (
+__cڡ
+ \ 5*
+__¡r\9ag
+,
+size_t
+
+__n
+)
+
+184
+__THROW
+
+__©\8cibu\8b_m®loc__
+
+ `__nÚnuÎ
+ ((1));
+
+187 #ià
+def\9aed
+
+__USE_GNU
+ && def\9aed
+__GNUC__
+
+
+189 \ 1
+ #¡rdu·
+(
+s
+) \
+
+190 (
+__ex\8bnsiÚ__
+ \
+
+192
+__cڡ
+ \ 5*
+__Þd
+ = (
+s
+); \
+
+193
+size_t
+
+__Ën
+ =
+ `¡¾\92
+ (
+__Þd
+) + 1; \
+
+194 \ 5*
+__Ãw
+ = (\ 5*è
+ `__bu\9et\9a_®loÿ
+ (
+__Ën
+); \
+
+195 (\ 5*è
+ `memýy
+ (
+__Ãw
+,
+__Þd
+,
+__Ën
+); \
+
+196
+ }
+}))
+
+ )
+
+199 \ 1
+ #¡ºdu·
+(
+s
+,
+n
+) \
+
+200 (
+__ex\8bnsiÚ__
+ \
+
+202
+__cڡ
+ \ 5*
+__Þd
+ = (
+s
+); \
+
+203
+size_t
+
+__Ën
+ =
+ `¡ºËn
+ (
+__Þd
+, (
+n
+)); \
+
+204 \ 5*
+__Ãw
+ = (\ 5*è
+ `__bu\9et\9a_®loÿ
+ (
+__Ën
+ + 1); \
+
+205
+__Ãw
+[
+__Ën
+] = '\0'; \
+
+206 (\ 5*è
+ `memýy
+ (
+__Ãw
+,
+__Þd
+,
+__Ën
+); \
+
+207 }))
+
+ )
+
+210
+ g__BEGIN_NAMESPACE_STD
+
+
+212 #ifdeà
+__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+215 \r\ 5*
+¡rchr
+ (\ 5*
+__s
+, \12
+__c
+)
+
+216
+__THROW
+
+__asm
+ ("¡rchr"è
+__©\8cibu\8b_pu»__
+
+__nÚnuÎ
+ ((1));
+
+217 \r
+__cڡ
+ \ 5*
+¡rchr
+ (__cڡ \ 5*
+__s
+, \12
+__c
+)
+
+218
+__THROW
+
+__asm
+ ("¡rchr"è
+__©\8cibu\8b_pu»__
+
+__nÚnuÎ
+ ((1));
+
+220 #ifdeà
+__OPTIMIZE__
+
+
+221
+__ex\8bº_®ways_\9al\9ae
+ \ 5*
+
+222
+¡rchr
+ (\ 5*
+__s
+, \12
+__c
+è
+ g__THROW
+
+
+224 \15
+__bu\9et\9a_¡rchr
+ (
+__s
+,
+__c
+);
+
+227
+__ex\8bº_®ways_\9al\9ae
+
+__cڡ
+ \ 5*
+
+228
+¡rchr
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__c
+è
+ g__THROW
+
+
+230 \15
+__bu\9et\9a_¡rchr
+ (
+__s
+,
+__c
+);
+
+235 \r\ 5*
+ $¡rchr
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__c
+)
+
+236
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+239 #ifdeà
+__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+242 \r\ 5*
+ `¡¼chr
+ (\ 5*
+__s
+, \12
+__c
+)
+
+243
+__THROW
+
+ `__asm
+ ("¡¼chr"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+244 \r
+__cڡ
+ \ 5*
+ `¡¼chr
+ (__cڡ \ 5*
+__s
+, \12
+__c
+)
+
+245
+__THROW
+
+ `__asm
+ ("¡¼chr"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+247 #ifdeà
+__OPTIMIZE__
+
+
+248
+__ex\8bº_®ways_\9al\9ae
+ \ 5*
+
+249
+ `¡¼chr
+ (\ 5*
+__s
+, \12
+__c
+è
+__THROW
+
+
+251 \15
+ `__bu\9et\9a_¡¼chr
+ (
+__s
+,
+__c
+);
+
+254
+__ex\8bº_®ways_\9al\9ae
+
+__cڡ
+ \ 5*
+
+255
+ `¡¼chr
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__c
+è
+__THROW
+
+
+257 \15
+ `__bu\9et\9a_¡¼chr
+ (
+__s
+,
+__c
+);
+
+260
+ }
+}
+
+262 \r\ 5*
+ $¡¼chr
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__c
+)
+
+263
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+265
+__END_NAMESPACE_STD
+
+
+267 #ifdeà
+__USE_GNU
+
+
+270 #ifdeà
+__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+271 \r"C++" \ 5*
+ $¡rchºul
+ (\ 5*
+__s
+, \12
+__c
+)
+
+272
+__THROW
+
+ `__asm
+ ("¡rchºul"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+273 \r"C++"
+__cڡ
+ \ 5*
+ $¡rchºul
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__c
+)
+
+274
+__THROW
+
+ `__asm
+ ("¡rchºul"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+276 \r\ 5*
+ $¡rchºul
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__c
+)
+
+277
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+281
+__BEGIN_NAMESPACE_STD
+
+
+284 \r
+size_t
+
+ $¡rc¥n
+ (
+__cڡ
+ \ 5*
+__s
+, __cڡ \ 5*
+__»jeù
+)
+
+285
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+288 \r
+size_t
+
+ $¡r¥n
+ (
+__cڡ
+ \ 5*
+__s
+, __cڡ \ 5*
+__acû±
+)
+
+289
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+291 #ifdeà
+__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+294 \r\ 5*
+ `¡½brk
+ (\ 5*
+__s
+,
+__cڡ
+ \ 5*
+__acû±
+)
+
+295
+__THROW
+
+ `__asm
+ ("¡½brk"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+296 \r
+__cڡ
+ \ 5*
+ `¡½brk
+ (__cڡ \ 5*
+__s
+, __cڡ \ 5*
+__acû±
+)
+
+297
+__THROW
+
+ `__asm
+ ("¡½brk"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+299 #ifdeà
+__OPTIMIZE__
+
+
+300
+__ex\8bº_®ways_\9al\9ae
+ \ 5*
+
+301
+ `¡½brk
+ (\ 5*
+__s
+,
+__cڡ
+ \ 5*
+__acû±
+è
+__THROW
+
+
+303 \15
+ `__bu\9et\9a_¡½brk
+ (
+__s
+,
+__acû±
+);
+
+306
+__ex\8bº_®ways_\9al\9ae
+
+__cڡ
+ \ 5*
+
+307
+ `¡½brk
+ (
+__cڡ
+ \ 5*
+__s
+, __cڡ \ 5*
+__acû±
+è
+__THROW
+
+
+309 \15
+ `__bu\9et\9a_¡½brk
+ (
+__s
+,
+__acû±
+);
+
+312
+ }
+}
+
+314 \r\ 5*
+ $¡½brk
+ (
+__cڡ
+ \ 5*
+__s
+, __cڡ \ 5*
+__acû±
+)
+
+315
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+318 #ifdeà
+__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+321 \r\ 5*
+ `¡r¡r
+ (\ 5*
+__hay¡ack
+,
+__cڡ
+ \ 5*
+__ÃedË
+)
+
+322
+__THROW
+
+ `__asm
+ ("¡r¡r"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+323 \r
+__cڡ
+ \ 5*
+ `¡r¡r
+ (__cڡ \ 5*
+__hay¡ack
+,
+
+324
+__cڡ
+ \ 5*
+__ÃedË
+)
+
+325
+__THROW
+
+ `__asm
+ ("¡r¡r"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+327 #ifdeà
+__OPTIMIZE__
+
+
+328
+__ex\8bº_®ways_\9al\9ae
+ \ 5*
+
+329
+ `¡r¡r
+ (\ 5*
+__hay¡ack
+,
+__cڡ
+ \ 5*
+__ÃedË
+è
+__THROW
+
+
+331 \15
+ `__bu\9et\9a_¡r¡r
+ (
+__hay¡ack
+,
+__ÃedË
+);
+
+334
+__ex\8bº_®ways_\9al\9ae
+
+__cڡ
+ \ 5*
+
+335
+ `¡r¡r
+ (
+__cڡ
+ \ 5*
+__hay¡ack
+, __cڡ \ 5*
+__ÃedË
+è
+__THROW
+
+
+337 \15
+ `__bu\9et\9a_¡r¡r
+ (
+__hay¡ack
+,
+__ÃedË
+);
+
+340
+ }
+}
+
+342 \r\ 5*
+ $¡r¡r
+ (
+__cڡ
+ \ 5*
+__hay¡ack
+, __cڡ \ 5*
+__ÃedË
+)
+
+343
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+348 \r\ 5*
+ $¡¹ok
+ (\ 5*
+__»¡riù
+
+__s
+,
+__cڡ
+ \ 5*__»¡riù
+__d\96im
+)
+
+349
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+350
+__END_NAMESPACE_STD
+
+
+354 \r\ 5*
+ $__¡¹ok_r
+ (\ 5*
+__»¡riù
+
+__s
+,
+
+355
+__cڡ
+ \ 5*
+__»¡riù
+
+__d\96im
+,
+
+356 \ 5**
+__»¡riù
+
+__§ve_±r
+)
+
+357
+__THROW
+
+ `__nÚnuÎ
+ ((2, 3));
+
+358 #ià
+def\9aed
+
+__USE_POSIX
+ || def\9aed
+__USE_MISC
+
+
+359 \r\ 5*
+ $¡¹ok_r
+ (\ 5*
+__»¡riù
+
+__s
+,
+__cڡ
+ \ 5*__»¡riù
+__d\96im
+,
+
+360 \ 5**
+__»¡riù
+
+__§ve_±r
+)
+
+361
+__THROW
+
+ `__nÚnuÎ
+ ((2, 3));
+
+364 #ifdeà
+__USE_GNU
+
+
+366 #ifdeà
+__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+367 \r"C++" \ 5*
+ $¡rÿ£¡r
+ (\ 5*
+__hay¡ack
+,
+__cڡ
+ \ 5*
+__ÃedË
+)
+
+368
+__THROW
+
+ `__asm
+ ("¡rÿ£¡r"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+369 \r"C++"
+__cڡ
+ \ 5*
+ $¡rÿ£¡r
+ (
+__cڡ
+ \ 5*
+__hay¡ack
+,
+
+370
+__cڡ
+ \ 5*
+__ÃedË
+)
+
+371
+__THROW
+
+ `__asm
+ ("¡rÿ£¡r"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+373 \r\ 5*
+ $¡rÿ£¡r
+ (
+__cڡ
+ \ 5*
+__hay¡ack
+, __cڡ \ 5*
+__ÃedË
+)
+
+374
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+378 #ifdeà
+__USE_GNU
+
+
+382 \r\1e*
+ $memmem
+ (
+__cڡ
+ \1e*
+__hay¡ack
+,
+size_t
+
+__hay¡ackËn
+,
+
+383
+__cڡ
+ \1e*
+__ÃedË
+,
+size_t
+
+__ÃedËËn
+)
+
+384
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 3));
+
+388 \r\1e*
+ $__mempýy
+ (\1e*
+__»¡riù
+
+__de¡
+,
+
+389
+__cڡ
+ \1e*
+__»¡riù
+
+__¤c
+,
+size_t
+
+__n
+)
+
+390
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+391 \r\1e*
+ $mempýy
+ (\1e*
+__»¡riù
+
+__de¡
+,
+
+392
+__cڡ
+ \1e*
+__»¡riù
+
+__¤c
+,
+size_t
+
+__n
+)
+
+393
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+397
+__BEGIN_NAMESPACE_STD
+
+
+399 \r
+size_t
+
+ $¡¾\92
+ (
+__cڡ
+ \ 5*
+__s
+)
+
+400
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+401
+__END_NAMESPACE_STD
+
+
+403 #ifdef
+__USE_XOPEN2K8
+
+
+406 \r
+size_t
+
+ $¡ºËn
+ (
+__cڡ
+ \ 5*
+__¡r\9ag
+,
+size_t
+
+__maxËn
+)
+
+407
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+411
+__BEGIN_NAMESPACE_STD
+
+
+413 \r\ 5*
+ $¡»¼Ü
+ (\12
+__\94ºum
+è
+__THROW
+;
+
+414
+__END_NAMESPACE_STD
+
+
+415 #ià
+def\9aed
+
+__USE_XOPEN2K
+ || def\9aed
+__USE_MISC
+
+
+423 #ià
+def\9aed
+
+__USE_XOPEN2K
+ && !def\9aed
+__USE_GNU
+
+
+426 #ifdeà
+__REDIRECT_NTH
+
+
+427 \r\12
+ `__REDIRECT_NTH
+ (
+¡»¼Ü_r
+,
+
+428 (\12
+__\94ºum
+, \ 5*
+__buf
+,
+size_t
+
+__buæ\92
+),
+
+429
+__xpg_¡»¼Ü_r
+è
+ `__nÚnuÎ
+ ((2));
+
+431 \r\12
+ $__xpg_¡»¼Ü_r
+ (\12
+__\94ºum
+, \ 5*
+__buf
+,
+size_t
+
+__buæ\92
+)
+
+432
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+433 \ 1
+ #¡»¼Ü_r
+
+__xpg_¡»¼Ü_r
+
+
+ )
+
+438 \r\ 5*
+ $¡»¼Ü_r
+ (\12
+__\94ºum
+, \ 5*
+__buf
+,
+size_t
+
+__buæ\92
+)
+
+439
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+443 #ifdeà
+__USE_XOPEN2K8
+
+
+445 \r\ 5*
+ $¡»¼Ü_l
+ (\12
+__\94ºum
+,
+__loÿË_t
+
+__l
+è
+__THROW
+;
+
+451 \r\1e
+ $__bz\94o
+ (\1e*
+__s
+,
+size_t
+
+__n
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+453 #ifdeà
+__USE_BSD
+
+
+455 \r\1e
+ $bcÝy
+ (
+__cڡ
+ \1e*
+__¤c
+, \1e*
+__de¡
+,
+size_t
+
+__n
+)
+
+456
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+459 \r\1e
+ $bz\94o
+ (\1e*
+__s
+,
+size_t
+
+__n
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+462 \r\12
+ $bcmp
+ (
+__cڡ
+ \1e*
+__s1
+, __cڡ \1e*
+__s2
+,
+size_t
+
+__n
+)
+
+463
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+466 #ifdeà
+__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+469 \r\ 5*
+ `\9adex
+ (\ 5*
+__s
+, \12
+__c
+)
+
+470
+__THROW
+
+ `__asm
+ ("\9adex"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+471 \r
+__cڡ
+ \ 5*
+ `\9adex
+ (__cڡ \ 5*
+__s
+, \12
+__c
+)
+
+472
+__THROW
+
+ `__asm
+ ("\9adex"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+474 #ià
+def\9aed
+
+__OPTIMIZE__
+ && !def\9aed
+__CORRECT_ISO_CPP_STRINGS_H_PROTO
+
+
+475
+__ex\8bº_®ways_\9al\9ae
+ \ 5*
+
+476
+ `\9adex
+ (\ 5*
+__s
+, \12
+__c
+è
+__THROW
+
+
+478 \15
+ `__bu\9et\9a_\9adex
+ (
+__s
+,
+__c
+);
+
+481
+__ex\8bº_®ways_\9al\9ae
+
+__cڡ
+ \ 5*
+
+482
+ `\9adex
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__c
+è
+__THROW
+
+
+484 \15
+ `__bu\9et\9a_\9adex
+ (
+__s
+,
+__c
+);
+
+487
+ }
+}
+
+489 \r\ 5*
+ $\9adex
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__c
+)
+
+490
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+494 #ifdeà
+__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+497 \r\ 5*
+ `r\9adex
+ (\ 5*
+__s
+, \12
+__c
+)
+
+498
+__THROW
+
+ `__asm
+ ("r\9adex"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+499 \r
+__cڡ
+ \ 5*
+ `r\9adex
+ (__cڡ \ 5*
+__s
+, \12
+__c
+)
+
+500
+__THROW
+
+ `__asm
+ ("r\9adex"è
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+502 #ià
+def\9aed
+
+__OPTIMIZE__
+ && !def\9aed
+__CORRECT_ISO_CPP_STRINGS_H_PROTO
+
+
+503
+__ex\8bº_®ways_\9al\9ae
+ \ 5*
+
+504
+ `r\9adex
+ (\ 5*
+__s
+, \12
+__c
+è
+__THROW
+
+
+506 \15
+ `__bu\9et\9a_r\9adex
+ (
+__s
+,
+__c
+);
+
+509
+__ex\8bº_®ways_\9al\9ae
+
+__cڡ
+ \ 5*
+
+510
+ `r\9adex
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__c
+è
+__THROW
+
+
+512 \15
+ `__bu\9et\9a_r\9adex
+ (
+__s
+,
+__c
+);
+
+515
+ }
+}
+
+517 \r\ 5*
+ $r\9adex
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__c
+)
+
+518
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1));
+
+523 \r\12
+ $ffs
+ (\12
+__i
+è
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+));
+
+527 #ifdef
+__USE_GNU
+
+
+528 \r\12
+ $ff¦
+ (\13\12
+__l
+è
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+));
+
+529 #ifdeà
+__GNUC__
+
+
+530
+__ex\8bnsiÚ__
+ \r\12
+ $ff¦l
+ (\13\13\12
+__Î
+)
+
+531
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+));
+
+536 \r\12
+ $¡rÿ£cmp
+ (
+__cڡ
+ \ 5*
+__s1
+, __cڡ \ 5*
+__s2
+)
+
+537
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+540 \r\12
+ $¡ºÿ£cmp
+ (
+__cڡ
+ \ 5*
+__s1
+, __cڡ \ 5*
+__s2
+,
+size_t
+
+__n
+)
+
+541
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+544 #ifdef
+__USE_GNU
+
+
+547 \r\12
+ $¡rÿ£cmp_l
+ (
+__cڡ
+ \ 5*
+__s1
+, __cڡ \ 5*
+__s2
+,
+
+548
+__loÿË_t
+
+__loc
+)
+
+549
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2, 3));
+
+551 \r\12
+ $¡ºÿ£cmp_l
+ (
+__cڡ
+ \ 5*
+__s1
+, __cڡ \ 5*
+__s2
+,
+
+552
+size_t
+
+__n
+,
+__loÿË_t
+
+__loc
+)
+
+553
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2, 4));
+
+556 #ifdef
+__USE_BSD
+
+
+559 \r\ 5*
+ $¡r£p
+ (\ 5**
+__»¡riù
+
+__¡r\9agp
+,
+
+560
+__cڡ
+ \ 5*
+__»¡riù
+
+__d\96im
+)
+
+561
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+564 #ifdef
+__USE_XOPEN2K8
+
+
+566 \r\ 5*
+ $¡rsigÇl
+ (\12
+__sig
+è
+__THROW
+;
+
+569 \r\ 5*
+ $__¡pýy
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \ 5*__»¡riù
+__¤c
+)
+
+570
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+571 \r\ 5*
+ $¡pýy
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \ 5*__»¡riù
+__¤c
+)
+
+572
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+576 \r\ 5*
+ $__¡²ýy
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+
+577
+__cڡ
+ \ 5*
+__»¡riù
+
+__¤c
+,
+size_t
+
+__n
+)
+
+578
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+579 \r\ 5*
+ $¡²ýy
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+
+580
+__cڡ
+ \ 5*
+__»¡riù
+
+__¤c
+,
+size_t
+
+__n
+)
+
+581
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+584 #ifdef
+__USE_GNU
+
+
+586 \r\12
+ $¡rv\94scmp
+ (
+__cڡ
+ \ 5*
+__s1
+, __cڡ \ 5*
+__s2
+)
+
+587
+__THROW
+
+__©\8cibu\8b_pu»__
+
+ `__nÚnuÎ
+ ((1, 2));
+
+590 \r\ 5*
+ $¡räy
+ (\ 5*
+__¡r\9ag
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+593 \r\1e*
+ $memäob
+ (\1e*
+__s
+,
+size_t
+
+__n
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+595 #iâdeà
+ba£Çme
+
+
+600 #ifdeà
+__CORRECT_ISO_CPP_STRING_H_PROTO
+
+
+601 \r"C++" \ 5*
+ $ba£Çme
+ (\ 5*
+__f\9e\92ame
+)
+
+602
+__THROW
+
+ `__asm
+ ("ba£Çme"è
+ `__nÚnuÎ
+ ((1));
+
+603 \r"C++"
+__cڡ
+ \ 5*
+ $ba£Çme
+ (
+__cڡ
+ \ 5*
+__f\9e\92ame
+)
+
+604
+__THROW
+
+ `__asm
+ ("ba£Çme"è
+ `__nÚnuÎ
+ ((1));
+
+606 \r\ 5*
+ $ba£Çme
+ (
+__cڡ
+ \ 5*
+__f\9e\92ame
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+612 #ià
+def\9aed
+
+__GNUC__
+ && __GNUC__ >= 2
+
+613 #ià
+def\9aed
+
+__OPTIMIZE__
+ && !def\9aed
+__OPTIMIZE_SIZE__
+ \
+
+614 && !
+def\9aed
+
+__NO_INLINE__
+ && !def\9aed
+__ýlu¥lus
+
+
+634 \ 2
+ ~<b\99s/¡r\9ag.h
+>
+
+637 \ 2
+ ~<b\99s/¡r\9ag2.h
+>
+
+640 #ià
+__USE_FORTIFY_LEVEL
+ > 0 &&
+def\9aed
+
+__ex\8bº_®ways_\9al\9ae
+
+
+642 \ 2
+ ~<b\99s/¡r\9ag3.h
+>
+
+646
+__END_DECLS
+
+
+ @/usr/include/alloca.h
+
+19 #iâdef
+_ALLOCA_H
+
+
+20 \ 1
+ #_ALLOCA_H
+ 1
+
+ )
+
+22 \ 2
+ ~<ã©u»s.h
+>
+
+24 \ 1
+ #__Ãed_size_t
+
+
+ )
+
+25 \ 2
+ ~<¡ddef.h
+>
+
+27
+ g__BEGIN_DECLS
+
+
+30 #undeà
+®loÿ
+
+
+33 \r\1e*
+ $®loÿ
+ (
+size_t
+
+__size
+è
+__THROW
+;
+
+35 #ifdef
+__GNUC__
+
+
+36 \ 1
+ #®loÿ
+(
+size
+è
+ `__bu\9et\9a_®loÿ
+ (size)
+
+ )
+
+39
+__END_DECLS
+
+
+ @/usr/include/bits/posix1_lim.h
+
+25 #iâdef
+_BITS_POSIX1_LIM_H
+
+
+26 \ 1
+ #_BITS_POSIX1_LIM_H
+ 1
+
+ )
+
+32 \ 1
+ #_POSIX_AIO_LISTIO_MAX
+ 2
+
+ )
+
+35 \ 1
+ #_POSIX_AIO_MAX
+ 1
+
+ )
+
+38 \ 1
+ #_POSIX_ARG_MAX
+ 4096
+
+ )
+
+41 #ifdeà
+__USE_XOPEN2K
+
+
+42 \ 1
+ #_POSIX_CHILD_MAX
+ 25
+
+ )
+
+44 \ 1
+ #_POSIX_CHILD_MAX
+ 6
+
+ )
+
+48 \ 1
+ #_POSIX_DELAYTIMER_MAX
+ 32
+
+ )
+
+52 \ 1
+ #_POSIX_HOST_NAME_MAX
+ 255
+
+ )
+
+55 \ 1
+ #_POSIX_LINK_MAX
+ 8
+
+ )
+
+58 \ 1
+ #_POSIX_LOGIN_NAME_MAX
+ 9
+
+ )
+
+61 \ 1
+ #_POSIX_MAX_CANON
+ 255
+
+ )
+
+65 \ 1
+ #_POSIX_MAX_INPUT
+ 255
+
+ )
+
+68 \ 1
+ #_POSIX_MQ_OPEN_MAX
+ 8
+
+ )
+
+71 \ 1
+ #_POSIX_MQ_PRIO_MAX
+ 32
+
+ )
+
+74 \ 1
+ #_POSIX_NAME_MAX
+ 14
+
+ )
+
+77 #ifdeà
+__USE_XOPEN2K
+
+
+78 \ 1
+ #_POSIX_NGROUPS_MAX
+ 8
+
+ )
+
+80 \ 1
+ #_POSIX_NGROUPS_MAX
+ 0
+
+ )
+
+84 #ifdeà
+__USE_XOPEN2K
+
+
+85 \ 1
+ #_POSIX_OPEN_MAX
+ 20
+
+ )
+
+87 \ 1
+ #_POSIX_OPEN_MAX
+ 16
+
+ )
+
+90 #ià!
+def\9aed
+
+__USE_XOPEN2K
+ || def\9aed
+__USE_GNU
+
+
+93 \ 1
+ #_POSIX_FD_SETSIZE
+
+_POSIX_OPEN_MAX
+
+
+ )
+
+97 \ 1
+ #_POSIX_PATH_MAX
+ 256
+
+ )
+
+100 \ 1
+ #_POSIX_PIPE_BUF
+ 512
+
+ )
+
+104 \ 1
+ #_POSIX_RE_DUP_MAX
+ 255
+
+ )
+
+107 \ 1
+ #_POSIX_RTSIG_MAX
+ 8
+
+ )
+
+110 \ 1
+ #_POSIX_SEM_NSEMS_MAX
+ 256
+
+ )
+
+113 \ 1
+ #_POSIX_SEM_VALUE_MAX
+ 32767
+
+ )
+
+116 \ 1
+ #_POSIX_SIGQUEUE_MAX
+ 32
+
+ )
+
+119 \ 1
+ #_POSIX_SSIZE_MAX
+ 32767
+
+ )
+
+122 \ 1
+ #_POSIX_STREAM_MAX
+ 8
+
+ )
+
+125 \ 1
+ #_POSIX_SYMLINK_MAX
+ 255
+
+ )
+
+129 \ 1
+ #_POSIX_SYMLOOP_MAX
+ 8
+
+ )
+
+132 \ 1
+ #_POSIX_TIMER_MAX
+ 32
+
+ )
+
+135 \ 1
+ #_POSIX_TTY_NAME_MAX
+ 9
+
+ )
+
+138 \ 1
+ #_POSIX_TZNAME_MAX
+ 6
+
+ )
+
+140 #ià!
+def\9aed
+
+__USE_XOPEN2K
+ || def\9aed
+__USE_GNU
+
+
+142 \ 1
+ #_POSIX_QLIMIT
+ 1
+
+ )
+
+146 \ 1
+ #_POSIX_HIWAT
+
+_POSIX_PIPE_BUF
+
+
+ )
+
+149 \ 1
+ #_POSIX_UIO_MAXIOV
+ 16
+
+ )
+
+153 \ 1
+ #_POSIX_CLOCKRES_MIN
+ 20000000
+
+ )
+
+157 \ 2
+ ~<b\99s/loÿl_lim.h
+>
+
+160 #iâdef
+SSIZE_MAX
+
+
+161 \ 1
+ #SSIZE_MAX
+
+LONG_MAX
+
+
+ )
+
+168 #iâdef
+NGROUPS_MAX
+
+
+169 \ 1
+ #NGROUPS_MAX
+ 8
+
+ )
+
+ @/usr/include/bits/posix2_lim.h
+
+23 #iâdef
+_BITS_POSIX2_LIM_H
+
+
+24 \ 1
+ #_BITS_POSIX2_LIM_H
+ 1
+
+ )
+
+28 \ 1
+ #_POSIX2_BC_BASE_MAX
+ 99
+
+ )
+
+31 \ 1
+ #_POSIX2_BC_DIM_MAX
+ 2048
+
+ )
+
+34 \ 1
+ #_POSIX2_BC_SCALE_MAX
+ 99
+
+ )
+
+37 \ 1
+ #_POSIX2_BC_STRING_MAX
+ 1000
+
+ )
+
+41 \ 1
+ #_POSIX2_COLL_WEIGHTS_MAX
+ 2
+
+ )
+
+45 \ 1
+ #_POSIX2_EXPR_NEST_MAX
+ 32
+
+ )
+
+48 \ 1
+ #_POSIX2_LINE_MAX
+ 2048
+
+ )
+
+52 \ 1
+ #_POSIX2_RE_DUP_MAX
+ 255
+
+ )
+
+56 \ 1
+ #_POSIX2_CHARCLASS_NAME_MAX
+ 14
+
+ )
+
+63 #iâdef
+BC_BASE_MAX
+
+
+64 \ 1
+ #BC_BASE_MAX
+
+_POSIX2_BC_BASE_MAX
+
+
+ )
+
+66 #iâdef
+BC_DIM_MAX
+
+
+67 \ 1
+ #BC_DIM_MAX
+
+_POSIX2_BC_DIM_MAX
+
+
+ )
+
+69 #iâdef
+BC_SCALE_MAX
+
+
+70 \ 1
+ #BC_SCALE_MAX
+
+_POSIX2_BC_SCALE_MAX
+
+
+ )
+
+72 #iâdef
+BC_STRING_MAX
+
+
+73 \ 1
+ #BC_STRING_MAX
+
+_POSIX2_BC_STRING_MAX
+
+
+ )
+
+75 #iâdef
+COLL_WEIGHTS_MAX
+
+
+76 \ 1
+ #COLL_WEIGHTS_MAX
+ 255
+
+ )
+
+78 #iâdef
+EXPR_NEST_MAX
+
+
+79 \ 1
+ #EXPR_NEST_MAX
+
+_POSIX2_EXPR_NEST_MAX
+
+
+ )
+
+81 #iâdef
+LINE_MAX
+
+
+82 \ 1
+ #LINE_MAX
+
+_POSIX2_LINE_MAX
+
+
+ )
+
+84 #iâdef
+CHARCLASS_NAME_MAX
+
+
+85 \ 1
+ #CHARCLASS_NAME_MAX
+ 2048
+
+ )
+
+89 \ 1
+ #RE_DUP_MAX
+ (0x7fff)
+
+ )
+
+ @/usr/include/bits/stdio-ldbl.h
+
+20 #iâdeà
+_STDIO_H
+
+
+24
+__BEGIN_NAMESPACE_STD
+
+
+25
+ $__LDBL_REDIR_DECL
+ (
+år\9atf
+)
+
+26
+ $__LDBL_REDIR_DECL
+ (
+´\9atf
+)
+
+27
+ $__LDBL_REDIR_DECL
+ (
+¥r\9atf
+)
+
+28
+ $__LDBL_REDIR_DECL
+ (
+vår\9atf
+)
+
+29
+ $__LDBL_REDIR_DECL
+ (
+v´\9atf
+)
+
+30
+ $__LDBL_REDIR_DECL
+ (
+v¥r\9atf
+)
+
+31 #ià
+def\9aed
+
+__USE_ISOC99
+ && !def\9aed
+__USE_GNU
+ \
+
+32 && !
+def\9aed
+
+__REDIRECT
+ \
+
+33 && (
+def\9aed
+
+__STRICT_ANSI__
+ || def\9aed
+__USE_XOPEN2K
+)
+
+34
+ $__LDBL_REDIR1_DECL
+ (
+fsÿnf
+,
+__Ædbl___isoc99_fsÿnf
+)
+
+35
+ $__LDBL_REDIR1_DECL
+ (
+sÿnf
+,
+__Ædbl___isoc99_sÿnf
+)
+
+36
+ $__LDBL_REDIR1_DECL
+ (
+ssÿnf
+,
+__Ædbl___isoc99_ssÿnf
+)
+
+38
+ $__LDBL_REDIR_DECL
+ (
+fsÿnf
+)
+
+39
+ $__LDBL_REDIR_DECL
+ (
+sÿnf
+)
+
+40
+ $__LDBL_REDIR_DECL
+ (
+ssÿnf
+)
+
+42
+__END_NAMESPACE_STD
+
+
+44 #ià
+def\9aed
+
+__USE_BSD
+ || def\9aed
+__USE_ISOC99
+ || def\9aed
+__USE_UNIX98
+
+
+45
+__BEGIN_NAMESPACE_C99
+
+
+46
+ $__LDBL_REDIR_DECL
+ (
+¢´\9atf
+)
+
+47
+ $__LDBL_REDIR_DECL
+ (
+v¢´\9atf
+)
+
+48
+__END_NAMESPACE_C99
+
+
+51 #ifdef
+__USE_ISOC99
+
+
+52
+__BEGIN_NAMESPACE_C99
+
+
+53 #ià!
+def\9aed
+
+__USE_GNU
+ && !def\9aed
+__REDIRECT
+ \
+
+54 && (
+def\9aed
+
+__STRICT_ANSI__
+ || def\9aed
+__USE_XOPEN2K
+)
+
+55
+ $__LDBL_REDIR1_DECL
+ (
+vfsÿnf
+,
+__Ædbl___isoc99_vfsÿnf
+)
+
+56
+ $__LDBL_REDIR1_DECL
+ (
+vsÿnf
+,
+__Ædbl___isoc99_vsÿnf
+)
+
+57
+ $__LDBL_REDIR1_DECL
+ (
+vssÿnf
+,
+__Ædbl___isoc99_vssÿnf
+)
+
+59
+ $__LDBL_REDIR_DECL
+ (
+vfsÿnf
+)
+
+60
+ $__LDBL_REDIR_DECL
+ (
+vssÿnf
+)
+
+61
+ $__LDBL_REDIR_DECL
+ (
+vsÿnf
+)
+
+63
+__END_NAMESPACE_C99
+
+
+66 #ifdeà
+__USE_GNU
+
+
+67
+ $__LDBL_REDIR_DECL
+ (
+vd´\9atf
+)
+
+68
+ $__LDBL_REDIR_DECL
+ (
+d´\9atf
+)
+
+69
+ $__LDBL_REDIR_DECL
+ (
+va¥r\9atf
+)
+
+70
+ $__LDBL_REDIR_DECL
+ (
+__a¥r\9atf
+)
+
+71
+ $__LDBL_REDIR_DECL
+ (
+a¥r\9atf
+)
+
+72
+ $__LDBL_REDIR_DECL
+ (
+ob¡ack_´\9atf
+)
+
+73
+ $__LDBL_REDIR_DECL
+ (
+ob¡ack_v´\9atf
+)
+
+76 #ià
+__USE_FORTIFY_LEVEL
+ > 0 &&
+def\9aed
+
+__ex\8bº_®ways_\9al\9ae
+
+
+77
+ $__LDBL_REDIR_DECL
+ (
+__¥r\9atf_chk
+)
+
+78
+ $__LDBL_REDIR_DECL
+ (
+__v¥r\9atf_chk
+)
+
+79 #ià
+def\9aed
+
+__USE_BSD
+ || def\9aed
+__USE_ISOC99
+ || def\9aed
+__USE_UNIX98
+
+
+80
+ $__LDBL_REDIR_DECL
+ (
+__¢´\9atf_chk
+)
+
+81
+ $__LDBL_REDIR_DECL
+ (
+__v¢´\9atf_chk
+)
+
+83 #ià
+__USE_FORTIFY_LEVEL
+ > 1
+
+84
+ $__LDBL_REDIR_DECL
+ (
+__år\9atf_chk
+)
+
+85
+ $__LDBL_REDIR_DECL
+ (
+__´\9atf_chk
+)
+
+86
+ $__LDBL_REDIR_DECL
+ (
+__vår\9atf_chk
+)
+
+87
+ $__LDBL_REDIR_DECL
+ (
+__v´\9atf_chk
+)
+
+88 #ifdeà
+__USE_GNU
+
+
+89
+ $__LDBL_REDIR_DECL
+ (
+__a¥r\9atf_chk
+)
+
+90
+ $__LDBL_REDIR_DECL
+ (
+__va¥r\9atf_chk
+)
+
+91
+ $__LDBL_REDIR_DECL
+ (
+__d´\9atf_chk
+)
+
+92
+ $__LDBL_REDIR_DECL
+ (
+__vd´\9atf_chk
+)
+
+93
+ $__LDBL_REDIR_DECL
+ (
+__ob¡ack_´\9atf_chk
+)
+
+94
+ $__LDBL_REDIR_DECL
+ (
+__ob¡ack_v´\9atf_chk
+)
+
+ @/usr/include/bits/stdio.h
+
+20 #iâdeà
+_STDIO_H
+
+
+24 #iâdeà
+__ex\8bº_\9al\9ae
+
+
+25 \ 1
+ #__STDIO_INLINE
+
+\9al\9ae
+
+
+ )
+
+27 \ 1
+ #__STDIO_INLINE
+
+__ex\8bº_\9al\9ae
+
+
+ )
+
+31 #ifdeà
+__USE_EXTERN_INLINES
+
+
+34 #ià!(
+__USE_FORTIFY_LEVEL
+ > 0 &&
+def\9aed
+
+__ex\8bº_®ways_\9al\9ae
+)
+
+36
+__STDIO_INLINE
+ \12
+
+37
+ $v´\9atf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+,
+_G_va_li¡
+
+__¬g
+)
+
+39 \15
+ `vår\9atf
+ (
+¡dout
+,
+__fmt
+,
+__¬g
+);
+
+40
+ }
+}
+
+44
+__STDIO_INLINE
+ \12
+
+45
+ $g\91ch¬
+ (\1e)
+
+47 \15
+ `_IO_g\91c
+ (
+¡d\9a
+);
+
+48
+ }
+}
+
+51 #ifdeà
+__USE_MISC
+
+
+53
+__STDIO_INLINE
+ \12
+
+54
+ $fg\91c_uÆocked
+ (
+FILE
+ *
+__å
+)
+
+56 \15
+ `_IO_g\91c_uÆocked
+ (
+__å
+);
+
+57
+ }
+}
+
+61 #ià
+def\9aed
+
+__USE_POSIX
+ || def\9aed
+__USE_MISC
+
+
+63
+__STDIO_INLINE
+ \12
+
+64
+ $g\91c_uÆocked
+ (
+FILE
+ *
+__å
+)
+
+66 \15
+ `_IO_g\91c_uÆocked
+ (
+__å
+);
+
+67
+ }
+}
+
+70
+__STDIO_INLINE
+ \12
+
+71
+ $g\91ch¬_uÆocked
+ (\1e)
+
+73 \15
+ `_IO_g\91c_uÆocked
+ (
+¡d\9a
+);
+
+74
+ }
+}
+
+79
+__STDIO_INLINE
+ \12
+
+80
+ $putch¬
+ (\12
+__c
+)
+
+82 \15
+ `_IO_putc
+ (
+__c
+,
+¡dout
+);
+
+83
+ }
+}
+
+86 #ifdeà
+__USE_MISC
+
+
+88
+__STDIO_INLINE
+ \12
+
+89
+ $åutc_uÆocked
+ (\12
+__c
+,
+FILE
+ *
+__¡»am
+)
+
+91 \15
+ `_IO_putc_uÆocked
+ (
+__c
+,
+__¡»am
+);
+
+92
+ }
+}
+
+96 #ià
+def\9aed
+
+__USE_POSIX
+ || def\9aed
+__USE_MISC
+
+
+98
+__STDIO_INLINE
+ \12
+
+99
+ $putc_uÆocked
+ (\12
+__c
+,
+FILE
+ *
+__¡»am
+)
+
+101 \15
+ `_IO_putc_uÆocked
+ (
+__c
+,
+__¡»am
+);
+
+102
+ }
+}
+
+105
+__STDIO_INLINE
+ \12
+
+106
+ $putch¬_uÆocked
+ (\12
+__c
+)
+
+108 \15
+ `_IO_putc_uÆocked
+ (
+__c
+,
+¡dout
+);
+
+109
+ }
+}
+
+113 #ifdef
+__USE_GNU
+
+
+115
+__STDIO_INLINE
+
+_IO_ssize_t
+
+
+116
+ $g\91l\9ae
+ (\ 5**
+__l\9a\95\8c
+,
+size_t
+ *
+__n
+,
+FILE
+ *
+__¡»am
+)
+
+118 \15
+ `__g\91d\96im
+ (
+__l\9a\95\8c
+,
+__n
+, '\n',
+__¡»am
+);
+
+119
+ }
+}
+
+123 #ifdeà
+__USE_MISC
+
+
+125
+__STDIO_INLINE
+ \12
+
+126
+__NTH
+ (
+ $ãof_uÆocked
+ (
+FILE
+ *
+__¡»am
+))
+
+128 \15
+ `_IO_ãof_uÆocked
+ (
+__¡»am
+);
+
+129
+ }
+}
+
+132
+__STDIO_INLINE
+ \12
+
+133
+__NTH
+ (
+ $ã¼Ü_uÆocked
+ (
+FILE
+ *
+__¡»am
+))
+
+135 \15
+ `_IO_ã¼Ü_uÆocked
+ (
+__¡»am
+);
+
+136
+ }
+}
+
+142 #ià
+def\9aed
+
+__USE_MISC
+ && def\9aed
+__GNUC__
+ && def\9aed
+__OPTIMIZE__
+ \
+
+143 && !
+def\9aed
+
+ g__ýlu¥lus
+
+
+145 \ 1
+ #ä\97d_uÆocked
+(
+±r
+,
+size
+,
+n
+,
+¡»am
+) \
+
+146 (
+ `__ex\8bnsiÚ__
+ ((
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+size
+è&& __bu\9et\9a_cÚ¡ªt_°(
+n
+) \
+
+147 && (
+size_t
+è(
+size
+è* (size_tè(
+n
+) <= 8 \
+
+148 && (
+size_t
+è(
+size
+) != 0) \
+
+149 ? ({ \ 5*
+__±r
+ = (\ 5*è(
+±r
+); \
+
+150
+FILE
+ *
+__¡»am
+ = (
+¡»am
+); \
+
+151
+size_t
+
+__út
+; \
+
+152 \ f
+__út
+ = (
+size_t
+è(
+size
+è* (size_tè(
+n
+); \
+
+153
+__út
+ > 0; --__cnt) \
+
+155 \12
+__c
+ =
+ `_IO_g\91c_uÆocked
+ (
+__¡»am
+); \
+
+156 ià(
+__c
+ =ð
+EOF
+) \
+
+158 *
+__±r
+++ =
+__c
+; \
+
+160 ((
+size_t
+è(
+size
+è* (size_tè(
+n
+è-
+__út
+) \
+
+161 / (
+size_t
+è(
+size
+); }) \
+
+162 : (((
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+size
+è&& (
+size_t
+) (size) == 0) \
+
+163 || (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+n
+è&& (
+size_t
+) (n) == 0)) \
+
+165 ? ((\1eè(
+±r
+), (\1eè(
+¡»am
+), (\1eè(
+size
+), \
+
+166 (\1eè(
+n
+), (
+size_t
+) 0) \
+
+167 :
+ `ä\97d_uÆocked
+ (
+±r
+,
+size
+,
+n
+,
+¡»am
+))))
+
+ )
+
+169 \ 1
+ #fwr\99e_uÆocked
+(
+±r
+,
+size
+,
+n
+,
+¡»am
+) \
+
+170 (
+ `__ex\8bnsiÚ__
+ ((
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+size
+è&& __bu\9et\9a_cÚ¡ªt_°(
+n
+) \
+
+171 && (
+size_t
+è(
+size
+è* (size_tè(
+n
+) <= 8 \
+
+172 && (
+size_t
+è(
+size
+) != 0) \
+
+173 ? ({ cڡ \ 5*
+__±r
+ = (cÚ¡ \ 5*è(
+±r
+); \
+
+174
+FILE
+ *
+__¡»am
+ = (
+¡»am
+); \
+
+175
+size_t
+
+__út
+; \
+
+176 \ f
+__út
+ = (
+size_t
+è(
+size
+è* (size_tè(
+n
+); \
+
+177
+__út
+ > 0; --__cnt) \
+
+178 ià(
+ `_IO_putc_uÆocked
+ (*
+__±r
+++,
+__¡»am
+è=ð
+EOF
+) \
+
+180 ((
+size_t
+è(
+size
+è* (size_tè(
+n
+è-
+__út
+) \
+
+181 / (
+size_t
+è(
+size
+); }) \
+
+182 : (((
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+size
+è&& (
+size_t
+) (size) == 0) \
+
+183 || (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+n
+è&& (
+size_t
+) (n) == 0)) \
+
+185 ? ((\1eè(
+±r
+), (\1eè(
+¡»am
+), (\1eè(
+size
+), \
+
+186 (\1eè(
+n
+), (
+size_t
+) 0) \
+
+187 :
+ `fwr\99e_uÆocked
+ (
+±r
+,
+size
+,
+n
+,
+¡»am
+))))
+
+ )
+
+191 #undeà
+__STDIO_INLINE
+
+
+ @/usr/include/bits/stdio2.h
+
+20 #iâdeà
+_STDIO_H
+
+
+24 \r\12
+ $__¥r\9atf_chk
+ (\ 5*
+__»¡riù
+
+__s
+, \12
+__æag
+,
+size_t
+
+__¦\92
+,
+
+25
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...è
+__THROW
+;
+
+26 \r\12
+ $__v¥r\9atf_chk
+ (\ 5*
+__»¡riù
+
+__s
+, \12
+__æag
+,
+size_t
+
+__¦\92
+,
+
+27
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+28
+_G_va_li¡
+
+__
+è
+__THROW
+;
+
+30 #ifdeà
+__va_¬g_·ck
+
+
+31
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+32
+ `__NTH
+ (
+ $¥r\9atf
+ (\ 5*
+__»¡riù
+
+__s
+,
+__cڡ
+ \ 5*__»¡riù
+__fmt
+, ...))
+
+34 \15
+ `__bu\9et\9a___¥r\9atf_chk
+ (
+__s
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+
+35
+ `__bos
+ (
+__s
+),
+__fmt
+,
+ `__va_¬g_·ck
+ ());
+
+36
+ }
+}
+
+37 #\96ià!
+def\9aed
+
+__ýlu¥lus
+
+
+38 \ 1
+ #¥r\9atf
+(
+¡r
+, ...) \
+
+39
+ `__bu\9et\9a___¥r\9atf_chk
+ (
+¡r
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+ `__bos
+ (str), \
+
+40
+__VA_ARGS__
+)
+
+ )
+
+43
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+44
+__NTH
+ (
+ $v¥r\9atf
+ (\ 5*
+__»¡riù
+
+__s
+,
+__cڡ
+ \ 5*__»¡riù
+__fmt
+,
+
+45
+_G_va_li¡
+
+__
+))
+
+47 \15
+ `__bu\9et\9a___v¥r\9atf_chk
+ (
+__s
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+
+48
+ `__bos
+ (
+__s
+),
+__fmt
+,
+__
+);
+
+49
+ }
+}
+
+51 #ià
+def\9aed
+
+__USE_BSD
+ || def\9aed
+__USE_ISOC99
+ || def\9aed
+__USE_UNIX98
+
+
+53 \r\12
+ $__¢´\9atf_chk
+ (\ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+, \12
+__æag
+,
+
+54
+size_t
+
+__¦\92
+,
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+55 ...è
+__THROW
+;
+
+56 \r\12
+ $__v¢´\9atf_chk
+ (\ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+, \12
+__æag
+,
+
+57
+size_t
+
+__¦\92
+,
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+58
+_G_va_li¡
+
+__
+è
+__THROW
+;
+
+60 #ifdeà
+__va_¬g_·ck
+
+
+61
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+62
+ `__NTH
+ (
+ $¢´\9atf
+ (\ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+63
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+, ...))
+
+65 \15
+ `__bu\9et\9a___¢´\9atf_chk
+ (
+__s
+,
+__n
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+
+66
+ `__bos
+ (
+__s
+),
+__fmt
+,
+ `__va_¬g_·ck
+ ());
+
+67
+ }
+}
+
+68 #\96ià!
+def\9aed
+
+__ýlu¥lus
+
+
+69 \ 1
+ #¢´\9atf
+(
+¡r
+,
+Ën
+, ...) \
+
+70
+ `__bu\9et\9a___¢´\9atf_chk
+ (
+¡r
+,
+Ën
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+ `__bos
+ (str), \
+
+71
+__VA_ARGS__
+)
+
+ )
+
+74
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+75
+__NTH
+ (
+ $v¢´\9atf
+ (\ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+76
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+,
+_G_va_li¡
+
+__
+))
+
+78 \15
+ `__bu\9et\9a___v¢´\9atf_chk
+ (
+__s
+,
+__n
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+
+79
+ `__bos
+ (
+__s
+),
+__fmt
+,
+__
+);
+
+80
+ }
+}
+
+84 #ià
+__USE_FORTIFY_LEVEL
+ > 1
+
+86 \r\12
+__år\9atf_chk
+ (
+FILE
+ *
+__»¡riù
+
+__¡»am
+, \12
+__æag
+,
+
+87
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...);
+
+88 \r\12
+__´\9atf_chk
+ (\12
+__æag
+,
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+, ...);
+
+89 \r\12
+__vår\9atf_chk
+ (
+FILE
+ *
+__»¡riù
+
+__¡»am
+, \12
+__æag
+,
+
+90
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+_G_va_li¡
+
+__
+);
+
+91 \r\12
+__v´\9atf_chk
+ (\12
+__æag
+,
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+92
+_G_va_li¡
+
+__
+);
+
+94 #ifdeà
+__va_¬g_·ck
+
+
+95
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+96
+ $år\9atf
+ (
+FILE
+ *
+__»¡riù
+
+__¡»am
+,
+__cڡ
+ \ 5*__»¡riù
+__fmt
+, ...)
+
+98 \15
+ `__år\9atf_chk
+ (
+__¡»am
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+
+99
+ `__va_¬g_·ck
+ ());
+
+100
+ }
+}
+
+102
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+103
+ $´\9atf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+, ...)
+
+105 \15
+ `__´\9atf_chk
+ (
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+ `__va_¬g_·ck
+ ());
+
+106
+ }
+}
+
+107 #\96ià!
+def\9aed
+
+__ýlu¥lus
+
+
+108 \ 1
+ #´\9atf
+(...) \
+
+109
+ `__´\9atf_chk
+ (
+__USE_FORTIFY_LEVEL
+ - 1,
+__VA_ARGS__
+)
+
+ )
+
+110 \ 1
+ #år\9atf
+(
+¡»am
+, ...) \
+
+111
+ `__år\9atf_chk
+ (
+¡»am
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__VA_ARGS__
+)
+
+ )
+
+114
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+115
+ $v´\9atf
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+,
+_G_va_li¡
+
+__
+)
+
+117 #ifdeà
+__USE_EXTERN_INLINES
+
+
+118 \15
+ `__vår\9atf_chk
+ (
+¡dout
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+__
+);
+
+120 \15
+ `__v´\9atf_chk
+ (
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+__
+);
+
+122
+ }
+}
+
+124
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+125
+ $vår\9atf
+ (
+FILE
+ *
+__»¡riù
+
+__¡»am
+,
+
+126
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+,
+_G_va_li¡
+
+__
+)
+
+128 \15
+ `__vår\9atf_chk
+ (
+__¡»am
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+__
+);
+
+129
+ }
+}
+
+131 #ifdeà
+__USE_GNU
+
+
+133 \r\12
+ $__a¥r\9atf_chk
+ (\ 5**
+__»¡riù
+
+__±r
+, \12
+__æag
+,
+
+134
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+, ...)
+
+135
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+ $__fÜm©__
+ (
+__´\9atf__
+, 3, 4))è
+__wur
+;
+
+136 \r\12
+ $__va¥r\9atf_chk
+ (\ 5**
+__»¡riù
+
+__±r
+, \12
+__æag
+,
+
+137
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+,
+_G_va_li¡
+
+__¬g
+)
+
+138
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+ $__fÜm©__
+ (
+__´\9atf__
+, 3, 0))è
+__wur
+;
+
+139 \r\12
+ $__d´\9atf_chk
+ (\12
+__fd
+, \12
+__æag
+,
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+,
+
+140 ...è
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__´\9atf__
+, 3, 4)));
+
+141 \r\12
+ $__vd´\9atf_chk
+ (\12
+__fd
+, \12
+__æag
+,
+
+142
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+,
+_G_va_li¡
+
+__¬g
+)
+
+143
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__´\9atf__
+, 3, 0)));
+
+144 \r\12
+ $__ob¡ack_´\9atf_chk
+ (\19
+ob¡ack
+ *
+__»¡riù
+
+__ob¡ack
+,
+
+145 \12
+__æag
+,
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+147
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__´\9atf__
+, 3, 4)));
+
+148 \r\12
+ $__ob¡ack_v´\9atf_chk
+ (\19
+ob¡ack
+ *
+__»¡riù
+
+__ob¡ack
+,
+
+149 \12
+__æag
+,
+
+150
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+151
+_G_va_li¡
+
+__¬gs
+)
+
+152
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__´\9atf__
+, 3, 0)));
+
+154 #ifdeà
+__va_¬g_·ck
+
+
+155
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+156
+ `__NTH
+ (
+ $a¥r\9atf
+ (\ 5**
+__»¡riù
+
+__±r
+,
+__cڡ
+ \ 5*__»¡riù
+__fmt
+, ...))
+
+158 \15
+ `__a¥r\9atf_chk
+ (
+__±r
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+
+159
+ `__va_¬g_·ck
+ ());
+
+160
+ }
+}
+
+162
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+163
+__NTH
+ (
+ $__a¥r\9atf
+ (\ 5**
+__»¡riù
+
+__±r
+,
+__cڡ
+ \ 5*__»¡riù
+__fmt
+,
+
+166 \15
+ `__a¥r\9atf_chk
+ (
+__±r
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+
+167
+ `__va_¬g_·ck
+ ());
+
+168
+ }
+}
+
+170
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+171
+ $d´\9atf
+ (\12
+__fd
+,
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+, ...)
+
+173 \15
+ `__d´\9atf_chk
+ (
+__fd
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+
+174
+ `__va_¬g_·ck
+ ());
+
+175
+ }
+}
+
+177
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+178
+__NTH
+ (
+ $ob¡ack_´\9atf
+ (\19
+ob¡ack
+ *
+__»¡riù
+
+__ob¡ack
+,
+
+179
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+, ...))
+
+181 \15
+ `__ob¡ack_´\9atf_chk
+ (
+__ob¡ack
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+
+182
+ `__va_¬g_·ck
+ ());
+
+183
+ }
+}
+
+184 #\96ià!
+def\9aed
+
+__ýlu¥lus
+
+
+185 \ 1
+ #a¥r\9atf
+(
+±r
+, ...) \
+
+186
+ `__a¥r\9atf_chk
+ (
+±r
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__VA_ARGS__
+)
+
+ )
+
+187 \ 1
+ #__a¥r\9atf
+(
+±r
+, ...) \
+
+188
+ `__a¥r\9atf_chk
+ (
+±r
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__VA_ARGS__
+)
+
+ )
+
+189 \ 1
+ #d´\9atf
+(
+fd
+, ...) \
+
+190
+ `__d´\9atf_chk
+ (
+fd
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__VA_ARGS__
+)
+
+ )
+
+191 \ 1
+ #ob¡ack_´\9atf
+(
+ob¡ack
+, ...) \
+
+192
+ `__ob¡ack_´\9atf_chk
+ (
+ob¡ack
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__VA_ARGS__
+)
+
+ )
+
+195
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+196
+__NTH
+ (
+ $va¥r\9atf
+ (\ 5**
+__»¡riù
+
+__±r
+,
+__cڡ
+ \ 5*__»¡riù
+__fmt
+,
+
+197
+_G_va_li¡
+
+__
+))
+
+199 \15
+ `__va¥r\9atf_chk
+ (
+__±r
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+__
+);
+
+200
+ }
+}
+
+202
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+203
+ $vd´\9atf
+ (\12
+__fd
+,
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+,
+_G_va_li¡
+
+__
+)
+
+205 \15
+ `__vd´\9atf_chk
+ (
+__fd
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+__
+);
+
+206
+ }
+}
+
+208
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+209
+__NTH
+ (
+ $ob¡ack_v´\9atf
+ (\19
+ob¡ack
+ *
+__»¡riù
+
+__ob¡ack
+,
+
+210
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+,
+_G_va_li¡
+
+__
+))
+
+212 \15
+ `__ob¡ack_v´\9atf_chk
+ (
+__ob¡ack
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+
+213
+__
+);
+
+214
+ }
+}
+
+220 \r\ 5*
+ $__g\91s_chk
+ (\ 5*
+__¡r
+,
+size_t
+è
+__wur
+;
+
+221 \r\ 5*
+ `__REDIRECT
+ (
+__g\91s_w¬n
+, (\ 5*
+__¡r
+),
+g\91s
+)
+
+222
+__wur
+
+ `__w‚\89r
+ ("please use fgets or getline instead, gets can't "
+
+225
+__ex\8bº_®ways_\9al\9ae
+
+__wur
+ \ 5*
+
+226
+ $g\91s
+ (\ 5*
+__¡r
+)
+
+228 ià(
+ `__bos
+ (
+__¡r
+è!ð(
+size_t
+) -1)
+
+229 \15
+ `__g\91s_chk
+ (
+__¡r
+,
+ `__bos
+ (__str));
+
+230 \15
+ `__g\91s_w¬n
+ (
+__¡r
+);
+
+231
+ }
+}
+
+233 \r\ 5*
+ $__fg\91s_chk
+ (\ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__size
+, \12
+__n
+,
+
+234
+FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+235 \r\ 5*
+ `__REDIRECT
+ (
+__fg\91s_®\9fs
+,
+
+236 (\ 5*
+__»¡riù
+
+__s
+, \12
+__n
+,
+
+237
+FILE
+ *
+__»¡riù
+
+__¡»am
+),
+fg\91s
+è
+__wur
+;
+
+238 \r\ 5*
+ `__REDIRECT
+ (
+__fg\91s_chk_w¬n
+,
+
+239 (\ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__size
+, \12
+__n
+,
+
+240
+FILE
+ *
+__»¡riù
+
+__¡»am
+),
+__fg\91s_chk
+)
+
+241
+__wur
+
+ `__w‚\89r
+ ("fgets called with bigger size\81han\86ength "
+
+244
+__ex\8bº_®ways_\9al\9ae
+
+__wur
+ \ 5*
+
+245
+ $fg\91s
+ (\ 5*
+__»¡riù
+
+__s
+, \12
+__n
+,
+FILE
+ *__»¡riù
+__¡»am
+)
+
+247 ià(
+ `__bos
+ (
+__s
+è!ð(
+size_t
+) -1)
+
+249 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+) || __n <= 0)
+
+250 \15
+ `__fg\91s_chk
+ (
+__s
+,
+ `__bos
+ (__s),
+__n
+,
+__¡»am
+);
+
+252 ià((
+size_t
+è
+__n
+ >
+ `__bos
+ (
+__s
+))
+
+253 \15
+ `__fg\91s_chk_w¬n
+ (
+__s
+,
+ `__bos
+ (__s),
+__n
+,
+__¡»am
+);
+
+255 \15
+ `__fg\91s_®\9fs
+ (
+__s
+,
+__n
+,
+__¡»am
+);
+
+256
+ }
+}
+
+258 \r
+size_t
+
+ $__ä\97d_chk
+ (\1e*
+__»¡riù
+
+__±r
+,
+size_t
+
+__±¾\92
+,
+
+259
+size_t
+
+__size
+, size_\88
+__n
+,
+
+260
+FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+261 \r
+size_t
+
+ `__REDIRECT
+ (
+__ä\97d_®\9fs
+,
+
+262 (\1e*
+__»¡riù
+
+__±r
+,
+size_t
+
+__size
+,
+
+263
+size_t
+
+__n
+,
+FILE
+ *
+__»¡riù
+
+__¡»am
+),
+
+264
+ä\97d
+è
+__wur
+;
+
+265 \r
+size_t
+
+ `__REDIRECT
+ (
+__ä\97d_chk_w¬n
+,
+
+266 (\1e*
+__»¡riù
+
+__±r
+,
+size_t
+
+__±¾\92
+,
+
+267
+size_t
+
+__size
+, size_\88
+__n
+,
+
+268
+FILE
+ *
+__»¡riù
+
+__¡»am
+),
+
+269
+__ä\97d_chk
+)
+
+270
+__wur
+
+ `__w‚\89r
+ ("fread called with bigger size *\82memb\81han\86ength "
+
+273
+__ex\8bº_®ways_\9al\9ae
+
+__wur
+
+size_t
+
+
+274
+ $ä\97d
+ (\1e*
+__»¡riù
+
+__±r
+,
+size_t
+
+__size
+, size_\88
+__n
+,
+
+275
+FILE
+ *
+__»¡riù
+
+__¡»am
+)
+
+277 ià(
+ `__bos0
+ (
+__±r
+è!ð(
+size_t
+) -1)
+
+279 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__size
+)
+
+280 || !
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+)
+
+281 || (
+__size
+ |
+__n
+è>ð(((
+size_t
+) 1) << (8 * \17 (size_t) / 2)))
+
+282 \15
+ `__ä\97d_chk
+ (
+__±r
+,
+ `__bos0
+ (__±r),
+__size
+,
+__n
+,
+__¡»am
+);
+
+284 ià(
+__size
+ *
+__n
+ >
+ `__bos0
+ (
+__±r
+))
+
+285 \15
+ `__ä\97d_chk_w¬n
+ (
+__±r
+,
+ `__bos0
+ (__±r),
+__size
+,
+__n
+,
+__¡»am
+);
+
+287 \15
+ `__ä\97d_®\9fs
+ (
+__±r
+,
+__size
+,
+__n
+,
+__¡»am
+);
+
+288
+ }
+}
+
+290 #ifdeà
+__USE_GNU
+
+
+291 \r\ 5*
+ $__fg\91s_uÆocked_chk
+ (\ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__size
+,
+
+292 \12
+__n
+,
+FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+293 \r\ 5*
+ `__REDIRECT
+ (
+__fg\91s_uÆocked_®\9fs
+,
+
+294 (\ 5*
+__»¡riù
+
+__s
+, \12
+__n
+,
+
+295
+FILE
+ *
+__»¡riù
+
+__¡»am
+),
+fg\91s_uÆocked
+è
+__wur
+;
+
+296 \r\ 5*
+ `__REDIRECT
+ (
+__fg\91s_uÆocked_chk_w¬n
+,
+
+297 (\ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__size
+, \12
+__n
+,
+
+298
+FILE
+ *
+__»¡riù
+
+__¡»am
+),
+__fg\91s_uÆocked_chk
+)
+
+299
+__wur
+
+ `__w‚\89r
+ ("fgets_unlocked called with bigger size\81han\86ength "
+
+302
+__ex\8bº_®ways_\9al\9ae
+
+__wur
+ \ 5*
+
+303
+ $fg\91s_uÆocked
+ (\ 5*
+__»¡riù
+
+__s
+, \12
+__n
+,
+FILE
+ *__»¡riù
+__¡»am
+)
+
+305 ià(
+ `__bos
+ (
+__s
+è!ð(
+size_t
+) -1)
+
+307 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+) || __n <= 0)
+
+308 \15
+ `__fg\91s_uÆocked_chk
+ (
+__s
+,
+ `__bos
+ (__s),
+__n
+,
+__¡»am
+);
+
+310 ià((
+size_t
+è
+__n
+ >
+ `__bos
+ (
+__s
+))
+
+311 \15
+ `__fg\91s_uÆocked_chk_w¬n
+ (
+__s
+,
+ `__bos
+ (__s),
+__n
+,
+__¡»am
+);
+
+313 \15
+ `__fg\91s_uÆocked_®\9fs
+ (
+__s
+,
+__n
+,
+__¡»am
+);
+
+314
+ }
+}
+
+317 #ifdeà
+__USE_MISC
+
+
+318 #undeà
+ä\97d_uÆocked
+
+
+319 \r
+size_t
+
+ $__ä\97d_uÆocked_chk
+ (\1e*
+__»¡riù
+
+__±r
+,
+size_t
+
+__±¾\92
+,
+
+320
+size_t
+
+__size
+, size_\88
+__n
+,
+
+321
+FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+322 \r
+size_t
+
+ `__REDIRECT
+ (
+__ä\97d_uÆocked_®\9fs
+,
+
+323 (\1e*
+__»¡riù
+
+__±r
+,
+size_t
+
+__size
+,
+
+324
+size_t
+
+__n
+,
+FILE
+ *
+__»¡riù
+
+__¡»am
+),
+
+325
+ä\97d_uÆocked
+è
+__wur
+;
+
+326 \r
+size_t
+
+ `__REDIRECT
+ (
+__ä\97d_uÆocked_chk_w¬n
+,
+
+327 (\1e*
+__»¡riù
+
+__±r
+,
+size_t
+
+__±¾\92
+,
+
+328
+size_t
+
+__size
+, size_\88
+__n
+,
+
+329
+FILE
+ *
+__»¡riù
+
+__¡»am
+),
+
+330
+__ä\97d_uÆocked_chk
+)
+
+331
+__wur
+
+ `__w‚\89r
+ ("fread_unlocked called with bigger size *\82memb\81han "
+
+334
+__ex\8bº_®ways_\9al\9ae
+
+__wur
+
+size_t
+
+
+335
+ $ä\97d_uÆocked
+ (\1e*
+__»¡riù
+
+__±r
+,
+size_t
+
+__size
+, size_\88
+__n
+,
+
+336
+FILE
+ *
+__»¡riù
+
+__¡»am
+)
+
+338 ià(
+ `__bos0
+ (
+__±r
+è!ð(
+size_t
+) -1)
+
+340 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__size
+)
+
+341 || !
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+)
+
+342 || (
+__size
+ |
+__n
+è>ð(((
+size_t
+) 1) << (8 * \17 (size_t) / 2)))
+
+343 \15
+ `__ä\97d_uÆocked_chk
+ (
+__±r
+,
+ `__bos0
+ (__±r),
+__size
+,
+__n
+,
+
+344
+__¡»am
+);
+
+346 ià(
+__size
+ *
+__n
+ >
+ `__bos0
+ (
+__±r
+))
+
+347 \15
+ `__ä\97d_uÆocked_chk_w¬n
+ (
+__±r
+,
+ `__bos0
+ (__±r),
+__size
+,
+__n
+,
+
+348
+__¡»am
+);
+
+351 #ifdeà
+__USE_EXTERN_INLINES
+
+
+352 ià(
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__size
+)
+
+353 &&
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+)
+
+354 && (
+__size
+ |
+__n
+è< (((
+size_t
+) 1) << (8 * \17 (size_t) / 2))
+
+355 &&
+__size
+ *
+__n
+ <= 8)
+
+357
+size_t
+
+__út
+ =
+__size
+ *
+__n
+;
+
+358 \ 5*
+__ý\8c
+ = (\ 5*è
+__±r
+;
+
+359 ià(
+__út
+ == 0)
+
+362 \ f;
+__út
+ > 0; --__cnt)
+
+364 \12
+__c
+ =
+ `_IO_g\91c_uÆocked
+ (
+__¡»am
+);
+
+365 ià(
+__c
+ =ð
+EOF
+)
+
+367 *
+__ý\8c
+++ =
+__c
+;
+
+369 \15 (
+__ý\8c
+ - (\ 5*è
+__±r
+è/
+__size
+;
+
+372 \15
+ `__ä\97d_uÆocked_®\9fs
+ (
+__±r
+,
+__size
+,
+__n
+,
+__¡»am
+);
+
+373
+ }
+}
+
+ @/usr/include/bits/stdio_lim.h
+
+19 #ià!
+def\9aed
+
+_STDIO_H
+ && !def\9aed
+__Ãed_FOPEN_MAX
+ && !def\9aed
+__Ãed_IOV_MAX
+
+
+23 #ifdeà
+_STDIO_H
+
+
+24 \ 1
+ #L_tm²am
+ 20
+
+ )
+
+25 \ 1
+ #TMP_MAX
+ 238328
+
+ )
+
+26 \ 1
+ #FILENAME_MAX
+ 4096
+
+ )
+
+28 #ifdeà
+__USE_POSIX
+
+
+29 \ 1
+ #L_ù\94mid
+ 9
+
+ )
+
+30 #ià!
+def\9aed
+
+__USE_XOPEN2K
+ || def\9aed
+__USE_GNU
+
+
+31 \ 1
+ #L_cu£rid
+ 9
+
+ )
+
+36 #ià
+def\9aed
+
+__Ãed_FOPEN_MAX
+ || def\9aed
+_STDIO_H
+
+
+37 #undeà
+FOPEN_MAX
+
+
+38 \ 1
+ #FOPEN_MAX
+ 16
+
+ )
+
+41 #ià
+def\9aed
+
+__Ãed_IOV_MAX
+ && !def\9aed
+IOV_MAX
+
+
+42 \ 1
+ #IOV_MAX
+ 1024
+
+ )
+
+ @/usr/include/bits/stdlib-ldbl.h
+
+20 #iâdeà
+_STDLIB_H
+
+
+24 #ifdef
+__USE_ISOC99
+
+
+25
+__BEGIN_NAMESPACE_C99
+
+
+26
+ $__LDBL_REDIR1_DECL
+ (
+¡¹Þd
+,
+¡¹od
+)
+
+27
+__END_NAMESPACE_C99
+
+
+30 #ifdeà
+__USE_GNU
+
+
+31
+ $__LDBL_REDIR1_DECL
+ (
+¡¹Þd_l
+,
+¡¹od_l
+)
+
+34 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_XOPEN_EXTENDED
+
+
+35 #ifdeà
+__USE_MISC
+
+
+36
+ $__LDBL_REDIR1_DECL
+ (
+qecvt
+,
+ecvt
+)
+
+37
+ $__LDBL_REDIR1_DECL
+ (
+qfcvt
+,
+fcvt
+)
+
+38
+ $__LDBL_REDIR1_DECL
+ (
+qgcvt
+,
+gcvt
+)
+
+39
+ $__LDBL_REDIR1_DECL
+ (
+qecvt_r
+,
+ecvt_r
+)
+
+40
+ $__LDBL_REDIR1_DECL
+ (
+qfcvt_r
+,
+fcvt_r
+)
+
+ @/usr/include/bits/stdlib.h
+
+20 #iâdeà
+_STDLIB_H
+
+
+24 \r\ 5*
+ $__»®·th_chk
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Çme
+,
+
+25 \ 5*
+__»¡riù
+
+__»sÞved
+,
+
+26
+size_t
+
+__»sÞvedËn
+è
+__THROW
+
+__wur
+;
+
+27 \r\ 5*
+ `__REDIRECT_NTH
+ (
+__»®·th_®\9fs
+,
+
+28 (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Çme
+,
+
+29 \ 5*
+__»¡riù
+
+__»sÞved
+),
+»®·th
+è
+__wur
+;
+
+30 \r\ 5*
+ `__REDIRECT_NTH
+ (
+__»®·th_chk_w¬n
+,
+
+31 (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Çme
+,
+
+32 \ 5*
+__»¡riù
+
+__»sÞved
+,
+
+33
+size_t
+
+__»sÞvedËn
+),
+__»®·th_chk
+è
+__wur
+
+
+34
+ `__w‚\89r
+ ("second\87rgument of\84ealpath must be\83ither NULL or\87t "
+
+37
+__ex\8bº_®ways_\9al\9ae
+
+__wur
+ \ 5*
+
+38
+ `__NTH
+ (
+ $»®·th
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__Çme
+, \ 5*__»¡riù
+__»sÞved
+))
+
+40 ià(
+ `__bos
+ (
+__»sÞved
+è!ð(
+size_t
+) -1)
+
+42 #ià
+def\9aed
+
+_LIBC_LIMITS_H_
+ && def\9aed
+PATH_MAX
+
+
+43 ià(
+ `__bos
+ (
+__»sÞved
+è<
+PATH_MAX
+)
+
+44 \15
+ `__»®·th_chk_w¬n
+ (
+__Çme
+,
+__»sÞved
+,
+ `__bos
+ (__resolved));
+
+46 \15
+ `__»®·th_chk
+ (
+__Çme
+,
+__»sÞved
+,
+ `__bos
+ (__resolved));
+
+49 \15
+ `__»®·th_®\9fs
+ (
+__Çme
+,
+__»sÞved
+);
+
+50
+ }
+}
+
+53 \r\12
+ $__±¢ame_r_chk
+ (\12
+__fd
+, \ 5*
+__buf
+,
+size_t
+
+__buæ\92
+,
+
+54
+size_t
+
+__ėl
+è
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+55 \r\12
+ `__REDIRECT_NTH
+ (
+__±¢ame_r_®\9fs
+, (\12
+__fd
+, \ 5*
+__buf
+,
+
+56
+size_t
+
+__buæ\92
+),
+±¢ame_r
+)
+
+57
+ `__nÚnuÎ
+ ((2));
+
+58 \r\12
+ `__REDIRECT_NTH
+ (
+__±¢ame_r_chk_w¬n
+,
+
+59 (\12
+__fd
+, \ 5*
+__buf
+,
+size_t
+
+__buæ\92
+,
+
+60
+size_t
+
+__ėl
+),
+__±¢ame_r_chk
+)
+
+61
+ `__nÚnuÎ
+ ((2)è
+ `__w‚\89r
+ ("ptsname_r called with buflen bigger\81han "
+
+64
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+65
+ `__NTH
+ (
+ $±¢ame_r
+ (\12
+__fd
+, \ 5*
+__buf
+,
+size_t
+
+__buæ\92
+))
+
+67 ià(
+ `__bos
+ (
+__buf
+è!ð(
+size_t
+) -1)
+
+69 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__buæ\92
+))
+
+70 \15
+ `__±¢ame_r_chk
+ (
+__fd
+,
+__buf
+,
+__buæ\92
+,
+ `__bos
+ (__buf));
+
+71 ià(
+__buæ\92
+ >
+ `__bos
+ (
+__buf
+))
+
+72 \15
+ `__±¢ame_r_chk_w¬n
+ (
+__fd
+,
+__buf
+,
+__buæ\92
+,
+ `__bos
+ (__buf));
+
+74 \15
+ `__±¢ame_r_®\9fs
+ (
+__fd
+,
+__buf
+,
+__buæ\92
+);
+
+75
+ }
+}
+
+78 \r\12
+ $__wùomb_chk
+ (\ 5*
+__s
+,
+wch¬_t
+
+__wch¬
+,
+size_t
+
+__buæ\92
+)
+
+79
+__THROW
+
+__wur
+;
+
+80 \r\12
+ `__REDIRECT_NTH
+ (
+__wùomb_®\9fs
+, (\ 5*
+__s
+,
+wch¬_t
+
+__wch¬
+),
+
+81
+wùomb
+è
+__wur
+;
+
+83
+__ex\8bº_®ways_\9al\9ae
+
+__wur
+ \12
+
+84
+ `__NTH
+ (
+ $wùomb
+ (\ 5*
+__s
+,
+wch¬_t
+
+__wch¬
+))
+
+89 \ 1
+ #__STDLIB_MB_LEN_MAX
+ 16
+
+ )
+
+90 #ià
+def\9aed
+
+MB_LEN_MAX
+ && MB_LEN_MAX !ð
+__STDLIB_MB_LEN_MAX
+
+
+93 ià(
+ `__bos
+ (
+__s
+è!ð(
+size_t
+è-1 &&
+__STDLIB_MB_LEN_MAX
+ > __bos (__s))
+
+94 \15
+ `__wùomb_chk
+ (
+__s
+,
+__wch¬
+,
+ `__bos
+ (__s));
+
+95 \15
+ `__wùomb_®\9fs
+ (
+__s
+,
+__wch¬
+);
+
+96
+ }
+}
+
+99 \r
+size_t
+
+ $__mb¡owcs_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+
+100
+__cڡ
+ \ 5*
+__»¡riù
+
+__¤c
+,
+
+101
+size_t
+
+__Ën
+, size_\88
+__d¡Ën
+è
+__THROW
+;
+
+102 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__mb¡owcs_®\9fs
+,
+
+103 (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+
+104
+__cڡ
+ \ 5*
+__»¡riù
+
+__¤c
+,
+
+105
+size_t
+
+__Ën
+),
+mb¡owcs
+);
+
+106 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__mb¡owcs_chk_w¬n
+,
+
+107 (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+
+108
+__cڡ
+ \ 5*
+__»¡riù
+
+__¤c
+,
+
+109
+size_t
+
+__Ën
+, size_\88
+__d¡Ën
+),
+__mb¡owcs_chk
+)
+
+110
+ `__w‚\89r
+ ("mbstowcs called with dst buffer smaller\81han\86en "
+
+113
+__ex\8bº_®ways_\9al\9ae
+
+size_t
+
+
+114
+ `__NTH
+ (
+ $mb¡owcs
+ (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+__cڡ
+ \ 5*__»¡riù
+__¤c
+,
+
+115
+size_t
+
+__Ën
+))
+
+117 ià(
+ `__bos
+ (
+__d¡
+è!ð(
+size_t
+) -1)
+
+119 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__Ën
+))
+
+120 \15
+ `__mb¡owcs_chk
+ (
+__d¡
+,
+__¤c
+,
+__Ën
+,
+
+121
+ `__bos
+ (
+__d¡
+è/ \17 (
+wch¬_t
+));
+
+123 ià(
+__Ën
+ >
+ `__bos
+ (
+__d¡
+è/ \17 (
+wch¬_t
+))
+
+124 \15
+ `__mb¡owcs_chk_w¬n
+ (
+__d¡
+,
+__¤c
+,
+__Ën
+,
+
+125
+ `__bos
+ (
+__d¡
+è/ \17 (
+wch¬_t
+));
+
+127 \15
+ `__mb¡owcs_®\9fs
+ (
+__d¡
+,
+__¤c
+,
+__Ën
+);
+
+128
+ }
+}
+
+131 \r
+size_t
+
+ $__wc¡ombs_chk
+ (\ 5*
+__»¡riù
+
+__d¡
+,
+
+132
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+
+133
+size_t
+
+__Ën
+, size_\88
+__d¡Ën
+è
+__THROW
+;
+
+134 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__wc¡ombs_®\9fs
+,
+
+135 (\ 5*
+__»¡riù
+
+__d¡
+,
+
+136
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+
+137
+size_t
+
+__Ën
+),
+wc¡ombs
+);
+
+138 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__wc¡ombs_chk_w¬n
+,
+
+139 (\ 5*
+__»¡riù
+
+__d¡
+,
+
+140
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+
+141
+size_t
+
+__Ën
+, size_\88
+__d¡Ën
+),
+__wc¡ombs_chk
+)
+
+142
+ `__w‚\89r
+ ("wcstombs called with dst buffer smaller\81han\86en");
+
+144
+__ex\8bº_®ways_\9al\9ae
+
+size_t
+
+
+145
+ `__NTH
+ (
+ $wc¡ombs
+ (\ 5*
+__»¡riù
+
+__d¡
+,
+__cڡ
+
+wch¬_t
+ *__»¡riù
+__¤c
+,
+
+146
+size_t
+
+__Ën
+))
+
+148 ià(
+ `__bos
+ (
+__d¡
+è!ð(
+size_t
+) -1)
+
+150 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__Ën
+))
+
+151 \15
+ `__wc¡ombs_chk
+ (
+__d¡
+,
+__¤c
+,
+__Ën
+,
+ `__bos
+ (__dst));
+
+152 ià(
+__Ën
+ >
+ `__bos
+ (
+__d¡
+))
+
+153 \15
+ `__wc¡ombs_chk_w¬n
+ (
+__d¡
+,
+__¤c
+,
+__Ën
+,
+ `__bos
+ (__dst));
+
+155 \15
+ `__wc¡ombs_®\9fs
+ (
+__d¡
+,
+__¤c
+,
+__Ën
+);
+
+156
+ }
+}
+
+ @/usr/include/bits/string.h
+
+20 #iâdeà
+_STRING_H
+
+
+26 \ 1
+ #_STRING_ARCH_uÇligÃd
+ 1
+
+ )
+
+ @/usr/include/bits/string2.h
+
+21 #iâdeà
+_STRING_H
+
+
+25 #ià!
+def\9aed
+
+__NO_STRING_INLINES
+ && !def\9aed
+__BOUNDED_POINTERS__
+
+
+42 #iâdeà
+__STRING_INLINE
+
+
+43 #ifdeà
+__ýlu¥lus
+
+
+44 \ 1
+ #__STRING_INLINE
+
+\9al\9ae
+
+
+ )
+
+46 \ 1
+ #__STRING_INLINE
+
+__ex\8bº_\9al\9ae
+
+
+ )
+
+50 #ià
+_STRING_ARCH_uÇligÃd
+
+
+52 \ 2
+ ~<\92d\9fn.h
+>
+
+53 \ 2
+ ~<b\99s/ty³s.h
+>
+
+55 #ià
+__BYTE_ORDER
+ =ð
+__LITTLE_ENDIAN
+
+
+56 \ 1
+ #__STRING2_SMALL_GET16
+(
+¤c
+,
+idx
+) \
+
+57 (((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+¤c
+))[
+idx
+ + 1] << 8 \
+
+58 | ((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+¤c
+))[
+idx
+])
+
+ )
+
+59 \ 1
+ #__STRING2_SMALL_GET32
+(
+¤c
+,
+idx
+) \
+
+60 (((((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+¤c
+))[
+idx
+ + 3] << 8 \
+
+61 | ((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+¤c
+))[
+idx
+ + 2]) << 8 \
+
+62 | ((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+¤c
+))[
+idx
+ + 1]) << 8 \
+
+63 | ((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+¤c
+))[
+idx
+])
+
+ )
+
+65 \ 1
+ #__STRING2_SMALL_GET16
+(
+¤c
+,
+idx
+) \
+
+66 (((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+¤c
+))[
+idx
+] << 8 \
+
+67 | ((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+¤c
+))[
+idx
+ + 1])
+
+ )
+
+68 \ 1
+ #__STRING2_SMALL_GET32
+(
+¤c
+,
+idx
+) \
+
+69 (((((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+¤c
+))[
+idx
+] << 8 \
+
+70 | ((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+¤c
+))[
+idx
+ + 1]) << 8 \
+
+71 | ((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+¤c
+))[
+idx
+ + 2]) << 8 \
+
+72 | ((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+¤c
+))[
+idx
+ + 3])
+
+ )
+
+77 \ 1
+ #__STRING2_COPY_TYPE
+(
+N
+) \
+
+78 \e¡ruù { \1d\ 5
+__¬r
+[
+N
+]; } \
+
+79
+ t__©\8cibu\8b__
+ ((
+ t__·cked__
+)è
+ t__STRING2_COPY_ARR
+##
+ tN
+
+
+ )
+
+80
+ t__STRING2_COPY_TYPE
+ (2);
+
+81
+__STRING2_COPY_TYPE
+ (3);
+
+82
+__STRING2_COPY_TYPE
+ (4);
+
+83
+__STRING2_COPY_TYPE
+ (5);
+
+84
+__STRING2_COPY_TYPE
+ (6);
+
+85
+__STRING2_COPY_TYPE
+ (7);
+
+86
+__STRING2_COPY_TYPE
+ (8);
+
+87 #undeà
+__STRING2_COPY_TYPE
+
+
+93 \ 1
+ #__¡r\9ag2_1b±r_p
+(
+__x
+) \
+
+94 ((
+size_t
+)(cڡ \1e*)((
+__x
+è+ 1è- (size_t)(cÚ¡ \1e*)(__xè=ð1)
+
+ )
+
+97 #ià!
+def\9aed
+
+_HAVE_STRING_ARCH_mem£t
+
+
+98 #ià!
+__GNUC_PREREQ
+ (3, 0)
+
+99 #ià
+_STRING_ARCH_uÇligÃd
+
+
+100 \ 1
+ #mem£t
+(
+s
+,
+c
+,
+n
+) \
+
+101 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+n
+) && (n) <= 16 \
+
+102 ? ((
+n
+) == 1 \
+
+103 ?
+ `__mem£t_1
+ (
+s
+,
+c
+) \
+
+104 :
+ `__mem£t_gc
+ (
+s
+,
+c
+,
+n
+)) \
+
+105 : (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+c
+) && (c) == '\0' \
+
+106 ? ({ \1e*
+__s
+ = (
+s
+);
+ `__bz\94o
+ (__s,
+n
+); __s; }) \
+
+107 :
+ `mem£t
+ (
+s
+,
+c
+,
+n
+))))
+
+ )
+
+109 \ 1
+ #__mem£t_1
+(
+s
+,
+c
+è({ \1e*
+__s
+ = (s); \
+
+110 *((
+__u\9at8_t
+ *è
+__s
+èð(__u\9at8_tè
+c
+; __s; })
+
+ )
+
+112 \ 1
+ #__mem£t_gc
+(
+s
+,
+c
+,
+n
+) \
+
+113 ({ \1e*
+__s
+ = (
+s
+); \
+
+115 \1d\12
+__ui
+; \
+
+116 \1d\16\12
+__usi
+; \
+
+117 \1d\ 5
+__uc
+; \
+
+118 } *
+__u
+ =
+__s
+; \
+
+119
+__u\9at8_t
+
+__c
+ = (__u\9at8_tè(
+c
+); \
+
+122 \1a(\1d\12è(
+n
+)) \
+
+125
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+126
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4); \
+
+128
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+129
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4); \
+
+131
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+132
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4); \
+
+134
+__u
+->
+__usi
+ = (\1d\16\12è
+__c
+ * 0x0101; \
+
+135
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 2); \
+
+136
+__u
+->
+__uc
+ = (\1d\ 5è
+__c
+; \
+
+140
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+141
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4); \
+
+143
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+144
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4); \
+
+146
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+147
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4); \
+
+149
+__u
+->
+__usi
+ = (\1d\16\12è
+__c
+ * 0x0101; \
+
+153
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+154
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4); \
+
+156
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+157
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4); \
+
+159
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+160
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4); \
+
+162
+__u
+->
+__uc
+ = (\1d\ 5è
+__c
+; \
+
+166
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+167
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4); \
+
+169
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+170
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4); \
+
+172
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+173
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4); \
+
+175
+__u
+->
+__ui
+ =
+__c
+ * 0x01010101; \
+
+180
+__s
+; })
+
+ )
+
+182 \ 1
+ #mem£t
+(
+s
+,
+c
+,
+n
+) \
+
+183 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+c
+) && (c) == '\0' \
+
+184 ? ({ \1e*
+__s
+ = (
+s
+);
+ `__bz\94o
+ (__s,
+n
+); __s; }) \
+
+185 :
+ `mem£t
+ (
+s
+,
+c
+,
+n
+)))
+
+ )
+
+194 #ià
+__GNUC_PREREQ
+ (2, 91)
+
+195 \ 1
+ #__bz\94o
+(
+s
+,
+n
+è
+ `__bu\9et\9a_mem£t
+ (s, '\0',\82)
+
+ )
+
+203 #ifdeà
+__USE_GNU
+
+
+204 #ià!
+def\9aed
+
+_HAVE_STRING_ARCH_mempýy
+ || def\9aed
+_FORCE_INLINES
+
+
+205 #iâdeà
+_HAVE_STRING_ARCH_mempýy
+
+
+206 #ià
+__GNUC_PREREQ
+ (3, 4)
+
+207 \ 1
+ #__mempýy
+(
+de¡
+,
+¤c
+,
+n
+è
+ `__bu\9et\9a_mempýy
+ (de¡, src,\82)
+
+ )
+
+208 #\96ià
+__GNUC_PREREQ
+ (3, 0)
+
+209 \ 1
+ #__mempýy
+(
+de¡
+,
+¤c
+,
+n
+) \
+
+210 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+¤c
+è&& __bu\9et\9a_cÚ¡ªt_°(
+n
+) \
+
+211 &&
+ `__¡r\9ag2_1b±r_p
+ (
+¤c
+è&&
+n
+ <= 8 \
+
+212 ?
+ `__bu\9et\9a_memýy
+ (
+de¡
+,
+¤c
+,
+n
+) + (n) \
+
+213 :
+ `__mempýy
+ (
+de¡
+,
+¤c
+,
+n
+)))
+
+ )
+
+215 \ 1
+ #__mempýy
+(
+de¡
+,
+¤c
+,
+n
+) \
+
+216 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+¤c
+è&& __bu\9et\9a_cÚ¡ªt_°(
+n
+) \
+
+217 &&
+ `__¡r\9ag2_1b±r_p
+ (
+¤c
+è&&
+n
+ <= 8 \
+
+218 ?
+ `__mempýy_sm®l
+ (
+de¡
+,
+ `__mempýy_¬gs
+ (
+¤c
+),
+n
+) \
+
+219 :
+ `__mempýy
+ (
+de¡
+,
+¤c
+,
+n
+)))
+
+ )
+
+223 \ 1
+ #mempýy
+(
+de¡
+,
+¤c
+,
+n
+è
+ `__mempýy
+ (de¡, src,\82)
+
+ )
+
+226 #ià!
+__GNUC_PREREQ
+ (3, 0è||
+def\9aed
+
+_FORCE_INLINES
+
+
+227 #ià
+_STRING_ARCH_uÇligÃd
+
+
+228 #iâdeà
+_FORCE_INLINES
+
+
+229 \ 1
+ #__mempýy_¬gs
+(
+¤c
+) \
+
+230 ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[2], \
+
+231 ((
+__cڡ
+ \ 5*è(
+¤c
+))[4], ((__const \ 5*) (src))[6], \
+
+232
+__ex\8bnsiÚ__
+
+ `__STRING2_SMALL_GET16
+ (
+¤c
+, 0), \
+
+233
+__ex\8bnsiÚ__
+
+ `__STRING2_SMALL_GET16
+ (
+¤c
+, 4), \
+
+234
+__ex\8bnsiÚ__
+
+ `__STRING2_SMALL_GET32
+ (
+¤c
+, 0), \
+
+235
+__ex\8bnsiÚ__
+
+ `__STRING2_SMALL_GET32
+ (
+¤c
+, 4)
+
+ )
+
+237
+__STRING_INLINE
+ \1e*
+__mempýy_sm®l
+ (\1e*, \ 5, \ 5, \ 5, \ 5,
+
+238
+__u\9at16_t
+, __u\9at16_t,
+__u\9at32_t
+,
+
+239
+__u\9at32_t
+,
+size_t
+);
+
+240
+__STRING_INLINE
+ \1e*
+
+241
+ $__mempýy_sm®l
+ (\1e*
+__de¡1
+,
+
+242 \ 5
+__¤c0_1
+, \ 5
+__¤c2_1
+, \ 5
+__¤c4_1
+, \ 5
+__¤c6_1
+,
+
+243
+__u\9at16_t
+
+__¤c0_2
+, __u\9at16_\88
+__¤c4_2
+,
+
+244
+__u\9at32_t
+
+__¤c0_4
+, __u\9at32_\88
+__¤c4_4
+,
+
+245
+size_t
+
+__¤þ\92
+)
+
+248
+__u\9at32_t
+
+__ui
+;
+
+249
+__u\9at16_t
+
+__usi
+;
+
+250 \1d\ 5
+__uc
+;
+
+251 \1d\ 5
+__c
+;
+
+252 } *
+__u
+ =
+__de¡1
+;
+
+253 \1a(\1d\12è
+__¤þ\92
+)
+
+256
+__u
+->
+__c
+ =
+__¤c0_1
+;
+
+257
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 1);
+
+260
+__u
+->
+__usi
+ =
+__¤c0_2
+;
+
+261
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 2);
+
+264
+__u
+->
+__usi
+ =
+__¤c0_2
+;
+
+265
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 2);
+
+266
+__u
+->
+__c
+ =
+__¤c2_1
+;
+
+267
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 1);
+
+270
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+271
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+274
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+275
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+276
+__u
+->
+__c
+ =
+__¤c4_1
+;
+
+277
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 1);
+
+280
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+281
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+282
+__u
+->
+__usi
+ =
+__¤c4_2
+;
+
+283
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 2);
+
+286
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+287
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+288
+__u
+->
+__usi
+ =
+__¤c4_2
+;
+
+289
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 2);
+
+290
+__u
+->
+__c
+ =
+__¤c6_1
+;
+
+291
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 1);
+
+294
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+295
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+296
+__u
+->
+__ui
+ =
+__¤c4_4
+;
+
+297
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+300 \15 (\1e*è
+__u
+;
+
+301
+ }
+}
+
+303 #iâdeà
+_FORCE_INLINES
+
+
+304 \ 1
+ #__mempýy_¬gs
+(
+¤c
+) \
+
+305 ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], \
+
+306
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR2
+) \
+
+307 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1] } }), \
+
+308
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR3
+) \
+
+309 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+310 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2] } }), \
+
+311
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR4
+) \
+
+312 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+313 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3] } }), \
+
+314
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR5
+) \
+
+315 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+316 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3], \
+
+317 ((
+__cڡ
+ \ 5*è(
+¤c
+))[4] } }), \
+
+318
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR6
+) \
+
+319 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+320 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3], \
+
+321 ((
+__cڡ
+ \ 5*è(
+¤c
+))[4], ((__const \ 5*) (src))[5] } }), \
+
+322
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR7
+) \
+
+323 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+324 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3], \
+
+325 ((
+__cڡ
+ \ 5*è(
+¤c
+))[4], ((__const \ 5*) (src))[5], \
+
+326 ((
+__cڡ
+ \ 5*è(
+¤c
+))[6] } }), \
+
+327
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR8
+) \
+
+328 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+329 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3], \
+
+330 ((
+__cڡ
+ \ 5*è(
+¤c
+))[4], ((__const \ 5*) (src))[5], \
+
+331 ((
+__cڡ
+ \ 5*è(
+¤c
+))[6], ((__cÚ¡ \ 5*è(¤c))[7] } })
+
+ )
+
+333
+__STRING_INLINE
+ \1e*
+__mempýy_sm®l
+ (\1e*, \ 5,
+__STRING2_COPY_ARR2
+,
+
+334
+__STRING2_COPY_ARR3
+,
+
+335
+__STRING2_COPY_ARR4
+,
+
+336
+__STRING2_COPY_ARR5
+,
+
+337
+__STRING2_COPY_ARR6
+,
+
+338
+__STRING2_COPY_ARR7
+,
+
+339
+__STRING2_COPY_ARR8
+,
+size_t
+);
+
+340
+__STRING_INLINE
+ \1e*
+
+341
+ $__mempýy_sm®l
+ (\1e*
+__de¡
+, \ 5
+__¤c1
+,
+
+342
+__STRING2_COPY_ARR2
+
+__¤c2
+,
+__STRING2_COPY_ARR3
+
+__¤c3
+,
+
+343
+__STRING2_COPY_ARR4
+
+__¤c4
+,
+__STRING2_COPY_ARR5
+
+__¤c5
+,
+
+344
+__STRING2_COPY_ARR6
+
+__¤c6
+,
+__STRING2_COPY_ARR7
+
+__¤c7
+,
+
+345
+__STRING2_COPY_ARR8
+
+__¤c8
+,
+size_t
+
+__¤þ\92
+)
+
+348 \ 5
+__c
+;
+
+349
+__STRING2_COPY_ARR2
+
+__sÿ2
+;
+
+350
+__STRING2_COPY_ARR3
+
+__sÿ3
+;
+
+351
+__STRING2_COPY_ARR4
+
+__sÿ4
+;
+
+352
+__STRING2_COPY_ARR5
+
+__sÿ5
+;
+
+353
+__STRING2_COPY_ARR6
+
+__sÿ6
+;
+
+354
+__STRING2_COPY_ARR7
+
+__sÿ7
+;
+
+355
+__STRING2_COPY_ARR8
+
+__sÿ8
+;
+
+356 } *
+__u
+ =
+__de¡
+;
+
+357 \1a(\1d\12è
+__¤þ\92
+)
+
+360
+__u
+->
+__c
+ =
+__¤c1
+;
+
+363
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ2
+ =
+__¤c2
+;
+
+366
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ3
+ =
+__¤c3
+;
+
+369
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ4
+ =
+__¤c4
+;
+
+372
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ5
+ =
+__¤c5
+;
+
+375
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ6
+ =
+__¤c6
+;
+
+378
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ7
+ =
+__¤c7
+;
+
+381
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ8
+ =
+__¤c8
+;
+
+384 \15
+ `__ex\8bnsiÚ__
+ ((\1e*è
+__u
+ +
+__¤þ\92
+);
+
+385
+ }
+}
+
+393 #iâdeà
+_HAVE_STRING_ARCH_¡rchr
+
+
+394 \r\1e*
+__¿wmemchr
+ (cڡ \1e*
+__s
+, \12
+__c
+);
+
+395 #ià
+__GNUC_PREREQ
+ (3, 2)
+
+396 \ 1
+ #¡rchr
+(
+s
+,
+c
+) \
+
+397 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+c
+è&& !__bu\9et\9a_cÚ¡ªt_°(
+s
+) \
+
+398 && (
+c
+) == '\0' \
+
+399 ? (\ 5*è
+ `__¿wmemchr
+ (
+s
+,
+c
+) \
+
+400 :
+ `__bu\9et\9a_¡rchr
+ (
+s
+,
+c
+)))
+
+ )
+
+402 \ 1
+ #¡rchr
+(
+s
+,
+c
+) \
+
+403 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+c
+) && (c) == '\0' \
+
+404 ? (\ 5*è
+ `__¿wmemchr
+ (
+s
+,
+c
+) \
+
+405 :
+ `¡rchr
+ (
+s
+,
+c
+)))
+
+ )
+
+411 #ià(!
+def\9aed
+
+_HAVE_STRING_ARCH_¡rýy
+ && !
+__GNUC_PREREQ
+ (3, 0)) \
+
+412 ||
+def\9aed
+
+ g_FORCE_INLINES
+
+
+413 #ià!
+def\9aed
+
+_HAVE_STRING_ARCH_¡rýy
+ && !
+__GNUC_PREREQ
+ (3, 0)
+
+414 \ 1
+ #¡rýy
+(
+de¡
+,
+¤c
+) \
+
+415 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+¤c
+) \
+
+416 ? (
+ `__¡r\9ag2_1b±r_p
+ (
+¤c
+è&&
+ `¡¾\92
+ (src) + 1 <= 8 \
+
+417 ?
+ `__¡rýy_sm®l
+ (
+de¡
+,
+ `__¡rýy_¬gs
+ (
+¤c
+), \
+
+418
+ `¡¾\92
+ (
+¤c
+) + 1) \
+
+419 : (\ 5*è
+ `memýy
+ (
+de¡
+,
+¤c
+,
+ `¡¾\92
+ (src) + 1)) \
+
+420 :
+ `¡rýy
+ (
+de¡
+,
+¤c
+)))
+
+ )
+
+423 #ià
+_STRING_ARCH_uÇligÃd
+
+
+424 #iâdeà
+_FORCE_INLINES
+
+
+425 \ 1
+ #__¡rýy_¬gs
+(
+¤c
+) \
+
+426
+__ex\8bnsiÚ__
+
+ `__STRING2_SMALL_GET16
+ (
+¤c
+, 0), \
+
+427
+__ex\8bnsiÚ__
+
+ `__STRING2_SMALL_GET16
+ (
+¤c
+, 4), \
+
+428
+__ex\8bnsiÚ__
+
+ `__STRING2_SMALL_GET32
+ (
+¤c
+, 0), \
+
+429
+__ex\8bnsiÚ__
+
+ `__STRING2_SMALL_GET32
+ (
+¤c
+, 4)
+
+ )
+
+431
+__STRING_INLINE
+ \ 5*
+__¡rýy_sm®l
+ (\ 5*,
+__u\9at16_t
+, __uint16_t,
+
+432
+__u\9at32_t
+, __u\9at32_t,
+size_t
+);
+
+433
+__STRING_INLINE
+ \ 5*
+
+434
+ $__¡rýy_sm®l
+ (\ 5*
+__de¡
+,
+
+435
+__u\9at16_t
+
+__¤c0_2
+, __u\9at16_\88
+__¤c4_2
+,
+
+436
+__u\9at32_t
+
+__¤c0_4
+, __u\9at32_\88
+__¤c4_4
+,
+
+437
+size_t
+
+__¤þ\92
+)
+
+440
+__u\9at32_t
+
+__ui
+;
+
+441
+__u\9at16_t
+
+__usi
+;
+
+442 \1d\ 5
+__uc
+;
+
+443 } *
+__u
+ = (\1e*è
+__de¡
+;
+
+444 \1a(\1d\12è
+__¤þ\92
+)
+
+447
+__u
+->
+__uc
+ = '\0';
+
+450
+__u
+->
+__usi
+ =
+__¤c0_2
+;
+
+453
+__u
+->
+__usi
+ =
+__¤c0_2
+;
+
+454
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 2);
+
+455
+__u
+->
+__uc
+ = '\0';
+
+458
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+461
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+462
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+463
+__u
+->
+__uc
+ = '\0';
+
+466
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+467
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+468
+__u
+->
+__usi
+ =
+__¤c4_2
+;
+
+471
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+472
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+473
+__u
+->
+__usi
+ =
+__¤c4_2
+;
+
+474
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 2);
+
+475
+__u
+->
+__uc
+ = '\0';
+
+478
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+479
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+480
+__u
+->
+__ui
+ =
+__¤c4_4
+;
+
+483 \15
+__de¡
+;
+
+484
+ }
+}
+
+486 #iâdeà
+_FORCE_INLINES
+
+
+487 \ 1
+ #__¡rýy_¬gs
+(
+¤c
+) \
+
+488
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR2
+) \
+
+489 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], '\0' } }), \
+
+490
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR3
+) \
+
+491 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+493
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR4
+) \
+
+494 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+495 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], '\0' } }), \
+
+496
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR5
+) \
+
+497 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+498 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3], \
+
+500
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR6
+) \
+
+501 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+502 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3], \
+
+503 ((
+__cڡ
+ \ 5*è(
+¤c
+))[4], '\0' } }), \
+
+504
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR7
+) \
+
+505 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+506 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3], \
+
+507 ((
+__cڡ
+ \ 5*è(
+¤c
+))[4], ((__const \ 5*) (src))[5], \
+
+509
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR8
+) \
+
+510 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+511 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3], \
+
+512 ((
+__cڡ
+ \ 5*è(
+¤c
+))[4], ((__const \ 5*) (src))[5], \
+
+513 ((
+__cڡ
+ \ 5*è(
+¤c
+))[6], '\0' } })
+
+ )
+
+515
+__STRING_INLINE
+ \ 5*
+__¡rýy_sm®l
+ (\ 5*,
+__STRING2_COPY_ARR2
+,
+
+516
+__STRING2_COPY_ARR3
+,
+
+517
+__STRING2_COPY_ARR4
+,
+
+518
+__STRING2_COPY_ARR5
+,
+
+519
+__STRING2_COPY_ARR6
+,
+
+520
+__STRING2_COPY_ARR7
+,
+
+521
+__STRING2_COPY_ARR8
+,
+size_t
+);
+
+522
+__STRING_INLINE
+ \ 5*
+
+523
+ $__¡rýy_sm®l
+ (\ 5*
+__de¡
+,
+
+524
+__STRING2_COPY_ARR2
+
+__¤c2
+,
+__STRING2_COPY_ARR3
+
+__¤c3
+,
+
+525
+__STRING2_COPY_ARR4
+
+__¤c4
+,
+__STRING2_COPY_ARR5
+
+__¤c5
+,
+
+526
+__STRING2_COPY_ARR6
+
+__¤c6
+,
+__STRING2_COPY_ARR7
+
+__¤c7
+,
+
+527
+__STRING2_COPY_ARR8
+
+__¤c8
+,
+size_t
+
+__¤þ\92
+)
+
+530 \ 5
+__c
+;
+
+531
+__STRING2_COPY_ARR2
+
+__sÿ2
+;
+
+532
+__STRING2_COPY_ARR3
+
+__sÿ3
+;
+
+533
+__STRING2_COPY_ARR4
+
+__sÿ4
+;
+
+534
+__STRING2_COPY_ARR5
+
+__sÿ5
+;
+
+535
+__STRING2_COPY_ARR6
+
+__sÿ6
+;
+
+536
+__STRING2_COPY_ARR7
+
+__sÿ7
+;
+
+537
+__STRING2_COPY_ARR8
+
+__sÿ8
+;
+
+538 } *
+__u
+ = (\1e*è
+__de¡
+;
+
+539 \1a(\1d\12è
+__¤þ\92
+)
+
+542
+__u
+->
+__c
+ = '\0';
+
+545
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ2
+ =
+__¤c2
+;
+
+548
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ3
+ =
+__¤c3
+;
+
+551
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ4
+ =
+__¤c4
+;
+
+554
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ5
+ =
+__¤c5
+;
+
+557
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ6
+ =
+__¤c6
+;
+
+560
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ7
+ =
+__¤c7
+;
+
+563
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ8
+ =
+__¤c8
+;
+
+566 \15
+__de¡
+;
+
+567
+ }
+}
+
+573 #ifdeà
+__USE_GNU
+
+
+574 #ià!
+def\9aed
+
+_HAVE_STRING_ARCH_¡pýy
+ || def\9aed
+_FORCE_INLINES
+
+
+575 #iâdeà
+_HAVE_STRING_ARCH_¡pýy
+
+
+576 #ià
+__GNUC_PREREQ
+ (3, 4)
+
+577 \ 1
+ #__¡pýy
+(
+de¡
+,
+¤c
+è
+ `__bu\9et\9a_¡pýy
+ (de¡, src)
+
+ )
+
+578 #\96ià
+__GNUC_PREREQ
+ (3, 0)
+
+579 \ 1
+ #__¡pýy
+(
+de¡
+,
+¤c
+) \
+
+580 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+¤c
+) \
+
+581 ? (
+ `__¡r\9ag2_1b±r_p
+ (
+¤c
+è&&
+ `¡¾\92
+ (src) + 1 <= 8 \
+
+582 ?
+ `__bu\9et\9a_¡rýy
+ (
+de¡
+,
+¤c
+è+
+ `¡¾\92
+ (src) \
+
+583 : ((\ 5*è(
+__mempýy
+è(
+de¡
+,
+¤c
+,
+ `¡¾\92
+ (src) + 1) \
+
+585 :
+ `__¡pýy
+ (
+de¡
+,
+¤c
+)))
+
+ )
+
+587 \ 1
+ #__¡pýy
+(
+de¡
+,
+¤c
+) \
+
+588 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+¤c
+) \
+
+589 ? (
+ `__¡r\9ag2_1b±r_p
+ (
+¤c
+è&&
+ `¡¾\92
+ (src) + 1 <= 8 \
+
+590 ?
+ `__¡pýy_sm®l
+ (
+de¡
+,
+ `__¡pýy_¬gs
+ (
+¤c
+), \
+
+591
+ `¡¾\92
+ (
+¤c
+) + 1) \
+
+592 : ((\ 5*è(
+__mempýy
+è(
+de¡
+,
+¤c
+,
+ `¡¾\92
+ (src) + 1) \
+
+594 :
+ `__¡pýy
+ (
+de¡
+,
+¤c
+)))
+
+ )
+
+598 \ 1
+ #¡pýy
+(
+de¡
+,
+¤c
+è
+ `__¡pýy
+ (de¡, src)
+
+ )
+
+601 #ià!
+__GNUC_PREREQ
+ (3, 0è||
+def\9aed
+
+_FORCE_INLINES
+
+
+602 #ià
+_STRING_ARCH_uÇligÃd
+
+
+603 #iâdeà
+_FORCE_INLINES
+
+
+604 \ 1
+ #__¡pýy_¬gs
+(
+¤c
+) \
+
+605
+__ex\8bnsiÚ__
+
+ `__STRING2_SMALL_GET16
+ (
+¤c
+, 0), \
+
+606
+__ex\8bnsiÚ__
+
+ `__STRING2_SMALL_GET16
+ (
+¤c
+, 4), \
+
+607
+__ex\8bnsiÚ__
+
+ `__STRING2_SMALL_GET32
+ (
+¤c
+, 0), \
+
+608
+__ex\8bnsiÚ__
+
+ `__STRING2_SMALL_GET32
+ (
+¤c
+, 4)
+
+ )
+
+610
+__STRING_INLINE
+ \ 5*
+__¡pýy_sm®l
+ (\ 5*,
+__u\9at16_t
+, __uint16_t,
+
+611
+__u\9at32_t
+, __u\9at32_t,
+size_t
+);
+
+612
+__STRING_INLINE
+ \ 5*
+
+613
+ $__¡pýy_sm®l
+ (\ 5*
+__de¡
+,
+
+614
+__u\9at16_t
+
+__¤c0_2
+, __u\9at16_\88
+__¤c4_2
+,
+
+615
+__u\9at32_t
+
+__¤c0_4
+, __u\9at32_\88
+__¤c4_4
+,
+
+616
+size_t
+
+__¤þ\92
+)
+
+619 \1d\12
+__ui
+;
+
+620 \1d\16\12
+__usi
+;
+
+621 \1d\ 5
+__uc
+;
+
+622 \ 5
+__c
+;
+
+623 } *
+__u
+ = (\1e*è
+__de¡
+;
+
+624 \1a(\1d\12è
+__¤þ\92
+)
+
+627
+__u
+->
+__uc
+ = '\0';
+
+630
+__u
+->
+__usi
+ =
+__¤c0_2
+;
+
+631
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 1);
+
+634
+__u
+->
+__usi
+ =
+__¤c0_2
+;
+
+635
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 2);
+
+636
+__u
+->
+__uc
+ = '\0';
+
+639
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+640
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 3);
+
+643
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+644
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+645
+__u
+->
+__uc
+ = '\0';
+
+648
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+649
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+650
+__u
+->
+__usi
+ =
+__¤c4_2
+;
+
+651
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 1);
+
+654
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+655
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+656
+__u
+->
+__usi
+ =
+__¤c4_2
+;
+
+657
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 2);
+
+658
+__u
+->
+__uc
+ = '\0';
+
+661
+__u
+->
+__ui
+ =
+__¤c0_4
+;
+
+662
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 4);
+
+663
+__u
+->
+__ui
+ =
+__¤c4_4
+;
+
+664
+__u
+ =
+ `__ex\8bnsiÚ__
+ ((\1e*) __u + 3);
+
+667 \15 &
+__u
+->
+__c
+;
+
+668
+ }
+}
+
+670 #iâdeà
+_FORCE_INLINES
+
+
+671 \ 1
+ #__¡pýy_¬gs
+(
+¤c
+) \
+
+672
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR2
+) \
+
+673 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], '\0' } }), \
+
+674
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR3
+) \
+
+675 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+677
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR4
+) \
+
+678 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+679 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], '\0' } }), \
+
+680
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR5
+) \
+
+681 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+682 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3], \
+
+684
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR6
+) \
+
+685 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+686 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3], \
+
+687 ((
+__cڡ
+ \ 5*è(
+¤c
+))[4], '\0' } }), \
+
+688
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR7
+) \
+
+689 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+690 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3], \
+
+691 ((
+__cڡ
+ \ 5*è(
+¤c
+))[4], ((__const \ 5*) (src))[5], \
+
+693
+ `__ex\8bnsiÚ__
+ ((
+__STRING2_COPY_ARR8
+) \
+
+694 { { ((
+__cڡ
+ \ 5*è(
+¤c
+))[0], ((__const \ 5*) (src))[1], \
+
+695 ((
+__cڡ
+ \ 5*è(
+¤c
+))[2], ((__const \ 5*) (src))[3], \
+
+696 ((
+__cڡ
+ \ 5*è(
+¤c
+))[4], ((__const \ 5*) (src))[5], \
+
+697 ((
+__cڡ
+ \ 5*è(
+¤c
+))[6], '\0' } })
+
+ )
+
+699
+__STRING_INLINE
+ \ 5*
+__¡pýy_sm®l
+ (\ 5*,
+__STRING2_COPY_ARR2
+,
+
+700
+__STRING2_COPY_ARR3
+,
+
+701
+__STRING2_COPY_ARR4
+,
+
+702
+__STRING2_COPY_ARR5
+,
+
+703
+__STRING2_COPY_ARR6
+,
+
+704
+__STRING2_COPY_ARR7
+,
+
+705
+__STRING2_COPY_ARR8
+,
+size_t
+);
+
+706
+__STRING_INLINE
+ \ 5*
+
+707
+ $__¡pýy_sm®l
+ (\ 5*
+__de¡
+,
+
+708
+__STRING2_COPY_ARR2
+
+__¤c2
+,
+__STRING2_COPY_ARR3
+
+__¤c3
+,
+
+709
+__STRING2_COPY_ARR4
+
+__¤c4
+,
+__STRING2_COPY_ARR5
+
+__¤c5
+,
+
+710
+__STRING2_COPY_ARR6
+
+__¤c6
+,
+__STRING2_COPY_ARR7
+
+__¤c7
+,
+
+711
+__STRING2_COPY_ARR8
+
+__¤c8
+,
+size_t
+
+__¤þ\92
+)
+
+714 \ 5
+__c
+;
+
+715
+__STRING2_COPY_ARR2
+
+__sÿ2
+;
+
+716
+__STRING2_COPY_ARR3
+
+__sÿ3
+;
+
+717
+__STRING2_COPY_ARR4
+
+__sÿ4
+;
+
+718
+__STRING2_COPY_ARR5
+
+__sÿ5
+;
+
+719
+__STRING2_COPY_ARR6
+
+__sÿ6
+;
+
+720
+__STRING2_COPY_ARR7
+
+__sÿ7
+;
+
+721
+__STRING2_COPY_ARR8
+
+__sÿ8
+;
+
+722 } *
+__u
+ = (\1e*è
+__de¡
+;
+
+723 \1a(\1d\12è
+__¤þ\92
+)
+
+726
+__u
+->
+__c
+ = '\0';
+
+729
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ2
+ =
+__¤c2
+;
+
+732
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ3
+ =
+__¤c3
+;
+
+735
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ4
+ =
+__¤c4
+;
+
+738
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ5
+ =
+__¤c5
+;
+
+741
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ6
+ =
+__¤c6
+;
+
+744
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ7
+ =
+__¤c7
+;
+
+747
+__ex\8bnsiÚ__
+
+__u
+->
+__sÿ8
+ =
+__¤c8
+;
+
+750 \15
+__de¡
+ +
+__¤þ\92
+ - 1;
+
+751
+ }
+}
+
+759 #iâdeà
+_HAVE_STRING_ARCH_¡ºýy
+
+
+760 #ià
+__GNUC_PREREQ
+ (3, 2)
+
+761 \ 1
+ #¡ºýy
+(
+de¡
+,
+¤c
+,
+n
+è
+ `__bu\9et\9a_¡ºýy
+ (de¡, src,\82)
+
+ )
+
+763 \ 1
+ #¡ºýy
+(
+de¡
+,
+¤c
+,
+n
+) \
+
+764 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+¤c
+è&& __bu\9et\9a_cÚ¡ªt_°(
+n
+) \
+
+765 ? (
+ `¡¾\92
+ (
+¤c
+è+ 1 >ð((
+size_t
+è(
+n
+)) \
+
+766 ? (\ 5*è
+ `memýy
+ (
+de¡
+,
+¤c
+,
+n
+) \
+
+767 :
+ `¡ºýy
+ (
+de¡
+,
+¤c
+,
+n
+)) \
+
+768 :
+ `¡ºýy
+ (
+de¡
+,
+¤c
+,
+n
+)))
+
+ )
+
+774 #iâdeà
+_HAVE_STRING_ARCH_¡ºÿt
+
+
+775 #ifdeà
+_USE_STRING_ARCH_¡rchr
+
+
+776 \ 1
+ #¡ºÿt
+(
+de¡
+,
+¤c
+,
+n
+) \
+
+777 (
+ `__ex\8bnsiÚ__
+ ({ \ 5*
+__de¡
+ = (
+de¡
+); \
+
+778
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+¤c
+è&& __bu\9et\9a_cÚ¡ªt_°(
+n
+) \
+
+779 ? (
+ `¡¾\92
+ (
+¤c
+è< ((
+size_t
+è(
+n
+)) \
+
+780 ?
+ `¡rÿt
+ (
+__de¡
+,
+¤c
+) \
+
+781 : (*((\ 5*è
+ `__mempýy
+ (
+ `¡rchr
+ (
+__de¡
+, '\0'), \
+
+782
+¤c
+,
+n
+)èð'\0',
+__de¡
+)) \
+
+783 :
+ `¡ºÿt
+ (
+de¡
+,
+¤c
+,
+n
+); }))
+
+ )
+
+784 #\96ià
+__GNUC_PREREQ
+ (3, 2)
+
+785 \ 1
+ #¡ºÿt
+(
+de¡
+,
+¤c
+,
+n
+è
+ `__bu\9et\9a_¡ºÿt
+ (de¡, src,\82)
+
+ )
+
+787 \ 1
+ #¡ºÿt
+(
+de¡
+,
+¤c
+,
+n
+) \
+
+788 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+¤c
+è&& __bu\9et\9a_cÚ¡ªt_°(
+n
+) \
+
+789 ? (
+ `¡¾\92
+ (
+¤c
+è< ((
+size_t
+è(
+n
+)) \
+
+790 ?
+ `¡rÿt
+ (
+de¡
+,
+¤c
+) \
+
+791 :
+ `¡ºÿt
+ (
+de¡
+,
+¤c
+,
+n
+)) \
+
+792 :
+ `¡ºÿt
+ (
+de¡
+,
+¤c
+,
+n
+)))
+
+ )
+
+798 #iâdeà
+_HAVE_STRING_ARCH_¡rcmp
+
+
+799 #ià
+__GNUC_PREREQ
+ (3, 2)
+
+800 \ 1
+ #¡rcmp
+(
+s1
+,
+s2
+) \
+
+801
+__ex\8bnsiÚ__
+ \
+
+802 ({
+size_t
+
+__s1_Ën
+,
+__s2_Ën
+; \
+
+803 (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s1
+è&& __bu\9et\9a_cÚ¡ªt_°(
+s2
+) \
+
+804 && (
+__s1_Ën
+ =
+ `__bu\9et\9a_¡¾\92
+ (
+s1
+),
+__s2_Ën
+ = __bu\9et\9a_¡¾\92 (
+s2
+), \
+
+805 (!
+ `__¡r\9ag2_1b±r_p
+ (
+s1
+è||
+__s1_Ën
+ >= 4) \
+
+806 && (!
+ `__¡r\9ag2_1b±r_p
+ (
+s2
+è||
+__s2_Ën
+ >= 4)) \
+
+807 ?
+ `__bu\9et\9a_¡rcmp
+ (
+s1
+,
+s2
+) \
+
+808 : (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s1
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s1) \
+
+809 && (
+__s1_Ën
+ =
+ `__bu\9et\9a_¡¾\92
+ (
+s1
+), __s1_len < 4) \
+
+810 ? (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s2
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s2) \
+
+811 ?
+ `__bu\9et\9a_¡rcmp
+ (
+s1
+,
+s2
+) \
+
+812 :
+ `__¡rcmp_cg
+ (
+s1
+,
+s2
+,
+__s1_Ën
+)) \
+
+813 : (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s2
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s2) \
+
+814 && (
+__s2_Ën
+ =
+ `__bu\9et\9a_¡¾\92
+ (
+s2
+), __s2_len < 4) \
+
+815 ? (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s1
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s1) \
+
+816 ?
+ `__bu\9et\9a_¡rcmp
+ (
+s1
+,
+s2
+) \
+
+817 :
+ `__¡rcmp_gc
+ (
+s1
+,
+s2
+,
+__s2_Ën
+)) \
+
+818 :
+ `__bu\9et\9a_¡rcmp
+ (
+s1
+,
+s2
+)))); })
+
+ )
+
+820 \ 1
+ #¡rcmp
+(
+s1
+,
+s2
+) \
+
+821
+__ex\8bnsiÚ__
+ \
+
+822 ({
+size_t
+
+__s1_Ën
+,
+__s2_Ën
+; \
+
+823 (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s1
+è&& __bu\9et\9a_cÚ¡ªt_°(
+s2
+) \
+
+824 && (
+__s1_Ën
+ =
+ `¡¾\92
+ (
+s1
+),
+__s2_Ën
+ = s\8cËÀ(
+s2
+), \
+
+825 (!
+ `__¡r\9ag2_1b±r_p
+ (
+s1
+è||
+__s1_Ën
+ >= 4) \
+
+826 && (!
+ `__¡r\9ag2_1b±r_p
+ (
+s2
+è||
+__s2_Ën
+ >= 4)) \
+
+827 ?
+ `memcmp
+ ((
+__cڡ
+ \ 5*è(
+s1
+), (__cÚ¡ \ 5*è(
+s2
+), \
+
+828 (
+__s1_Ën
+ <
+__s2_Ën
+ ? __s1_len : __s2_len) + 1) \
+
+829 : (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s1
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s1) \
+
+830 && (
+__s1_Ën
+ =
+ `¡¾\92
+ (
+s1
+), __s1_len < 4) \
+
+831 ? (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s2
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s2) \
+
+832 ?
+ `__¡rcmp_cc
+ (
+s1
+,
+s2
+,
+__s1_Ën
+) \
+
+833 :
+ `__¡rcmp_cg
+ (
+s1
+,
+s2
+,
+__s1_Ën
+)) \
+
+834 : (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s2
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s2) \
+
+835 && (
+__s2_Ën
+ =
+ `¡¾\92
+ (
+s2
+), __s2_len < 4) \
+
+836 ? (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s1
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s1) \
+
+837 ?
+ `__¡rcmp_cc
+ (
+s1
+,
+s2
+,
+__s2_Ën
+) \
+
+838 :
+ `__¡rcmp_gc
+ (
+s1
+,
+s2
+,
+__s2_Ën
+)) \
+
+839 :
+ `¡rcmp
+ (
+s1
+,
+s2
+)))); })
+
+ )
+
+842 \ 1
+ #__¡rcmp_cc
+(
+s1
+,
+s2
+,
+l
+) \
+
+843 (
+ `__ex\8bnsiÚ__
+ ({ \14\12
+__»suÉ
+ = \
+
+844 (((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+s1
+))[0] \
+
+845 - ((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*)(
+s2
+))[0]);\
+
+846 ià(
+l
+ > 0 &&
+__»suÉ
+ == 0) \
+
+848
+__»suÉ
+ = (((
+__cڡ
+ \1d\ 5*) \
+
+849 (
+__cڡ
+ \ 5*è(
+s1
+))[1] \
+
+850 - ((
+__cڡ
+ \1d\ 5*) \
+
+851 (
+__cڡ
+ \ 5*è(
+s2
+))[1]); \
+
+852 ià(
+l
+ > 1 &&
+__»suÉ
+ == 0) \
+
+854
+__»suÉ
+ = \
+
+855 (((
+__cڡ
+ \1d\ 5*) \
+
+856 (
+__cڡ
+ \ 5*è(
+s1
+))[2] \
+
+857 - ((
+__cڡ
+ \1d\ 5*) \
+
+858 (
+__cڡ
+ \ 5*è(
+s2
+))[2]); \
+
+859 ià(
+l
+ > 2 &&
+__»suÉ
+ == 0) \
+
+860
+__»suÉ
+ = \
+
+861 (((
+__cڡ
+ \1d\ 5*) \
+
+862 (
+__cڡ
+ \ 5*è(
+s1
+))[3] \
+
+863 - ((
+__cڡ
+ \1d\ 5*) \
+
+864 (
+__cڡ
+ \ 5*è(
+s2
+))[3]); \
+
+867
+__»suÉ
+; }))
+
+ )
+
+869 \ 1
+ #__¡rcmp_cg
+(
+s1
+,
+s2
+,
+l1
+) \
+
+870 (
+ `__ex\8bnsiÚ__
+ ({
+__cڡ
+ \1d\ 5*
+__s2
+ = \
+
+871 (
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+s2
+); \
+
+872 \14\12
+__»suÉ
+ = \
+
+873 (((
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+s1
+))[0] \
+
+874 -
+__s2
+[0]); \
+
+875 ià(
+l1
+ > 0 &&
+__»suÉ
+ == 0) \
+
+877
+__»suÉ
+ = (((
+__cڡ
+ \1d\ 5*) \
+
+878 (
+__cڡ
+ \ 5*è(
+s1
+))[1] -
+__s2
+[1]); \
+
+879 ià(
+l1
+ > 1 &&
+__»suÉ
+ == 0) \
+
+881
+__»suÉ
+ = (((
+__cڡ
+ \1d\ 5*) \
+
+882 (
+__cڡ
+ \ 5*è(
+s1
+))[2] -
+__s2
+[2]);\
+
+883 ià(
+l1
+ > 2 &&
+__»suÉ
+ == 0) \
+
+884
+__»suÉ
+ = (((
+__cڡ
+ \1d\ 5*) \
+
+885 (
+__cڡ
+ \ 5*è(
+s1
+))[3] \
+
+886 -
+__s2
+[3]); \
+
+889
+__»suÉ
+; }))
+
+ )
+
+891 \ 1
+ #__¡rcmp_gc
+(
+s1
+,
+s2
+,
+l2
+) \
+
+892 (
+ `__ex\8bnsiÚ__
+ ({
+__cڡ
+ \1d\ 5*
+__s1
+ = \
+
+893 (
+__cڡ
+ \1d\ 5*è(__cÚ¡ \ 5*è(
+s1
+); \
+
+894 \14\12
+__»suÉ
+ = \
+
+895
+__s1
+[0] - ((
+__cڡ
+ \1d\ 5*) \
+
+896 (
+__cڡ
+ \ 5*è(
+s2
+))[0]; \
+
+897 ià(
+l2
+ > 0 &&
+__»suÉ
+ == 0) \
+
+899
+__»suÉ
+ = (
+__s1
+[1] \
+
+900 - ((
+__cڡ
+ \1d\ 5*) \
+
+901 (
+__cڡ
+ \ 5*è(
+s2
+))[1]); \
+
+902 ià(
+l2
+ > 1 &&
+__»suÉ
+ == 0) \
+
+904
+__»suÉ
+ = \
+
+905 (
+__s1
+[2] - ((
+__cڡ
+ \1d\ 5*) \
+
+906 (
+__cڡ
+ \ 5*è(
+s2
+))[2]); \
+
+907 ià(
+l2
+ > 2 &&
+__»suÉ
+ == 0) \
+
+908
+__»suÉ
+ = \
+
+909 (
+__s1
+[3] \
+
+910 - ((
+__cڡ
+ \1d\ 5*) \
+
+911 (
+__cڡ
+ \ 5*è(
+s2
+))[3]); \
+
+914
+__»suÉ
+; }))
+
+ )
+
+919 #iâdeà
+_HAVE_STRING_ARCH_¡ºcmp
+
+
+920 \ 1
+ #¡ºcmp
+(
+s1
+,
+s2
+,
+n
+) \
+
+921 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+n
+) \
+
+922 && ((
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s1
+) \
+
+923 &&
+ `¡¾\92
+ (
+s1
+è< ((
+size_t
+è(
+n
+))) \
+
+924 || (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s2
+) \
+
+925 &&
+ `¡¾\92
+ (
+s2
+è< ((
+size_t
+è(
+n
+)))) \
+
+926 ?
+ `¡rcmp
+ (
+s1
+,
+s2
+è:
+ `¡ºcmp
+ (s1, s2,
+n
+)))
+
+ )
+
+932 #ià!
+def\9aed
+
+_HAVE_STRING_ARCH_¡rc¥n
+ || def\9aed
+_FORCE_INLINES
+
+
+933 #iâdeà
+_HAVE_STRING_ARCH_¡rc¥n
+
+
+934 #ià
+__GNUC_PREREQ
+ (3, 2)
+
+935 \ 1
+ #¡rc¥n
+(
+s
+,
+»jeù
+) \
+
+936
+__ex\8bnsiÚ__
+ \
+
+937 ({ \ 5
+__r0
+,
+__r1
+,
+__r2
+; \
+
+938 (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+»jeù
+è&&
+ `__¡r\9ag2_1b±r_p
+ (reject) \
+
+939 ? ((
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s)) \
+
+940 ?
+ `__bu\9et\9a_¡rc¥n
+ (
+s
+,
+»jeù
+) \
+
+941 : ((
+__r0
+ = ((
+__cڡ
+ \ 5*è(
+»jeù
+))[0], __r0 == '\0') \
+
+942 ?
+ `¡¾\92
+ (
+s
+) \
+
+943 : ((
+__r1
+ = ((
+__cڡ
+ \ 5*è(
+»jeù
+))[1], __r1 == '\0') \
+
+944 ?
+ `__¡rc¥n_c1
+ (
+s
+,
+__r0
+) \
+
+945 : ((
+__r2
+ = ((
+__cڡ
+ \ 5*è(
+»jeù
+))[2], __r2 == '\0') \
+
+946 ?
+ `__¡rc¥n_c2
+ (
+s
+,
+__r0
+,
+__r1
+) \
+
+947 : (((
+__cڡ
+ \ 5*è(
+»jeù
+))[3] == '\0' \
+
+948 ?
+ `__¡rc¥n_c3
+ (
+s
+,
+__r0
+,
+__r1
+,
+__r2
+) \
+
+949 :
+ `__bu\9et\9a_¡rc¥n
+ (
+s
+,
+»jeù
+)))))) \
+
+950 :
+ `__bu\9et\9a_¡rc¥n
+ (
+s
+,
+»jeù
+)); })
+
+ )
+
+952 \ 1
+ #¡rc¥n
+(
+s
+,
+»jeù
+) \
+
+953
+__ex\8bnsiÚ__
+ \
+
+954 ({ \ 5
+__r0
+,
+__r1
+,
+__r2
+; \
+
+955 (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+»jeù
+è&&
+ `__¡r\9ag2_1b±r_p
+ (reject) \
+
+956 ? ((
+__r0
+ = ((
+__cڡ
+ \ 5*è(
+»jeù
+))[0], __r0 == '\0') \
+
+957 ?
+ `¡¾\92
+ (
+s
+) \
+
+958 : ((
+__r1
+ = ((
+__cڡ
+ \ 5*è(
+»jeù
+))[1], __r1 == '\0') \
+
+959 ?
+ `__¡rc¥n_c1
+ (
+s
+,
+__r0
+) \
+
+960 : ((
+__r2
+ = ((
+__cڡ
+ \ 5*è(
+»jeù
+))[2], __r2 == '\0') \
+
+961 ?
+ `__¡rc¥n_c2
+ (
+s
+,
+__r0
+,
+__r1
+) \
+
+962 : (((
+__cڡ
+ \ 5*è(
+»jeù
+))[3] == '\0' \
+
+963 ?
+ `__¡rc¥n_c3
+ (
+s
+,
+__r0
+,
+__r1
+,
+__r2
+) \
+
+964 :
+ `¡rc¥n
+ (
+s
+,
+»jeù
+))))) \
+
+965 :
+ `¡rc¥n
+ (
+s
+,
+»jeù
+)); })
+
+ )
+
+969
+__STRING_INLINE
+
+size_t
+
+__¡rc¥n_c1
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__»jeù
+);
+
+970
+__STRING_INLINE
+
+size_t
+
+
+971
+ $__¡rc¥n_c1
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__»jeù
+)
+
+973 \14
+size_t
+
+__»suÉ
+ = 0;
+
+974 \1f
+__s
+[
+__»suÉ
+] !ð'\0' && __s[__»suÉ] !ð
+__»jeù
+)
+
+975 ++
+__»suÉ
+;
+
+976 \15
+__»suÉ
+;
+
+977
+ }
+}
+
+979
+__STRING_INLINE
+
+size_t
+
+__¡rc¥n_c2
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__»jeù1
+,
+
+980 \12
+__»jeù2
+);
+
+981
+__STRING_INLINE
+
+size_t
+
+
+982
+ $__¡rc¥n_c2
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__»jeù1
+, \12
+__»jeù2
+)
+
+984 \14
+size_t
+
+__»suÉ
+ = 0;
+
+985 \1f
+__s
+[
+__»suÉ
+] !ð'\0' && __s[__»suÉ] !ð
+__»jeù1
+
+
+986 &&
+__s
+[
+__»suÉ
+] !ð
+__»jeù2
+)
+
+987 ++
+__»suÉ
+;
+
+988 \15
+__»suÉ
+;
+
+989
+ }
+}
+
+991
+__STRING_INLINE
+
+size_t
+
+__¡rc¥n_c3
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__»jeù1
+,
+
+992 \12
+__»jeù2
+, \12
+__»jeù3
+);
+
+993
+__STRING_INLINE
+
+size_t
+
+
+994
+ $__¡rc¥n_c3
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__»jeù1
+, \12
+__»jeù2
+,
+
+995 \12
+__»jeù3
+)
+
+997 \14
+size_t
+
+__»suÉ
+ = 0;
+
+998 \1f
+__s
+[
+__»suÉ
+] !ð'\0' && __s[__»suÉ] !ð
+__»jeù1
+
+
+999 &&
+__s
+[
+__»suÉ
+] !ð
+__»jeù2
+ && __s[__»suÉ] !ð
+__»jeù3
+)
+
+1000 ++
+__»suÉ
+;
+
+1001 \15
+__»suÉ
+;
+
+1002
+ }
+}
+
+1008 #ià!
+def\9aed
+
+_HAVE_STRING_ARCH_¡r¥n
+ || def\9aed
+_FORCE_INLINES
+
+
+1009 #iâdeà
+_HAVE_STRING_ARCH_¡r¥n
+
+
+1010 #ià
+__GNUC_PREREQ
+ (3, 2)
+
+1011 \ 1
+ #¡r¥n
+(
+s
+,
+acû±
+) \
+
+1012
+__ex\8bnsiÚ__
+ \
+
+1013 ({ \ 5
+__a0
+,
+__a1
+,
+__a2
+; \
+
+1014 (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+acû±
+è&&
+ `__¡r\9ag2_1b±r_p
+ (accept) \
+
+1015 ? ((
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s)) \
+
+1016 ?
+ `__bu\9et\9a_¡r¥n
+ (
+s
+,
+acû±
+) \
+
+1017 : ((
+__a0
+ = ((
+__cڡ
+ \ 5*è(
+acû±
+))[0], __a0 == '\0') \
+
+1018 ? ((\1eè(
+s
+), 0) \
+
+1019 : ((
+__a1
+ = ((
+__cڡ
+ \ 5*è(
+acû±
+))[1], __a1 == '\0') \
+
+1020 ?
+ `__¡r¥n_c1
+ (
+s
+,
+__a0
+) \
+
+1021 : ((
+__a2
+ = ((
+__cڡ
+ \ 5*è(
+acû±
+))[2], __a2 == '\0') \
+
+1022 ?
+ `__¡r¥n_c2
+ (
+s
+,
+__a0
+,
+__a1
+) \
+
+1023 : (((
+__cڡ
+ \ 5*è(
+acû±
+))[3] == '\0' \
+
+1024 ?
+ `__¡r¥n_c3
+ (
+s
+,
+__a0
+,
+__a1
+,
+__a2
+) \
+
+1025 :
+ `__bu\9et\9a_¡r¥n
+ (
+s
+,
+acû±
+)))))) \
+
+1026 :
+ `__bu\9et\9a_¡r¥n
+ (
+s
+,
+acû±
+)); })
+
+ )
+
+1028 \ 1
+ #¡r¥n
+(
+s
+,
+acû±
+) \
+
+1029
+__ex\8bnsiÚ__
+ \
+
+1030 ({ \ 5
+__a0
+,
+__a1
+,
+__a2
+; \
+
+1031 (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+acû±
+è&&
+ `__¡r\9ag2_1b±r_p
+ (accept) \
+
+1032 ? ((
+__a0
+ = ((
+__cڡ
+ \ 5*è(
+acû±
+))[0], __a0 == '\0') \
+
+1033 ? ((\1eè(
+s
+), 0) \
+
+1034 : ((
+__a1
+ = ((
+__cڡ
+ \ 5*è(
+acû±
+))[1], __a1 == '\0') \
+
+1035 ?
+ `__¡r¥n_c1
+ (
+s
+,
+__a0
+) \
+
+1036 : ((
+__a2
+ = ((
+__cڡ
+ \ 5*è(
+acû±
+))[2], __a2 == '\0') \
+
+1037 ?
+ `__¡r¥n_c2
+ (
+s
+,
+__a0
+,
+__a1
+) \
+
+1038 : (((
+__cڡ
+ \ 5*è(
+acû±
+))[3] == '\0' \
+
+1039 ?
+ `__¡r¥n_c3
+ (
+s
+,
+__a0
+,
+__a1
+,
+__a2
+) \
+
+1040 :
+ `¡r¥n
+ (
+s
+,
+acû±
+))))) \
+
+1041 :
+ `¡r¥n
+ (
+s
+,
+acû±
+)); })
+
+ )
+
+1045
+__STRING_INLINE
+
+size_t
+
+__¡r¥n_c1
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__acû±
+);
+
+1046
+__STRING_INLINE
+
+size_t
+
+
+1047
+ $__¡r¥n_c1
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__acû±
+)
+
+1049 \14
+size_t
+
+__»suÉ
+ = 0;
+
+1051 \1f
+__s
+[
+__»suÉ
+] =ð
+__acû±
+)
+
+1052 ++
+__»suÉ
+;
+
+1053 \15
+__»suÉ
+;
+
+1054
+ }
+}
+
+1056
+__STRING_INLINE
+
+size_t
+
+__¡r¥n_c2
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__acû±1
+,
+
+1057 \12
+__acû±2
+);
+
+1058
+__STRING_INLINE
+
+size_t
+
+
+1059
+ $__¡r¥n_c2
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__acû±1
+, \12
+__acû±2
+)
+
+1061 \14
+size_t
+
+__»suÉ
+ = 0;
+
+1063 \1f
+__s
+[
+__»suÉ
+] =ð
+__acû±1
+ || __s[__»suÉ] =ð
+__acû±2
+)
+
+1064 ++
+__»suÉ
+;
+
+1065 \15
+__»suÉ
+;
+
+1066
+ }
+}
+
+1068
+__STRING_INLINE
+
+size_t
+
+__¡r¥n_c3
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__acû±1
+,
+
+1069 \12
+__acû±2
+, \12
+__acû±3
+);
+
+1070
+__STRING_INLINE
+
+size_t
+
+
+1071
+ $__¡r¥n_c3
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__acû±1
+, \12
+__acû±2
+, \12
+__acû±3
+)
+
+1073 \14
+size_t
+
+__»suÉ
+ = 0;
+
+1075 \1f
+__s
+[
+__»suÉ
+] =ð
+__acû±1
+ || __s[__»suÉ] =ð
+__acû±2
+
+
+1076 ||
+__s
+[
+__»suÉ
+] =ð
+__acû±3
+)
+
+1077 ++
+__»suÉ
+;
+
+1078 \15
+__»suÉ
+;
+
+1079
+ }
+}
+
+1084 #ià!
+def\9aed
+
+_HAVE_STRING_ARCH_¡½brk
+ || def\9aed
+_FORCE_INLINES
+
+
+1085 #iâdeà
+_HAVE_STRING_ARCH_¡½brk
+
+
+1086 #ià
+__GNUC_PREREQ
+ (3, 2)
+
+1087 \ 1
+ #¡½brk
+(
+s
+,
+acû±
+) \
+
+1088
+__ex\8bnsiÚ__
+ \
+
+1089 ({ \ 5
+__a0
+,
+__a1
+,
+__a2
+; \
+
+1090 (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+acû±
+è&&
+ `__¡r\9ag2_1b±r_p
+ (accept) \
+
+1091 ? ((
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s)) \
+
+1092 ?
+ `__bu\9et\9a_¡½brk
+ (
+s
+,
+acû±
+) \
+
+1093 : ((
+__a0
+ = ((
+__cڡ
+ \ 5*è(
+acû±
+))[0], __a0 == '\0') \
+
+1094 ? ((\1eè(
+s
+), (\ 5*è
+NULL
+) \
+
+1095 : ((
+__a1
+ = ((
+__cڡ
+ \ 5*è(
+acû±
+))[1], __a1 == '\0') \
+
+1096 ?
+ `__bu\9et\9a_¡rchr
+ (
+s
+,
+__a0
+) \
+
+1097 : ((
+__a2
+ = ((
+__cڡ
+ \ 5*è(
+acû±
+))[2], __a2 == '\0') \
+
+1098 ?
+ `__¡½brk_c2
+ (
+s
+,
+__a0
+,
+__a1
+) \
+
+1099 : (((
+__cڡ
+ \ 5*è(
+acû±
+))[3] == '\0' \
+
+1100 ?
+ `__¡½brk_c3
+ (
+s
+,
+__a0
+,
+__a1
+,
+__a2
+) \
+
+1101 :
+ `__bu\9et\9a_¡½brk
+ (
+s
+,
+acû±
+)))))) \
+
+1102 :
+ `__bu\9et\9a_¡½brk
+ (
+s
+,
+acû±
+)); })
+
+ )
+
+1104 \ 1
+ #¡½brk
+(
+s
+,
+acû±
+) \
+
+1105
+__ex\8bnsiÚ__
+ \
+
+1106 ({ \ 5
+__a0
+,
+__a1
+,
+__a2
+; \
+
+1107 (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+acû±
+è&&
+ `__¡r\9ag2_1b±r_p
+ (accept) \
+
+1108 ? ((
+__a0
+ = ((
+__cڡ
+ \ 5*è(
+acû±
+))[0], __a0 == '\0') \
+
+1109 ? ((\1eè(
+s
+), (\ 5*è
+NULL
+) \
+
+1110 : ((
+__a1
+ = ((
+__cڡ
+ \ 5*è(
+acû±
+))[1], __a1 == '\0') \
+
+1111 ?
+ `¡rchr
+ (
+s
+,
+__a0
+) \
+
+1112 : ((
+__a2
+ = ((
+__cڡ
+ \ 5*è(
+acû±
+))[2], __a2 == '\0') \
+
+1113 ?
+ `__¡½brk_c2
+ (
+s
+,
+__a0
+,
+__a1
+) \
+
+1114 : (((
+__cڡ
+ \ 5*è(
+acû±
+))[3] == '\0' \
+
+1115 ?
+ `__¡½brk_c3
+ (
+s
+,
+__a0
+,
+__a1
+,
+__a2
+) \
+
+1116 :
+ `¡½brk
+ (
+s
+,
+acû±
+))))) \
+
+1117 :
+ `¡½brk
+ (
+s
+,
+acû±
+)); })
+
+ )
+
+1121
+__STRING_INLINE
+ \ 5*
+__¡½brk_c2
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__acû±1
+,
+
+1122 \12
+__acû±2
+);
+
+1123
+__STRING_INLINE
+ \ 5*
+
+1124
+ $__¡½brk_c2
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__acû±1
+, \12
+__acû±2
+)
+
+1127 \1f*
+__s
+ !ð'\0' && *__ !ð
+__acû±1
+ && *__ !ð
+__acû±2
+)
+
+1128 ++
+__s
+;
+
+1129 \15 *
+__s
+ =ð'\0' ?
+NULL
+ : (\ 5*è(
+size_t
+) __s;
+
+1130
+ }
+}
+
+1132
+__STRING_INLINE
+ \ 5*
+__¡½brk_c3
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__acû±1
+,
+
+1133 \12
+__acû±2
+, \12
+__acû±3
+);
+
+1134
+__STRING_INLINE
+ \ 5*
+
+1135
+ $__¡½brk_c3
+ (
+__cڡ
+ \ 5*
+__s
+, \12
+__acû±1
+, \12
+__acû±2
+,
+
+1136 \12
+__acû±3
+)
+
+1139 \1f*
+__s
+ !ð'\0' && *__ !ð
+__acû±1
+ && *__ !ð
+__acû±2
+
+
+1140 && *
+__s
+ !ð
+__acû±3
+)
+
+1141 ++
+__s
+;
+
+1142 \15 *
+__s
+ =ð'\0' ?
+NULL
+ : (\ 5*è(
+size_t
+) __s;
+
+1143
+ }
+}
+
+1149 #ià!
+def\9aed
+
+_HAVE_STRING_ARCH_¡r¡r
+ && !
+__GNUC_PREREQ
+ (2, 97)
+
+1150 \ 1
+ #¡r¡r
+(
+hay¡ack
+,
+ÃedË
+) \
+
+1151 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+ÃedË
+è&&
+ `__¡r\9ag2_1b±r_p
+ (needle) \
+
+1152 ? (((
+__cڡ
+ \ 5*è(
+ÃedË
+))[0] == '\0' \
+
+1153 ? (\ 5*è(
+size_t
+è(
+hay¡ack
+) \
+
+1154 : (((
+__cڡ
+ \ 5*è(
+ÃedË
+))[1] == '\0' \
+
+1155 ?
+ `¡rchr
+ (
+hay¡ack
+, \
+
+1156 ((
+__cڡ
+ \ 5*è(
+ÃedË
+))[0]) \
+
+1157 :
+ `¡r¡r
+ (
+hay¡ack
+,
+ÃedË
+))) \
+
+1158 :
+ `¡r¡r
+ (
+hay¡ack
+,
+ÃedË
+)))
+
+ )
+
+1162 #ià!
+def\9aed
+
+_HAVE_STRING_ARCH_¡¹ok_r
+ || def\9aed
+_FORCE_INLINES
+
+
+1163 #iâdeà
+_HAVE_STRING_ARCH_¡¹ok_r
+
+
+1164 \ 1
+ #__¡¹ok_r
+(
+s
+,
+£p
+,
+Ãx\8d
+) \
+
+1165 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+£p
+è&&
+ `__¡r\9ag2_1b±r_p
+ (sep) \
+
+1166 && ((
+__cڡ
+ \ 5*è(
+£p
+))[0] != '\0' \
+
+1167 && ((
+__cڡ
+ \ 5*è(
+£p
+))[1] == '\0' \
+
+1168 ?
+ `__¡¹ok_r_1c
+ (
+s
+, ((
+__cڡ
+ \ 5*è(
+£p
+))[0],
+Ãx\8d
+) \
+
+1169 :
+ `__¡¹ok_r
+ (
+s
+,
+£p
+,
+Ãx\8d
+)))
+
+ )
+
+1172
+__STRING_INLINE
+ \ 5*
+__¡¹ok_r_1c
+ (\ 5*
+__s
+, \ 5
+__£p
+, \ 5**
+__Ãx\8d
+);
+
+1173
+__STRING_INLINE
+ \ 5*
+
+1174
+ $__¡¹ok_r_1c
+ (\ 5*
+__s
+, \ 5
+__£p
+, \ 5**
+__Ãx\8d
+)
+
+1176 \ 5*
+__»suÉ
+;
+
+1177 ià(
+__s
+ =ð
+NULL
+)
+
+1178
+__s
+ = *
+__Ãx\8d
+;
+
+1179 \1f*
+__s
+ =ð
+__£p
+)
+
+1180 ++
+__s
+;
+
+1181
+__»suÉ
+ =
+NULL
+;
+
+1182 ià(*
+__s
+ != '\0')
+
+1184
+__»suÉ
+ =
+__s
+++;
+
+1185 \1f*
+__s
+ != '\0')
+
+1186 ià(*
+__s
+++ =ð
+__£p
+)
+
+1188
+__s
+[-1] = '\0';
+
+1192 *
+__Ãx\8d
+ =
+__s
+;
+
+1193 \15
+__»suÉ
+;
+
+1194
+ }
+}
+
+1195 #ià
+def\9aed
+
+__USE_POSIX
+ || def\9aed
+__USE_MISC
+
+
+1196 \ 1
+ #¡¹ok_r
+(
+s
+,
+£p
+,
+Ãx\8d
+è
+ `__¡¹ok_r
+ (s, s\95,\82ex\8d)
+
+ )
+
+1201 #ià!
+def\9aed
+
+_HAVE_STRING_ARCH_¡r£p
+ || def\9aed
+_FORCE_INLINES
+
+
+1202 #iâdeà
+_HAVE_STRING_ARCH_¡r£p
+
+
+1204 \r\ 5*
+__¡r£p_g
+ (\ 5**
+__¡r\9agp
+,
+__cڡ
+ \ 5*
+__d\96im
+);
+
+1205 \ 1
+ #__¡r£p
+(
+s
+,
+»jeù
+) \
+
+1206
+__ex\8bnsiÚ__
+ \
+
+1207 ({ \ 5
+__r0
+,
+__r1
+,
+__r2
+; \
+
+1208 (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+»jeù
+è&&
+ `__¡r\9ag2_1b±r_p
+ (reject) \
+
+1209 && (
+__r0
+ = ((
+__cڡ
+ \ 5*è(
+»jeù
+))[0], \
+
+1210 ((
+__cڡ
+ \ 5*è(
+»jeù
+))[0] != '\0') \
+
+1211 ? ((
+__r1
+ = ((
+__cڡ
+ \ 5*è(
+»jeù
+))[1], \
+
+1212 ((
+__cڡ
+ \ 5*è(
+»jeù
+))[1] == '\0') \
+
+1213 ?
+ `__¡r£p_1c
+ (
+s
+,
+__r0
+) \
+
+1214 : ((
+__r2
+ = ((
+__cڡ
+ \ 5*è(
+»jeù
+))[2], __r2 == '\0') \
+
+1215 ?
+ `__¡r£p_2c
+ (
+s
+,
+__r0
+,
+__r1
+) \
+
+1216 : (((
+__cڡ
+ \ 5*è(
+»jeù
+))[3] == '\0' \
+
+1217 ?
+ `__¡r£p_3c
+ (
+s
+,
+__r0
+,
+__r1
+,
+__r2
+) \
+
+1218 :
+ `__¡r£p_g
+ (
+s
+,
+»jeù
+)))) \
+
+1219 :
+ `__¡r£p_g
+ (
+s
+,
+»jeù
+)); })
+
+ )
+
+1222
+__STRING_INLINE
+ \ 5*
+__¡r£p_1c
+ (\ 5**
+__s
+, \ 5
+__»jeù
+);
+
+1223
+__STRING_INLINE
+ \ 5*
+
+1224
+ $__¡r£p_1c
+ (\ 5**
+__s
+, \ 5
+__»jeù
+)
+
+1226 \14\ 5*
+__»tv®
+ = *
+__s
+;
+
+1227 ià(
+__»tv®
+ !ð
+NULL
+ && (*
+__s
+ =
+ `¡rchr
+ (__»tv®,
+__»jeù
+)) != NULL)
+
+1228 *(*
+__s
+)++ = '\0';
+
+1229 \15
+__»tv®
+;
+
+1230
+ }
+}
+
+1232
+__STRING_INLINE
+ \ 5*
+__¡r£p_2c
+ (\ 5**
+__s
+, \ 5
+__»jeù1
+, \ 5
+__»jeù2
+);
+
+1233
+__STRING_INLINE
+ \ 5*
+
+1234
+ $__¡r£p_2c
+ (\ 5**
+__s
+, \ 5
+__»jeù1
+, \ 5
+__»jeù2
+)
+
+1236 \14\ 5*
+__»tv®
+ = *
+__s
+;
+
+1237 ià(
+__»tv®
+ !ð
+NULL
+)
+
+1239 \14\ 5*
+__ý
+ =
+__»tv®
+;
+
+1242 ià(*
+__ý
+ == '\0')
+
+1244
+__ý
+ =
+NULL
+;
+
+1247 ià(*
+__ý
+ =ð
+__»jeù1
+ || *__ý =ð
+__»jeù2
+)
+
+1249 *
+__ý
+++ = '\0';
+
+1252 ++
+__ý
+;
+
+1254 *
+__s
+ =
+__ý
+;
+
+1256 \15
+__»tv®
+;
+
+1257
+ }
+}
+
+1259
+__STRING_INLINE
+ \ 5*
+__¡r£p_3c
+ (\ 5**
+__s
+, \ 5
+__»jeù1
+, \ 5
+__»jeù2
+,
+
+1260 \ 5
+__»jeù3
+);
+
+1261
+__STRING_INLINE
+ \ 5*
+
+1262
+ $__¡r£p_3c
+ (\ 5**
+__s
+, \ 5
+__»jeù1
+, \ 5
+__»jeù2
+, \ 5
+__»jeù3
+)
+
+1264 \14\ 5*
+__»tv®
+ = *
+__s
+;
+
+1265 ià(
+__»tv®
+ !ð
+NULL
+)
+
+1267 \14\ 5*
+__ý
+ =
+__»tv®
+;
+
+1270 ià(*
+__ý
+ == '\0')
+
+1272
+__ý
+ =
+NULL
+;
+
+1275 ià(*
+__ý
+ =ð
+__»jeù1
+ || *__ý =ð
+__»jeù2
+ || *__ý =ð
+__»jeù3
+)
+
+1277 *
+__ý
+++ = '\0';
+
+1280 ++
+__ý
+;
+
+1282 *
+__s
+ =
+__ý
+;
+
+1284 \15
+__»tv®
+;
+
+1285
+ }
+}
+
+1286 #ifdeà
+__USE_BSD
+
+
+1287 \ 1
+ #¡r£p
+(
+s
+,
+»jeù
+è
+ `__¡r£p
+ (s,\84ejeù)
+
+ )
+
+1294 #ifdeà
+__USE_MISC
+
+
+1296 #ià!
+def\9aed
+
+_HAVE_STRING_ARCH_¡rdup
+ || !def\9aed
+_HAVE_STRING_ARCH_¡ºdup
+
+
+1297 \ 1
+ #__Ãed_m®loc_ªd_ÿÎoc
+
+
+ )
+
+1298 \ 2
+ ~<¡dlib.h
+>
+
+1301 #iâdeà
+_HAVE_STRING_ARCH_¡rdup
+
+
+1303 \r\ 5*
+ $__¡rdup
+ (
+__cڡ
+ \ 5*
+__¡r\9ag
+è
+__THROW
+
+__©\8cibu\8b_m®loc__
+;
+
+1304 \ 1
+ #__¡rdup
+(
+s
+) \
+
+1305 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s) \
+
+1306 ? (((
+__cڡ
+ \ 5*è(
+s
+))[0] == '\0' \
+
+1307 ? (\ 5*è
+ `ÿÎoc
+ ((
+size_t
+) 1, (size_t) 1) \
+
+1308 : ({
+size_t
+
+__Ën
+ =
+ `¡¾\92
+ (
+s
+) + 1; \
+
+1309 \ 5*
+__»tv®
+ = (\ 5*è
+ `m®loc
+ (
+__Ën
+); \
+
+1310 ià(
+__»tv®
+ !ð
+NULL
+) \
+
+1311
+__»tv®
+ = (\ 5*è
+ `memýy
+ (__»tv®,
+s
+,
+__Ën
+); \
+
+1312
+__»tv®
+;
+ }
+})) \
+
+1313 :
+ `__¡rdup
+ (
+s
+)))
+
+ )
+
+1315 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_BSD
+ || def\9aed
+__USE_XOPEN_EXTENDED
+
+
+1316 \ 1
+ #¡rdup
+(
+s
+è
+ `__¡rdup
+ (s)
+
+ )
+
+1320 #iâdeà
+_HAVE_STRING_ARCH_¡ºdup
+
+
+1322 \r\ 5*
+ $__¡ºdup
+ (
+__cڡ
+ \ 5*
+__¡r\9ag
+,
+size_t
+
+__n
+)
+
+1323
+__THROW
+
+__©\8cibu\8b_m®loc__
+;
+
+1324 \ 1
+ #__¡ºdup
+(
+s
+,
+n
+) \
+
+1325 (
+ `__ex\8bnsiÚ__
+ (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+s
+è&&
+ `__¡r\9ag2_1b±r_p
+ (s) \
+
+1326 ? (((
+__cڡ
+ \ 5*è(
+s
+))[0] == '\0' \
+
+1327 ? (\ 5*è
+ `ÿÎoc
+ ((
+size_t
+) 1, (size_t) 1) \
+
+1328 : ({
+size_t
+
+__Ën
+ =
+ `¡¾\92
+ (
+s
+) + 1; \
+
+1329
+size_t
+
+__n
+ = (
+n
+); \
+
+1330 \ 5*
+__»tv®
+; \
+
+1331 ià(
+__n
+ <
+__Ën
+) \
+
+1332
+__Ën
+ =
+__n
+ + 1; \
+
+1333
+__»tv®
+ = (\ 5*è
+ `m®loc
+ (
+__Ën
+); \
+
+1334 ià(
+__»tv®
+ !ð
+NULL
+) \
+
+1336
+__»tv®
+[
+__Ën
+ - 1] = '\0'; \
+
+1337
+__»tv®
+ = (\ 5*è
+ `memýy
+ (__»tv®,
+s
+, \
+
+1338
+__Ën
+ - 1); \
+
+1340
+__»tv®
+;
+ }
+})) \
+
+1341 :
+ `__¡ºdup
+ (
+s
+,
+n
+)))
+
+ )
+
+1343 #ifdeà
+__USE_GNU
+
+
+1344 \ 1
+ #¡ºdup
+(
+s
+,
+n
+è
+ `__¡ºdup
+ (s,\82)
+
+ )
+
+1350 #iâdeà
+_FORCE_INLINES
+
+
+1351 #undeà
+__STRING_INLINE
+
+
+ @/usr/include/bits/string3.h
+
+19 #iâdeà
+_STRING_H
+
+
+23
+__w¬ndeþ
+ (
+__w¬n_mem£t_z\94o_Ën
+,
+
+26 #iâdeà
+__ýlu¥lus
+
+
+30 #undeà
+memýy
+
+
+31 #undeà
+memmove
+
+
+32 #undeà
+mem£t
+
+
+33 #undeà
+¡rÿt
+
+
+34 #undeà
+¡rýy
+
+
+35 #undeà
+¡ºÿt
+
+
+36 #undeà
+¡ºýy
+
+
+37 #ifdeà
+__USE_GNU
+
+
+38 #undeà
+mempýy
+
+
+39 #undeà
+¡pýy
+
+
+41 #ifdeà
+__USE_BSD
+
+
+42 #undeà
+bcÝy
+
+
+43 #undeà
+bz\94o
+
+
+48
+__ex\8bº_®ways_\9al\9ae
+ \1e*
+
+49
+__NTH
+ (
+ $memýy
+ (\1e*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \1e*__»¡riù
+__¤c
+,
+
+50
+size_t
+
+__Ën
+))
+
+52 \15
+ `__bu\9et\9a___memýy_chk
+ (
+__de¡
+,
+__¤c
+,
+__Ën
+,
+ `__bos0
+ (__dest));
+
+53
+ }
+}
+
+55
+__ex\8bº_®ways_\9al\9ae
+ \1e*
+
+56
+__NTH
+ (
+ $memmove
+ (\1e*
+__de¡
+,
+__cڡ
+ \1e*
+__¤c
+,
+size_t
+
+__Ën
+))
+
+58 \15
+ `__bu\9et\9a___memmove_chk
+ (
+__de¡
+,
+__¤c
+,
+__Ën
+,
+ `__bos0
+ (__dest));
+
+59
+ }
+}
+
+61 #ifdeà
+__USE_GNU
+
+
+62
+__ex\8bº_®ways_\9al\9ae
+ \1e*
+
+63
+__NTH
+ (
+ $mempýy
+ (\1e*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \1e*__»¡riù
+__¤c
+,
+
+64
+size_t
+
+__Ën
+))
+
+66 \15
+ `__bu\9et\9a___mempýy_chk
+ (
+__de¡
+,
+__¤c
+,
+__Ën
+,
+ `__bos0
+ (__dest));
+
+67
+ }
+}
+
+76
+__ex\8bº_®ways_\9al\9ae
+ \1e*
+
+77
+__NTH
+ (
+ $mem£t
+ (\1e*
+__de¡
+, \12
+__ch
+,
+size_t
+
+__Ën
+))
+
+79 ià(
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__Ën
+) && __len == 0
+
+80 && (!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__ch
+) || __ch != 0))
+
+82
+ `__w¬n_mem£t_z\94o_Ën
+ ();
+
+83 \15
+__de¡
+;
+
+85 \15
+ `__bu\9et\9a___mem£t_chk
+ (
+__de¡
+,
+__ch
+,
+__Ën
+,
+ `__bos0
+ (__dest));
+
+86
+ }
+}
+
+88 #ifdeà
+__USE_BSD
+
+
+89
+__ex\8bº_®ways_\9al\9ae
+ \1e
+
+90
+__NTH
+ (
+ $bcÝy
+ (
+__cڡ
+ \1e*
+__¤c
+, \1e*
+__de¡
+,
+size_t
+
+__Ën
+))
+
+92 (\1eè
+ `__bu\9et\9a___memmove_chk
+ (
+__de¡
+,
+__¤c
+,
+__Ën
+,
+ `__bos0
+ (__dest));
+
+93
+ }
+}
+
+95
+__ex\8bº_®ways_\9al\9ae
+ \1e
+
+96
+__NTH
+ (
+ $bz\94o
+ (\1e*
+__de¡
+,
+size_t
+
+__Ën
+))
+
+98 (\1eè
+ `__bu\9et\9a___mem£t_chk
+ (
+__de¡
+, '\0',
+__Ën
+,
+ `__bos0
+ (__dest));
+
+99
+ }
+}
+
+102
+__ex\8bº_®ways_\9al\9ae
+ \ 5*
+
+103
+__NTH
+ (
+ $¡rýy
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \ 5*__»¡riù
+__¤c
+))
+
+105 \15
+ `__bu\9et\9a___¡rýy_chk
+ (
+__de¡
+,
+__¤c
+,
+ `__bos
+ (__dest));
+
+106
+ }
+}
+
+108 #ifdeà
+__USE_GNU
+
+
+109
+__ex\8bº_®ways_\9al\9ae
+ \ 5*
+
+110
+__NTH
+ (
+ $¡pýy
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \ 5*__»¡riù
+__¤c
+))
+
+112 \15
+ `__bu\9et\9a___¡pýy_chk
+ (
+__de¡
+,
+__¤c
+,
+ `__bos
+ (__dest));
+
+113
+ }
+}
+
+117
+__ex\8bº_®ways_\9al\9ae
+ \ 5*
+
+118
+__NTH
+ (
+ $¡ºýy
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \ 5*__»¡riù
+__¤c
+,
+
+119
+size_t
+
+__Ën
+))
+
+121 \15
+ `__bu\9et\9a___¡ºýy_chk
+ (
+__de¡
+,
+__¤c
+,
+__Ën
+,
+ `__bos
+ (__dest));
+
+122
+ }
+}
+
+125 \r\ 5*
+ $__¡²ýy_chk
+ (\ 5*
+__de¡
+,
+__cڡ
+ \ 5*
+__¤c
+,
+size_t
+
+__n
+,
+
+126
+size_t
+
+__de¡Ën
+è
+__THROW
+;
+
+127 \r\ 5*
+ `__REDIRECT_NTH
+ (
+__¡²ýy_®\9fs
+, (\ 5*
+__de¡
+,
+
+128
+__cڡ
+ \ 5*
+__¤c
+,
+
+129
+size_t
+
+__n
+),
+¡²ýy
+);
+
+131
+__ex\8bº_®ways_\9al\9ae
+ \ 5*
+
+132
+ `__NTH
+ (
+ $¡²ýy
+ (\ 5*
+__de¡
+,
+__cڡ
+ \ 5*
+__¤c
+,
+size_t
+
+__n
+))
+
+134 ià(
+ `__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1
+
+135 && (!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+è|| __À<ð
+ `__bos
+ (
+__de¡
+)))
+
+136 \15
+ `__¡²ýy_chk
+ (
+__de¡
+,
+__¤c
+,
+__n
+,
+ `__bos
+ (__dest));
+
+137 \15
+ `__¡²ýy_®\9fs
+ (
+__de¡
+,
+__¤c
+,
+__n
+);
+
+138
+ }
+}
+
+141
+__ex\8bº_®ways_\9al\9ae
+ \ 5*
+
+142
+__NTH
+ (
+ $¡rÿt
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \ 5*__»¡riù
+__¤c
+))
+
+144 \15
+ `__bu\9et\9a___¡rÿt_chk
+ (
+__de¡
+,
+__¤c
+,
+ `__bos
+ (__dest));
+
+145
+ }
+}
+
+148
+__ex\8bº_®ways_\9al\9ae
+ \ 5*
+
+149
+__NTH
+ (
+ $¡ºÿt
+ (\ 5*
+__»¡riù
+
+__de¡
+,
+__cڡ
+ \ 5*__»¡riù
+__¤c
+,
+
+150
+size_t
+
+__Ën
+))
+
+152 \15
+ `__bu\9et\9a___¡ºÿt_chk
+ (
+__de¡
+,
+__¤c
+,
+__Ën
+,
+ `__bos
+ (__dest));
+
+153
+ }
+}
+
+ @/usr/include/bits/sys_errlist.h
+
+20 #iâdeà
+_STDIO_H
+
+
+26 #ifdeà
+__USE_BSD
+
+
+27 \r\12
+sys_ü
+;
+
+28 \r
+__cڡ
+ \ 5*__cڡ
+sys_\94¾i¡
+[];
+
+30 #ifdeà
+__USE_GNU
+
+
+31 \r\12
+_sys_ü
+;
+
+32 \r
+__cڡ
+ \ 5*__cڡ
+_sys_\94¾i¡
+[];
+
+ @/usr/include/bits/types.h
+
+24 #iâdef
+_BITS_TYPES_H
+
+
+25 \ 1
+ #_BITS_TYPES_H
+ 1
+
+ )
+
+27 \ 2
+ ~<ã©u»s.h
+>
+
+28 \ 2
+ ~<b\99s/wÜdsize.h
+>
+
+31 \e\1d\ 5
+ t__u_ch¬
+;
+
+32 \e\1d\16\12
+ t__u_shÜt
+;
+
+33 \e\1d\12
+ t__u_\9at
+;
+
+34 \e\1d\13\12
+ t__u_lÚg
+;
+
+37 \esigÃd \ 5
+ t__\9at8_t
+;
+
+38 \e\1d\ 5
+ t__u\9at8_t
+;
+
+39 \esigÃd \16\12
+ t__\9at16_t
+;
+
+40 \e\1d\16\12
+ t__u\9at16_t
+;
+
+41 \esigÃd \12
+ t__\9at32_t
+;
+
+42 \e\1d\12
+ t__u\9at32_t
+;
+
+43 #ià
+__WORDSIZE
+ == 64
+
+44 \esigÃd \13\12
+ t__\9at64_t
+;
+
+45 \e\1d\13\12
+ t__u\9at64_t
+;
+
+46 #\96ià
+def\9aed
+
+__GLIBC_HAVE_LONG_LONG
+
+
+47
+__ex\8bnsiÚ__
+ \esigÃd \13\13\12
+ t__\9at64_t
+;
+
+48
+__ex\8bnsiÚ__
+ \e\1d\13\13\12
+ t__u\9at64_t
+;
+
+52 #ià
+__WORDSIZE
+ == 64
+
+53 \e\13\12
+ t__quad_t
+;
+
+54 \e\1d\13\12
+ t__u_quad_t
+;
+
+55 #\96ià
+def\9aed
+
+__GLIBC_HAVE_LONG_LONG
+
+
+56
+__ex\8bnsiÚ__
+ \e\13\13\12
+ t__quad_t
+;
+
+57
+__ex\8bnsiÚ__
+ \e\1d\13\13\12
+ t__u_quad_t
+;
+
+61 \13
+ m__v®
+[2];
+
+62 }
+ t__quad_t
+;
+
+65
+__u_lÚg
+
+ m__v®
+[2];
+
+66 }
+ t__u_quad_t
+;
+
+99 \ 1
+ #__S16_TYPE
+ \16\12
+
+ )
+
+100 \ 1
+ #__U16_TYPE
+ \1d\16\12
+
+ )
+
+101 \ 1
+ #__S32_TYPE
+ \12
+
+ )
+
+102 \ 1
+ #__U32_TYPE
+ \1d\12
+
+ )
+
+103 \ 1
+ #__SLONGWORD_TYPE
+ \13\12
+
+ )
+
+104 \ 1
+ #__ULONGWORD_TYPE
+ \1d\13\12
+
+ )
+
+105 #ià
+__WORDSIZE
+ == 32
+
+106 \ 1
+ #__SQUAD_TYPE
+
+__quad_t
+
+
+ )
+
+107 \ 1
+ #__UQUAD_TYPE
+
+__u_quad_t
+
+
+ )
+
+108 \ 1
+ #__SWORD_TYPE
+ \12
+
+ )
+
+109 \ 1
+ #__UWORD_TYPE
+ \1d\12
+
+ )
+
+110 \ 1
+ #__SLONG32_TYPE
+ \13\12
+
+ )
+
+111 \ 1
+ #__ULONG32_TYPE
+ \1d\13\12
+
+ )
+
+112 \ 1
+ #__S64_TYPE
+
+__quad_t
+
+
+ )
+
+113 \ 1
+ #__U64_TYPE
+
+__u_quad_t
+
+
+ )
+
+116 \ 1
+ #__STD_TYPE
+
+__ex\8bnsiÚ__
+ \e
+
+ )
+
+117 #\96ià
+__WORDSIZE
+ == 64
+
+118 \ 1
+ t__SQUAD_TYPE
+ \13\12
+
+ )
+
+119 \ 1
+ t__UQUAD_TYPE
+ \1d\13\12
+
+ )
+
+120 \ 1
+ t__SWORD_TYPE
+ \13\12
+
+ )
+
+121 \ 1
+ t__UWORD_TYPE
+ \1d\13\12
+
+ )
+
+122 \ 1
+ t__SLONG32_TYPE
+ \12
+
+ )
+
+123 \ 1
+ t__ULONG32_TYPE
+ \1d\12
+
+ )
+
+124 \ 1
+ t__S64_TYPE
+ \13\12
+
+ )
+
+125 \ 1
+ t__U64_TYPE
+ \1d\13\12
+
+ )
+
+127 \ 1
+ t__STD_TYPE
+ \e
+
+ )
+
+131 \ 2
+ ~<b\99s/ty³sizes.h
+>
+
+134
+__STD_TYPE
+
+ t__DEV_T_TYPE
+
+ t__dev_t
+;
+
+135
+__STD_TYPE
+
+__UID_T_TYPE
+
+ g__uid_t
+;
+
+136
+__STD_TYPE
+
+__GID_T_TYPE
+
+ g__gid_t
+;
+
+137
+__STD_TYPE
+
+__INO_T_TYPE
+
+ g__\9ao_t
+;
+
+138
+__STD_TYPE
+
+__INO64_T_TYPE
+
+ g__\9ao64_t
+;
+
+139
+__STD_TYPE
+
+__MODE_T_TYPE
+
+ g__mode_t
+;
+
+140
+__STD_TYPE
+
+__NLINK_T_TYPE
+
+ g__ƚk_t
+;
+
+141
+__STD_TYPE
+
+__OFF_T_TYPE
+
+ g__off_t
+;
+
+142
+__STD_TYPE
+
+__OFF64_T_TYPE
+
+ g__off64_t
+;
+
+143
+__STD_TYPE
+
+__PID_T_TYPE
+
+ g__pid_t
+;
+
+144
+__STD_TYPE
+
+__FSID_T_TYPE
+
+ g__fsid_t
+;
+
+145
+__STD_TYPE
+
+__CLOCK_T_TYPE
+
+ g__þock_t
+;
+
+146
+__STD_TYPE
+
+__RLIM_T_TYPE
+
+ g__¾im_t
+;
+
+147
+__STD_TYPE
+
+__RLIM64_T_TYPE
+
+ g__¾im64_t
+;
+
+148
+__STD_TYPE
+
+__ID_T_TYPE
+
+ g__id_t
+;
+
+149
+__STD_TYPE
+
+__TIME_T_TYPE
+
+ g__time_t
+;
+
+150
+__STD_TYPE
+
+__USECONDS_T_TYPE
+
+ g__u£cÚds_t
+;
+
+151
+__STD_TYPE
+
+__SUSECONDS_T_TYPE
+
+ g__su£cÚds_t
+;
+
+153
+__STD_TYPE
+
+__DADDR_T_TYPE
+
+ g__daddr_t
+;
+
+154
+__STD_TYPE
+
+__SWBLK_T_TYPE
+
+ g__swblk_t
+;
+
+155
+__STD_TYPE
+
+__KEY_T_TYPE
+
+ g__key_t
+;
+
+158
+__STD_TYPE
+
+__CLOCKID_T_TYPE
+
+ g__þockid_t
+;
+
+161
+__STD_TYPE
+
+__TIMER_T_TYPE
+
+ g__tim\94_t
+;
+
+164
+__STD_TYPE
+
+__BLKSIZE_T_TYPE
+
+ g__blksize_t
+;
+
+169
+__STD_TYPE
+
+__BLKCNT_T_TYPE
+
+ g__blkút_t
+;
+
+170
+__STD_TYPE
+
+__BLKCNT64_T_TYPE
+
+ g__blkút64_t
+;
+
+173
+__STD_TYPE
+
+__FSBLKCNT_T_TYPE
+
+ g__fsblkút_t
+;
+
+174
+__STD_TYPE
+
+__FSBLKCNT64_T_TYPE
+
+ g__fsblkút64_t
+;
+
+177
+__STD_TYPE
+
+__FSFILCNT_T_TYPE
+
+ g__fsf\9eút_t
+;
+
+178
+__STD_TYPE
+
+__FSFILCNT64_T_TYPE
+
+ g__fsf\9eút64_t
+;
+
+180
+__STD_TYPE
+
+__SSIZE_T_TYPE
+
+ g__ssize_t
+;
+
+184 \e
+__off64_t
+
+ t__loff_t
+;
+
+185 \e
+__quad_t
+ *
+ t__qaddr_t
+;
+
+186 \e\ 5*
+ t__ÿddr_t
+;
+
+189
+__STD_TYPE
+
+__SWORD_TYPE
+
+ g__\9a\8d\8c_t
+;
+
+192
+__STD_TYPE
+
+__U32_TYPE
+
+ g__sockËn_t
+;
+
+195 #undeà
+__STD_TYPE
+
+
+ @/usr/include/bits/waitflags.h
+
+20 #ià!
+def\9aed
+
+_SYS_WAIT_H
+ && !def\9aed
+_STDLIB_H
+
+
+26 \ 1
+ #WNOHANG
+ 1
+
+ )
+
+27 \ 1
+ #WUNTRACED
+ 2
+
+ )
+
+30 \ 1
+ #WSTOPPED
+ 2
+
+ )
+
+31 \ 1
+ #WEXITED
+ 4
+
+ )
+
+32 \ 1
+ #WCONTINUED
+ 8
+
+ )
+
+33 \ 1
+ #WNOWAIT
+ 0x01000000
+
+ )
+
+35 \ 1
+ #__WNOTHREAD
+ 0x20000000
+
+ )
+
+37 \ 1
+ #__WALL
+ 0x40000000
+
+ )
+
+38 \ 1
+ #__WCLONE
+ 0x80000000
+
+ )
+
+ @/usr/include/bits/waitstatus.h
+
+20 #ià!
+def\9aed
+
+_SYS_WAIT_H
+ && !def\9aed
+_STDLIB_H
+
+
+29 \ 1
+ #__WEXITSTATUS
+(
+¡©us
+è(((¡©usè& 0xff00è>> 8)
+
+ )
+
+32 \ 1
+ #__WTERMSIG
+(
+¡©us
+è((¡©usè& 0x7f)
+
+ )
+
+35 \ 1
+ #__WSTOPSIG
+(
+¡©us
+è
+ `__WEXITSTATUS
+(¡©us)
+
+ )
+
+38 \ 1
+ #__WIFEXITED
+(
+¡©us
+è(
+ `__WTERMSIG
+(¡©usè=ð0)
+
+ )
+
+41 \ 1
+ #__WIFSIGNALED
+(
+¡©us
+) \
+
+42 (((sigÃd \ 5è(((
+¡©us
+è& 0x7fè+ 1è>> 1è> 0)
+
+ )
+
+45 \ 1
+ #__WIFSTOPPED
+(
+¡©us
+è(((¡©usè& 0xffè=ð0x7f)
+
+ )
+
+49 #ifdeà
+WCONTINUED
+
+
+50 \ 1
+ #__WIFCONTINUED
+(
+¡©us
+è((¡©usè=ð
+__W_CONTINUED
+)
+
+ )
+
+54 \ 1
+ #__WCOREDUMP
+(
+¡©us
+è((¡©usè&
+__WCOREFLAG
+)
+
+ )
+
+57 \ 1
+ #__W_EXITCODE
+(
+»t
+,
+sig
+è(Ô\91è<< 8 | (sig))
+
+ )
+
+58 \ 1
+ #__W_STOPCODE
+(
+sig
+è((sigè<< 8 | 0x7f)
+
+ )
+
+59 \ 1
+ #__W_CONTINUED
+ 0xffff
+
+ )
+
+60 \ 1
+ #__WCOREFLAG
+ 0x80
+
+ )
+
+63 #ifdef
+__USE_BSD
+
+
+65 \ 2
+ ~<\92d\9fn.h
+>
+
+67 \1c
+ uwa\99
+
+
+69 \12
+ mw_¡©us
+;
+
+72 #if
+__BYTE_ORDER
+ =ð
+__LITTLE_ENDIAN
+
+
+73 \1d\12
+ m__w_\8brmsig
+:7;
+
+74 \1d\12
+ m__w_cÜedump
+:1;
+
+75 \1d\12
+ m__w_»tcode
+:8;
+
+78 #if
+__BYTE_ORDER
+ =ð
+__BIG_ENDIAN
+
+
+80 \1d\12
+ m__w_»tcode
+:8;
+
+81 \1d\12
+ m__w_cÜedump
+:1;
+
+82 \1d\12
+ m__w_\8brmsig
+:7;
+
+84 }
+ m__wa\99_\8brm\9a©ed
+;
+
+87 #if
+__BYTE_ORDER
+ =ð
+__LITTLE_ENDIAN
+
+
+88 \1d\12
+ m__w_¡Ýv®
+:8;
+
+89 \1d\12
+ m__w_¡Ýsig
+:8;
+
+92 #if
+__BYTE_ORDER
+ =ð
+__BIG_ENDIAN
+
+
+94 \1d\12
+ m__w_¡Ýsig
+:8;
+
+95 \1d\12
+ m__w_¡Ýv®
+:8;
+
+97 }
+ m__wa\99_¡Ý³d
+;
+
+100 \ 1
+ #w_\8brmsig
+
+__wa\99_\8brm\9a©ed
+.
+__w_\8brmsig
+
+
+ )
+
+101 \ 1
+ #w_cÜedump
+
+__wa\99_\8brm\9a©ed
+.
+__w_cÜedump
+
+
+ )
+
+102 \ 1
+ #w_»tcode
+
+__wa\99_\8brm\9a©ed
+.
+__w_»tcode
+
+
+ )
+
+103 \ 1
+ #w_¡Ýsig
+
+__wa\99_¡Ý³d
+.
+__w_¡Ýsig
+
+
+ )
+
+104 \ 1
+ #w_¡Ýv®
+
+__wa\99_¡Ý³d
+.
+__w_¡Ýv®
+
+
+ )
+
+ @/usr/include/bits/wordsize.h
+
+3 #ià
+def\9aed
+
+__x86_64__
+
+
+4 \ 1
+ #__WORDSIZE
+ 64
+
+ )
+
+5 \ 1
+ #__WORDSIZE_COMPAT32
+ 1
+
+ )
+
+7 \ 1
+ #__WORDSIZE
+ 32
+
+ )
+
+ @/usr/include/bits/xopen_lim.h
+
+30 #iâdeà
+_XOPEN_LIM_H
+
+
+31 \ 1
+ #_XOPEN_LIM_H
+ 1
+
+ )
+
+33 \ 1
+ #__Ãed_IOV_MAX
+
+
+ )
+
+34 \ 2
+ ~<b\99s/¡dio_lim.h
+>
+
+66 \ 1
+ #_XOPEN_IOV_MAX
+
+_POSIX_UIO_MAXIOV
+
+
+ )
+
+71 \ 1
+ #NL_ARGMAX
+
+_POSIX_ARG_MAX
+
+
+ )
+
+74 \ 1
+ #NL_LANGMAX
+
+_POSIX2_LINE_MAX
+
+
+ )
+
+77 \ 1
+ #NL_MSGMAX
+
+INT_MAX
+
+
+ )
+
+81 \ 1
+ #NL_NMAX
+
+INT_MAX
+
+
+ )
+
+84 \ 1
+ #NL_SETMAX
+
+INT_MAX
+
+
+ )
+
+87 \ 1
+ #NL_TEXTMAX
+
+INT_MAX
+
+
+ )
+
+90 \ 1
+ #NZERO
+ 20
+
+ )
+
+94 #ifdeà
+INT_MAX
+
+
+95 #ià
+INT_MAX
+ == 32767
+
+96 \ 1
+ #WORD_BIT
+ 16
+
+ )
+
+98 #ià
+INT_MAX
+ == 2147483647
+
+99 \ 1
+ #WORD_BIT
+ 32
+
+ )
+
+102 \ 1
+ #WORD_BIT
+ 64
+
+ )
+
+105 #\96ià
+def\9aed
+
+__INT_MAX__
+
+
+106 #ià
+__INT_MAX__
+ == 32767
+
+107 \ 1
+ #WORD_BIT
+ 16
+
+ )
+
+109 #ià
+__INT_MAX__
+ == 2147483647
+
+110 \ 1
+ #WORD_BIT
+ 32
+
+ )
+
+113 \ 1
+ #WORD_BIT
+ 64
+
+ )
+
+117 \ 1
+ #WORD_BIT
+ 32
+
+ )
+
+121 #ifdeà
+LONG_MAX
+
+
+122 #ià
+LONG_MAX
+ == 2147483647
+
+123 \ 1
+ #LONG_BIT
+ 32
+
+ )
+
+126 \ 1
+ #LONG_BIT
+ 64
+
+ )
+
+128 #\96ià
+def\9aed
+
+__LONG_MAX__
+
+
+129 #ià
+__LONG_MAX__
+ == 2147483647
+
+130 \ 1
+ #LONG_BIT
+ 32
+
+ )
+
+133 \ 1
+ #LONG_BIT
+ 64
+
+ )
+
+136 \ 2
+ ~<b\99s/wÜdsize.h
+>
+
+137 #ià
+__WORDSIZE
+ == 64
+
+138 \ 1
+ #LONG_BIT
+ 64
+
+ )
+
+140 \ 1
+ #LONG_BIT
+ 32
+
+ )
+
+ @/usr/include/features.h
+
+20 #iâdef
+_FEATURES_H
+
+
+21 \ 1
+ #_FEATURES_H
+ 1
+
+ )
+
+98 #undeà
+__USE_ISOC99
+
+
+99 #undeà
+__USE_ISOC95
+
+
+100 #undeà
+__USE_POSIX
+
+
+101 #undeà
+__USE_POSIX2
+
+
+102 #undeà
+__USE_POSIX199309
+
+
+103 #undeà
+__USE_POSIX199506
+
+
+104 #undeà
+__USE_XOPEN
+
+
+105 #undeà
+__USE_XOPEN_EXTENDED
+
+
+106 #undeà
+__USE_UNIX98
+
+
+107 #undeà
+__USE_XOPEN2K
+
+
+108 #undeà
+__USE_XOPEN2KXSI
+
+
+109 #undeà
+__USE_XOPEN2K8
+
+
+110 #undeà
+__USE_XOPEN2K8XSI
+
+
+111 #undeà
+__USE_LARGEFILE
+
+
+112 #undeà
+__USE_LARGEFILE64
+
+
+113 #undeà
+__USE_FILE_OFFSET64
+
+
+114 #undeà
+__USE_BSD
+
+
+115 #undeà
+__USE_SVID
+
+
+116 #undeà
+__USE_MISC
+
+
+117 #undeà
+__USE_ATFILE
+
+
+118 #undeà
+__USE_GNU
+
+
+119 #undeà
+__USE_REENTRANT
+
+
+120 #undeà
+__USE_FORTIFY_LEVEL
+
+
+121 #undeà
+__FAVOR_BSD
+
+
+122 #undeà
+__KERNEL_STRICT_NAMES
+
+
+126 #iâdeà
+_LOOSE_KERNEL_NAMES
+
+
+127 \ 1
+ #__KERNEL_STRICT_NAMES
+
+
+ )
+
+131 \ 1
+ #__USE_ANSI
+ 1
+
+ )
+
+140 #ià
+def\9aed
+
+__GNUC__
+ && def\9aed
+__GNUC_MINOR__
+
+
+141 \ 1
+ #__GNUC_PREREQ
+(
+maj
+,
+m\9a
+) \
+
+142 ((
+__GNUC__
+ << 16è+
+__GNUC_MINOR__
+ >ð((
+maj
+è<< 16è+ (
+m\9a
+))
+
+ )
+
+144 \ 1
+ #__GNUC_PREREQ
+(
+maj
+,
+m\9a
+è0
+
+ )
+
+149 #ià
+def\9aed
+
+_BSD_SOURCE
+ && \
+
+150 !(
+def\9aed
+
+ g_POSIX_SOURCE
+ || def\9aed
+ g_POSIX_C_SOURCE
+ || \
+
+151
+def\9aed
+
+ g_XOPEN_SOURCE
+ || def\9aed
+ g_GNU_SOURCE
+ || def\9aed
+ g_SVID_SOURCE
+)
+
+152 \ 1
+ #__FAVOR_BSD
+ 1
+
+ )
+
+156 #ifdeà
+_GNU_SOURCE
+
+
+157 #undeà
+_ISOC95_SOURCE
+
+
+158 \ 1
+ #_ISOC95_SOURCE
+ 1
+
+ )
+
+159 #undeà
+_ISOC99_SOURCE
+
+
+160 \ 1
+ #_ISOC99_SOURCE
+ 1
+
+ )
+
+161 #undeà
+_POSIX_SOURCE
+
+
+162 \ 1
+ #_POSIX_SOURCE
+ 1
+
+ )
+
+163 #undeà
+_POSIX_C_SOURCE
+
+
+164 \ 1
+ #_POSIX_C_SOURCE
+ 200809L
+
+ )
+
+165 #undeà
+_XOPEN_SOURCE
+
+
+166 \ 1
+ #_XOPEN_SOURCE
+ 700
+
+ )
+
+167 #undeà
+_XOPEN_SOURCE_EXTENDED
+
+
+168 \ 1
+ #_XOPEN_SOURCE_EXTENDED
+ 1
+
+ )
+
+169 #undeà
+_LARGEFILE64_SOURCE
+
+
+170 \ 1
+ #_LARGEFILE64_SOURCE
+ 1
+
+ )
+
+171 #undeà
+_BSD_SOURCE
+
+
+172 \ 1
+ #_BSD_SOURCE
+ 1
+
+ )
+
+173 #undeà
+_SVID_SOURCE
+
+
+174 \ 1
+ #_SVID_SOURCE
+ 1
+
+ )
+
+175 #undeà
+_ATFILE_SOURCE
+
+
+176 \ 1
+ #_ATFILE_SOURCE
+ 1
+
+ )
+
+181 #ià(!
+def\9aed
+
+__STRICT_ANSI__
+ && !def\9aed
+_ISOC99_SOURCE
+ && \
+
+182 !
+def\9aed
+
+ g_POSIX_SOURCE
+ && !def\9aed
+ g_POSIX_C_SOURCE
+ && \
+
+183 !
+def\9aed
+
+ g_XOPEN_SOURCE
+ && !def\9aed
+ g_BSD_SOURCE
+ && !def\9aed
+ g_SVID_SOURCE
+)
+
+184 \ 1
+ #_BSD_SOURCE
+ 1
+
+ )
+
+185 \ 1
+ #_SVID_SOURCE
+ 1
+
+ )
+
+192 #ià(
+def\9aed
+
+_ISOC99_SOURCE
+ || def\9aed
+_ISOC9X_SOURCE
+ \
+
+193 || (
+def\9aed
+
+ g__STDC_VERSION__
+ && __STDC_VERSION__ >= 199901L))
+
+194 \ 1
+ #__USE_ISOC99
+ 1
+
+ )
+
+198 #ià(
+def\9aed
+
+_ISOC99_SOURCE
+ || def\9aed
+_ISOC9X_SOURCE
+ \
+
+199 || (
+def\9aed
+
+__STDC_VERSION__
+ && __STDC_VERSION__ >= 199409L))
+
+200 \ 1
+ #__USE_ISOC95
+ 1
+
+ )
+
+205 #ià((!
+def\9aed
+
+__STRICT_ANSI__
+ || (
+_XOPEN_SOURCE
+ - 0) >= 500) && \
+
+206 !
+def\9aed
+
+_POSIX_SOURCE
+ && !def\9aed
+_POSIX_C_SOURCE
+)
+
+207 \ 1
+ #_POSIX_SOURCE
+ 1
+
+ )
+
+208 #ià
+def\9aed
+
+_XOPEN_SOURCE
+ && (_XOPEN_SOURCE - 0) < 500
+
+209 \ 1
+ #_POSIX_C_SOURCE
+ 2
+
+ )
+
+210 #\96ià
+def\9aed
+
+_XOPEN_SOURCE
+ && (_XOPEN_SOURCE - 0) < 600
+
+211 \ 1
+ #_POSIX_C_SOURCE
+ 199506L
+
+ )
+
+212 #\96ià
+def\9aed
+
+_XOPEN_SOURCE
+ && (_XOPEN_SOURCE - 0) < 700
+
+213 \ 1
+ #_POSIX_C_SOURCE
+ 200112L
+
+ )
+
+215 \ 1
+ #_POSIX_C_SOURCE
+ 200809L
+
+ )
+
+217 \ 1
+ #__USE_POSIX_IMPLICITLY
+ 1
+
+ )
+
+220 #ià
+def\9aed
+
+_POSIX_SOURCE
+ ||
+_POSIX_C_SOURCE
+ >ð1 || def\9aed
+_XOPEN_SOURCE
+
+
+221 \ 1
+ #__USE_POSIX
+ 1
+
+ )
+
+224 #ià
+def\9aed
+
+_POSIX_C_SOURCE
+ && _POSIX_C_SOURCE >ð2 || def\9aed
+_XOPEN_SOURCE
+
+
+225 \ 1
+ #__USE_POSIX2
+ 1
+
+ )
+
+228 #ià(
+_POSIX_C_SOURCE
+ - 0) >= 199309L
+
+229 \ 1
+ #__USE_POSIX199309
+ 1
+
+ )
+
+232 #ià(
+_POSIX_C_SOURCE
+ - 0) >= 199506L
+
+233 \ 1
+ #__USE_POSIX199506
+ 1
+
+ )
+
+236 #ià(
+_POSIX_C_SOURCE
+ - 0) >= 200112L
+
+237 \ 1
+ #__USE_XOPEN2K
+ 1
+
+ )
+
+238 #undeà
+__USE_ISOC95
+
+
+239 \ 1
+ #__USE_ISOC95
+ 1
+
+ )
+
+240 #undeà
+__USE_ISOC99
+
+
+241 \ 1
+ #__USE_ISOC99
+ 1
+
+ )
+
+244 #ià(
+_POSIX_C_SOURCE
+ - 0) >= 200809L
+
+245 \ 1
+ #__USE_XOPEN2K8
+ 1
+
+ )
+
+246 #undeà
+_ATFILE_SOURCE
+
+
+247 \ 1
+ #_ATFILE_SOURCE
+ 1
+
+ )
+
+250 #ifdef
+_XOPEN_SOURCE
+
+
+251 \ 1
+ #__USE_XOPEN
+ 1
+
+ )
+
+252 #ià(
+_XOPEN_SOURCE
+ - 0) >= 500
+
+253 \ 1
+ #__USE_XOPEN_EXTENDED
+ 1
+
+ )
+
+254 \ 1
+ #__USE_UNIX98
+ 1
+
+ )
+
+255 #undeà
+_LARGEFILE_SOURCE
+
+
+256 \ 1
+ #_LARGEFILE_SOURCE
+ 1
+
+ )
+
+257 #ià(
+_XOPEN_SOURCE
+ - 0) >= 600
+
+258 #ià(
+_XOPEN_SOURCE
+ - 0) >= 700
+
+259 \ 1
+ #__USE_XOPEN2K8
+ 1
+
+ )
+
+260 \ 1
+ #__USE_XOPEN2K8XSI
+ 1
+
+ )
+
+262 \ 1
+ #__USE_XOPEN2K
+ 1
+
+ )
+
+263 \ 1
+ #__USE_XOPEN2KXSI
+ 1
+
+ )
+
+264 #undeà
+__USE_ISOC95
+
+
+265 \ 1
+ #__USE_ISOC95
+ 1
+
+ )
+
+266 #undeà
+__USE_ISOC99
+
+
+267 \ 1
+ #__USE_ISOC99
+ 1
+
+ )
+
+270 #ifdeà
+_XOPEN_SOURCE_EXTENDED
+
+
+271 \ 1
+ #__USE_XOPEN_EXTENDED
+ 1
+
+ )
+
+276 #ifdeà
+_LARGEFILE_SOURCE
+
+
+277 \ 1
+ #__USE_LARGEFILE
+ 1
+
+ )
+
+280 #ifdeà
+_LARGEFILE64_SOURCE
+
+
+281 \ 1
+ #__USE_LARGEFILE64
+ 1
+
+ )
+
+284 #ià
+def\9aed
+
+_FILE_OFFSET_BITS
+ && _FILE_OFFSET_BITS == 64
+
+285 \ 1
+ #__USE_FILE_OFFSET64
+ 1
+
+ )
+
+288 #ià
+def\9aed
+
+_BSD_SOURCE
+ || def\9aed
+_SVID_SOURCE
+
+
+289 \ 1
+ #__USE_MISC
+ 1
+
+ )
+
+292 #ifdef
+_BSD_SOURCE
+
+
+293 \ 1
+ #__USE_BSD
+ 1
+
+ )
+
+296 #ifdef
+_SVID_SOURCE
+
+
+297 \ 1
+ #__USE_SVID
+ 1
+
+ )
+
+300 #ifdef
+_ATFILE_SOURCE
+
+
+301 \ 1
+ #__USE_ATFILE
+ 1
+
+ )
+
+304 #ifdef
+_GNU_SOURCE
+
+
+305 \ 1
+ #__USE_GNU
+ 1
+
+ )
+
+308 #ià
+def\9aed
+
+_REENTRANT
+ || def\9aed
+_THREAD_SAFE
+
+
+309 \ 1
+ #__USE_REENTRANT
+ 1
+
+ )
+
+312 #ià
+def\9aed
+
+_FORTIFY_SOURCE
+ && _FORTIFY_SOURCE > 0 \
+
+313 &&
+__GNUC_PREREQ
+ (4, 1è&&
+def\9aed
+
+ g__OPTIMIZE__
+ && __OPTIMIZE__ > 0
+
+314 #ià
+_FORTIFY_SOURCE
+ > 1
+
+315 \ 1
+ #__USE_FORTIFY_LEVEL
+ 2
+
+ )
+
+317 \ 1
+ #__USE_FORTIFY_LEVEL
+ 1
+
+ )
+
+320 \ 1
+ #__USE_FORTIFY_LEVEL
+ 0
+
+ )
+
+324 \ 2
+ ~<b\99s/´edefs.h
+>
+
+327 \ 1
+ #__STDC_ISO_10646__
+ 200009L
+
+ )
+
+335 #undeà
+__GNU_LIBRARY__
+
+
+336 \ 1
+ #__GNU_LIBRARY__
+ 6
+
+ )
+
+340 \ 1
+ #__GLIBC__
+ 2
+
+ )
+
+341 \ 1
+ #__GLIBC_MINOR__
+ 15
+
+ )
+
+343 \ 1
+ #__GLIBC_PREREQ
+(
+maj
+,
+m\9a
+) \
+
+344 ((
+__GLIBC__
+ << 16è+
+__GLIBC_MINOR__
+ >ð((
+maj
+è<< 16è+ (
+m\9a
+))
+
+ )
+
+347 #ià
+def\9aed
+
+__GNUC__
+ \
+
+348 || (
+def\9aed
+
+ g__PGI
+ && def\9aed
+ g__i386__
+ ) \
+
+349 || (
+def\9aed
+
+ g__INTEL_COMPILER
+ && (def\9aed
+ g__i386__
+ || def\9aed
+ g__\9f64__
+)) \
+
+350 || (
+def\9aed
+
+ g__STDC_VERSION__
+ && __STDC_VERSION__ >= 199901L)
+
+351 \ 1
+ #__GLIBC_HAVE_LONG_LONG
+ 1
+
+ )
+
+355 #iâdeà
+__ASSEMBLER__
+
+
+356 #iâdeà
+_SYS_CDEFS_H
+
+
+357 \ 2
+ ~<sys/cdefs.h
+>
+
+362 #ià
+def\9aed
+
+__USE_FILE_OFFSET64
+ && !def\9aed
+__REDIRECT
+
+
+363 \ 1
+ #__USE_LARGEFILE
+ 1
+
+ )
+
+364 \ 1
+ #__USE_LARGEFILE64
+ 1
+
+ )
+
+370 #ià
+__GNUC_PREREQ
+ (2, 7è&&
+def\9aed
+
+__OPTIMIZE__
+ \
+
+371 && !
+def\9aed
+
+ g__OPTIMIZE_SIZE__
+ && !def\9aed
+ g__NO_INLINE__
+ \
+
+372 &&
+def\9aed
+
+ g__ex\8bº_\9al\9ae
+
+
+373 \ 1
+ #__USE_EXTERN_INLINES
+ 1
+
+ )
+
+378 #ià
+__GNUC_PREREQ
+ (2, 7è&&
+def\9aed
+
+__OPTIMIZE__
+ \
+
+379 && (
+def\9aed
+
+ g_LIBC
+ || !def\9aed
+ g__OPTIMIZE_SIZE__
+è&& !def\9aed
+ g__NO_INLINE__
+ \
+
+380 &&
+def\9aed
+
+ g__ex\8bº_\9al\9ae
+
+
+381 \ 1
+ #__USE_EXTERN_INLINES_IN_LIBC
+ 1
+
+ )
+
+389 \ 2
+ ~<gnu/¡ubs.h
+>
+
+ @/usr/include/getopt.h
+
+21 #iâdeà
+_GETOPT_H
+
+
+23 #iâdeà
+__Ãed_g\91Ýt
+
+
+24 \ 1
+ #_GETOPT_H
+ 1
+
+ )
+
+34 #ià!
+def\9aed
+
+__GNU_LIBRARY__
+
+
+35 \ 2
+ ~<ùy³.h
+>
+
+38 #iâdeà
+__THROW
+
+
+39 #iâdeà
+__GNUC_PREREQ
+
+
+40 \ 1
+ #__GNUC_PREREQ
+(
+maj
+,
+m\9a
+è(0)
+
+ )
+
+42 #ià
+def\9aed
+
+__ýlu¥lus
+ &&
+__GNUC_PREREQ
+ (2,8)
+
+43 \ 1
+ #__THROW
+
+ `throw
+ ()
+
+ )
+
+45 \ 1
+ #__THROW
+
+
+ )
+
+49 #ifdef
+__ýlu¥lus
+
+
+59 \r\ 5*
+ݏrg
+;
+
+73 \r\12
+Ýt\9ad
+;
+
+78 \r\12
+Ý\8b¼
+;
+
+82 \r\12
+ÝtÝt
+;
+
+84 #iâdeà
+__Ãed_g\91Ýt
+
+
+106 \19
+ sÝtiÚ
+
+
+108 cڡ \ 5*
+ gÇme
+;
+
+111 \12
+ ghas_¬g
+;
+
+112 \12*
+ gæag
+;
+
+113 \12
+ gv®
+;
+
+118 \ 1
+ #no_¬gum\92t
+ 0
+
+ )
+
+119 \ 1
+ #»qu\9ced_¬gum\92t
+ 1
+
+ )
+
+120 \ 1
+ #ÝtiÚ®_¬gum\92t
+ 2
+
+ )
+
+148 #ifdeà
+__GNU_LIBRARY__
+
+
+152 \r\12
+g\91Ýt
+ (\12
+___¬gc
+, \ 5*cڡ *
+___¬gv
+, cڡ \ 5*
+__shÜtÝts
+)
+
+153
+__THROW
+;
+
+155 #ià
+def\9aed
+
+__Ãed_g\91Ýt
+ && def\9aed
+__USE_POSIX2
+ \
+
+156 && !
+def\9aed
+
+ g__USE_POSIX_IMPLICITLY
+ && !def\9aed
+ g__USE_GNU
+
+
+160 #ifdeà
+__REDIRECT
+
+
+161 \r\12
+__REDIRECT_NTH
+ (
+g\91Ýt
+, (\12
+___¬gc
+, \ 5*cڡ *
+___¬gv
+,
+
+162 cڡ \ 5*
+__shÜtÝts
+),
+
+163
+__posix_g\91Ýt
+);
+
+165 \r\12
+__posix_g\91Ýt
+ (\12
+___¬gc
+, \ 5*cڡ *
+___¬gv
+,
+
+166 cڡ \ 5*
+__shÜtÝts
+è
+__THROW
+;
+
+167 \ 1
+ #g\91Ýt
+
+__posix_g\91Ýt
+
+
+ )
+
+171 \r\12
+g\91Ýt
+ ();
+
+174 #iâdeà
+__Ãed_g\91Ýt
+
+
+175 \r\12
+g\91Ýt_lÚg
+ (\12
+___¬gc
+, \ 5*cڡ *
+___¬gv
+,
+
+176 cڡ \ 5*
+__shÜtÝts
+,
+
+177 cڡ \19
+ÝtiÚ
+ *
+__lÚgÝts
+, \12*
+__lÚg\9ad
+)
+
+178
+__THROW
+;
+
+179 \r\12
+g\91Ýt_lÚg_Úly
+ (\12
+___¬gc
+, \ 5*cڡ *
+___¬gv
+,
+
+180 cڡ \ 5*
+__shÜtÝts
+,
+
+181 cڡ \19
+ÝtiÚ
+ *
+__lÚgÝts
+, \12*
+__lÚg\9ad
+)
+
+182
+__THROW
+;
+
+186 #ifdef
+__ýlu¥lus
+
+
+191 #undeà
+__Ãed_g\91Ýt
+
+
+ @/usr/include/libio.h
+
+29 #iâdeà
+_IO_STDIO_H
+
+
+30 \ 1
+ #_IO_STDIO_H
+
+
+ )
+
+32 \ 2
+ ~<_G_cÚfig.h
+>
+
+34 \ 1
+ #_IO_pos_t
+
+_G_åos_t
+
+
+ )
+
+35 \ 1
+ #_IO_åos_t
+
+_G_åos_t
+
+
+ )
+
+36 \ 1
+ #_IO_åos64_t
+
+_G_åos64_t
+
+
+ )
+
+37 \ 1
+ #_IO_size_t
+
+_G_size_t
+
+
+ )
+
+38 \ 1
+ #_IO_ssize_t
+
+_G_ssize_t
+
+
+ )
+
+39 \ 1
+ #_IO_off_t
+
+_G_off_t
+
+
+ )
+
+40 \ 1
+ #_IO_off64_t
+
+_G_off64_t
+
+
+ )
+
+41 \ 1
+ #_IO_pid_t
+
+_G_pid_t
+
+
+ )
+
+42 \ 1
+ #_IO_uid_t
+
+_G_uid_t
+
+
+ )
+
+43 \ 1
+ #_IO_icÚv_t
+
+_G_icÚv_t
+
+
+ )
+
+44 \ 1
+ #_IO_HAVE_SYS_WAIT
+
+_G_HAVE_SYS_WAIT
+
+
+ )
+
+45 \ 1
+ #_IO_HAVE_ST_BLKSIZE
+
+_G_HAVE_ST_BLKSIZE
+
+
+ )
+
+46 \ 1
+ #_IO_BUFSIZ
+
+_G_BUFSIZ
+
+
+ )
+
+47 \ 1
+ #_IO_va_li¡
+
+_G_va_li¡
+
+
+ )
+
+48 \ 1
+ #_IO_w\9at_t
+
+_G_w\9at_t
+
+
+ )
+
+50 #ifdeà
+_G_NEED_STDARG_H
+
+
+52 \ 1
+ #__Ãed___va_li¡
+
+
+ )
+
+53 \ 2
+ ~<¡d¬g.h
+>
+
+54 #ifdeà
+__GNUC_VA_LIST
+
+
+55 #undeà
+_IO_va_li¡
+
+
+56 \ 1
+ #_IO_va_li¡
+
+__gnuc_va_li¡
+
+
+ )
+
+60 #iâdeà
+__P
+
+
+61 #ià
+_G_HAVE_SYS_CDEFS
+
+
+62 \ 2
+ ~<sys/cdefs.h
+>
+
+64 #ifdeà
+__STDC__
+
+
+65 \ 1
+ #__P
+(
+p
+è
+ )
+p
+
+66 \ 1
+ #__PMT
+(
+p
+è
+ )
+p
+
+68 \ 1
+ #__P
+(
+p
+è()
+
+ )
+
+69 \ 1
+ #__PMT
+(
+p
+è()
+
+ )
+
+75 #iâdeà
+_PARAMS
+
+
+76 \ 1
+ #_PARAMS
+(
+´Ùos
+è
+ `__P
+ÕrÙos)
+
+ )
+
+79 #iâdeà
+__STDC__
+
+
+81 \ 1cڡ
+
+ )
+
+84 \ 1
+ #_IO_UNIFIED_JUMPTABLES
+ 1
+
+ )
+
+85 #iâdeà
+_G_HAVE_PRINTF_FP
+
+
+86 \ 1
+ #_IO_USE_DTOA
+ 1
+
+ )
+
+89 #iâdeà
+EOF
+
+
+90 \ 1
+ #EOF
+ (-1)
+
+ )
+
+92 #iâdeà
+NULL
+
+
+93 #ià
+def\9aed
+
+__GNUG__
+ && \
+
+94 (
+ g__GNUC__
+ > 2 || (__GNUC__ =ð2 &&
+__GNUC_MINOR__
+ >= 8))
+
+95 \ 1
+ #NULL
+ (
+__nuÎ
+)
+
+ )
+
+97 #ià!
+def\9aed
+(
+__ýlu¥lus
+)
+
+98 \ 1
+ #NULL
+ ((\1e*)0)
+
+ )
+
+100 \ 1
+ #NULL
+ (0)
+
+ )
+
+105 \ 1
+ #_IOS_INPUT
+ 1
+
+ )
+
+106 \ 1
+ #_IOS_OUTPUT
+ 2
+
+ )
+
+107 \ 1
+ #_IOS_ATEND
+ 4
+
+ )
+
+108 \ 1
+ #_IOS_APPEND
+ 8
+
+ )
+
+109 \ 1
+ #_IOS_TRUNC
+ 16
+
+ )
+
+110 \ 1
+ #_IOS_NOCREATE
+ 32
+
+ )
+
+111 \ 1
+ #_IOS_NOREPLACE
+ 64
+
+ )
+
+112 \ 1
+ #_IOS_BIN
+ 128
+
+ )
+
+120 \ 1
+ #_IO_MAGIC
+ 0xFBAD0000
+
+ )
+
+121 \ 1
+ #_OLD_STDIO_MAGIC
+ 0xFABC0000
+
+ )
+
+122 \ 1
+ #_IO_MAGIC_MASK
+ 0xFFFF0000
+
+ )
+
+123 \ 1
+ #_IO_USER_BUF
+ 1
+
+ )
+
+124 \ 1
+ #_IO_UNBUFFERED
+ 2
+
+ )
+
+125 \ 1
+ #_IO_NO_READS
+ 4
+
+ )
+
+126 \ 1
+ #_IO_NO_WRITES
+ 8
+
+ )
+
+127 \ 1
+ #_IO_EOF_SEEN
+ 0x10
+
+ )
+
+128 \ 1
+ #_IO_ERR_SEEN
+ 0x20
+
+ )
+
+129 \ 1
+ #_IO_DELETE_DONT_CLOSE
+ 0x40
+
+ )
+
+130 \ 1
+ #_IO_LINKED
+ 0x80
+
+ )
+
+131 \ 1
+ #_IO_IN_BACKUP
+ 0x100
+
+ )
+
+132 \ 1
+ #_IO_LINE_BUF
+ 0x200
+
+ )
+
+133 \ 1
+ #_IO_TIED_PUT_GET
+ 0x400
+
+ )
+
+134 \ 1
+ #_IO_CURRENTLY_PUTTING
+ 0x800
+
+ )
+
+135 \ 1
+ #_IO_IS_APPENDING
+ 0x1000
+
+ )
+
+136 \ 1
+ #_IO_IS_FILEBUF
+ 0x2000
+
+ )
+
+137 \ 1
+ #_IO_BAD_SEEN
+ 0x4000
+
+ )
+
+138 \ 1
+ #_IO_USER_LOCK
+ 0x8000
+
+ )
+
+140 \ 1
+ #_IO_FLAGS2_MMAP
+ 1
+
+ )
+
+141 \ 1
+ #_IO_FLAGS2_NOTCANCEL
+ 2
+
+ )
+
+142 #ifdeà
+_LIBC
+
+
+143 \ 1
+ #_IO_FLAGS2_FORTIFY
+ 4
+
+ )
+
+145 \ 1
+ #_IO_FLAGS2_USER_WBUF
+ 8
+
+ )
+
+146 #ifdeà
+_LIBC
+
+
+147 \ 1
+ #_IO_FLAGS2_SCANF_STD
+ 16
+
+ )
+
+148 \ 1
+ #_IO_FLAGS2_NOCLOSE
+ 32
+
+ )
+
+149 \ 1
+ #_IO_FLAGS2_CLOEXEC
+ 64
+
+ )
+
+153 \ 1
+ #_IO_SKIPWS
+ 01
+
+ )
+
+154 \ 1
+ #_IO_LEFT
+ 02
+
+ )
+
+155 \ 1
+ #_IO_RIGHT
+ 04
+
+ )
+
+156 \ 1
+ #_IO_INTERNAL
+ 010
+
+ )
+
+157 \ 1
+ #_IO_DEC
+ 020
+
+ )
+
+158 \ 1
+ #_IO_OCT
+ 040
+
+ )
+
+159 \ 1
+ #_IO_HEX
+ 0100
+
+ )
+
+160 \ 1
+ #_IO_SHOWBASE
+ 0200
+
+ )
+
+161 \ 1
+ #_IO_SHOWPOINT
+ 0400
+
+ )
+
+162 \ 1
+ #_IO_UPPERCASE
+ 01000
+
+ )
+
+163 \ 1
+ #_IO_SHOWPOS
+ 02000
+
+ )
+
+164 \ 1
+ #_IO_SCIENTIFIC
+ 04000
+
+ )
+
+165 \ 1
+ #_IO_FIXED
+ 010000
+
+ )
+
+166 \ 1
+ #_IO_UNITBUF
+ 020000
+
+ )
+
+167 \ 1
+ #_IO_STDIO
+ 040000
+
+ )
+
+168 \ 1
+ #_IO_DONT_CLOSE
+ 0100000
+
+ )
+
+169 \ 1
+ #_IO_BOOLALPHA
+ 0200000
+
+ )
+
+172 \19
+_IO_jump_t
+; \19
+ g_IO_FILE
+;
+
+175 #ifdeà
+_IO_MTSAFE_IO
+
+
+176 #ià
+def\9aed
+
+__GLIBC__
+ && __GLIBC__ >= 2
+
+177 \ 2
+ ~<b\99s/¡dio-lock.h
+>
+
+182 \e\1e
+ t_IO_lock_t
+;
+
+188 \19
+ s_IO_m¬k\94
+ {
+
+189 \19
+_IO_m¬k\94
+ *
+ m_Ãxt
+;
+
+190 \19
+_IO_FILE
+ *
+ m_sbuf
+;
+
+194 \12
+ m_pos
+;
+
+196 \1e
+£t_¡»ampos
+(
+¡»ampos
+
+¥
+è{
+ m_¥os
+ = sp; }
+
+197 \1e
+£t_off£t
+(\12
+off£t
+è{
+ m_pos
+ = off£t;
+ m_¥os
+ = (
+¡»ampos
+)(-2); }
+
+198
+ mpublic
+:
+
+199
+¡»amm¬k\94
+(
+¡»ambuf
+ *
+sb
+);
+
+200 ~
+¡»amm¬k\94
+();
+
+201 \12
+§v\9ag
+(è{ \15
+ m_¥os
+ == -2; }
+
+202 \12
+d\96\8f
+(
+¡»amm¬k\94
+&);
+
+203 \12
+d\96\8f
+();
+
+208 \f
+ e__codecvt_»suÉ
+
+
+210
+ m__codecvt_ok
+,
+
+211
+ m__codecvt_·¹\9fl
+,
+
+212
+ m__codecvt_\94rÜ
+,
+
+213
+ m__codecvt_nocÚv
+
+
+216 #ià
+def\9aed
+
+_LIBC
+ || def\9aed
+_GLIBCPP_USE_WCHAR_T
+
+
+219 \19
+ s_IO_codecvt
+
+
+221 \1e(*
+ m__codecvt_de¡r
+è(\19
+ m_IO_codecvt
+ *);
+
+222 \f
+__codecvt_»suÉ
+ (*
+__codecvt_do_out
+è(\19
+ m_IO_codecvt
+ *,
+
+223
+ m__mb¡©e_t
+ *,
+
+224 cڡ
+ mwch¬_t
+ *,
+
+225 cڡ
+ mwch¬_t
+ *,
+
+226 cڡ
+ mwch¬_t
+ **, \ 5*,
+
+228 \f
+__codecvt_»suÉ
+ (*
+__codecvt_do_unshiá
+è(\19
+ m_IO_codecvt
+ *,
+
+229
+ m__mb¡©e_t
+ *, \ 5*,
+
+231 \f
+__codecvt_»suÉ
+ (*
+__codecvt_do_\9a
+è(\19
+ m_IO_codecvt
+ *,
+
+232
+ m__mb¡©e_t
+ *,
+
+234 cڡ \ 5**,
+ mwch¬_t
+ *,
+
+235
+ mwch¬_t
+ *, wchar_t **);
+
+236 \12(*
+ m__codecvt_do_\92cod\9ag
+è(\19
+ m_IO_codecvt
+ *);
+
+237 \12(*
+ m__codecvt_do_®ways_nocÚv
+è(\19
+ m_IO_codecvt
+ *);
+
+238 \12(*
+ m__codecvt_do_Ëngth
+è(\19
+ m_IO_codecvt
+ *,
+ m__mb¡©e_t
+ *,
+
+239 cڡ \ 5*, cڡ \ 5*,
+ m_IO_size_t
+);
+
+240 \12(*
+ m__codecvt_do_max_Ëngth
+è(\19
+ m_IO_codecvt
+ *);
+
+242
+_IO_icÚv_t
+
+ m__cd_\9a
+;
+
+243
+_IO_icÚv_t
+
+ m__cd_out
+;
+
+247 \19
+ s_IO_wide_d©a
+
+
+249
+wch¬_t
+ *
+ m_IO_»ad_±r
+;
+
+250
+wch¬_t
+ *
+ m_IO_»ad_\92d
+;
+
+251
+wch¬_t
+ *
+ m_IO_»ad_ba£
+;
+
+252
+wch¬_t
+ *
+ m_IO_wr\99e_ba£
+;
+
+253
+wch¬_t
+ *
+ m_IO_wr\99e_±r
+;
+
+254
+wch¬_t
+ *
+ m_IO_wr\99e_\92d
+;
+
+255
+wch¬_t
+ *
+ m_IO_buf_ba£
+;
+
+256
+wch¬_t
+ *
+ m_IO_buf_\92d
+;
+
+258
+wch¬_t
+ *
+ m_IO_§ve_ba£
+;
+
+259
+wch¬_t
+ *
+ m_IO_backup_ba£
+;
+
+261
+wch¬_t
+ *
+ m_IO_§ve_\92d
+;
+
+263
+__mb¡©e_t
+
+ m_IO_¡©e
+;
+
+264
+__mb¡©e_t
+
+ m_IO_Ï¡_¡©e
+;
+
+265 \19
+_IO_codecvt
+
+ m_codecvt
+;
+
+267
+wch¬_t
+
+ m_shÜtbuf
+[1];
+
+269 cڡ \19
+_IO_jump_t
+ *
+ m_wide_v\8fbË
+;
+
+273 \19
+ s_IO_FILE
+ {
+
+274 \12
+ m_æags
+;
+
+275 \ 1
+ #_IO_f\9ee_æags
+
+_æags
+
+
+ )
+
+279 \ 5*
+ m_IO_»ad_±r
+;
+
+280 \ 5*
+ m_IO_»ad_\92d
+;
+
+281 \ 5*
+ m_IO_»ad_ba£
+;
+
+282 \ 5*
+ m_IO_wr\99e_ba£
+;
+
+283 \ 5*
+ m_IO_wr\99e_±r
+;
+
+284 \ 5*
+ m_IO_wr\99e_\92d
+;
+
+285 \ 5*
+ m_IO_buf_ba£
+;
+
+286 \ 5*
+ m_IO_buf_\92d
+;
+
+288 \ 5*
+ m_IO_§ve_ba£
+;
+
+289 \ 5*
+ m_IO_backup_ba£
+;
+
+290 \ 5*
+ m_IO_§ve_\92d
+;
+
+292 \19
+_IO_m¬k\94
+ *
+ m_m¬k\94s
+;
+
+294 \19
+_IO_FILE
+ *
+ m_cha\9a
+;
+
+296 \12
+ m_f\9e\92o
+;
+
+298 \12
+ m_blksize
+;
+
+300 \12
+ m_æags2
+;
+
+302
+_IO_off_t
+
+ m_Þd_off£t
+;
+
+304 \ 1
+ #__HAVE_COLUMN
+
+
+ )
+
+306 \1d\16
+ m_cur_cÞumn
+;
+
+307 sigÃd \ 5
+ m_v\8fbË_off£t
+;
+
+308 \ 5
+ m_shÜtbuf
+[1];
+
+312
+_IO_lock_t
+ *
+ m_lock
+;
+
+313 #ifdeà
+_IO_USE_OLD_IO_FILE
+
+
+316 \19
+ s_IO_FILE_com¶\91e
+
+
+318 \19
+_IO_FILE
+
+ m_f\9ee
+;
+
+320 #ià
+def\9aed
+
+_G_IO_IO_FILE_VERSION
+ && _G_IO_IO_FILE_VERSION == 0x20001
+
+321
+_IO_off64_t
+
+ m_off£t
+;
+
+322 #ià
+def\9aed
+
+_LIBC
+ || def\9aed
+_GLIBCPP_USE_WCHAR_T
+
+
+324 \19
+_IO_codecvt
+ *
+ m_codecvt
+;
+
+325 \19
+_IO_wide_d©a
+ *
+ m_wide_d©a
+;
+
+326 \19
+_IO_FILE
+ *
+ m_ä\93»s_li¡
+;
+
+327 \1e*
+ m_䓻s_buf
+;
+
+328
+size_t
+
+ m_䓻s_size
+;
+
+330 \1e*
+ m__·d1
+;
+
+331 \1e*
+ m__·d2
+;
+
+332 \1e*
+ m__·d3
+;
+
+333 \1e*
+ m__·d4
+;
+
+334
+size_t
+
+ m__·d5
+;
+
+336 \12
+ m_mode
+;
+
+338 \ 5
+ m_unu£d2
+[15 * \17 (\12è- 4 * \17 (\1e*è- \17 (
+size_t
+)];
+
+342 #iâdeà
+__ýlu¥lus
+
+
+343 \e\19
+_IO_FILE
+
+ t_IO_FILE
+;
+
+346 \19
+ g_IO_FILE_¶us
+;
+
+348 \r\19
+_IO_FILE_¶us
+
+_IO_2_1_¡d\9a_
+;
+
+349 \r\19
+_IO_FILE_¶us
+
+_IO_2_1_¡dout_
+;
+
+350 \r\19
+_IO_FILE_¶us
+
+_IO_2_1_¡d\94r_
+;
+
+351 #iâdeà
+_LIBC
+
+
+352 \ 1
+ #_IO_¡d\9a
+ ((
+_IO_FILE
+*)(&
+_IO_2_1_¡d\9a_
+))
+
+ )
+
+353 \ 1
+ #_IO_¡dout
+ ((
+_IO_FILE
+*)(&
+_IO_2_1_¡dout_
+))
+
+ )
+
+354 \ 1
+ #_IO_¡d\94r
+ ((
+_IO_FILE
+*)(&
+_IO_2_1_¡d\94r_
+))
+
+ )
+
+356 \r
+_IO_FILE
+ *
+_IO_¡d\9a
+
+©\8cibu\8b_hidd\92
+;
+
+357 \r
+_IO_FILE
+ *
+_IO_¡dout
+
+©\8cibu\8b_hidd\92
+;
+
+358 \r
+_IO_FILE
+ *
+_IO_¡d\94r
+
+©\8cibu\8b_hidd\92
+;
+
+366 \e
+__ssize_t
+
+ t__io_»ad_â
+ (\1e*
+ t__cook\9b
+, \ 5*
+ t__buf
+,
+ tsize_t
+
+ t__nby\8bs
+);
+
+374 \e
+__ssize_t
+
+ t__io_wr\99e_â
+ (\1e*
+ t__cook\9b
+,
+ t__cڡ
+ \ 5*
+ t__buf
+,
+
+375
+ tsize_t
+
+ t__n
+);
+
+383 \e\12
+ t__io_£ek_â
+ (\1e*
+ t__cook\9b
+,
+ t_IO_off64_t
+ *
+ t__pos
+, \12
+ t__w
+);
+
+386 \e\12
+ t__io_þo£_â
+ (\1e*
+ t__cook\9b
+);
+
+389 #ifdeà
+_GNU_SOURCE
+
+
+391 \e
+__io_»ad_â
+
+ tcook\9b_»ad_funùiÚ_t
+;
+
+392 \e
+__io_wr\99e_â
+
+ tcook\9b_wr\99e_funùiÚ_t
+;
+
+393 \e
+__io_£ek_â
+
+ tcook\9b_£ek_funùiÚ_t
+;
+
+394 \e
+__io_þo£_â
+
+ tcook\9b_þo£_funùiÚ_t
+;
+
+399
+__io_»ad_â
+ *
+ m»ad
+;
+
+400
+__io_wr\99e_â
+ *
+ mwr\99e
+;
+
+401
+__io_£ek_â
+ *
+ m£ek
+;
+
+402
+__io_þo£_â
+ *
+ mþo£
+;
+
+403 }
+ t_IO_cook\9b_io_funùiÚs_t
+;
+
+404 \e
+_IO_cook\9b_io_funùiÚs_t
+
+ tcook\9b_io_funùiÚs_t
+;
+
+406 \19
+ g_IO_cook\9b_f\9ee
+;
+
+409 \r\1e
+_IO_cook\9b_\9a\99
+ (\19
+_IO_cook\9b_f\9ee
+ *
+__cf\9ee
+, \12
+__»ad_wr\99e
+,
+
+410 \1e*
+__cook\9b
+,
+_IO_cook\9b_io_funùiÚs_t
+
+__âs
+);
+
+414 #ifdeà
+__ýlu¥lus
+
+
+418 \r\12
+__und\94æow
+ (
+_IO_FILE
+ *);
+
+419 \r\12
+__uæow
+ (
+_IO_FILE
+ *);
+
+420 \r\12
+__ov\94æow
+ (
+_IO_FILE
+ *, \12);
+
+421 #ià
+def\9aed
+
+_LIBC
+ || def\9aed
+_GLIBCPP_USE_WCHAR_T
+
+
+422 \r
+_IO_w\9at_t
+
+__wund\94æow
+ (
+_IO_FILE
+ *);
+
+423 \r
+_IO_w\9at_t
+
+__wuæow
+ (
+_IO_FILE
+ *);
+
+424 \r
+_IO_w\9at_t
+
+__wov\94æow
+ (
+_IO_FILE
+ *, _IO_wint_t);
+
+427 #ià
+__GNUC__
+ >= 3
+
+428 \ 1
+ #_IO_BE
+(
+ex´
+,
+»s
+è
+ `__bu\9et\9a_ex³ù
+ (Óx´),\84es)
+
+ )
+
+430 \ 1
+ #_IO_BE
+(
+ex´
+,
+»s
+èÓx´)
+
+ )
+
+433 \ 1
+ #_IO_g\91c_uÆocked
+(
+_å
+) \
+
+434 (
+ `_IO_BE
+ ((
+_å
+)->
+_IO_»ad_±r
+ >ð(_å)->
+_IO_»ad_\92d
+, 0) \
+
+435 ?
+ `__uæow
+ (
+_å
+è: *(\1d\ 5*è(_å)->
+_IO_»ad_±r
+++)
+
+ )
+
+436 \ 1
+ #_IO_³ekc_uÆocked
+(
+_å
+) \
+
+437 (
+ `_IO_BE
+ ((
+_å
+)->
+_IO_»ad_±r
+ >ð(_å)->
+_IO_»ad_\92d
+, 0) \
+
+438 &&
+ `__und\94æow
+ (
+_å
+è=ð
+EOF
+ ? EOF \
+
+439 : *(\1d\ 5*è(
+_å
+)->
+_IO_»ad_±r
+)
+
+ )
+
+440 \ 1
+ #_IO_putc_uÆocked
+(
+_ch
+,
+_å
+) \
+
+441 (
+ `_IO_BE
+ ((
+_å
+)->
+_IO_wr\99e_±r
+ >ð(_å)->
+_IO_wr\99e_\92d
+, 0) \
+
+442 ?
+ `__ov\94æow
+ (
+_å
+, (\1d\ 5è(
+_ch
+)) \
+
+443 : (\1d\ 5è(*(
+_å
+)->
+_IO_wr\99e_±r
+++ = (
+_ch
+)))
+
+ )
+
+445 #ià
+def\9aed
+
+_LIBC
+ || def\9aed
+_GLIBCPP_USE_WCHAR_T
+
+
+446 \ 1
+ #_IO_g\91wc_uÆocked
+(
+_å
+) \
+
+447 (
+ `_IO_BE
+ ((
+_å
+)->
+_wide_d©a
+ =ð
+NULL
+ \
+
+448 || ((
+_å
+)->
+_wide_d©a
+->
+_IO_»ad_±r
+ \
+
+449 >ð(
+_å
+)->
+_wide_d©a
+->
+_IO_»ad_\92d
+), 0) \
+
+450 ?
+ `__wuæow
+ (
+_å
+è: (
+_IO_w\9at_t
+è*(_å)->
+_wide_d©a
+->
+_IO_»ad_±r
+++)
+
+ )
+
+451 \ 1
+ #_IO_putwc_uÆocked
+(
+_wch
+,
+_å
+) \
+
+452 (
+ `_IO_BE
+ ((
+_å
+)->
+_wide_d©a
+ =ð
+NULL
+ \
+
+453 || ((
+_å
+)->
+_wide_d©a
+->
+_IO_wr\99e_±r
+ \
+
+454 >ð(
+_å
+)->
+_wide_d©a
+->
+_IO_wr\99e_\92d
+), 0) \
+
+455 ?
+ `__wov\94æow
+ (
+_å
+,
+_wch
+) \
+
+456 : (
+_IO_w\9at_t
+è(*(
+_å
+)->
+_wide_d©a
+->
+_IO_wr\99e_±r
+++ = (
+_wch
+)))
+
+ )
+
+459 \ 1
+ #_IO_ãof_uÆocked
+(
+__å
+è(((__å)->
+_æags
+ &
+_IO_EOF_SEEN
+è!ð0)
+
+ )
+
+460 \ 1
+ #_IO_ã¼Ü_uÆocked
+(
+__å
+è(((__å)->
+_æags
+ &
+_IO_ERR_SEEN
+è!ð0)
+
+ )
+
+462 \r\12
+_IO_g\91c
+ (
+_IO_FILE
+ *
+__å
+);
+
+463 \r\12
+_IO_putc
+ (\12
+__c
+,
+_IO_FILE
+ *
+__å
+);
+
+464 \r\12
+_IO_ãof
+ (
+_IO_FILE
+ *
+__å
+è
+__THROW
+;
+
+465 \r\12
+_IO_ã¼Ü
+ (
+_IO_FILE
+ *
+__å
+è
+__THROW
+;
+
+467 \r\12
+_IO_³ekc_locked
+ (
+_IO_FILE
+ *
+__å
+);
+
+470 \ 1
+ #_IO_PENDING_OUTPUT_COUNT
+(
+_å
+) \
+
+471 ((
+_å
+)->
+_IO_wr\99e_±r
+ - (_å)->
+_IO_wr\99e_ba£
+)
+
+ )
+
+473 \r\1e
+_IO_æockf\9ee
+ (
+_IO_FILE
+ *è
+__THROW
+;
+
+474 \r\1e
+_IO_fuÆockf\9ee
+ (
+_IO_FILE
+ *è
+__THROW
+;
+
+475 \r\12
+_IO_árylockf\9ee
+ (
+_IO_FILE
+ *è
+__THROW
+;
+
+477 #ifdeà
+_IO_MTSAFE_IO
+
+
+478 \ 1
+ #_IO_³ekc
+(
+_å
+è
+ `_IO_³ekc_locked
+ (_å)
+
+ )
+
+479 \ 1
+ #_IO_æockf\9ee
+(
+_å
+) \
+
+480 ià(((
+_å
+)->
+_æags
+ &
+_IO_USER_LOCK
+è=ð0è
+ `_IO_æockf\9ee
+ (_å)
+
+ )
+
+481 \ 1
+ #_IO_fuÆockf\9ee
+(
+_å
+) \
+
+482 ià(((
+_å
+)->
+_æags
+ &
+_IO_USER_LOCK
+è=ð0è
+ `_IO_fuÆockf\9ee
+ (_å)
+
+ )
+
+484 \ 1
+ #_IO_³ekc
+(
+_å
+è
+ `_IO_³ekc_uÆocked
+ (_å)
+
+ )
+
+485 \ 1
+ #_IO_æockf\9ee
+(
+_å
+è
+
+ )
+
+486 \ 1
+ #_IO_fuÆockf\9ee
+(
+_å
+è
+
+ )
+
+487 \ 1
+ #_IO_árylockf\9ee
+(
+_å
+è
+
+ )
+
+488 \ 1
+ #_IO_þ\97nup_»giÚ_¡¬t
+(
+_fù
+,
+_å
+è
+
+ )
+
+489 \ 1
+ #_IO_þ\97nup_»giÚ_\92d
+(
+_Do\99
+è
+
+ )
+
+492 \r\12
+_IO_vfsÿnf
+ (
+_IO_FILE
+ *
+__»¡riù
+, const \ 5* __restrict,
+
+493
+_IO_va_li¡
+, \12*
+__»¡riù
+);
+
+494 \r\12
+_IO_vår\9atf
+ (
+_IO_FILE
+ *
+__»¡riù
+, const \ 5*__restrict,
+
+495
+_IO_va_li¡
+);
+
+496 \r
+_IO_ssize_t
+
+_IO_·dn
+ (
+_IO_FILE
+ *, \12, _IO_ssize_t);
+
+497 \r
+_IO_size_t
+
+_IO_sg\91n
+ (
+_IO_FILE
+ *, \1e*, _IO_size_t);
+
+499 \r
+_IO_off64_t
+
+_IO_£ekoff
+ (
+_IO_FILE
+ *, _IO_off64_t, \12, \12);
+
+500 \r
+_IO_off64_t
+
+_IO_£ekpos
+ (
+_IO_FILE
+ *, _IO_off64_t, \12);
+
+502 \r\1e
+_IO_ä\93_backup_¬\97
+ (
+_IO_FILE
+ *è
+__THROW
+;
+
+504 #ià
+def\9aed
+
+_LIBC
+ || def\9aed
+_GLIBCPP_USE_WCHAR_T
+
+
+505 \r
+_IO_w\9at_t
+
+_IO_g\91wc
+ (
+_IO_FILE
+ *
+__å
+);
+
+506 \r
+_IO_w\9at_t
+
+_IO_putwc
+ (
+wch¬_t
+
+__wc
+,
+_IO_FILE
+ *
+__å
+);
+
+507 \r\12
+_IO_fwide
+ (
+_IO_FILE
+ *
+__å
+, \12
+__mode
+è
+__THROW
+;
+
+508 #ià
+__GNUC__
+ >= 2
+
+511 #ià
+def\9aed
+
+_LIBC
+ && def\9aed
+SHARED
+
+
+512 \ 2
+ ~<shlib-com·t.h
+>
+
+513 #ià
+SHLIB_COMPAT
+ (
+libc
+,
+GLIBC_2_0
+,
+GLIBC_2_1
+)
+
+514 \ 1
+ #_IO_fwide_maybe_\9acom·tibË
+ \
+
+515 (
+ `__bu\9et\9a_ex³ù
+ (&
+_IO_¡d\9a_u£d
+ =ð
+NULL
+, 0))
+
+ )
+
+516 \rcڡ \12
+_IO_¡d\9a_u£d
+;
+
+517
+w\97k_ex\8bº
+ (
+_IO_¡d\9a_u£d
+);
+
+520 #iâdeà
+_IO_fwide_maybe_\9acom·tibË
+
+
+521 \ 1
+ #_IO_fwide_maybe_\9acom·tibË
+ (0)
+
+ )
+
+525 \ 1
+ #_IO_fwide
+(
+__å
+,
+__mode
+) \
+
+526 ({ \12
+__»suÉ
+ = (
+__mode
+); \
+
+527 ià(
+__»suÉ
+ < 0 && !
+_IO_fwide_maybe_\9acom·tibË
+) \
+
+529 ià((
+__å
+)->
+_mode
+ == 0) \
+
+531 (
+__å
+)->
+_mode
+ = -1; \
+
+532
+__»suÉ
+ = (
+__å
+)->
+_mode
+; \
+
+534 \vià(
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__mode
+) && (__mode) == 0) \
+
+535
+__»suÉ
+ =
+_IO_fwide_maybe_\9acom·tibË
+ ? -1 : (
+__å
+)->
+_mode
+; \
+
+537
+__»suÉ
+ =
+ `_IO_fwide
+ (
+__å
+, __result); \
+
+538
+__»suÉ
+; })
+
+ )
+
+541 \r\12
+_IO_vfwsÿnf
+ (
+_IO_FILE
+ *
+__»¡riù
+, cڡ
+wch¬_t
+ * __restrict,
+
+542
+_IO_va_li¡
+, \12*
+__»¡riù
+);
+
+543 \r\12
+_IO_vfw´\9atf
+ (
+_IO_FILE
+ *
+__»¡riù
+, cڡ
+wch¬_t
+ *__restrict,
+
+544
+_IO_va_li¡
+);
+
+545 \r
+_IO_ssize_t
+
+_IO_w·dn
+ (
+_IO_FILE
+ *,
+w\9at_t
+, _IO_ssize_t);
+
+546 \r\1e
+_IO_ä\93_wbackup_¬\97
+ (
+_IO_FILE
+ *è
+__THROW
+;
+
+549 #ifdeà
+__LDBL_COMPAT
+
+
+550 \ 2
+ ~<b\99s/libio-ldbl.h
+>
+
+553 #ifdeà
+__ýlu¥lus
+
+
+ @/usr/include/sys/types.h
+
+23 #iâdef
+_SYS_TYPES_H
+
+
+24 \ 1
+ #_SYS_TYPES_H
+ 1
+
+ )
+
+26 \ 2
+ ~<ã©u»s.h
+>
+
+28
+ g__BEGIN_DECLS
+
+
+30 \ 2
+ ~<b\99s/ty³s.h
+>
+
+32 #ifdef
+__USE_BSD
+
+
+33 #iâdeà
+__u_ch¬_def\9aed
+
+
+34 \e
+__u_ch¬
+
+ tu_ch¬
+;
+
+35 \e
+__u_shÜt
+
+ tu_shÜt
+;
+
+36 \e
+__u_\9at
+
+ tu_\9at
+;
+
+37 \e
+__u_lÚg
+
+ tu_lÚg
+;
+
+38 \e
+__quad_t
+
+ tquad_t
+;
+
+39 \e
+__u_quad_t
+
+ tu_quad_t
+;
+
+40 \e
+__fsid_t
+
+ tfsid_t
+;
+
+41 \ 1
+ #__u_ch¬_def\9aed
+
+
+ )
+
+45 \e
+__loff_t
+
+ tloff_t
+;
+
+47 #iâdeà
+__\9ao_t_def\9aed
+
+
+48 #iâdeà
+__USE_FILE_OFFSET64
+
+
+49 \e
+__\9ao_t
+
+ t\9ao_t
+;
+
+51 \e
+__\9ao64_t
+
+ t\9ao_t
+;
+
+53 \ 1
+ #__\9ao_t_def\9aed
+
+
+ )
+
+55 #ià
+def\9aed
+
+__USE_LARGEFILE64
+ && !def\9aed
+__\9ao64_t_def\9aed
+
+
+56 \e
+__\9ao64_t
+
+ t\9ao64_t
+;
+
+57 \ 1
+ #__\9ao64_t_def\9aed
+
+
+ )
+
+60 #iâdeà
+__dev_t_def\9aed
+
+
+61 \e
+__dev_t
+
+ tdev_t
+;
+
+62 \ 1
+ #__dev_t_def\9aed
+
+
+ )
+
+65 #iâdeà
+__gid_t_def\9aed
+
+
+66 \e
+__gid_t
+
+ tgid_t
+;
+
+67 \ 1
+ #__gid_t_def\9aed
+
+
+ )
+
+70 #iâdeà
+__mode_t_def\9aed
+
+
+71 \e
+__mode_t
+
+ tmode_t
+;
+
+72 \ 1
+ #__mode_t_def\9aed
+
+
+ )
+
+75 #iâdeà
+__Æ\9ak_t_def\9aed
+
+
+76 \e
+__ƚk_t
+
+ tƚk_t
+;
+
+77 \ 1
+ #__Æ\9ak_t_def\9aed
+
+
+ )
+
+80 #iâdeà
+__uid_t_def\9aed
+
+
+81 \e
+__uid_t
+
+ tuid_t
+;
+
+82 \ 1
+ #__uid_t_def\9aed
+
+
+ )
+
+85 #iâdeà
+__off_t_def\9aed
+
+
+86 #iâdeà
+__USE_FILE_OFFSET64
+
+
+87 \e
+__off_t
+
+ toff_t
+;
+
+89 \e
+__off64_t
+
+ toff_t
+;
+
+91 \ 1
+ #__off_t_def\9aed
+
+
+ )
+
+93 #ià
+def\9aed
+
+__USE_LARGEFILE64
+ && !def\9aed
+__off64_t_def\9aed
+
+
+94 \e
+__off64_t
+
+ toff64_t
+;
+
+95 \ 1
+ #__off64_t_def\9aed
+
+
+ )
+
+98 #iâdeà
+__pid_t_def\9aed
+
+
+99 \e
+__pid_t
+
+ tpid_t
+;
+
+100 \ 1
+ #__pid_t_def\9aed
+
+
+ )
+
+103 #ià(
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_XOPEN
+ || def\9aed
+__USE_XOPEN2K8
+) \
+
+104 && !
+def\9aed
+
+__id_t_def\9aed
+
+
+105 \e
+__id_t
+
+ tid_t
+;
+
+106 \ 1
+ #__id_t_def\9aed
+
+
+ )
+
+109 #iâdeà
+__ssize_t_def\9aed
+
+
+110 \e
+__ssize_t
+
+ tssize_t
+;
+
+111 \ 1
+ #__ssize_t_def\9aed
+
+
+ )
+
+114 #ifdef
+__USE_BSD
+
+
+115 #iâdeà
+__daddr_t_def\9aed
+
+
+116 \e
+__daddr_t
+
+ tdaddr_t
+;
+
+117 \e
+__ÿddr_t
+
+ tÿddr_t
+;
+
+118 \ 1
+ #__daddr_t_def\9aed
+
+
+ )
+
+122 #ià(
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_XOPEN
+è&& !def\9aed
+__key_t_def\9aed
+
+
+123 \e
+__key_t
+
+ tkey_t
+;
+
+124 \ 1
+ #__key_t_def\9aed
+
+
+ )
+
+127 #ià
+def\9aed
+
+__USE_XOPEN
+ || def\9aed
+__USE_XOPEN2K8
+
+
+128 \ 1
+ #__Ãed_þock_t
+
+
+ )
+
+130 \ 1
+ #__Ãed_time_t
+
+
+ )
+
+131 \ 1
+ #__Ãed_tim\94_t
+
+
+ )
+
+132 \ 1
+ #__Ãed_þockid_t
+
+
+ )
+
+133 \ 2
+ ~<time.h
+>
+
+135 #ifdeà
+__USE_XOPEN
+
+
+136 #iâdeà
+__u£cÚds_t_def\9aed
+
+
+137 \e
+__u£cÚds_t
+
+ tu£cÚds_t
+;
+
+138 \ 1
+ #__u£cÚds_t_def\9aed
+
+
+ )
+
+140 #iâdeà
+__su£cÚds_t_def\9aed
+
+
+141 \e
+__su£cÚds_t
+
+ tsu£cÚds_t
+;
+
+142 \ 1
+ #__su£cÚds_t_def\9aed
+
+
+ )
+
+146 \ 1
+ #__Ãed_size_t
+
+
+ )
+
+147 \ 2
+ ~<¡ddef.h
+>
+
+149 #ifdeà
+__USE_MISC
+
+
+151 \e\1d\13\12
+ tulÚg
+;
+
+152 \e\1d\16\12
+ tushÜt
+;
+
+153 \e\1d\12
+ tu\9at
+;
+
+158 #ià!
+__GNUC_PREREQ
+ (2, 7)
+
+161 #iâdeà
+__\9at8_t_def\9aed
+
+
+162 \ 1
+ #__\9at8_t_def\9aed
+
+
+ )
+
+163 \e\ 5
+ t\9at8_t
+;
+
+164 \e\16\12
+ t\9at16_t
+;
+
+165 \e\12
+ t\9at32_t
+;
+
+166 #ià
+__WORDSIZE
+ == 64
+
+167 \e\13\12
+ t\9at64_t
+;
+
+168 #\96ià
+__GLIBC_HAVE_LONG_LONG
+
+
+169
+__ex\8bnsiÚ__
+ \e\13\13\12
+ t\9at64_t
+;
+
+174 \e\1d\ 5
+ tu_\9at8_t
+;
+
+175 \e\1d\16\12
+ tu_\9at16_t
+;
+
+176 \e\1d\12
+ tu_\9at32_t
+;
+
+177 #ià
+__WORDSIZE
+ == 64
+
+178 \e\1d\13\12
+ tu_\9at64_t
+;
+
+179 #\96ià
+__GLIBC_HAVE_LONG_LONG
+
+
+180
+__ex\8bnsiÚ__
+ \e\1d\13\13\12
+ tu_\9at64_t
+;
+
+183 \e\12
+ t»gi¡\94_t
+;
+
+188 \ 1
+ #__\9atN_t
+(
+N
+,
+MODE
+) \
+
+189 \e\12\12##
+ tN
+##
+ t_t
+
+ t__©\8cibu\8b__
+ ((
+ t__mode__
+ (
+ tMODE
+)))
+
+ )
+
+190 \ 1
+ t__u_\9atN_t
+(
+ tN
+,
+ tMODE
+) \
+
+191 \e\1d\12
+ tu_\9at
+##
+ tN
+##
+ t_t
+
+ t__©\8cibu\8b__
+ ((
+ t__mode__
+ (
+ tMODE
+)))
+
+ )
+
+193 #iâdeà
+ t__\9at8_t_def\9aed
+
+
+194 \ 1
+ t__\9at8_t_def\9aed
+
+
+ )
+
+195
+ t__\9atN_t
+ (8,
+ t__QI__
+);
+
+196
+__\9atN_t
+ (16,
+__HI__
+);
+
+197
+__\9atN_t
+ (32,
+__SI__
+);
+
+198
+__\9atN_t
+ (64,
+__DI__
+);
+
+201
+__u_\9atN_t
+ (8,
+__QI__
+);
+
+202
+__u_\9atN_t
+ (16,
+__HI__
+);
+
+203
+__u_\9atN_t
+ (32,
+__SI__
+);
+
+204
+__u_\9atN_t
+ (64,
+__DI__
+);
+
+206 \e\12
+ t»gi¡\94_t
+
+ t__©\8cibu\8b__
+ ((
+ t__mode__
+ (
+ t__wÜd__
+)));
+
+212 \ 1
+ #__BIT_TYPES_DEFINED__
+ 1
+
+ )
+
+215 #ifdef
+__USE_BSD
+
+
+217 \ 2
+ ~<\92d\9fn.h
+>
+
+220 \ 2
+ ~<sys/£Ëù.h
+>
+
+223 \ 2
+ ~<sys/sysmaüos.h
+>
+
+227 #ià(
+def\9aed
+
+__USE_UNIX98
+ || def\9aed
+__USE_XOPEN2K8
+) \
+
+228 && !
+def\9aed
+
+__blksize_t_def\9aed
+
+
+229 \e
+__blksize_t
+
+ tblksize_t
+;
+
+230 \ 1
+ #__blksize_t_def\9aed
+
+
+ )
+
+234 #iâdeà
+__USE_FILE_OFFSET64
+
+
+235 #iâdeà
+__blkút_t_def\9aed
+
+
+236 \e
+__blkút_t
+
+ tblkút_t
+;
+
+237 \ 1
+ #__blkút_t_def\9aed
+
+
+ )
+
+239 #iâdeà
+__fsblkút_t_def\9aed
+
+
+240 \e
+__fsblkút_t
+
+ tfsblkút_t
+;
+
+241 \ 1
+ #__fsblkút_t_def\9aed
+
+
+ )
+
+243 #iâdeà
+__fsf\9eút_t_def\9aed
+
+
+244 \e
+__fsf\9eút_t
+
+ tfsf\9eút_t
+;
+
+245 \ 1
+ #__fsf\9eút_t_def\9aed
+
+
+ )
+
+248 #iâdeà
+__blkút_t_def\9aed
+
+
+249 \e
+__blkút64_t
+
+ tblkút_t
+;
+
+250 \ 1
+ #__blkút_t_def\9aed
+
+
+ )
+
+252 #iâdeà
+__fsblkút_t_def\9aed
+
+
+253 \e
+__fsblkút64_t
+
+ tfsblkút_t
+;
+
+254 \ 1
+ #__fsblkút_t_def\9aed
+
+
+ )
+
+256 #iâdeà
+__fsf\9eút_t_def\9aed
+
+
+257 \e
+__fsf\9eút64_t
+
+ tfsf\9eút_t
+;
+
+258 \ 1
+ #__fsf\9eút_t_def\9aed
+
+
+ )
+
+262 #ifdeà
+__USE_LARGEFILE64
+
+
+263 \e
+__blkút64_t
+
+ tblkút64_t
+;
+
+264 \e
+__fsblkút64_t
+
+ tfsblkút64_t
+;
+
+265 \e
+__fsf\9eút64_t
+
+ tfsf\9eút64_t
+;
+
+270 #ià
+def\9aed
+
+__USE_POSIX199506
+ || def\9aed
+__USE_UNIX98
+
+
+271 \ 2
+ ~<b\99s/±h»adty³s.h
+>
+
+274
+ g__END_DECLS
+
+
+ @/usr/include/xlocale.h
+
+21 #iâdeà
+_XLOCALE_H
+
+
+22 \ 1
+ #_XLOCALE_H
+ 1
+
+ )
+
+28 \e\19
+ s__loÿË_¡ruù
+
+
+31 \19
+__loÿË_d©a
+ *
+ m__loÿËs
+[13];
+
+34 cڡ \1d\16\12*
+ m__ùy³_b
+;
+
+35 cڡ \12*
+ m__ùy³_tÞow\94
+;
+
+36 cڡ \12*
+ m__ùy³_touµ\94
+;
+
+39 cڡ \ 5*
+ m__Çmes
+[13];
+
+40 } *
+ t__loÿË_t
+;
+
+43 \e
+__loÿË_t
+
+ tloÿË_t
+;
+
+ @/usr/include/_G_config.h
+
+4 #iâdeà
+_G_cÚfig_h
+
+
+5 \ 1
+ #_G_cÚfig_h
+ 1
+
+ )
+
+9 \ 2
+ ~<b\99s/ty³s.h
+>
+
+10 \ 1
+ #__Ãed_size_t
+
+
+ )
+
+11 #ià
+def\9aed
+
+_LIBC
+ || def\9aed
+_GLIBCPP_USE_WCHAR_T
+
+
+12 \ 1
+ #__Ãed_wch¬_t
+
+
+ )
+
+14 \ 1
+ #__Ãed_NULL
+
+
+ )
+
+15 \ 2
+ ~<¡ddef.h
+>
+
+16 \ 1
+ #__Ãed_mb¡©e_t
+
+
+ )
+
+17 #ià
+def\9aed
+
+_LIBC
+ || def\9aed
+_GLIBCPP_USE_WCHAR_T
+
+
+18 \ 1
+ #__Ãed_w\9at_t
+
+
+ )
+
+20 \ 2
+ ~<wch¬.h
+>
+
+21 \ 1
+ #_G_size_t
+
+size_t
+
+
+ )
+
+24
+__off_t
+
+ m__pos
+;
+
+25
+__mb¡©e_t
+
+ m__¡©e
+;
+
+26 }
+ t_G_åos_t
+;
+
+29
+__off64_t
+
+ m__pos
+;
+
+30
+__mb¡©e_t
+
+ m__¡©e
+;
+
+31 }
+ t_G_åos64_t
+;
+
+32 \ 1
+ #_G_ssize_t
+
+__ssize_t
+
+
+ )
+
+33 \ 1
+ #_G_off_t
+
+__off_t
+
+
+ )
+
+34 \ 1
+ #_G_off64_t
+
+__off64_t
+
+
+ )
+
+35 \ 1
+ #_G_pid_t
+
+__pid_t
+
+
+ )
+
+36 \ 1
+ #_G_uid_t
+
+__uid_t
+
+
+ )
+
+37 \ 1
+ #_G_wch¬_t
+
+wch¬_t
+
+
+ )
+
+38 \ 1
+ #_G_w\9at_t
+
+w\9at_t
+
+
+ )
+
+39 \ 1
+ #_G_¡©64
+
+¡©64
+
+
+ )
+
+40 #ià
+def\9aed
+
+_LIBC
+ || def\9aed
+_GLIBCPP_USE_WCHAR_T
+
+
+41 \ 2
+ ~<gcÚv.h
+>
+
+44 \19
+__gcÚv_\9afo
+
+ m__cd
+;
+
+47 \19
+__gcÚv_\9afo
+
+ m__cd
+;
+
+48 \19
+__gcÚv_¡\95_d©a
+
+ m__d©a
+;
+
+49 }
+ m__comb\9aed
+;
+
+50 }
+ t_G_icÚv_t
+;
+
+53 \e\12
+ t_G_\9at16_t
+
+ t__©\8cibu\8b__
+ ((
+ t__mode__
+ (
+ t__HI__
+)));
+
+54 \e\12
+ t_G_\9at32_t
+
+ t__©\8cibu\8b__
+ ((
+ t__mode__
+ (
+ t__SI__
+)));
+
+55 \e\1d\12
+ t_G_u\9at16_t
+
+ t__©\8cibu\8b__
+ ((
+ t__mode__
+ (
+ t__HI__
+)));
+
+56 \e\1d\12
+ t_G_u\9at32_t
+
+ t__©\8cibu\8b__
+ ((
+ t__mode__
+ (
+ t__SI__
+)));
+
+58 \ 1
+ #_G_HAVE_BOOL
+ 1
+
+ )
+
+62 \ 1
+ #_G_HAVE_ATEXIT
+ 1
+
+ )
+
+63 \ 1
+ #_G_HAVE_SYS_CDEFS
+ 1
+
+ )
+
+64 \ 1
+ #_G_HAVE_SYS_WAIT
+ 1
+
+ )
+
+65 \ 1
+ #_G_NEED_STDARG_H
+ 1
+
+ )
+
+66 \ 1
+ #_G_va_li¡
+
+__gnuc_va_li¡
+
+
+ )
+
+68 \ 1
+ #_G_HAVE_PRINTF_FP
+ 1
+
+ )
+
+69 \ 1
+ #_G_HAVE_MMAP
+ 1
+
+ )
+
+70 \ 1
+ #_G_HAVE_MREMAP
+ 1
+
+ )
+
+71 \ 1
+ #_G_HAVE_LONG_DOUBLE_IO
+ 1
+
+ )
+
+72 \ 1
+ #_G_HAVE_IO_FILE_OPEN
+ 1
+
+ )
+
+73 \ 1
+ #_G_HAVE_IO_GETLINE_INFO
+ 1
+
+ )
+
+75 \ 1
+ #_G_IO_IO_FILE_VERSION
+ 0x20001
+
+ )
+
+77 \ 1
+ #_G_OPEN64
+
+__ݒ64
+
+
+ )
+
+78 \ 1
+ #_G_LSEEK64
+
+__l£ek64
+
+
+ )
+
+79 \ 1
+ #_G_MMAP64
+
+__mm64
+
+
+ )
+
+80 \ 1
+ #_G_FSTAT64
+(
+fd
+,
+buf
+è
+ `__fx¡©64
+ (
+_STAT_VER
+, fd, buf)
+
+ )
+
+83 \ 1
+ #_G_HAVE_ST_BLKSIZE
+
+ `def\9aed
+ (
+_STATBUF_ST_BLKSIZE
+)
+
+ )
+
+85 \ 1
+ #_G_BUFSIZ
+ 8192
+
+ )
+
+88 \ 1
+ #_G_NAMES_HAVE_UNDERSCORE
+ 0
+
+ )
+
+89 \ 1
+ #_G_VTABLE_LABEL_HAS_LENGTH
+ 1
+
+ )
+
+90 \ 1
+ #_G_USING_THUNKS
+ 1
+
+ )
+
+91 \ 1
+ #_G_VTABLE_LABEL_PREFIX
+ "__vt_"
+
+ )
+
+92 \ 1
+ #_G_VTABLE_LABEL_PREFIX_ID
+
+__vt_
+
+
+ )
+
+95 #ià
+def\9aed
+
+__ýlu¥lus
+ || def\9aed
+__STDC__
+
+
+96 \ 1
+ #_G_ARGS
+(
+ARGLIST
+è
+ )
+ARGLIST
+
+98 \ 1
+ #_G_ARGS
+(
+ARGLIST
+è()
+
+ )
+
+ @/usr/include/bits/libio-ldbl.h
+
+20 #iâdeà
+_IO_STDIO_H
+
+
+24
+ $__LDBL_REDIR_DECL
+ (
+_IO_vfsÿnf
+)
+
+25
+ `__LDBL_REDIR_DECL
+ (
+_IO_vår\9atf
+)
+
+ @/usr/include/bits/local_lim.h
+
+25 #iâdeà
+NR_OPEN
+
+
+26 \ 1
+ #__undef_NR_OPEN
+
+
+ )
+
+28 #iâdeà
+LINK_MAX
+
+
+29 \ 1
+ #__undef_LINK_MAX
+
+
+ )
+
+31 #iâdeà
+OPEN_MAX
+
+
+32 \ 1
+ #__undef_OPEN_MAX
+
+
+ )
+
+34 #iâdeà
+ARG_MAX
+
+
+35 \ 1
+ #__undef_ARG_MAX
+
+
+ )
+
+39 \ 2
+ ~<l\9aux/lim\99s.h
+>
+
+42 #ifdeà
+__undef_NR_OPEN
+
+
+43 #undeà
+NR_OPEN
+
+
+44 #undeà
+__undef_NR_OPEN
+
+
+47 #ifdeà
+__undef_LINK_MAX
+
+
+48 #undeà
+LINK_MAX
+
+
+49 #undeà
+__undef_LINK_MAX
+
+
+52 #ifdeà
+__undef_OPEN_MAX
+
+
+53 #undeà
+OPEN_MAX
+
+
+54 #undeà
+__undef_OPEN_MAX
+
+
+57 #ifdeà
+__undef_ARG_MAX
+
+
+58 #undeà
+ARG_MAX
+
+
+59 #undeà
+__undef_ARG_MAX
+
+
+63 \ 1
+ #_POSIX_THREAD_KEYS_MAX
+ 128
+
+ )
+
+65 \ 1
+ #PTHREAD_KEYS_MAX
+ 1024
+
+ )
+
+68 \ 1
+ #_POSIX_THREAD_DESTRUCTOR_ITERATIONS
+ 4
+
+ )
+
+70 \ 1
+ #PTHREAD_DESTRUCTOR_ITERATIONS
+
+_POSIX_THREAD_DESTRUCTOR_ITERATIONS
+
+
+ )
+
+73 \ 1
+ #_POSIX_THREAD_THREADS_MAX
+ 64
+
+ )
+
+75 #undeà
+PTHREAD_THREADS_MAX
+
+
+79 \ 1
+ #AIO_PRIO_DELTA_MAX
+ 20
+
+ )
+
+82 \ 1
+ #PTHREAD_STACK_MIN
+ 16384
+
+ )
+
+85 \ 1
+ #DELAYTIMER_MAX
+ 2147483647
+
+ )
+
+88 \ 1
+ #TTY_NAME_MAX
+ 32
+
+ )
+
+91 \ 1
+ #LOGIN_NAME_MAX
+ 256
+
+ )
+
+94 \ 1
+ #HOST_NAME_MAX
+ 64
+
+ )
+
+97 \ 1
+ #MQ_PRIO_MAX
+ 32768
+
+ )
+
+100 \ 1
+ #SEM_VALUE_MAX
+ (2147483647)
+
+ )
+
+ @/usr/include/bits/predefs.h
+
+19 #iâdeà
+_FEATURES_H
+
+
+23 #iâdeà
+_PREDEFS_H
+
+
+24 \ 1
+ #_PREDEFS_H
+
+
+ )
+
+27 \ 1
+ #__STDC_IEC_559__
+ 1
+
+ )
+
+28 \ 1
+ #__STDC_IEC_559_COMPLEX__
+ 1
+
+ )
+
+ @/usr/include/bits/pthreadtypes.h
+
+20 #iâdeà
+_BITS_PTHREADTYPES_H
+
+
+21 \ 1
+ #_BITS_PTHREADTYPES_H
+ 1
+
+ )
+
+23 \ 2
+ ~<b\99s/wÜdsize.h
+>
+
+25 #ià
+__WORDSIZE
+ == 64
+
+26 \ 1
+ #__SIZEOF_PTHREAD_ATTR_T
+ 56
+
+ )
+
+27 \ 1
+ #__SIZEOF_PTHREAD_MUTEX_T
+ 40
+
+ )
+
+28 \ 1
+ #__SIZEOF_PTHREAD_MUTEXATTR_T
+ 4
+
+ )
+
+29 \ 1
+ #__SIZEOF_PTHREAD_COND_T
+ 48
+
+ )
+
+30 \ 1
+ #__SIZEOF_PTHREAD_CONDATTR_T
+ 4
+
+ )
+
+31 \ 1
+ #__SIZEOF_PTHREAD_RWLOCK_T
+ 56
+
+ )
+
+32 \ 1
+ #__SIZEOF_PTHREAD_RWLOCKATTR_T
+ 8
+
+ )
+
+33 \ 1
+ #__SIZEOF_PTHREAD_BARRIER_T
+ 32
+
+ )
+
+34 \ 1
+ #__SIZEOF_PTHREAD_BARRIERATTR_T
+ 4
+
+ )
+
+36 \ 1
+ #__SIZEOF_PTHREAD_ATTR_T
+ 36
+
+ )
+
+37 \ 1
+ #__SIZEOF_PTHREAD_MUTEX_T
+ 24
+
+ )
+
+38 \ 1
+ #__SIZEOF_PTHREAD_MUTEXATTR_T
+ 4
+
+ )
+
+39 \ 1
+ #__SIZEOF_PTHREAD_COND_T
+ 48
+
+ )
+
+40 \ 1
+ #__SIZEOF_PTHREAD_CONDATTR_T
+ 4
+
+ )
+
+41 \ 1
+ #__SIZEOF_PTHREAD_RWLOCK_T
+ 32
+
+ )
+
+42 \ 1
+ #__SIZEOF_PTHREAD_RWLOCKATTR_T
+ 8
+
+ )
+
+43 \ 1
+ #__SIZEOF_PTHREAD_BARRIER_T
+ 20
+
+ )
+
+44 \ 1
+ #__SIZEOF_PTHREAD_BARRIERATTR_T
+ 4
+
+ )
+
+50 \e\1d\13\12
+ t±h»ad_t
+;
+
+55 \ 5
+ m__size
+[
+__SIZEOF_PTHREAD_ATTR_T
+];
+
+56 \13\12
+ m__®ign
+;
+
+57 }
+ t±h»ad_©\8c_t
+;
+
+60 #ià
+__WORDSIZE
+ == 64
+
+61 \e\19
+ s__±h»ad_\9a\8bº®_li¡
+
+
+63 \19
+__±h»ad_\9a\8bº®_li¡
+ *
+ m__´ev
+;
+
+64 \19
+__±h»ad_\9a\8bº®_li¡
+ *
+ m__Ãxt
+;
+
+65 }
+ t__±h»ad_li¡_t
+;
+
+67 \e\19
+ s__±h»ad_\9a\8bº®_¦i¡
+
+
+69 \19
+__±h»ad_\9a\8bº®_¦i¡
+ *
+ m__Ãxt
+;
+
+70 }
+ t__±h»ad_¦i¡_t
+;
+
+78 \19
+ s__±h»ad_mu\8bx_s
+
+
+80 \12
+ m__lock
+;
+
+81 \1d\12
+ m__couÁ
+;
+
+82 \12
+ m__owÃr
+;
+
+83 #ià
+__WORDSIZE
+ == 64
+
+84 \1d\12
+ m__nu£rs
+;
+
+88 \12
+ m__k\9ad
+;
+
+89 #ià
+__WORDSIZE
+ == 64
+
+90 \12
+ m__¥\9as
+;
+
+91
+__±h»ad_li¡_t
+
+ m__li¡
+;
+
+92 \ 1
+ #__PTHREAD_MUTEX_HAVE_PREV
+ 1
+
+ )
+
+94 \1d\12
+ m__nu£rs
+;
+
+95
+__ex\8bnsiÚ__
+ union
+
+97 \12
+ m__¥\9as
+;
+
+98
+__±h»ad_¦i¡_t
+
+ m__li¡
+;
+
+101 }
+ m__d©a
+;
+
+102 \ 5
+ m__size
+[
+__SIZEOF_PTHREAD_MUTEX_T
+];
+
+103 \13\12
+ m__®ign
+;
+
+104 }
+ t±h»ad_mu\8bx_t
+;
+
+108 \ 5
+ m__size
+[
+__SIZEOF_PTHREAD_MUTEXATTR_T
+];
+
+109 \12
+ m__®ign
+;
+
+110 }
+ t±h»ad_mu\8bx©\8c_t
+;
+
+119 \12
+ m__lock
+;
+
+120 \1d\12
+ m__fu\8bx
+;
+
+121
+__ex\8bnsiÚ__
+ \1d\13\13\12
+ m__tÙ®_£q
+;
+
+122
+__ex\8bnsiÚ__
+ \1d\13\13\12
+ m__wakeup_£q
+;
+
+123
+__ex\8bnsiÚ__
+ \1d\13\13\12
+ m__wok\92_£q
+;
+
+124 \1e*
+ m__mu\8bx
+;
+
+125 \1d\12
+ m__nwa\99\94s
+;
+
+126 \1d\12
+ m__brßdÿ¡_£q
+;
+
+127 }
+ m__d©a
+;
+
+128 \ 5
+ m__size
+[
+__SIZEOF_PTHREAD_COND_T
+];
+
+129
+__ex\8bnsiÚ__
+ \13\13\12
+ m__®ign
+;
+
+130 }
+ t±h»ad_cÚd_t
+;
+
+134 \ 5
+ m__size
+[
+__SIZEOF_PTHREAD_CONDATTR_T
+];
+
+135 \12
+ m__®ign
+;
+
+136 }
+ t±h»ad_cÚd©\8c_t
+;
+
+140 \e\1d\12
+ t±h»ad_key_t
+;
+
+144 \e\12
+ t±h»ad_Úû_t
+;
+
+147 #ià
+def\9aed
+
+__USE_UNIX98
+ || def\9aed
+__USE_XOPEN2K
+
+
+152 #ià
+__WORDSIZE
+ == 64
+
+155 \12
+ m__lock
+;
+
+156 \1d\12
+ m__Ä_»ad\94s
+;
+
+157 \1d\12
+ m__»ad\94s_wakeup
+;
+
+158 \1d\12
+ m__wr\99\94_wakeup
+;
+
+159 \1d\12
+ m__Ä_»ad\94s_queued
+;
+
+160 \1d\12
+ m__Ä_wr\99\94s_queued
+;
+
+161 \12
+ m__wr\99\94
+;
+
+162 \12
+ m__sh¬ed
+;
+
+163 \1d\13\12
+ m__·d1
+;
+
+164 \1d\13\12
+ m__·d2
+;
+
+167 \1d\12
+ m__æags
+;
+
+168 }
+ m__d©a
+;
+
+172 \12
+ m__lock
+;
+
+173 \1d\12
+ m__Ä_»ad\94s
+;
+
+174 \1d\12
+ m__»ad\94s_wakeup
+;
+
+175 \1d\12
+ m__wr\99\94_wakeup
+;
+
+176 \1d\12
+ m__Ä_»ad\94s_queued
+;
+
+177 \1d\12
+ m__Ä_wr\99\94s_queued
+;
+
+180 \1d\ 5
+ m__æags
+;
+
+181 \1d\ 5
+ m__sh¬ed
+;
+
+182 \1d\ 5
+ m__·d1
+;
+
+183 \1d\ 5
+ m__·d2
+;
+
+184 \12
+ m__wr\99\94
+;
+
+185 }
+ m__d©a
+;
+
+187 \ 5
+ m__size
+[
+__SIZEOF_PTHREAD_RWLOCK_T
+];
+
+188 \13\12
+ m__®ign
+;
+
+189 }
+ t±h»ad_rwlock_t
+;
+
+193 \ 5
+ m__size
+[
+__SIZEOF_PTHREAD_RWLOCKATTR_T
+];
+
+194 \13\12
+ m__®ign
+;
+
+195 }
+ t±h»ad_rwlock©\8c_t
+;
+
+199 #ifdeà
+__USE_XOPEN2K
+
+
+201 \evÞ©\9e\90\12
+ t±h»ad_¥\9alock_t
+;
+
+208 \ 5
+ m__size
+[
+__SIZEOF_PTHREAD_BARRIER_T
+];
+
+209 \13\12
+ m__®ign
+;
+
+210 }
+ t±h»ad_b¬r\9br_t
+;
+
+214 \ 5
+ m__size
+[
+__SIZEOF_PTHREAD_BARRIERATTR_T
+];
+
+215 \12
+ m__®ign
+;
+
+216 }
+ t±h»ad_b¬r\9b¿\89r_t
+;
+
+220 #ià
+__WORDSIZE
+ == 32
+
+222 \ 1
+ #__þ\97nup_fù_©\8cibu\8b
+
+ `__©\8cibu\8b__
+ ((
+ `__»g·rm__
+ (1)))
+
+ )
+
+ @/usr/include/bits/stdio-lock.h
+
+20 #iâdeà
+_BITS_STDIO_LOCK_H
+
+
+21 \ 1
+ #_BITS_STDIO_LOCK_H
+ 1
+
+ )
+
+23 \ 2
+ ~<b\99s/libc-lock.h
+>
+
+24 \ 2
+ ~<lowËv\96lock.h
+>
+
+28 \ 1
+ #_IO_lock_\9aex³nsive
+ 1
+
+ )
+
+30 \e¡ruù { \12
+ mlock
+; \12
+ mút
+; \1e*
+ mowÃr
+; }
+ t_IO_lock_t
+;
+
+32 \ 1
+ #_IO_lock_\9a\99\9fliz\94
+ {
+LLL_LOCK_INITIALIZER
+, 0,
+NULL
+ }
+
+ )
+
+34 \ 1
+ #_IO_lock_\9a\99
+(
+_Çme
+) \
+
+35 ((
+_Çme
+èð(
+_IO_lock_t
+è
+_IO_lock_\9a\99\9fliz\94
+ , 0)
+
+ )
+
+37 \ 1
+ #_IO_lock_f\9ai
+(
+_Çme
+) \
+
+38 ((\1eè0)
+
+ )
+
+40 \ 1
+ #_IO_lock_lock
+(
+_Çme
+) \
+
+42 \1e*
+__£lf
+ =
+THREAD_SELF
+; \
+
+43 ià((
+_Çme
+).
+owÃr
+ !ð
+__£lf
+) \
+
+45
+ `Îl_lock
+ ((
+_Çme
+).
+lock
+,
+LLL_PRIVATE
+); \
+
+46 (
+_Çme
+).
+owÃr
+ =
+__£lf
+; \
+
+48 ++(
+_Çme
+).
+út
+; \
+
+49 } \1f0)
+
+ )
+
+51 \ 1
+ #_IO_lock_\8cylock
+(
+_Çme
+) \
+
+53 \12
+__»suÉ
+ = 0; \
+
+54 \1e*
+__£lf
+ =
+THREAD_SELF
+; \
+
+55 ià((
+_Çme
+).
+owÃr
+ !ð
+__£lf
+) \
+
+57 ià(
+ `Îl_\8cylock
+ ((
+_Çme
+).
+lock
+) == 0) \
+
+59 (
+_Çme
+).
+owÃr
+ =
+__£lf
+; \
+
+60 (
+_Çme
+).
+út
+ = 1; \
+
+63
+__»suÉ
+ =
+EBUSY
+; \
+
+66 ++(
+_Çme
+).
+út
+; \
+
+67
+__»suÉ
+; \
+
+68 })
+
+ )
+
+70 \ 1
+ #_IO_lock_uÆock
+(
+_Çme
+) \
+
+72 ià(--(
+_Çme
+).
+út
+ == 0) \
+
+74 (
+_Çme
+).
+owÃr
+ =
+NULL
+; \
+
+75
+ `Îl_uÆock
+ ((
+_Çme
+).
+lock
+,
+LLL_PRIVATE
+); \
+
+77 } \1f0)
+
+ )
+
+81 \ 1
+ #_IO_þ\97nup_»giÚ_¡¬t
+(
+_fù
+,
+_å
+) \
+
+82
+ `__libc_þ\97nup_»giÚ_¡¬t
+ (((
+_å
+)->
+_æags
+ &
+_IO_USER_LOCK
+è=ð0,
+_fù
+, _å)
+
+ )
+
+83 \ 1
+ #_IO_þ\97nup_»giÚ_¡¬t_nßrg
+(
+_fù
+) \
+
+84
+ `__libc_þ\97nup_»giÚ_¡¬t
+ (1,
+_fù
+,
+NULL
+)
+
+ )
+
+85 \ 1
+ #_IO_þ\97nup_»giÚ_\92d
+(
+_do\99
+) \
+
+86
+ `__libc_þ\97nup_»giÚ_\92d
+ (
+_do\99
+)
+
+ )
+
+88 #ià
+def\9aed
+
+_LIBC
+ && !def\9aed
+NOT_IN_libc
+
+
+90 #ifdeà
+__EXCEPTIONS
+
+
+91 \ 1
+ #_IO_acqu\9ce_lock
+(
+_å
+) \
+
+93
+_IO_FILE
+ *
+_IO_acqu\9ce_lock_f\9ee
+ \
+
+94
+ `__©\8cibu\8b__
+((
+ `þ\97nup
+ (
+_IO_acqu\9ce_lock_fù
+))) \
+
+95 ð(
+_å
+); \
+
+96
+ `_IO_æockf\9ee
+ (
+_IO_acqu\9ce_lock_f\9ee
+);
+
+ )
+
+97 \ 1
+ #_IO_acqu\9ce_lock_þ\97r_æags2
+(
+_å
+) \
+
+99
+_IO_FILE
+ *
+_IO_acqu\9ce_lock_f\9ee
+ \
+
+100
+ `__©\8cibu\8b__
+((
+ `þ\97nup
+ (
+_IO_acqu\9ce_lock_þ\97r_æags2_fù
+))) \
+
+101 ð(
+_å
+); \
+
+102
+ `_IO_æockf\9ee
+ (
+_IO_acqu\9ce_lock_f\9ee
+);
+
+ )
+
+104 \ 1
+ #_IO_acqu\9ce_lock
+(
+_å
+è
+_IO_acqu\9ce_lock_Ãeds_exû±iÚs_\92abËd
+
+
+ )
+
+105 \ 1
+ #_IO_acqu\9ce_lock_þ\97r_æags2
+(
+_å
+è
+ `_IO_acqu\9ce_lock
+ (_å)
+
+ )
+
+107 \ 1
+ #_IO_»Ëa£_lock
+(
+_å
+è; } \1f0)
+
+ )
+
+ @/usr/include/bits/typesizes.h
+
+20 #iâdeà
+_BITS_TYPES_H
+
+
+24 #iâdef
+_BITS_TYPESIZES_H
+
+
+25 \ 1
+ #_BITS_TYPESIZES_H
+ 1
+
+ )
+
+30 \ 1
+ #__DEV_T_TYPE
+
+__UQUAD_TYPE
+
+
+ )
+
+31 \ 1
+ #__UID_T_TYPE
+
+__U32_TYPE
+
+
+ )
+
+32 \ 1
+ #__GID_T_TYPE
+
+__U32_TYPE
+
+
+ )
+
+33 \ 1
+ #__INO_T_TYPE
+
+__ULONGWORD_TYPE
+
+
+ )
+
+34 \ 1
+ #__INO64_T_TYPE
+
+__UQUAD_TYPE
+
+
+ )
+
+35 \ 1
+ #__MODE_T_TYPE
+
+__U32_TYPE
+
+
+ )
+
+36 \ 1
+ #__NLINK_T_TYPE
+
+__UWORD_TYPE
+
+
+ )
+
+37 \ 1
+ #__OFF_T_TYPE
+
+__SLONGWORD_TYPE
+
+
+ )
+
+38 \ 1
+ #__OFF64_T_TYPE
+
+__SQUAD_TYPE
+
+
+ )
+
+39 \ 1
+ #__PID_T_TYPE
+
+__S32_TYPE
+
+
+ )
+
+40 \ 1
+ #__RLIM_T_TYPE
+
+__ULONGWORD_TYPE
+
+
+ )
+
+41 \ 1
+ #__RLIM64_T_TYPE
+
+__UQUAD_TYPE
+
+
+ )
+
+42 \ 1
+ #__BLKCNT_T_TYPE
+
+__SLONGWORD_TYPE
+
+
+ )
+
+43 \ 1
+ #__BLKCNT64_T_TYPE
+
+__SQUAD_TYPE
+
+
+ )
+
+44 \ 1
+ #__FSBLKCNT_T_TYPE
+
+__ULONGWORD_TYPE
+
+
+ )
+
+45 \ 1
+ #__FSBLKCNT64_T_TYPE
+
+__UQUAD_TYPE
+
+
+ )
+
+46 \ 1
+ #__FSFILCNT_T_TYPE
+
+__ULONGWORD_TYPE
+
+
+ )
+
+47 \ 1
+ #__FSFILCNT64_T_TYPE
+
+__UQUAD_TYPE
+
+
+ )
+
+48 \ 1
+ #__ID_T_TYPE
+
+__U32_TYPE
+
+
+ )
+
+49 \ 1
+ #__CLOCK_T_TYPE
+
+__SLONGWORD_TYPE
+
+
+ )
+
+50 \ 1
+ #__TIME_T_TYPE
+
+__SLONGWORD_TYPE
+
+
+ )
+
+51 \ 1
+ #__USECONDS_T_TYPE
+
+__U32_TYPE
+
+
+ )
+
+52 \ 1
+ #__SUSECONDS_T_TYPE
+
+__SLONGWORD_TYPE
+
+
+ )
+
+53 \ 1
+ #__DADDR_T_TYPE
+
+__S32_TYPE
+
+
+ )
+
+54 \ 1
+ #__SWBLK_T_TYPE
+
+__SLONGWORD_TYPE
+
+
+ )
+
+55 \ 1
+ #__KEY_T_TYPE
+
+__S32_TYPE
+
+
+ )
+
+56 \ 1
+ #__CLOCKID_T_TYPE
+
+__S32_TYPE
+
+
+ )
+
+57 \ 1
+ #__TIMER_T_TYPE
+ \1e*
+
+ )
+
+58 \ 1
+ #__BLKSIZE_T_TYPE
+
+__SLONGWORD_TYPE
+
+
+ )
+
+59 \ 1
+ #__FSID_T_TYPE
+ s\8cuù { \12
+__v®
+[2]; }
+
+ )
+
+60 \ 1
+ #__SSIZE_T_TYPE
+
+__SWORD_TYPE
+
+
+ )
+
+63 \ 1
+ #__FD_SETSIZE
+ 1024
+
+ )
+
+ @/usr/include/ctype.h
+
+24 #iâdef
+_CTYPE_H
+
+
+25 \ 1
+ #_CTYPE_H
+ 1
+
+ )
+
+27 \ 2
+ ~<ã©u»s.h
+>
+
+28 \ 2
+ ~<b\99s/ty³s.h
+>
+
+30
+ g__BEGIN_DECLS
+
+
+32 #iâdeà
+_ISb\99
+
+
+41 \ 2
+ ~<\92d\9fn.h
+>
+
+42 #ià
+__BYTE_ORDER
+ =ð
+__BIG_ENDIAN
+
+
+43 \ 1
+ #_ISb\99
+(
+b\99
+è(1 << (b\99))
+
+ )
+
+45 \ 1
+ #_ISb\99
+(
+b\99
+è((b\99è< 8 ? ((1 << (b\99)è<< 8è: ((1 << (b\99)è>> 8))
+
+ )
+
+50
+ m_ISuµ\94
+ =
+_ISb\99
+ (0),
+
+51
+ m_ISlow\94
+ =
+_ISb\99
+ (1),
+
+52
+ m_IS®pha
+ =
+_ISb\99
+ (2),
+
+53
+ m_ISdig\99
+ =
+_ISb\99
+ (3),
+
+54
+ m_ISxdig\99
+ =
+_ISb\99
+ (4),
+
+55
+ m_IS¥aû
+ =
+_ISb\99
+ (5),
+
+56
+ m_IS´\9at
+ =
+_ISb\99
+ (6),
+
+57
+ m_ISg¿ph
+ =
+_ISb\99
+ (7),
+
+58
+ m_ISbÏnk
+ =
+_ISb\99
+ (8),
+
+59
+ m_ISú\8cl
+ =
+_ISb\99
+ (9),
+
+60
+ m_ISpunù
+ =
+_ISb\99
+ (10),
+
+61
+ m_IS®num
+ =
+_ISb\99
+ (11)
+
+81 \r
+__cڡ
+ \1d\16\12**
+ $__ùy³_b_loc
+ (\1e)
+
+82
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ
+));
+
+83 \r
+__cڡ
+
+__\9at32_t
+ **
+ $__ùy³_tÞow\94_loc
+ (\1e)
+
+84
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ
+));
+
+85 \r
+__cڡ
+
+__\9at32_t
+ **
+ $__ùy³_touµ\94_loc
+ (\1e)
+
+86
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ
+));
+
+89 #iâdeà
+__ýlu¥lus
+
+
+90 \ 1
+ #__isùy³
+(
+c
+,
+ty³
+) \
+
+91 ((*
+ `__ùy³_b_loc
+ ())[(\12è(
+c
+)] & (\1d\16\12è
+ty³
+)
+
+ )
+
+92 #\96ià
+def\9aed
+
+__USE_EXTERN_INLINES
+
+
+93 \ 1
+ #__isùy³_f
+(
+ty³
+) \
+
+94
+__ex\8bº_\9al\9ae
+ \12\
+
+95
+is
+##
+ `ty³
+ (\12
+__c
+è
+__THROW
+ \
+
+97 \15 (*
+ `__ùy³_b_loc
+ ())[(\12è(
+__c
+)] & (\1d\16\12è
+_IS
+##
+ty³
+; \
+
+98
+ }
+
+ )
+}
+
+101 \ 1
+ #__i§scii
+(
+c
+è(((cè& ~0x7fè=ð0è
+
+ )
+
+102 \ 1
+ #__tßscii
+(
+c
+è((cè& 0x7fè
+
+ )
+
+104 \ 1
+ #__exùy³
+(
+Çme
+è\r\12
+ `Çme
+ (\12è
+__THROW
+
+
+ )
+
+106
+__BEGIN_NAMESPACE_STD
+
+
+112
+__exùy³
+ (
+i§Êum
+);
+
+113
+__exùy³
+ (
+i§Íha
+);
+
+114
+__exùy³
+ (
+isú\8cl
+);
+
+115
+__exùy³
+ (
+isdig\99
+);
+
+116
+__exùy³
+ (
+i¦ow\94
+);
+
+117
+__exùy³
+ (
+isg¿ph
+);
+
+118
+__exùy³
+ (
+i¥r\9at
+);
+
+119
+__exùy³
+ (
+i¥unù
+);
+
+120
+__exùy³
+ (
+is¥aû
+);
+
+121
+__exùy³
+ (
+isuµ\94
+);
+
+122
+__exùy³
+ (
+isxdig\99
+);
+
+126 \r\12
+ $tÞow\94
+ (\12
+__c
+è
+__THROW
+;
+
+129 \r\12
+ $touµ\94
+ (\12
+__c
+è
+__THROW
+;
+
+131
+__END_NAMESPACE_STD
+
+
+135 #ifdef
+__USE_ISOC99
+
+
+136
+__BEGIN_NAMESPACE_C99
+
+
+138
+ `__exùy³
+ (
+isbÏnk
+);
+
+140
+__END_NAMESPACE_C99
+
+
+143 #ifdeà
+__USE_GNU
+
+
+145 \r\12
+ $isùy³
+ (\12
+__c
+, \12
+__mask
+è
+__THROW
+;
+
+148 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_MISC
+ || def\9aed
+__USE_XOPEN
+
+
+152 \r\12
+ $i§scii
+ (\12
+__c
+è
+__THROW
+;
+
+156 \r\12
+ $tßscii
+ (\12
+__c
+è
+__THROW
+;
+
+160
+ `__exùy³
+ (
+_touµ\94
+);
+
+161
+ `__exùy³
+ (
+_tÞow\94
+);
+
+165 \ 1
+ #__tobody
+(
+c
+,
+f
+,
+a
+,
+¬gs
+) \
+
+166 (
+__ex\8bnsiÚ__
+ \
+
+167 ({ \12
+__»s
+; \
+
+168 ià(\17 (
+c
+) > 1) \
+
+170 ià(
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+c
+)) \
+
+172 \12
+__c
+ = (
+c
+); \
+
+173
+__»s
+ =
+__c
+ < -128 || __ø> 255 ? __ø: (
+a
+)[__c]; \
+
+176
+__»s
+ =
+f
+
+¬gs
+; \
+
+179
+__»s
+ = (
+a
+)[(\12è(
+c
+)]; \
+
+180
+__»s
+;
+ }
+}))
+
+ )
+
+182 #ià!
+def\9aed
+
+__NO_CTYPE
+
+
+183 #ifdeà
+__isùy³_f
+
+
+184
+ $__isùy³_f
+ (
+®num
+)
+
+185
+ $__isùy³_f
+ (
+®pha
+)
+
+186
+ $__isùy³_f
+ (
+ú\8cl
+)
+
+187
+ $__isùy³_f
+ (
+dig\99
+)
+
+188
+ $__isùy³_f
+ (
+low\94
+)
+
+189
+ $__isùy³_f
+ (
+g¿ph
+)
+
+190
+ $__isùy³_f
+ (
+´\9at
+)
+
+191
+ $__isùy³_f
+ (
+punù
+)
+
+192
+ $__isùy³_f
+ (
+¥aû
+)
+
+193
+ $__isùy³_f
+ (
+uµ\94
+)
+
+194
+ $__isùy³_f
+ (
+xdig\99
+)
+
+195 #ifdeà
+__USE_ISOC99
+
+
+196
+ $__isùy³_f
+ (
+bÏnk
+)
+
+198 #\96ià
+def\9aed
+
+__isùy³
+
+
+199 \ 1
+ #i§Êum
+(
+c
+è
+ `__isùy³
+((c),
+_IS®num
+)
+
+ )
+
+200 \ 1
+ #i§Íha
+(
+c
+è
+ `__isùy³
+((c),
+_IS®pha
+)
+
+ )
+
+201 \ 1
+ #isú\8cl
+(
+c
+è
+ `__isùy³
+((c),
+_ISú\8cl
+)
+
+ )
+
+202 \ 1
+ #isdig\99
+(
+c
+è
+ `__isùy³
+((c),
+_ISdig\99
+)
+
+ )
+
+203 \ 1
+ #i¦ow\94
+(
+c
+è
+ `__isùy³
+((c),
+_ISlow\94
+)
+
+ )
+
+204 \ 1
+ #isg¿ph
+(
+c
+è
+ `__isùy³
+((c),
+_ISg¿ph
+)
+
+ )
+
+205 \ 1
+ #i¥r\9at
+(
+c
+è
+ `__isùy³
+((c),
+_IS´\9at
+)
+
+ )
+
+206 \ 1
+ #i¥unù
+(
+c
+è
+ `__isùy³
+((c),
+_ISpunù
+)
+
+ )
+
+207 \ 1
+ #is¥aû
+(
+c
+è
+ `__isùy³
+((c),
+_IS¥aû
+)
+
+ )
+
+208 \ 1
+ #isuµ\94
+(
+c
+è
+ `__isùy³
+((c),
+_ISuµ\94
+)
+
+ )
+
+209 \ 1
+ #isxdig\99
+(
+c
+è
+ `__isùy³
+((c),
+_ISxdig\99
+)
+
+ )
+
+210 #ifdeà
+__USE_ISOC99
+
+
+211 \ 1
+ #isbÏnk
+(
+c
+è
+ `__isùy³
+((c),
+_ISbÏnk
+)
+
+ )
+
+215 #ifdeà
+__USE_EXTERN_INLINES
+
+
+216
+__ex\8bº_\9al\9ae
+ \12
+
+217
+ `__NTH
+ (
+ $tÞow\94
+ (\12
+__c
+))
+
+219 \15
+__c
+ >ð-128 && __ø< 256 ? (*
+ `__ùy³_tÞow\94_loc
+ ())[__c] : __c;
+
+220
+ }
+}
+
+222
+__ex\8bº_\9al\9ae
+ \12
+
+223
+__NTH
+ (
+ $touµ\94
+ (\12
+__c
+))
+
+225 \15
+__c
+ >ð-128 && __ø< 256 ? (*
+ `__ùy³_touµ\94_loc
+ ())[__c] : __c;
+
+226
+ }
+}
+
+229 #ià
+__GNUC__
+ >ð2 &&
+def\9aed
+
+__OPTIMIZE__
+ && !def\9aed
+__ýlu¥lus
+
+
+230 \ 1
+ #tÞow\94
+(
+c
+è
+ `__tobody
+ (c,
+tÞow\94
+, *
+ `__ùy³_tÞow\94_loc
+ (), (c))
+
+ )
+
+231 \ 1
+ #touµ\94
+(
+c
+è
+ `__tobody
+ (c,
+touµ\94
+, *
+ `__ùy³_touµ\94_loc
+ (), (c))
+
+ )
+
+234 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_MISC
+ || def\9aed
+__USE_XOPEN
+
+
+235 \ 1
+ #i§scii
+(
+c
+è
+ `__i§scii
+ (c)
+
+ )
+
+236 \ 1
+ #tßscii
+(
+c
+è
+ `__tßscii
+ (c)
+
+ )
+
+238 \ 1
+ #_tÞow\94
+(
+c
+è((\12è(*
+ `__ùy³_tÞow\94_loc
+ ())[(\12è(c)])
+
+ )
+
+239 \ 1
+ #_touµ\94
+(
+c
+è((\12è(*
+ `__ùy³_touµ\94_loc
+ ())[(\12è(c)])
+
+ )
+
+245 #ifdeà
+__USE_XOPEN2K8
+
+
+259 \ 2
+ ~<xloÿË.h
+>
+
+263 \ 1
+ #__isùy³_l
+(
+c
+,
+ty³
+,
+loÿË
+) \
+
+264 ((
+loÿË
+)->
+__ùy³_b
+[(\12è(
+c
+)] & (\1d\16\12è
+ty³
+)
+
+ )
+
+266 \ 1
+ #__exùy³_l
+(
+Çme
+) \
+
+267 \r\12
+ `Çme
+ (\12,
+__loÿË_t
+è
+__THROW
+
+
+ )
+
+273
+__exùy³_l
+ (
+i§Êum_l
+);
+
+274
+__exùy³_l
+ (
+i§Íha_l
+);
+
+275
+__exùy³_l
+ (
+isú\8cl_l
+);
+
+276
+__exùy³_l
+ (
+isdig\99_l
+);
+
+277
+__exùy³_l
+ (
+i¦ow\94_l
+);
+
+278
+__exùy³_l
+ (
+isg¿ph_l
+);
+
+279
+__exùy³_l
+ (
+i¥r\9at_l
+);
+
+280
+__exùy³_l
+ (
+i¥unù_l
+);
+
+281
+__exùy³_l
+ (
+is¥aû_l
+);
+
+282
+__exùy³_l
+ (
+isuµ\94_l
+);
+
+283
+__exùy³_l
+ (
+isxdig\99_l
+);
+
+285
+__exùy³_l
+ (
+isbÏnk_l
+);
+
+289 \r\12
+ $__tÞow\94_l
+ (\12
+__c
+,
+__loÿË_t
+
+__l
+è
+__THROW
+;
+
+290 \r\12
+ $tÞow\94_l
+ (\12
+__c
+,
+__loÿË_t
+
+__l
+è
+__THROW
+;
+
+293 \r\12
+ $__touµ\94_l
+ (\12
+__c
+,
+__loÿË_t
+
+__l
+è
+__THROW
+;
+
+294 \r\12
+ $touµ\94_l
+ (\12
+__c
+,
+__loÿË_t
+
+__l
+è
+__THROW
+;
+
+296 #ià
+__GNUC__
+ >ð2 &&
+def\9aed
+
+__OPTIMIZE__
+ && !def\9aed
+__ýlu¥lus
+
+
+297 \ 1
+ #__tÞow\94_l
+(
+c
+,
+loÿË
+) \
+
+298
+ `__tobody
+ (
+c
+,
+__tÞow\94_l
+, (
+loÿË
+)->
+__ùy³_tÞow\94
+, (c,\86oÿË))
+
+ )
+
+299 \ 1
+ #__touµ\94_l
+(
+c
+,
+loÿË
+) \
+
+300
+ `__tobody
+ (
+c
+,
+__touµ\94_l
+, (
+loÿË
+)->
+__ùy³_touµ\94
+, (c,\86oÿË))
+
+ )
+
+301 \ 1
+ #tÞow\94_l
+(
+c
+,
+loÿË
+è
+ `__tÞow\94_l
+ ((c), (loÿË))
+
+ )
+
+302 \ 1
+ #touµ\94_l
+(
+c
+,
+loÿË
+è
+ `__touµ\94_l
+ ((c), (loÿË))
+
+ )
+
+306 #iâdeà
+__NO_CTYPE
+
+
+307 \ 1
+ #__i§Êum_l
+(
+c
+,
+l
+è
+ `__isùy³_l
+((c),
+_IS®num
+, (l))
+
+ )
+
+308 \ 1
+ #__i§Íha_l
+(
+c
+,
+l
+è
+ `__isùy³_l
+((c),
+_IS®pha
+, (l))
+
+ )
+
+309 \ 1
+ #__isú\8cl_l
+(
+c
+,
+l
+è
+ `__isùy³_l
+((c),
+_ISú\8cl
+, (l))
+
+ )
+
+310 \ 1
+ #__isdig\99_l
+(
+c
+,
+l
+è
+ `__isùy³_l
+((c),
+_ISdig\99
+, (l))
+
+ )
+
+311 \ 1
+ #__i¦ow\94_l
+(
+c
+,
+l
+è
+ `__isùy³_l
+((c),
+_ISlow\94
+, (l))
+
+ )
+
+312 \ 1
+ #__isg¿ph_l
+(
+c
+,
+l
+è
+ `__isùy³_l
+((c),
+_ISg¿ph
+, (l))
+
+ )
+
+313 \ 1
+ #__i¥r\9at_l
+(
+c
+,
+l
+è
+ `__isùy³_l
+((c),
+_IS´\9at
+, (l))
+
+ )
+
+314 \ 1
+ #__i¥unù_l
+(
+c
+,
+l
+è
+ `__isùy³_l
+((c),
+_ISpunù
+, (l))
+
+ )
+
+315 \ 1
+ #__is¥aû_l
+(
+c
+,
+l
+è
+ `__isùy³_l
+((c),
+_IS¥aû
+, (l))
+
+ )
+
+316 \ 1
+ #__isuµ\94_l
+(
+c
+,
+l
+è
+ `__isùy³_l
+((c),
+_ISuµ\94
+, (l))
+
+ )
+
+317 \ 1
+ #__isxdig\99_l
+(
+c
+,
+l
+è
+ `__isùy³_l
+((c),
+_ISxdig\99
+, (l))
+
+ )
+
+319 \ 1
+ #__isbÏnk_l
+(
+c
+,
+l
+è
+ `__isùy³_l
+((c),
+_ISbÏnk
+, (l))
+
+ )
+
+321 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_MISC
+
+
+322 \ 1
+ #__i§scii_l
+(
+c
+,
+l
+è(Ö),
+ `__i§scii
+ (c))
+
+ )
+
+323 \ 1
+ #__tßscii_l
+(
+c
+,
+l
+è(Ö),
+ `__tßscii
+ (c))
+
+ )
+
+326 \ 1
+ #i§Êum_l
+(
+c
+,
+l
+è
+ `__i§Êum_l
+ ((c), (l))
+
+ )
+
+327 \ 1
+ #i§Íha_l
+(
+c
+,
+l
+è
+ `__i§Íha_l
+ ((c), (l))
+
+ )
+
+328 \ 1
+ #isú\8cl_l
+(
+c
+,
+l
+è
+ `__isú\8cl_l
+ ((c), (l))
+
+ )
+
+329 \ 1
+ #isdig\99_l
+(
+c
+,
+l
+è
+ `__isdig\99_l
+ ((c), (l))
+
+ )
+
+330 \ 1
+ #i¦ow\94_l
+(
+c
+,
+l
+è
+ `__i¦ow\94_l
+ ((c), (l))
+
+ )
+
+331 \ 1
+ #isg¿ph_l
+(
+c
+,
+l
+è
+ `__isg¿ph_l
+ ((c), (l))
+
+ )
+
+332 \ 1
+ #i¥r\9at_l
+(
+c
+,
+l
+è
+ `__i¥r\9at_l
+ ((c), (l))
+
+ )
+
+333 \ 1
+ #i¥unù_l
+(
+c
+,
+l
+è
+ `__i¥unù_l
+ ((c), (l))
+
+ )
+
+334 \ 1
+ #is¥aû_l
+(
+c
+,
+l
+è
+ `__is¥aû_l
+ ((c), (l))
+
+ )
+
+335 \ 1
+ #isuµ\94_l
+(
+c
+,
+l
+è
+ `__isuµ\94_l
+ ((c), (l))
+
+ )
+
+336 \ 1
+ #isxdig\99_l
+(
+c
+,
+l
+è
+ `__isxdig\99_l
+ ((c), (l))
+
+ )
+
+338 \ 1
+ #isbÏnk_l
+(
+c
+,
+l
+è
+ `__isbÏnk_l
+ ((c), (l))
+
+ )
+
+340 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_MISC
+
+
+341 \ 1
+ #i§scii_l
+(
+c
+,
+l
+è
+ `__i§scii_l
+ ((c), (l))
+
+ )
+
+342 \ 1
+ #tßscii_l
+(
+c
+,
+l
+è
+ `__tßscii_l
+ ((c), (l))
+
+ )
+
+349
+__END_DECLS
+
+
+ @/usr/include/endian.h
+
+19 #iâdef
+_ENDIAN_H
+
+
+20 \ 1
+ #_ENDIAN_H
+ 1
+
+ )
+
+22 \ 2
+ ~<ã©u»s.h
+>
+
+32 \ 1
+ #__LITTLE_ENDIAN
+ 1234
+
+ )
+
+33 \ 1
+ #__BIG_ENDIAN
+ 4321
+
+ )
+
+34 \ 1
+ #__PDP_ENDIAN
+ 3412
+
+ )
+
+37 \ 2
+ ~<b\99s/\92d\9fn.h
+>
+
+41 #iâdeà
+__FLOAT_WORD_ORDER
+
+
+42 \ 1
+ #__FLOAT_WORD_ORDER
+
+__BYTE_ORDER
+
+
+ )
+
+45 #ifdef
+__USE_BSD
+
+
+46 \ 1
+ #LITTLE_ENDIAN
+
+__LITTLE_ENDIAN
+
+
+ )
+
+47 \ 1
+ #BIG_ENDIAN
+
+__BIG_ENDIAN
+
+
+ )
+
+48 \ 1
+ #PDP_ENDIAN
+
+__PDP_ENDIAN
+
+
+ )
+
+49 \ 1
+ #BYTE_ORDER
+
+__BYTE_ORDER
+
+
+ )
+
+52 #ià
+__BYTE_ORDER
+ =ð
+__LITTLE_ENDIAN
+
+
+53 \ 1
+ #__LONG_LONG_PAIR
+(
+HI
+,
+LO
+èLO,
+ )
+HI
+
+54 #\96ià
+__BYTE_ORDER
+ =ð
+__BIG_ENDIAN
+
+
+55 \ 1
+ #__LONG_LONG_PAIR
+(
+HI
+,
+LO
+èHI,
+ )
+LO
+
+59 #ifdeà
+__USE_BSD
+
+
+61 \ 2
+ ~<b\99s/by\8bsw.h
+>
+
+63 #ià
+__BYTE_ORDER
+ =ð
+__LITTLE_ENDIAN
+
+
+64 \ 1
+ #htobe16
+(
+x
+è
+ `__bsw_16
+ (x)
+
+ )
+
+65 \ 1
+ #htÞe16
+(
+x
+è(x)
+
+ )
+
+66 \ 1
+ #be16toh
+(
+x
+è
+ `__bsw_16
+ (x)
+
+ )
+
+67 \ 1
+ #Ë16toh
+(
+x
+è(x)
+
+ )
+
+69 \ 1
+ #htobe32
+(
+x
+è
+ `__bsw_32
+ (x)
+
+ )
+
+70 \ 1
+ #htÞe32
+(
+x
+è(x)
+
+ )
+
+71 \ 1
+ #be32toh
+(
+x
+è
+ `__bsw_32
+ (x)
+
+ )
+
+72 \ 1
+ #Ë32toh
+(
+x
+è(x)
+
+ )
+
+74 \ 1
+ #htobe64
+(
+x
+è
+ `__bsw_64
+ (x)
+
+ )
+
+75 \ 1
+ #htÞe64
+(
+x
+è(x)
+
+ )
+
+76 \ 1
+ #be64toh
+(
+x
+è
+ `__bsw_64
+ (x)
+
+ )
+
+77 \ 1
+ #Ë64toh
+(
+x
+è(x)
+
+ )
+
+79 \ 1
+ #htobe16
+(
+x
+è(x)
+
+ )
+
+80 \ 1
+ #htÞe16
+(
+x
+è
+ `__bsw_16
+ (x)
+
+ )
+
+81 \ 1
+ #be16toh
+(
+x
+è(x)
+
+ )
+
+82 \ 1
+ #Ë16toh
+(
+x
+è
+ `__bsw_16
+ (x)
+
+ )
+
+84 \ 1
+ #htobe32
+(
+x
+è(x)
+
+ )
+
+85 \ 1
+ #htÞe32
+(
+x
+è
+ `__bsw_32
+ (x)
+
+ )
+
+86 \ 1
+ #be32toh
+(
+x
+è(x)
+
+ )
+
+87 \ 1
+ #Ë32toh
+(
+x
+è
+ `__bsw_32
+ (x)
+
+ )
+
+89 \ 1
+ #htobe64
+(
+x
+è(x)
+
+ )
+
+90 \ 1
+ #htÞe64
+(
+x
+è
+ `__bsw_64
+ (x)
+
+ )
+
+91 \ 1
+ #be64toh
+(
+x
+è(x)
+
+ )
+
+92 \ 1
+ #Ë64toh
+(
+x
+è
+ `__bsw_64
+ (x)
+
+ )
+
+ @/usr/include/gnu/stubs.h
+
+4 \ 2
+ ~<b\99s/wÜdsize.h
+>
+
+6 #ià
+__WORDSIZE
+ == 32
+
+7 \ 2
+ ~<gnu/¡ubs-32.h
+>
+
+8 #\96ià
+__WORDSIZE
+ == 64
+
+9 \ 2
+ ~<gnu/¡ubs-64.h
+>
+
+ @/usr/include/sys/cdefs.h
+
+20 #iâdef
+_SYS_CDEFS_H
+
+
+21 \ 1
+ #_SYS_CDEFS_H
+ 1
+
+ )
+
+24 #iâdeà
+_FEATURES_H
+
+
+25 \ 2
+ ~<ã©u»s.h
+>
+
+31 #ià
+def\9aed
+
+__GNUC__
+ && !def\9aed
+__STDC__
+
+
+36 #undeà
+__P
+
+
+37 #undeà
+__PMT
+
+
+39 #ifdeà
+__GNUC__
+
+
+43 #ià
+__GNUC_PREREQ
+ (4, 6è&& !
+def\9aed
+
+_LIBC
+
+
+44 \ 1
+ #__LEAF
+ ,
+__Ëaf__
+
+
+ )
+
+45 \ 1
+ #__LEAF_ATTR
+
+ `__©\8cibu\8b__
+ ((
+__Ëaf__
+))
+
+ )
+
+47 \ 1
+ #__LEAF
+
+
+ )
+
+48 \ 1
+ #__LEAF_ATTR
+
+
+ )
+
+56 #ià!
+def\9aed
+
+__ýlu¥lus
+ &&
+__GNUC_PREREQ
+ (3, 3)
+
+57 \ 1
+ #__THROW
+
+ `__©\8cibu\8b__
+ ((
+__nÙhrow__
+
+__LEAF
+))
+
+ )
+
+58 \ 1
+ #__THROWNL
+
+ `__©\8cibu\8b__
+ ((
+__nÙhrow__
+))
+
+ )
+
+59 \ 1
+ #__NTH
+(
+fù
+è
+ `__©\8cibu\8b__
+ ((
+__nÙhrow__
+
+__LEAF
+)è
+ )
+fct
+
+61 #ià
+def\9aed
+
+__ýlu¥lus
+ &&
+__GNUC_PREREQ
+ (2,8)
+
+62 \ 1
+ #__THROW
+
+ `throw
+ ()
+
+ )
+
+63 \ 1
+ #__THROWNL
+
+ `throw
+ ()
+
+ )
+
+64 \ 1
+ #__NTH
+(
+fù
+è
+__LEAF_ATTR
+ fù
+ `throw
+ ()
+
+ )
+
+66 \ 1
+ #__THROW
+
+
+ )
+
+67 \ 1
+ #__THROWNL
+
+
+ )
+
+68 \ 1
+ #__NTH
+(
+fù
+è
+ )
+fct
+
+74 \ 1
+ #__\9al\9ae
+
+
+ )
+
+76 \ 1
+ #__THROW
+
+
+ )
+
+77 \ 1
+ #__THROWNL
+
+
+ )
+
+78 \ 1
+ #__NTH
+(
+fù
+è
+ )
+fct
+
+80 \ 1
+ #__cڡ
+ cڡ
+
+ )
+
+81 \ 1
+ #__sigÃd
+ sigÃd
+
+ )
+
+82 \ 1
+ #__vÞ©\9ee
+ vÞ©\9ee
+
+ )
+
+88 \ 1
+ #__P
+(
+¬gs
+è
+ )
+args
+
+89 \ 1
+ #__PMT
+(
+¬gs
+è
+ )
+args
+
+94 \ 1
+ #__CONCAT
+(
+x
+,
+y
+èx ##
+ )
+y
+
+95 \ 1
+ #__STRING
+(
+x
+è#x
+
+ )
+
+98 \ 1
+ #__±r_t
+ \1e*
+
+ )
+
+99 \ 1
+ #__lÚg_doubË_t
+ \13\b
+
+ )
+
+103 #ifdef
+__ýlu¥lus
+
+
+104 \ 1
+ #__BEGIN_DECLS
+ \r"C" {
+
+ )
+
+105 \ 1
+ #__END_DECLS
+ }
+
+ )
+
+107 \ 1
+ #__BEGIN_DECLS
+
+
+ )
+
+108 \ 1
+ #__END_DECLS
+
+
+ )
+
+117 #ià
+def\9aed
+
+__ýlu¥lus
+ && def\9aed
+_GLIBCPP_USE_NAMESPACES
+
+
+118 \ 1
+ #__BEGIN_NAMESPACE_STD
+
+Çme¥aû
+
+¡d
+ {
+
+ )
+
+119 \ 1
+ #__END_NAMESPACE_STD
+ }
+
+ )
+
+120 \ 1
+ #__USING_NAMESPACE_STD
+(
+Çme
+è
+us\9ag
+
+¡d
+::Çme;
+
+ )
+
+121 \ 1
+ #__BEGIN_NAMESPACE_C99
+
+Çme¥aû
+
+__c99
+ {
+
+ )
+
+122 \ 1
+ #__END_NAMESPACE_C99
+ }
+
+ )
+
+123 \ 1
+ #__USING_NAMESPACE_C99
+(
+Çme
+è
+us\9ag
+
+__c99
+::Çme;
+
+ )
+
+128 \ 1
+ #__BEGIN_NAMESPACE_STD
+
+
+ )
+
+129 \ 1
+ #__END_NAMESPACE_STD
+
+
+ )
+
+130 \ 1
+ #__USING_NAMESPACE_STD
+(
+Çme
+)
+
+ )
+
+131 \ 1
+ #__BEGIN_NAMESPACE_C99
+
+
+ )
+
+132 \ 1
+ #__END_NAMESPACE_C99
+
+
+ )
+
+133 \ 1
+ #__USING_NAMESPACE_C99
+(
+Çme
+)
+
+ )
+
+138 #iâdeà
+__BOUNDED_POINTERS__
+
+
+139 \ 1
+ #__bounded
+
+
+ )
+
+140 \ 1
+ #__unbounded
+
+
+ )
+
+141 \ 1
+ #__±rv®ue
+
+
+ )
+
+146 \ 1
+ #__bos
+(
+±r
+è
+ `__bu\9et\9a_objeù_size
+ (±r,
+__USE_FORTIFY_LEVEL
+ > 1)
+
+ )
+
+147 \ 1
+ #__bos0
+(
+±r
+è
+ `__bu\9et\9a_objeù_size
+ (±r, 0)
+
+ )
+
+149 #ià
+__GNUC_PREREQ
+ (4,3)
+
+150 \ 1
+ #__w¬ndeþ
+(
+Çme
+,
+msg
+) \
+
+151 \r\1e
+ `Çme
+ (\1eè
+ `__©\8cibu\8b__
+((
+ `__w¬n\9ag__
+ (
+msg
+)))
+
+ )
+
+152 \ 1
+ #__w‚\89r
+(
+msg
+è
+ `__©\8cibu\8b__
+((
+ `__w¬n\9ag__
+ (msg)))
+
+ )
+
+153 \ 1
+ #__\94rÜdeþ
+(
+Çme
+,
+msg
+) \
+
+154 \r\1e
+ `Çme
+ (\1eè
+ `__©\8cibu\8b__
+((
+ `__\94rÜ__
+ (
+msg
+)))
+
+ )
+
+156 \ 1
+ #__w¬ndeþ
+(
+Çme
+,
+msg
+è\r\1e
+ `Çme
+ (\1e)
+
+ )
+
+157 \ 1
+ #__w‚\89r
+(
+msg
+)
+
+ )
+
+158 \ 1
+ #__\94rÜdeþ
+(
+Çme
+,
+msg
+è\r\1e
+ `Çme
+ (\1e)
+
+ )
+
+162 #ià
+__GNUC_PREREQ
+ (2,97)
+
+164 \ 1
+ #__æex¬r
+ []
+
+ )
+
+166 #ifdeà
+__GNUC__
+
+
+167 \ 1
+ #__æex¬r
+ [0]
+
+ )
+
+169 #ià
+def\9aed
+
+__STDC_VERSION__
+ && __STDC_VERSION__ >= 199901L
+
+170 \ 1
+ #__æex¬r
+ []
+
+ )
+
+173 \ 1
+ #__æex¬r
+ [1]
+
+ )
+
+189 #ià
+def\9aed
+
+__GNUC__
+ && __GNUC__ >= 2
+
+191 \ 1
+ #__REDIRECT
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+èÇm\90´ÙØ
+ `__asm__
+ (
+ `__ASMNAME
+ (#®\9fs))
+
+ )
+
+192 #ifdeà
+__ýlu¥lus
+
+
+193 \ 1
+ #__REDIRECT_NTH
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+) \
+
+194
+Çme
+
+´Ùo
+
+__THROW
+
+ `__asm__
+ (
+ `__ASMNAME
+ (#®\9fs))
+
+ )
+
+195 \ 1
+ #__REDIRECT_NTHNL
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+) \
+
+196
+Çme
+
+´Ùo
+
+__THROWNL
+
+ `__asm__
+ (
+ `__ASMNAME
+ (#®\9fs))
+
+ )
+
+198 \ 1
+ #__REDIRECT_NTH
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+) \
+
+199
+Çme
+
+´Ùo
+
+ `__asm__
+ (
+ `__ASMNAME
+ (#®\9fs)è
+__THROW
+
+
+ )
+
+200 \ 1
+ #__REDIRECT_NTHNL
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+) \
+
+201
+Çme
+
+´Ùo
+
+ `__asm__
+ (
+ `__ASMNAME
+ (#®\9fs)è
+__THROWNL
+
+
+ )
+
+203 \ 1
+ #__ASMNAME
+(
+úame
+è
+ `__ASMNAME2
+ (
+__USER_LABEL_PREFIX__
+, cÇme)
+
+ )
+
+204 \ 1
+ #__ASMNAME2
+(
+´efix
+,
+úame
+è
+ `__STRING
+ (´efixè
+ )
+cname
+
+217 #ià!
+def\9aed
+
+__GNUC__
+ || __GNUC__ < 2
+
+218 \ 1
+ #__©\8cibu\8b__
+(
+xyz
+è
+
+ )
+
+224 #ià
+__GNUC_PREREQ
+ (2,96)
+
+225 \ 1
+ #__©\8cibu\8b_m®loc__
+
+ `__©\8cibu\8b__
+ ((
+__m®loc__
+))
+
+ )
+
+227 \ 1
+ #__©\8cibu\8b_m®loc__
+
+
+ )
+
+233 #ià
+__GNUC_PREREQ
+ (2,96)
+
+234 \ 1
+ #__©\8cibu\8b_pu»__
+
+ `__©\8cibu\8b__
+ ((
+__pu»__
+))
+
+ )
+
+236 \ 1
+ #__©\8cibu\8b_pu»__
+
+
+ )
+
+240 #ià
+__GNUC_PREREQ
+ (2,5)
+
+241 \ 1
+ #__©\8cibu\8b_cÚ¡__
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+))
+
+ )
+
+243 \ 1
+ #__©\8cibu\8b_cÚ¡__
+
+
+ )
+
+249 #ià
+__GNUC_PREREQ
+ (3,1)
+
+250 \ 1
+ #__©\8cibu\8b_u£d__
+
+ `__©\8cibu\8b__
+ ((
+__u£d__
+))
+
+ )
+
+251 \ 1
+ #__©\8cibu\8b_no\9al\9ae__
+
+ `__©\8cibu\8b__
+ ((
+__no\9al\9ae__
+))
+
+ )
+
+253 \ 1
+ #__©\8cibu\8b_u£d__
+
+ `__©\8cibu\8b__
+ ((
+__unu£d__
+))
+
+ )
+
+254 \ 1
+ #__©\8cibu\8b_no\9al\9ae__
+
+
+ )
+
+258 #ià
+__GNUC_PREREQ
+ (3,2)
+
+259 \ 1
+ #__©\8cibu\8b_d\95»ÿ\8bd__
+
+ `__©\8cibu\8b__
+ ((
+__d\95»ÿ\8bd__
+))
+
+ )
+
+261 \ 1
+ #__©\8cibu\8b_d\95»ÿ\8bd__
+
+
+ )
+
+270 #ià
+__GNUC_PREREQ
+ (2,8)
+
+271 \ 1
+ #__©\8cibu\8b_fÜm©_¬g__
+(
+x
+è
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©_¬g__
+ (x)))
+
+ )
+
+273 \ 1
+ #__©\8cibu\8b_fÜm©_¬g__
+(
+x
+è
+
+ )
+
+280 #ià
+__GNUC_PREREQ
+ (2,97)
+
+281 \ 1
+ #__©\8cibu\8b_fÜm©_¡rfmÚ__
+(
+a
+,
+b
+) \
+
+282
+ `__©\8cibu\8b__
+ ((
+ `__fÜm©__
+ (
+__¡rfmÚ__
+,
+a
+,
+b
+)))
+
+ )
+
+284 \ 1
+ #__©\8cibu\8b_fÜm©_¡rfmÚ__
+(
+a
+,
+b
+è
+
+ )
+
+289 #ià
+__GNUC_PREREQ
+ (3,3)
+
+290 \ 1
+ #__nÚnuÎ
+(
+·¿ms
+è
+ `__©\8cibu\8b__
+ ((
+__nÚnuÎ__
+\85¬ams))
+
+ )
+
+292 \ 1
+ #__nÚnuÎ
+(
+·¿ms
+)
+
+ )
+
+297 #ià
+__GNUC_PREREQ
+ (3,4)
+
+298 \ 1
+ #__©\8cibu\8b_w¬n_unu£d_»suÉ__
+ \
+
+299
+ `__©\8cibu\8b__
+ ((
+__w¬n_unu£d_»suÉ__
+))
+
+ )
+
+300 #ià
+__USE_FORTIFY_LEVEL
+ > 0
+
+301 \ 1
+ #__wur
+
+__©\8cibu\8b_w¬n_unu£d_»suÉ__
+
+
+ )
+
+304 \ 1
+ #__©\8cibu\8b_w¬n_unu£d_»suÉ__
+
+
+ )
+
+306 #iâdeà
+__wur
+
+
+307 \ 1
+ #__wur
+
+
+ )
+
+311 #ià
+__GNUC_PREREQ
+ (3,2)
+
+312 \ 1
+ #__®ways_\9al\9ae
+
+__\9al\9ae
+
+ `__©\8cibu\8b__
+ ((
+__®ways_\9al\9ae__
+))
+
+ )
+
+314 \ 1
+ #__®ways_\9al\9ae
+
+__\9al\9ae
+
+
+ )
+
+319 #ià!
+def\9aed
+
+__ýlu¥lus
+ ||
+__GNUC_PREREQ
+ (4,3)
+
+320 #ià
+def\9aed
+
+__GNUC_STDC_INLINE__
+ || def\9aed
+__ýlu¥lus
+
+
+321 \ 1
+ #__ex\8bº_\9al\9ae
+ \r
+__\9al\9ae
+
+ `__©\8cibu\8b__
+ ((
+__gnu_\9al\9ae__
+))
+
+ )
+
+322 #ià
+__GNUC_PREREQ
+ (4,3)
+
+323 \ 1
+ #__ex\8bº_®ways_\9al\9ae
+ \
+
+324 \r
+__®ways_\9al\9ae
+
+ `__©\8cibu\8b__
+ ((
+__gnu_\9al\9ae__
+,
+__¬tific\9fl__
+))
+
+ )
+
+326 \ 1
+ #__ex\8bº_®ways_\9al\9ae
+ \
+
+327 \r
+__®ways_\9al\9ae
+
+ `__©\8cibu\8b__
+ ((
+__gnu_\9al\9ae__
+))
+
+ )
+
+330 \ 1
+ #__ex\8bº_\9al\9ae
+ \r
+__\9al\9ae
+
+
+ )
+
+331 #ià
+__GNUC_PREREQ
+ (4,3)
+
+332 \ 1
+ #__ex\8bº_®ways_\9al\9ae
+ \
+
+333 \r
+__®ways_\9al\9ae
+
+ `__©\8cibu\8b__
+ ((
+__¬tific\9fl__
+))
+
+ )
+
+335 \ 1
+ #__ex\8bº_®ways_\9al\9ae
+ \r
+__®ways_\9al\9ae
+
+
+ )
+
+342 #ià
+__GNUC_PREREQ
+ (4,3)
+
+343 \ 1
+ #__va_¬g_·ck
+(è
+ `__bu\9et\9a_va_¬g_·ck
+ ()
+
+ )
+
+344 \ 1
+ #__va_¬g_·ck_Ën
+(è
+ `__bu\9et\9a_va_¬g_·ck_Ën
+ ()
+
+ )
+
+351 #ià!
+__GNUC_PREREQ
+ (2,8)
+
+352 \ 1
+ #__ex\8bnsiÚ__
+
+
+ )
+
+356 #ià!
+__GNUC_PREREQ
+ (2,92)
+
+357 \ 1
+ #__»¡riù
+
+
+ )
+
+363 #ià
+__GNUC_PREREQ
+ (3,1è&& !
+def\9aed
+
+__GNUG__
+
+
+364 \ 1
+ #__»¡riù_¬r
+
+__»¡riù
+
+
+ )
+
+366 #ifdeà
+__GNUC__
+
+
+367 \ 1
+ #__»¡riù_¬r
+
+
+ )
+
+369 #ià
+def\9aed
+
+__STDC_VERSION__
+ && __STDC_VERSION__ >= 199901L
+
+370 \ 1
+ #__»¡riù_¬r
+
+»¡riù
+
+
+ )
+
+373 \ 1
+ #__»¡riù_¬r
+
+
+ )
+
+378 \ 2
+ ~<b\99s/wÜdsize.h
+>
+
+380 #ià
+def\9aed
+
+__LONG_DOUBLE_MATH_OPTIONAL
+ && def\9aed
+__NO_LONG_DOUBLE_MATH
+
+
+381 \ 1
+ #__LDBL_COMPAT
+ 1
+
+ )
+
+382 #ifdeà
+__REDIRECT
+
+
+383 \ 1
+ #__LDBL_REDIR1
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+è
+ `__REDIRECT
+ (Çme,\85rÙo,\87l\9fs)
+
+ )
+
+384 \ 1
+ #__LDBL_REDIR
+(
+Çme
+,
+´Ùo
+) \
+
+385
+ `__LDBL_REDIR1
+ (
+Çme
+,
+´Ùo
+,
+__Ædbl_
+##Çme)
+
+ )
+
+386 \ 1
+ #__LDBL_REDIR1_NTH
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+è
+ `__REDIRECT_NTH
+ (Çme,\85rÙo,\87l\9fs)
+
+ )
+
+387 \ 1
+ #__LDBL_REDIR_NTH
+(
+Çme
+,
+´Ùo
+) \
+
+388
+ `__LDBL_REDIR1_NTH
+ (
+Çme
+,
+´Ùo
+,
+__Ædbl_
+##Çme)
+
+ )
+
+389 \ 1
+ #__LDBL_REDIR1_DECL
+(
+Çme
+,
+®\9fs
+) \
+
+390 \r
+ `__ty³of
+ (
+Çme
+èÇm\90
+ `__asm
+ (
+ `__ASMNAME
+ (#®\9fs));
+
+ )
+
+391 \ 1
+ #__LDBL_REDIR_DECL
+(
+Çme
+) \
+
+392 \r
+ `__ty³of
+ (
+Çme
+èÇm\90
+ `__asm
+ (
+ `__ASMNAME
+ ("__Ædbl_" #Çme));
+
+ )
+
+393 \ 1
+ #__REDIRECT_LDBL
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+) \
+
+394
+ `__LDBL_REDIR1
+ (
+Çme
+,
+´Ùo
+,
+__Ædbl_
+##
+®\9fs
+)
+
+ )
+
+395 \ 1
+ #__REDIRECT_NTH_LDBL
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+) \
+
+396
+ `__LDBL_REDIR1_NTH
+ (
+Çme
+,
+´Ùo
+,
+__Ædbl_
+##
+®\9fs
+)
+
+ )
+
+399 #ià!
+def\9aed
+
+__LDBL_COMPAT
+ || !def\9aed
+__REDIRECT
+
+
+400 \ 1
+ #__LDBL_REDIR1
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+èÇm\90
+ )
+proto
+
+401 \ 1
+ #__LDBL_REDIR
+(
+Çme
+,
+´Ùo
+èÇm\90
+ )
+proto
+
+402 \ 1
+ #__LDBL_REDIR1_NTH
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+èÇm\90´ÙØ
+__THROW
+
+
+ )
+
+403 \ 1
+ #__LDBL_REDIR_NTH
+(
+Çme
+,
+´Ùo
+èÇm\90´ÙØ
+__THROW
+
+
+ )
+
+404 \ 1
+ #__LDBL_REDIR_DECL
+(
+Çme
+)
+
+ )
+
+405 #ifdeà
+__REDIRECT
+
+
+406 \ 1
+ #__REDIRECT_LDBL
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+è
+ `__REDIRECT
+ (Çme,\85rÙo,\87l\9fs)
+
+ )
+
+407 \ 1
+ #__REDIRECT_NTH_LDBL
+(
+Çme
+,
+´Ùo
+,
+®\9fs
+) \
+
+408
+ `__REDIRECT_NTH
+ (
+Çme
+,
+´Ùo
+,
+®\9fs
+)
+
+ )
+
+ @/usr/include/sys/select.h
+
+22 #iâdeà
+_SYS_SELECT_H
+
+
+23 \ 1
+ #_SYS_SELECT_H
+ 1
+
+ )
+
+25 \ 2
+ ~<ã©u»s.h
+>
+
+28 \ 2
+ ~<b\99s/ty³s.h
+>
+
+31 \ 2
+ ~<b\99s/£Ëù.h
+>
+
+34 \ 2
+ ~<b\99s/sig£t.h
+>
+
+36 #iâdeà
+__sig£t_t_def\9aed
+
+
+37 \ 1
+ #__sig£t_t_def\9aed
+
+
+ )
+
+38 \e
+__sig£t_t
+
+ tsig£t_t
+;
+
+42 \ 1
+ #__Ãed_time_t
+
+
+ )
+
+43 \ 1
+ #__Ãed_time¥ec
+
+
+ )
+
+44 \ 2
+ ~<time.h
+>
+
+45 \ 1
+ #__Ãed_timev®
+
+
+ )
+
+46 \ 2
+ ~<b\99s/time.h
+>
+
+48 #iâdeà
+__su£cÚds_t_def\9aed
+
+
+49 \e
+__su£cÚds_t
+
+ tsu£cÚds_t
+;
+
+50 \ 1
+ #__su£cÚds_t_def\9aed
+
+
+ )
+
+55 \e\13\12
+ t__fd_mask
+;
+
+58 #undeà
+__NFDBITS
+
+
+60 \ 1
+ #__NFDBITS
+ (8 * (\12è\17 (
+__fd_mask
+))
+
+ )
+
+61 \ 1
+ #__FD_ELT
+(
+d
+è((dè/
+__NFDBITS
+)
+
+ )
+
+62 \ 1
+ #__FD_MASK
+(
+d
+è((
+__fd_mask
+è1 << ((dè%
+__NFDBITS
+))
+
+ )
+
+69 #ifdeà
+__USE_XOPEN
+
+
+70
+__fd_mask
+
+ mfds_b\99s
+[
+__FD_SETSIZE
+ /
+__NFDBITS
+];
+
+71 \ 1
+ #__FDS_BITS
+(
+£t
+è((£t)->
+fds_b\99s
+)
+
+ )
+
+73
+__fd_mask
+
+ m__fds_b\99s
+[
+__FD_SETSIZE
+ /
+__NFDBITS
+];
+
+74 \ 1
+ #__FDS_BITS
+(
+£t
+è((£t)->
+__fds_b\99s
+)
+
+ )
+
+76 }
+ tfd_£t
+;
+
+79 \ 1
+ #FD_SETSIZE
+
+__FD_SETSIZE
+
+
+ )
+
+81 #ifdeà
+__USE_MISC
+
+
+83 \e
+__fd_mask
+
+ tfd_mask
+;
+
+86 \ 1
+ #NFDBITS
+
+__NFDBITS
+
+
+ )
+
+91 \ 1
+ #FD_SET
+(
+fd
+,
+fd£\8d
+è
+ `__FD_SET
+ (fd, fd£\8d)
+
+ )
+
+92 \ 1
+ #FD_CLR
+(
+fd
+,
+fd£\8d
+è
+ `__FD_CLR
+ (fd, fd£\8d)
+
+ )
+
+93 \ 1
+ #FD_ISSET
+(
+fd
+,
+fd£\8d
+è
+ `__FD_ISSET
+ (fd, fd£\8d)
+
+ )
+
+94 \ 1
+ #FD_ZERO
+(
+fd£\8d
+è
+ `__FD_ZERO
+ (fd£\8d)
+
+ )
+
+97
+__BEGIN_DECLS
+
+
+107 \r\12
+£Ëù
+ (\12
+__nfds
+,
+fd_£t
+ *
+__»¡riù
+
+__»adfds
+,
+
+108
+fd_£t
+ *
+__»¡riù
+
+__wr\99efds
+,
+
+109
+fd_£t
+ *
+__»¡riù
+
+__exû±fds
+,
+
+110 \19
+timev®
+ *
+__»¡riù
+
+__timeout
+);
+
+112 #ifdeà
+__USE_XOPEN2K
+
+
+119 \r\12
+p£Ëù
+ (\12
+__nfds
+,
+fd_£t
+ *
+__»¡riù
+
+__»adfds
+,
+
+120
+fd_£t
+ *
+__»¡riù
+
+__wr\99efds
+,
+
+121
+fd_£t
+ *
+__»¡riù
+
+__exû±fds
+,
+
+122 cڡ \19
+time¥ec
+ *
+__»¡riù
+
+__timeout
+,
+
+123 cڡ
+__sig£t_t
+ *
+__»¡riù
+
+__sigmask
+);
+
+128 #ià
+__USE_FORTIFY_LEVEL
+ > 0 &&
+def\9aed
+
+__GNUC__
+
+
+129 \ 2
+ ~<b\99s/£Ëù2.h
+>
+
+132
+ g__END_DECLS
+
+
+ @/usr/include/sys/sysmacros.h
+
+21 #iâdeà
+_SYS_SYSMACROS_H
+
+
+22 \ 1
+ #_SYS_SYSMACROS_H
+ 1
+
+ )
+
+24 \ 2
+ ~<ã©u»s.h
+>
+
+29 #ifdeà
+__GLIBC_HAVE_LONG_LONG
+
+
+30
+__BEGIN_DECLS
+
+
+32
+__ex\8bnsiÚ__
+
+
+33 \r\1d\12
+ $gnu_dev_majÜ
+ (\1d\13\13\12
+__dev
+)
+
+34
+__THROW
+
+__©\8cibu\8b_cÚ¡__
+;
+
+35
+__ex\8bnsiÚ__
+
+
+36 \r\1d\12
+ $gnu_dev_m\9aÜ
+ (\1d\13\13\12
+__dev
+)
+
+37
+__THROW
+
+__©\8cibu\8b_cÚ¡__
+;
+
+38
+__ex\8bnsiÚ__
+
+
+39 \r\1d\13\13\12
+ $gnu_dev_makedev
+ (\1d\12
+__majÜ
+,
+
+40 \1d\12
+__m\9aÜ
+)
+
+41
+__THROW
+
+__©\8cibu\8b_cÚ¡__
+;
+
+43 #ià
+def\9aed
+
+__GNUC__
+ && __GNUC__ >ð2 && def\9aed
+__USE_EXTERN_INLINES
+
+
+44
+__ex\8bnsiÚ__
+
+__ex\8bº_\9al\9ae
+
+__©\8cibu\8b_cÚ¡__
+ \1d\12
+
+45
+ `__NTH
+ (
+ $gnu_dev_majÜ
+ (\1d\13\13\12
+__dev
+))
+
+47 \15 ((
+__dev
+ >> 8) & 0xfff) | ((\1d\12) (__dev >> 32) & ~0xfff);
+
+48
+ }
+}
+
+50
+__ex\8bnsiÚ__
+
+__ex\8bº_\9al\9ae
+
+__©\8cibu\8b_cÚ¡__
+ \1d\12
+
+51
+__NTH
+ (
+ $gnu_dev_m\9aÜ
+ (\1d\13\13\12
+__dev
+))
+
+53 \15 (
+__dev
+ & 0xff) | ((\1d\12) (__dev >> 12) & ~0xff);
+
+54
+ }
+}
+
+56
+__ex\8bnsiÚ__
+
+__ex\8bº_\9al\9ae
+
+__©\8cibu\8b_cÚ¡__
+ \1d\13\13\12
+
+57
+__NTH
+ (
+ $gnu_dev_makedev
+ (\1d\12
+__majÜ
+, \1d\12
+__m\9aÜ
+))
+
+59 \15 ((
+__m\9aÜ
+ & 0xffè| ((
+__majÜ
+ & 0xfff) << 8)
+
+60 | (((\1d\13\13\12è(
+__m\9aÜ
+ & ~0xff)) << 12)
+
+61 | (((\1d\13\13\12è(
+__majÜ
+ & ~0xfff)) << 32));
+
+62
+ }
+}
+
+64
+ g__END_DECLS
+
+
+67 \ 1
+ #majÜ
+(
+dev
+è
+ `gnu_dev_majÜ
+ (dev)
+
+ )
+
+68 \ 1
+ #m\9aÜ
+(
+dev
+è
+ `gnu_dev_m\9aÜ
+ (dev)
+
+ )
+
+69 \ 1
+ #makedev
+(
+maj
+,
+m\9a
+è
+ `gnu_dev_makedev
+ (maj, m\9a)
+
+ )
+
+ @/usr/include/time.h
+
+23 #iâdef
+_TIME_H
+
+
+25 #ià(!
+def\9aed
+
+__Ãed_time_t
+ && !def\9aed
+__Ãed_þock_t
+ && \
+
+26 !
+def\9aed
+
+ g__Ãed_time¥ec
+)
+
+27 \ 1
+ #_TIME_H
+ 1
+
+ )
+
+28 \ 2
+ ~<ã©u»s.h
+>
+
+30
+ g__BEGIN_DECLS
+
+
+34 #ifdef
+_TIME_H
+
+
+36 \ 1
+ #__Ãed_size_t
+
+
+ )
+
+37 \ 1
+ #__Ãed_NULL
+
+
+ )
+
+38 \ 2
+ ~<¡ddef.h
+>
+
+42 \ 2
+ ~<b\99s/time.h
+>
+
+45 #ià!
+def\9aed
+
+__STRICT_ANSI__
+ && !def\9aed
+__USE_XOPEN2K
+
+
+46 #iâdeà
+CLK_TCK
+
+
+47 \ 1
+ #CLK_TCK
+
+CLOCKS_PER_SEC
+
+
+ )
+
+53 #ià!
+def\9aed
+
+__þock_t_def\9aed
+ && (def\9aed
+_TIME_H
+ || def\9aed
+__Ãed_þock_t
+)
+
+54 \ 1
+ #__þock_t_def\9aed
+ 1
+
+ )
+
+56 \ 2
+ ~<b\99s/ty³s.h
+>
+
+58
+__BEGIN_NAMESPACE_STD
+
+
+60 \e
+__þock_t
+
+ tþock_t
+;
+
+61
+ g__END_NAMESPACE_STD
+
+
+62 #ià
+def\9aed
+
+__USE_XOPEN
+ || def\9aed
+__USE_POSIX
+ || def\9aed
+__USE_MISC
+
+
+63
+ $__USING_NAMESPACE_STD
+(
+þock_t
+)
+
+67 #undeà
+__Ãed_þock_t
+
+
+69 #ià!
+def\9aed
+
+__time_t_def\9aed
+ && (def\9aed
+_TIME_H
+ || def\9aed
+__Ãed_time_t
+)
+
+70 \ 1
+ #__time_t_def\9aed
+ 1
+
+ )
+
+72 \ 2
+ ~<b\99s/ty³s.h
+>
+
+74
+__BEGIN_NAMESPACE_STD
+
+
+76 \e
+__time_t
+
+ ttime_t
+;
+
+77
+__END_NAMESPACE_STD
+
+
+78 #ià
+def\9aed
+
+__USE_POSIX
+ || def\9aed
+__USE_MISC
+ || def\9aed
+__USE_SVID
+
+
+79
+ $__USING_NAMESPACE_STD
+(
+time_t
+)
+
+83 #undeà
+__Ãed_time_t
+
+
+85 #ià!
+def\9aed
+
+__þockid_t_def\9aed
+ && \
+
+86 ((
+def\9aed
+
+_TIME_H
+ && def\9aed
+__USE_POSIX199309
+è|| def\9aed
+__Ãed_þockid_t
+)
+
+87 \ 1
+ #__þockid_t_def\9aed
+ 1
+
+ )
+
+89 \ 2
+ ~<b\99s/ty³s.h
+>
+
+92 \e
+__þockid_t
+
+ tþockid_t
+;
+
+95 #undeà
+__þockid_time_t
+
+
+97 #ià!
+def\9aed
+
+__tim\94_t_def\9aed
+ && \
+
+98 ((
+def\9aed
+
+_TIME_H
+ && def\9aed
+__USE_POSIX199309
+è|| def\9aed
+__Ãed_tim\94_t
+)
+
+99 \ 1
+ #__tim\94_t_def\9aed
+ 1
+
+ )
+
+101 \ 2
+ ~<b\99s/ty³s.h
+>
+
+104 \e
+__tim\94_t
+
+ ttim\94_t
+;
+
+107 #undeà
+__Ãed_tim\94_t
+
+
+110 #ià!
+def\9aed
+
+__time¥ec_def\9aed
+ && \
+
+111 ((
+def\9aed
+
+_TIME_H
+ && \
+
+112 (
+def\9aed
+
+__USE_POSIX199309
+ || def\9aed
+__USE_MISC
+)) || \
+
+113
+def\9aed
+
+__Ãed_time¥ec
+)
+
+114 \ 1
+ #__time¥ec_def\9aed
+ 1
+
+ )
+
+116 \ 2
+ ~<b\99s/ty³s.h
+>
+
+120 \19
+ stime¥ec
+
+
+122
+__time_t
+
+tv_£c
+;
+
+123 \13\12
+tv_n£c
+;
+
+127 #undeà
+__Ãed_time¥ec
+
+
+130 #ifdef
+_TIME_H
+
+
+131
+__BEGIN_NAMESPACE_STD
+
+
+133 \19
+ stm
+
+
+135 \12
+tm_£c
+;
+
+136 \12
+tm_m\9a
+;
+
+137 \12
+tm_hour
+;
+
+138 \12
+tm_mday
+;
+
+139 \12
+tm_mÚ
+;
+
+140 \12
+tm_y\97r
+;
+
+141 \12
+tm_wday
+;
+
+142 \12
+tm_yday
+;
+
+143 \12
+tm_isd¡
+;
+
+145 #ifdef
+__USE_BSD
+
+
+146 \13\12
+tm_gmtoff
+;
+
+147
+__cڡ
+ \ 5*
+tm_zÚe
+;
+
+149 \13\12
+__tm_gmtoff
+;
+
+150
+__cڡ
+ \ 5*
+__tm_zÚe
+;
+
+153
+__END_NAMESPACE_STD
+
+
+154 #ià
+def\9aed
+
+__USE_XOPEN
+ || def\9aed
+__USE_POSIX
+ || def\9aed
+__USE_MISC
+
+
+155
+ $__USING_NAMESPACE_STD
+(
+tm
+)
+
+159 #ifdeà
+__USE_POSIX199309
+
+
+161 \19
+ s\99im\94¥ec
+
+
+163 \19
+time¥ec
+
+\99_\9a\8brv®
+;
+
+164 \19
+time¥ec
+
+\99_v®ue
+;
+
+168 \19
+sigev\92t
+;
+
+172 #ifdeà
+__USE_XOPEN2K
+
+
+173 #iâdeà
+__pid_t_def\9aed
+
+
+174 \e
+__pid_t
+
+ tpid_t
+;
+
+175 \ 1
+ #__pid_t_def\9aed
+
+
+ )
+
+180
+__BEGIN_NAMESPACE_STD
+
+
+183 \r
+þock_t
+
+ $þock
+ (\1eè
+__THROW
+;
+
+186 \r
+time_t
+
+ $time
+ (
+time_t
+ *
+__tim\94
+è
+__THROW
+;
+
+189 \r\b
+ $difáime
+ (
+time_t
+
+__time1
+,\81ime_\88
+__time0
+)
+
+190
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+));
+
+193 \r
+time_t
+
+ $mktime
+ (\19
+tm
+ *
+__\8d
+è
+__THROW
+;
+
+199 \r
+size_t
+
+ $¡ráime
+ (\ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__maxsize
+,
+
+200
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+201
+__cڡ
+ \19
+tm
+ *
+__»¡riù
+
+__\8d
+è
+__THROW
+;
+
+202
+__END_NAMESPACE_STD
+
+
+204 #ifdeà
+__USE_XOPEN
+
+
+207 \r\ 5*
+ $¡½time
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+
+208
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+, \19
+tm
+ *
+__\8d
+)
+
+209
+__THROW
+;
+
+212 #ifdeà
+__USE_XOPEN2K8
+
+
+215 \ 2
+ ~<xloÿË.h
+>
+
+217 \r
+size_t
+
+ $¡ráime_l
+ (\ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__maxsize
+,
+
+218
+__cڡ
+ \ 5*
+__»¡riù
+
+__fÜm©
+,
+
+219
+__cڡ
+ \19
+tm
+ *
+__»¡riù
+
+__\8d
+,
+
+220
+__loÿË_t
+
+__loc
+è
+__THROW
+;
+
+223 #ifdeà
+__USE_GNU
+
+
+224 \r\ 5*
+ $¡½time_l
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+
+225
+__cڡ
+ \ 5*
+__»¡riù
+
+__fmt
+, \19
+tm
+ *
+__\8d
+,
+
+226
+__loÿË_t
+
+__loc
+è
+__THROW
+;
+
+230
+__BEGIN_NAMESPACE_STD
+
+
+233 \r\19
+tm
+ *
+ $gmtime
+ (
+__cڡ
+
+time_t
+ *
+__tim\94
+è
+__THROW
+;
+
+237 \r\19
+tm
+ *
+ $loÿÉime
+ (
+__cڡ
+
+time_t
+ *
+__tim\94
+è
+__THROW
+;
+
+238
+__END_NAMESPACE_STD
+
+
+240 #ià
+def\9aed
+
+__USE_POSIX
+ || def\9aed
+__USE_MISC
+
+
+243 \r\19
+tm
+ *
+ $gmtime_r
+ (
+__cڡ
+
+time_t
+ *
+__»¡riù
+
+__tim\94
+,
+
+244 \19
+tm
+ *
+__»¡riù
+
+__\8d
+è
+__THROW
+;
+
+248 \r\19
+tm
+ *
+ $loÿÉime_r
+ (
+__cڡ
+
+time_t
+ *
+__»¡riù
+
+__tim\94
+,
+
+249 \19
+tm
+ *
+__»¡riù
+
+__\8d
+è
+__THROW
+;
+
+252
+__BEGIN_NAMESPACE_STD
+
+
+255 \r\ 5*
+ $asùime
+ (
+__cڡ
+ \19
+tm
+ *
+__\8d
+è
+__THROW
+;
+
+258 \r\ 5*
+ $ùime
+ (
+__cڡ
+
+time_t
+ *
+__tim\94
+è
+__THROW
+;
+
+259
+__END_NAMESPACE_STD
+
+
+261 #ià
+def\9aed
+
+__USE_POSIX
+ || def\9aed
+__USE_MISC
+
+
+266 \r\ 5*
+ $asùime_r
+ (
+__cڡ
+ \19
+tm
+ *
+__»¡riù
+
+__\8d
+,
+
+267 \ 5*
+__»¡riù
+
+__buf
+è
+__THROW
+;
+
+270 \r\ 5*
+ $ùime_r
+ (
+__cڡ
+
+time_t
+ *
+__»¡riù
+
+__tim\94
+,
+
+271 \ 5*
+__»¡riù
+
+__buf
+è
+__THROW
+;
+
+276 \r\ 5*
+__tzÇme
+[2];
+
+277 \r\12
+__daylight
+;
+
+278 \r\13\12
+__timezÚe
+;
+
+281 #ifdef
+__USE_POSIX
+
+
+283 \r\ 5*
+tzÇme
+[2];
+
+287 \r\1e
+ $tz£t
+ (\1eè
+__THROW
+;
+
+290 #ià
+def\9aed
+
+__USE_SVID
+ || def\9aed
+__USE_XOPEN
+
+
+291 \r\12
+daylight
+;
+
+292 \r\13\12
+timezÚe
+;
+
+295 #ifdeà
+__USE_SVID
+
+
+298 \r\12
+ $¡ime
+ (
+__cڡ
+
+time_t
+ *
+__wh\92
+è
+__THROW
+;
+
+304 \ 1
+ #__i¦\97p
+(
+y\97r
+) \
+
+305 ((
+y\97r
+è% 4 =ð0 && ((y\97rè% 100 !ð0 || (y\97rè% 400 =ð0))
+
+ )
+
+308 #ifdeà
+__USE_MISC
+
+
+313 \r
+time_t
+
+ $timegm
+ (\19
+tm
+ *
+__\8d
+è
+__THROW
+;
+
+316 \r
+time_t
+
+ $tim\96oÿl
+ (\19
+tm
+ *
+__\8d
+è
+__THROW
+;
+
+319 \r\12
+ $dysize
+ (\12
+__y\97r
+è
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+));
+
+323 #ifdeà
+__USE_POSIX199309
+
+
+328 \r\12
+ `Çno¦\93p
+ (
+__cڡ
+ \19
+time¥ec
+ *
+__»que¡ed_time
+,
+
+329 \19
+time¥ec
+ *
+__»ma\9a\9ag
+);
+
+333 \r\12
+ $þock_g\91»s
+ (
+þockid_t
+
+__þock_id
+, \19
+time¥ec
+ *
+__»s
+è
+__THROW
+;
+
+336 \r\12
+ $þock_g\91time
+ (
+þockid_t
+
+__þock_id
+, \19
+time¥ec
+ *
+__\8d
+è
+__THROW
+;
+
+339 \r\12
+ $þock_£\89ime
+ (
+þockid_t
+
+__þock_id
+,
+__cڡ
+ \19
+time¥ec
+ *
+__\8d
+)
+
+340
+__THROW
+;
+
+342 #ifdeà
+__USE_XOPEN2K
+
+
+347 \r\12
+ `þock_Çno¦\93p
+ (
+þockid_t
+
+__þock_id
+, \12
+__æags
+,
+
+348
+__cڡ
+ \19
+time¥ec
+ *
+__»q
+,
+
+349 \19
+time¥ec
+ *
+__»m
+);
+
+352 \r\12
+ $þock_g\91ýuþockid
+ (
+pid_t
+
+__pid
+,
+þockid_t
+ *
+__þock_id
+è
+__THROW
+;
+
+357 \r\12
+ $tim\94_ü\97\8b
+ (
+þockid_t
+
+__þock_id
+,
+
+358 \19
+sigev\92t
+ *
+__»¡riù
+
+__evp
+,
+
+359
+tim\94_t
+ *
+__»¡riù
+
+__tim\94id
+è
+__THROW
+;
+
+362 \r\12
+ $tim\94_d\96\91e
+ (
+tim\94_t
+
+__tim\94id
+è
+__THROW
+;
+
+365 \r\12
+ $tim\94_£\89ime
+ (
+tim\94_t
+
+__tim\94id
+, \12
+__æags
+,
+
+366
+__cڡ
+ \19
+\99im\94¥ec
+ *
+__»¡riù
+
+__v®ue
+,
+
+367 \19
+\99im\94¥ec
+ *
+__»¡riù
+
+__ov®ue
+è
+__THROW
+;
+
+370 \r\12
+ $tim\94_g\91time
+ (
+tim\94_t
+
+__tim\94id
+, \19
+\99im\94¥ec
+ *
+__v®ue
+)
+
+371
+__THROW
+;
+
+374 \r\12
+ $tim\94_g\91ov\94run
+ (
+tim\94_t
+
+__tim\94id
+è
+__THROW
+;
+
+378 #ifdeà
+__USE_XOPEN_EXTENDED
+
+
+390 \r\12
+g\91d©e_\94r
+;
+
+399 \r\19
+tm
+ *
+ `g\91d©e
+ (
+__cڡ
+ \ 5*
+__¡r\9ag
+);
+
+402 #ifdeà
+__USE_GNU
+
+
+413 \r\12
+ `g\91d©e_r
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__¡r\9ag
+,
+
+414 \19
+tm
+ *
+__»¡riù
+
+__»sbuå
+);
+
+417
+__END_DECLS
+
+
+ @/usr/include/bits/byteswap.h
+
+21 #ià!
+def\9aed
+
+_BYTESWAP_H
+ && !def\9aed
+_NETINET_IN_H
+ && !def\9aed
+_ENDIAN_H
+
+
+25 #iâdeà
+_BITS_BYTESWAP_H
+
+
+26 \ 1
+ #_BITS_BYTESWAP_H
+ 1
+
+ )
+
+28 \ 2
+ ~<b\99s/wÜdsize.h
+>
+
+31 \ 1
+ #__bsw_cÚ¡ªt_16
+(
+x
+) \
+
+32 ((\1d\16\12è((((
+x
+è>> 8è& 0xffè| (((xè& 0xffè<< 8)))
+
+ )
+
+34 #ià
+def\9aed
+
+__GNUC__
+ && __GNUC__ >= 2
+
+35 \ 1
+ #__bsw_16
+(
+x
+) \
+
+36 (
+__ex\8bnsiÚ__
+ \
+
+37 ({ \14\1d\16\12
+__v
+,
+__x
+ = (\1d\16\12è(
+x
+); \
+
+38 ià(
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__x
+)) \
+
+39
+__v
+ =
+ `__bsw_cÚ¡ªt_16
+ (
+__x
+); \
+
+41
+ `__asm__
+ ("rorw $8, %w0" \
+
+42 : "ô" (
+__v
+) \
+
+43 : "0" (
+__x
+) \
+
+45
+__v
+; }))
+
+ )
+
+48 \ 1
+ #__bsw_16
+(
+x
+) \
+
+49 (
+__ex\8bnsiÚ__
+ \
+
+50 ({ \14\1d\16\12
+__x
+ = (\1d\16\12è(
+x
+); \
+
+51
+ `__bsw_cÚ¡ªt_16
+ (
+__x
+); }))
+
+ )
+
+56 \ 1
+ #__bsw_cÚ¡ªt_32
+(
+x
+) \
+
+57 ((((
+x
+) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \
+
+58 (((
+x
+è& 0x0000ff00è<< 8è| (((xè& 0x000000ffè<< 24))
+
+ )
+
+60 #ià
+def\9aed
+
+__GNUC__
+ && __GNUC__ >= 2
+
+61 #ià
+__WORDSIZE
+ =ð64 || (
+def\9aed
+
+__i486__
+ || def\9aed
+__³Áium__
+ \
+
+62 ||
+def\9aed
+
+ g__³Áium´o__
+ || def\9aed
+ g__³Áium4__
+ \
+
+63 ||
+def\9aed
+
+ g__k8__
+ || def\9aed
+ g__©hlÚ__
+ \
+
+64 ||
+def\9aed
+
+ g__k6__
+ || def\9aed
+ g__nocÚa__
+ \
+
+65 ||
+def\9aed
+
+ g__cÜe2__
+ || def\9aed
+ g__geode__
+ \
+
+66 ||
+def\9aed
+
+ g__amdçm10__
+)
+
+69 \ 1
+ #__bsw_32
+(
+x
+) \
+
+70 (
+__ex\8bnsiÚ__
+ \
+
+71 ({ \14\1d\12
+__v
+,
+__x
+ = (
+x
+); \
+
+72 ià(
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__x
+)) \
+
+73
+__v
+ =
+ `__bsw_cÚ¡ªt_32
+ (
+__x
+); \
+
+75
+ `__asm__
+ ("bsw %0" : "ô" (
+__v
+è: "0" (
+__x
+)); \
+
+76
+__v
+; }))
+
+ )
+
+78 \ 1
+ #__bsw_32
+(
+x
+) \
+
+79 (
+__ex\8bnsiÚ__
+ \
+
+80 ({ \14\1d\12
+__v
+,
+__x
+ = (
+x
+); \
+
+81 ià(
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__x
+)) \
+
+82
+__v
+ =
+ `__bsw_cÚ¡ªt_32
+ (
+__x
+); \
+
+84
+ `__asm__
+ ("rorw $8, %w0;" \
+
+87 : "ô" (
+__v
+) \
+
+88 : "0" (
+__x
+) \
+
+90
+__v
+; }))
+
+ )
+
+93 \ 1
+ #__bsw_32
+(
+x
+) \
+
+94 (
+__ex\8bnsiÚ__
+ \
+
+95 ({ \14\1d\12
+__x
+ = (
+x
+);
+ `__bsw_cÚ¡ªt_32
+ (__x); }))
+
+ )
+
+99 #ià
+def\9aed
+
+__GNUC__
+ && __GNUC__ >= 2
+
+101 \ 1
+ #__bsw_cÚ¡ªt_64
+(
+x
+) \
+
+102 (
+ `__ex\8bnsiÚ__
+ ((((
+x
+) & 0xff00000000000000ull) >> 56) \
+
+103 | (((
+x
+) & 0x00ff000000000000ull) >> 40) \
+
+104 | (((
+x
+) & 0x0000ff0000000000ull) >> 24) \
+
+105 | (((
+x
+) & 0x000000ff00000000ull) >> 8) \
+
+106 | (((
+x
+) & 0x00000000ff000000ull) << 8) \
+
+107 | (((
+x
+) & 0x0000000000ff0000ull) << 24) \
+
+108 | (((
+x
+) & 0x000000000000ff00ull) << 40) \
+
+109 | (((
+x
+è& 0x00000000000000ffuÎè<< 56)))
+
+ )
+
+111 #ià
+__WORDSIZE
+ == 64
+
+112 \ 1
+ #__bsw_64
+(
+x
+) \
+
+113 (
+__ex\8bnsiÚ__
+ \
+
+114 ({ \14\1d\13
+__v
+,
+__x
+ = (
+x
+); \
+
+115 ià(
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__x
+)) \
+
+116
+__v
+ =
+ `__bsw_cÚ¡ªt_64
+ (
+__x
+); \
+
+118
+ `__asm__
+ ("bsw %q0" : "ô" (
+__v
+è: "0" (
+__x
+)); \
+
+119
+__v
+; }))
+
+ )
+
+121 \ 1
+ #__bsw_64
+(
+x
+) \
+
+122 (
+__ex\8bnsiÚ__
+ \
+
+123 ({ uniÚ {
+__ex\8bnsiÚ__
+ \1d\13\13\12
+__Î
+; \
+
+124 \1d\12
+__l
+[2]; }
+__w
+,
+__r
+; \
+
+125 ià(
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+x
+)) \
+
+126
+__r
+.
+__Î
+ =
+ `__bsw_cÚ¡ªt_64
+ (
+x
+); \
+
+129
+__w
+.
+__Î
+ = (
+x
+); \
+
+130
+__r
+.
+__l
+[0] =
+ `__bsw_32
+ (
+__w
+.__l[1]); \
+
+131
+__r
+.
+__l
+[1] =
+ `__bsw_32
+ (
+__w
+.__l[0]); \
+
+133
+__r
+.
+__Î
+; }))
+
+ )
+
+ @/usr/include/bits/endian.h
+
+3 #iâdeà
+_ENDIAN_H
+
+
+7 \ 1
+ #__BYTE_ORDER
+
+__LITTLE_ENDIAN
+
+
+ )
+
+ @/usr/include/bits/libc-lock.h
+
+20 #iâdeà
+_BITS_LIBC_LOCK_H
+
+
+21 \ 1
+ #_BITS_LIBC_LOCK_H
+ 1
+
+ )
+
+23 \ 2
+ ~<±h»ad.h
+>
+
+24 \ 1
+ #__Ãed_NULL
+
+
+ )
+
+25 \ 2
+ ~<¡ddef.h
+>
+
+34 #ifdeà
+_LIBC
+
+
+35 \ 2
+ ~<lowËv\96lock.h
+>
+
+36 \ 2
+ ~<\8es.h
+>
+
+37 \ 2
+ ~<±h»ad-funùiÚs.h
+>
+
+38 \ 2
+ ~<\94ºo.h
+>
+
+39 \ 2
+ ~<gnu/ÝtiÚ-groups.h
+>
+
+43 #ià
+def\9aed
+
+_LIBC
+ || def\9aed
+_IO_MTSAFE_IO
+
+
+44 #ià(
+def\9aed
+
+NOT_IN_libc
+ && !def\9aed
+IS_IN_lib±h»ad
+è|| !def\9aed
+_LIBC
+
+
+45 \e
+±h»ad_mu\8bx_t
+
+ t__libc_lock_t
+;
+
+46 \e¡ruù {
+±h»ad_mu\8bx_t
+
+ mmu\8bx
+; }
+ t__libc_lock_»cursive_t
+;
+
+48 \e\12
+ t__libc_lock_t
+;
+
+49 \e¡ruù { \12
+ mlock
+; \12
+ mút
+; \1e*
+ mowÃr
+; }
+ t__libc_lock_»cursive_t
+;
+
+51 \e¡ruù {
+±h»ad_mu\8bx_t
+
+ mmu\8bx
+; }
+ t__¹ld_lock_»cursive_t
+;
+
+52 #ifdeà
+__USE_UNIX98
+
+
+53 \e
+±h»ad_rwlock_t
+
+ t__libc_rwlock_t
+;
+
+55 \e\19
+__libc_rwlock_Ýaque__
+
+ t__libc_rwlock_t
+;
+
+58 \e\19
+__libc_lock_Ýaque__
+
+ t__libc_lock_t
+;
+
+59 \e\19
+__libc_lock_»cursive_Ýaque__
+
+ t__libc_lock_»cursive_t
+;
+
+60 \e\19
+__libc_rwlock_Ýaque__
+
+ t__libc_rwlock_t
+;
+
+64 \e
+±h»ad_key_t
+
+ t__libc_key_t
+;
+
+73 \ 1
+ #__libc_lock_def\9ae
+(
+CLASS
+,
+NAME
+) \
+
+74
+CLASS
+
+__libc_lock_t
+
+NAME
+;
+
+ )
+
+75 \ 1
+ #__libc_rwlock_def\9ae
+(
+CLASS
+,
+NAME
+) \
+
+76
+CLASS
+
+__libc_rwlock_t
+
+NAME
+;
+
+ )
+
+77 \ 1
+ #__libc_lock_def\9ae_»cursive
+(
+CLASS
+,
+NAME
+) \
+
+78
+CLASS
+
+__libc_lock_»cursive_t
+
+NAME
+;
+
+ )
+
+79 \ 1
+ #__¹ld_lock_def\9ae_»cursive
+(
+CLASS
+,
+NAME
+) \
+
+80
+CLASS
+
+__¹ld_lock_»cursive_t
+
+NAME
+;
+
+ )
+
+91 #ià
+def\9aed
+
+_LIBC
+ && (!def\9aed
+NOT_IN_libc
+ || def\9aed
+IS_IN_lib±h»ad
+)
+
+92 #ià
+LLL_LOCK_INITIALIZER
+ == 0
+
+93 \ 1
+ #__libc_lock_def\9ae_\9a\99\9flized
+(
+CLASS
+,
+NAME
+) \
+
+94
+CLASS
+
+__libc_lock_t
+
+NAME
+;
+
+ )
+
+96 \ 1
+ #__libc_lock_def\9ae_\9a\99\9flized
+(
+CLASS
+,
+NAME
+) \
+
+97
+CLASS
+
+__libc_lock_t
+
+NAME
+ =
+LLL_LOCK_INITIALIZER
+;
+
+ )
+
+100 #ià
+__LT_SPINLOCK_INIT
+ == 0
+
+101 \ 1
+ #__libc_lock_def\9ae_\9a\99\9flized
+(
+CLASS
+,
+NAME
+) \
+
+102
+CLASS
+
+__libc_lock_t
+
+NAME
+;
+
+ )
+
+104 \ 1
+ #__libc_lock_def\9ae_\9a\99\9flized
+(
+CLASS
+,
+NAME
+) \
+
+105
+CLASS
+
+__libc_lock_t
+
+NAME
+ =
+PTHREAD_MUTEX_INITIALIZER
+;
+
+ )
+
+109 \ 1
+ #__libc_rwlock_def\9ae_\9a\99\9flized
+(
+CLASS
+,
+NAME
+) \
+
+110
+CLASS
+
+__libc_rwlock_t
+
+NAME
+ =
+PTHREAD_RWLOCK_INITIALIZER
+;
+
+ )
+
+114 #ià
+def\9aed
+
+_LIBC
+ && (!def\9aed
+NOT_IN_libc
+ || def\9aed
+IS_IN_lib±h»ad
+)
+
+115 #ià
+LLL_LOCK_INITIALIZER
+ == 0
+
+116 \ 1
+ #__libc_lock_def\9ae_\9a\99\9flized_»cursive
+(
+CLASS
+,
+NAME
+) \
+
+117
+CLASS
+
+__libc_lock_»cursive_t
+
+NAME
+;
+
+ )
+
+119 \ 1
+ #__libc_lock_def\9ae_\9a\99\9flized_»cursive
+(
+CLASS
+,
+NAME
+) \
+
+120
+CLASS
+
+__libc_lock_»cursive_t
+
+NAME
+ =
+_LIBC_LOCK_RECURSIVE_INITIALIZER
+;
+
+ )
+
+122 \ 1
+ #_LIBC_LOCK_RECURSIVE_INITIALIZER
+ \
+
+123 {
+LLL_LOCK_INITIALIZER
+, 0,
+NULL
+ }
+
+ )
+
+125 \ 1
+ #__libc_lock_def\9ae_\9a\99\9flized_»cursive
+(
+CLASS
+,
+NAME
+) \
+
+126
+CLASS
+
+__libc_lock_»cursive_t
+
+NAME
+ =
+_LIBC_LOCK_RECURSIVE_INITIALIZER
+;
+
+ )
+
+127 \ 1
+ #_LIBC_LOCK_RECURSIVE_INITIALIZER
+ \
+
+128 {
+PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
+}
+
+ )
+
+131 \ 1
+ #__¹ld_lock_def\9ae_\9a\99\9flized_»cursive
+(
+CLASS
+,
+NAME
+) \
+
+132
+CLASS
+
+__¹ld_lock_»cursive_t
+
+NAME
+ =
+_RTLD_LOCK_RECURSIVE_INITIALIZER
+;
+
+ )
+
+133 \ 1
+ #_RTLD_LOCK_RECURSIVE_INITIALIZER
+ \
+
+134 {
+PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
+}
+
+ )
+
+136 \ 1
+ #__¹ld_lock_\9a\99\9flize
+(
+NAME
+) \
+
+137 (\1eè((
+NAME
+èð(
+__¹ld_lock_»cursive_t
+è
+_RTLD_LOCK_RECURSIVE_INITIALIZER
+)
+
+ )
+
+144 #ifdeà
+__PIC__
+
+
+145 \ 1
+ #__libc_maybe_ÿÎ
+(
+FUNC
+,
+ARGS
+,
+ELSE
+) \
+
+146 (
+ `__ex\8bnsiÚ__
+ ({
+ `__ty³of
+ (
+FUNC
+è*
+_â
+ = (FUNC); \
+
+147
+_â
+ !ð
+NULL
+ ? (*_âè
+ARGS
+ :
+ELSE
+; }))
+
+ )
+
+149 \ 1
+ #__libc_maybe_ÿÎ
+(
+FUNC
+,
+ARGS
+,
+ELSE
+) \
+
+150 (
+FUNC
+ !ð
+NULL
+ ? FUNC
+ARGS
+ :
+ELSE
+)
+
+ )
+
+154 #ià
+def\9aed
+
+SHARED
+ && !def\9aed
+NOT_IN_libc
+
+
+155 \ 1
+ #PTFAVAIL
+(
+NAME
+è
+__libc_±h»ad_funùiÚs_\9a\99
+
+
+ )
+
+156 \ 1
+ #__libc_±f_ÿÎ
+(
+FUNC
+,
+ARGS
+,
+ELSE
+) \
+
+157 (
+__libc_±h»ad_funùiÚs_\9a\99
+ ?
+ `PTHFCT_CALL
+ (
+±r_
+##
+FUNC
+,
+ARGS
+è:
+ELSE
+)
+
+ )
+
+158 \ 1
+ #__libc_±f_ÿÎ_®ways
+(
+FUNC
+,
+ARGS
+) \
+
+159
+ `PTHFCT_CALL
+ (
+±r_
+##
+FUNC
+,
+ARGS
+)
+
+ )
+
+161 \ 1
+ #PTFAVAIL
+(
+NAME
+è(NAME !ð
+NULL
+)
+
+ )
+
+162 \ 1
+ #__libc_±f_ÿÎ
+(
+FUNC
+,
+ARGS
+,
+ELSE
+) \
+
+163
+ `__libc_maybe_ÿÎ
+ (
+FUNC
+,
+ARGS
+,
+ELSE
+)
+
+ )
+
+164 \ 1
+ #__libc_±f_ÿÎ_®ways
+(
+FUNC
+,
+ARGS
+) \
+
+165
+FUNC
+
+ARGS
+
+
+ )
+
+171 #ià
+def\9aed
+
+_LIBC
+ && (!def\9aed
+NOT_IN_libc
+ || def\9aed
+IS_IN_lib±h»ad
+)
+
+172 \ 1
+ #__libc_lock_\9a\99
+(
+NAME
+è((NAMEèð
+LLL_LOCK_INITIALIZER
+, 0)
+
+ )
+
+174 \ 1
+ #__libc_lock_\9a\99
+(
+NAME
+) \
+
+175
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_mu\8bx_\9a\99
+, (&(
+NAME
+),
+NULL
+), 0)
+
+ )
+
+177 #ià
+def\9aed
+
+SHARED
+ && !def\9aed
+NOT_IN_libc
+
+
+180 \ 1
+ #__libc_rwlock_\9a\99
+(
+NAME
+) \
+
+181 (
+ `__bu\9et\9a_mem£t
+ (&(
+NAME
+), '\0', \17 (NAME)), 0)
+
+ )
+
+183 \ 1
+ #__libc_rwlock_\9a\99
+(
+NAME
+) \
+
+184
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_rwlock_\9a\99
+, (&(
+NAME
+),
+NULL
+), 0)
+
+ )
+
+188 #ià
+def\9aed
+
+_LIBC
+ && (!def\9aed
+NOT_IN_libc
+ || def\9aed
+IS_IN_lib±h»ad
+)
+
+189 \ 1
+ #__libc_lock_\9a\99_»cursive
+(
+NAME
+) \
+
+190 ((
+NAME
+èð(
+__libc_lock_»cursive_t
+è
+_LIBC_LOCK_RECURSIVE_INITIALIZER
+, 0)
+
+ )
+
+192 \ 1
+ #__libc_lock_\9a\99_»cursive
+(
+NAME
+) \
+
+194 ià(
+__±h»ad_mu\8bx_\9a\99
+ !ð
+NULL
+) \
+
+196
+±h»ad_mu\8bx©\8c_t
+
+__©\8c
+; \
+
+197
+ `__±h»ad_mu\8bx©\8c_\9a\99
+ (&
+__©\8c
+); \
+
+198
+ `__±h»ad_mu\8bx©\8c_£\89y³
+ (&
+__©\8c
+,
+PTHREAD_MUTEX_RECURSIVE_NP
+); \
+
+199
+ `__±h»ad_mu\8bx_\9a\99
+ (&(
+NAME
+).
+mu\8bx
+, &
+__©\8c
+); \
+
+200
+ `__±h»ad_mu\8bx©\8c_de¡roy
+ (&
+__©\8c
+); \
+
+202 } \1f0)
+
+ )
+
+205 \ 1
+ #__¹ld_lock_\9a\99_»cursive
+(
+NAME
+) \
+
+207 ià(
+__±h»ad_mu\8bx_\9a\99
+ !ð
+NULL
+) \
+
+209
+±h»ad_mu\8bx©\8c_t
+
+__©\8c
+; \
+
+210
+ `__±h»ad_mu\8bx©\8c_\9a\99
+ (&
+__©\8c
+); \
+
+211
+ `__±h»ad_mu\8bx©\8c_£\89y³
+ (&
+__©\8c
+,
+PTHREAD_MUTEX_RECURSIVE_NP
+); \
+
+212
+ `__±h»ad_mu\8bx_\9a\99
+ (&(
+NAME
+).
+mu\8bx
+, &
+__©\8c
+); \
+
+213
+ `__±h»ad_mu\8bx©\8c_de¡roy
+ (&
+__©\8c
+); \
+
+215 } \1f0)
+
+ )
+
+220 #ià
+def\9aed
+
+_LIBC
+ && (!def\9aed
+NOT_IN_libc
+ || def\9aed
+IS_IN_lib±h»ad
+)
+
+221 \ 1
+ #__libc_lock_f\9ai
+(
+NAME
+è((\1eè0)
+
+ )
+
+223 \ 1
+ #__libc_lock_f\9ai
+(
+NAME
+) \
+
+224
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_mu\8bx_de¡roy
+, (&(
+NAME
+)), 0)
+
+ )
+
+226 #ià
+def\9aed
+
+SHARED
+ && !def\9aed
+NOT_IN_libc
+
+
+227 \ 1
+ #__libc_rwlock_f\9ai
+(
+NAME
+è((\1eè0)
+
+ )
+
+229 \ 1
+ #__libc_rwlock_f\9ai
+(
+NAME
+) \
+
+230
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_rwlock_de¡roy
+, (&(
+NAME
+)), 0)
+
+ )
+
+234 #ià
+def\9aed
+
+_LIBC
+ && (!def\9aed
+NOT_IN_libc
+ || def\9aed
+IS_IN_lib±h»ad
+)
+
+235 \ 1
+ #__libc_lock_f\9ai_»cursive
+(
+NAME
+è((\1eè0)
+
+ )
+
+237 \ 1
+ #__libc_lock_f\9ai_»cursive
+(
+NAME
+) \
+
+238
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_mu\8bx_de¡roy
+, (&(
+NAME
+)), 0)
+
+ )
+
+242 #ià
+def\9aed
+
+_LIBC
+ && (!def\9aed
+NOT_IN_libc
+ || def\9aed
+IS_IN_lib±h»ad
+)
+
+243 #ià
+__OPTION_EGLIBC_BIG_MACROS
+ != 1
+
+247 \r\1e
+__libc_lock_lock_â
+ (
+__libc_lock_t
+ *);
+
+248
+libc_hidd\92_´Ùo
+ (
+__libc_lock_lock_â
+);
+
+250 #ià
+__OPTION_EGLIBC_BIG_MACROS
+
+
+251 \ 1
+ #__libc_lock_lock
+(
+NAME
+) \
+
+252 ({
+ `Îl_lock
+ (
+NAME
+,
+LLL_PRIVATE
+); 0; })
+
+ )
+
+254 \ 1
+ #__libc_lock_lock
+(
+NAME
+) \
+
+255
+ `__libc_lock_lock_â
+ (&(
+NAME
+))
+
+ )
+
+258 \ 1
+ #__libc_lock_lock
+(
+NAME
+) \
+
+259
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_mu\8bx_lock
+, (&(
+NAME
+)), 0)
+
+ )
+
+261 \ 1
+ #__libc_rwlock_rdlock
+(
+NAME
+) \
+
+262
+ `__libc_±f_ÿÎ
+ (
+__±h»ad_rwlock_rdlock
+, (&(
+NAME
+)), 0)
+
+ )
+
+263 \ 1
+ #__libc_rwlock_w¾ock
+(
+NAME
+) \
+
+264
+ `__libc_±f_ÿÎ
+ (
+__±h»ad_rwlock_w¾ock
+, (&(
+NAME
+)), 0)
+
+ )
+
+267 #ià
+def\9aed
+
+_LIBC
+ && (!def\9aed
+NOT_IN_libc
+ || def\9aed
+IS_IN_lib±h»ad
+)
+
+268 #ià
+__OPTION_EGLIBC_BIG_MACROS
+ != 1
+
+272 \r\1e
+__libc_lock_lock_»cursive_â
+ (
+__libc_lock_»cursive_t
+ *);
+
+273
+libc_hidd\92_´Ùo
+ (
+__libc_lock_lock_»cursive_â
+);
+
+275 #ià
+__OPTION_EGLIBC_BIG_MACROS
+
+
+276 \ 1
+ #__libc_lock_lock_»cursive
+(
+NAME
+) \
+
+278 \1e*
+£lf
+ =
+THREAD_SELF
+; \
+
+279 ià((
+NAME
+).
+owÃr
+ !ð
+£lf
+) \
+
+281
+ `Îl_lock
+ ((
+NAME
+).
+lock
+,
+LLL_PRIVATE
+); \
+
+282 (
+NAME
+).
+owÃr
+ =
+£lf
+; \
+
+284 ++(
+NAME
+).
+út
+; \
+
+285 } \1f0)
+
+ )
+
+287 \ 1
+ #__libc_lock_lock_»cursive
+(
+NAME
+) \
+
+288
+ `__libc_lock_lock_»cursive_â
+ (&(
+NAME
+))
+
+ )
+
+291 \ 1
+ #__libc_lock_lock_»cursive
+(
+NAME
+) \
+
+292
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_mu\8bx_lock
+, (&(
+NAME
+).
+mu\8bx
+), 0)
+
+ )
+
+296 #ià
+def\9aed
+
+_LIBC
+ && (!def\9aed
+NOT_IN_libc
+ || def\9aed
+IS_IN_lib±h»ad
+)
+
+297 #ià
+__OPTION_EGLIBC_BIG_MACROS
+ != 1
+
+301 \r\12
+__libc_lock_\8cylock_â
+ (
+__libc_lock_t
+ *);
+
+302
+libc_hidd\92_´Ùo
+ (
+__libc_lock_\8cylock_â
+);
+
+304 #ià
+__OPTION_EGLIBC_BIG_MACROS
+
+
+305 \ 1
+ #__libc_lock_\8cylock
+(
+NAME
+) \
+
+306
+ `Îl_\8cylock
+ (
+NAME
+)
+
+ )
+
+308 \ 1
+ #__libc_lock_\8cylock
+(
+NAME
+) \
+
+309
+ `__libc_lock_\8cylock_â
+ (&(
+NAME
+))
+
+ )
+
+312 \ 1
+ #__libc_lock_\8cylock
+(
+NAME
+) \
+
+313
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_mu\8bx_\8cylock
+, (&(
+NAME
+)), 0)
+
+ )
+
+315 \ 1
+ #__libc_rwlock_\8cyrdlock
+(
+NAME
+) \
+
+316
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_rwlock_\8cyrdlock
+, (&(
+NAME
+)), 0)
+
+ )
+
+317 \ 1
+ #__libc_rwlock_\8cyw¾ock
+(
+NAME
+) \
+
+318
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_rwlock_\8cyw¾ock
+, (&(
+NAME
+)), 0)
+
+ )
+
+321 #ià
+def\9aed
+
+_LIBC
+ && (!def\9aed
+NOT_IN_libc
+ || def\9aed
+IS_IN_lib±h»ad
+)
+
+322 #ià
+__OPTION_EGLIBC_BIG_MACROS
+ != 1
+
+326 \r\12
+__libc_lock_\8cylock_»cursive_â
+ (
+__libc_lock_»cursive_t
+ *);
+
+327
+libc_hidd\92_´Ùo
+ (
+__libc_lock_\8cylock_»cursive_â
+);
+
+329 #ià
+__OPTION_EGLIBC_BIG_MACROS
+
+
+330 \ 1
+ #__libc_lock_\8cylock_»cursive
+(
+NAME
+) \
+
+332 \12
+»suÉ
+ = 0; \
+
+333 \1e*
+£lf
+ =
+THREAD_SELF
+; \
+
+334 ià((
+NAME
+).
+owÃr
+ !ð
+£lf
+) \
+
+336 ià(
+ `Îl_\8cylock
+ ((
+NAME
+).
+lock
+) == 0) \
+
+338 (
+NAME
+).
+owÃr
+ =
+£lf
+; \
+
+339 (
+NAME
+).
+út
+ = 1; \
+
+342
+»suÉ
+ =
+EBUSY
+; \
+
+345 ++(
+NAME
+).
+út
+; \
+
+346
+»suÉ
+; \
+
+347 })
+
+ )
+
+349 \ 1
+ #__libc_lock_\8cylock_»cursive
+(
+NAME
+) \
+
+350
+ `__libc_lock_\8cylock_»cursive_â
+ (&(
+NAME
+))
+
+ )
+
+353 \ 1
+ #__libc_lock_\8cylock_»cursive
+(
+NAME
+) \
+
+354
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_mu\8bx_\8cylock
+, (&(
+NAME
+)), 0)
+
+ )
+
+357 \ 1
+ #__¹ld_lock_\8cylock_»cursive
+(
+NAME
+) \
+
+358
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_mu\8bx_\8cylock
+, (&(
+NAME
+).
+mu\8bx
+), 0)
+
+ )
+
+361 #ià
+def\9aed
+
+_LIBC
+ && (!def\9aed
+NOT_IN_libc
+ || def\9aed
+IS_IN_lib±h»ad
+)
+
+362 #ià
+__OPTION_EGLIBC_BIG_MACROS
+ != 1
+
+366 \r\1e
+__libc_lock_uÆock_â
+ (
+__libc_lock_t
+ *);
+
+367
+libc_hidd\92_´Ùo
+ (
+__libc_lock_uÆock_â
+);
+
+369 #ià
+__OPTION_EGLIBC_BIG_MACROS
+
+
+370 \ 1
+ #__libc_lock_uÆock
+(
+NAME
+) \
+
+371
+ `Îl_uÆock
+ (
+NAME
+,
+LLL_PRIVATE
+)
+
+ )
+
+373 \ 1
+ #__libc_lock_uÆock
+(
+NAME
+) \
+
+374
+ `__libc_lock_uÆock_â
+ (&(
+NAME
+))
+
+ )
+
+377 \ 1
+ #__libc_lock_uÆock
+(
+NAME
+) \
+
+378
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_mu\8bx_uÆock
+, (&(
+NAME
+)), 0)
+
+ )
+
+380 \ 1
+ #__libc_rwlock_uÆock
+(
+NAME
+) \
+
+381
+ `__libc_±f_ÿÎ
+ (
+__±h»ad_rwlock_uÆock
+, (&(
+NAME
+)), 0)
+
+ )
+
+384 #ià
+def\9aed
+
+_LIBC
+ && (!def\9aed
+NOT_IN_libc
+ || def\9aed
+IS_IN_lib±h»ad
+)
+
+385 #ià
+__OPTION_EGLIBC_BIG_MACROS
+ != 1
+
+389 \r\1e
+__libc_lock_uÆock_»cursive_â
+ (
+__libc_lock_»cursive_t
+ *);
+
+390
+libc_hidd\92_´Ùo
+ (
+__libc_lock_uÆock_»cursive_â
+);
+
+392 #ià
+__OPTION_EGLIBC_BIG_MACROS
+
+
+394 \ 1
+ #__libc_lock_uÆock_»cursive
+(
+NAME
+) \
+
+396 ià(--(
+NAME
+).
+út
+ == 0) \
+
+398 (
+NAME
+).
+owÃr
+ =
+NULL
+; \
+
+399
+ `Îl_uÆock
+ ((
+NAME
+).
+lock
+,
+LLL_PRIVATE
+); \
+
+401 } \1f0)
+
+ )
+
+403 \ 1
+ #__libc_lock_uÆock_»cursive
+(
+NAME
+) \
+
+404
+ `__libc_lock_uÆock_»cursive_â
+ (&(
+NAME
+))
+
+ )
+
+407 \ 1
+ #__libc_lock_uÆock_»cursive
+(
+NAME
+) \
+
+408
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_mu\8bx_uÆock
+, (&(
+NAME
+)), 0)
+
+ )
+
+411 #ià
+def\9aed
+
+_LIBC
+ && def\9aed
+SHARED
+
+
+412 \ 1
+ #__¹ld_lock_deçuÉ_lock_»cursive
+(
+lock
+) \
+
+413 ++((
+±h»ad_mu\8bx_t
+ *)(
+lock
+))->
+__d©a
+.
+__couÁ
+;
+
+ )
+
+415 \ 1
+ #__¹ld_lock_deçuÉ_uÆock_»cursive
+(
+lock
+) \
+
+416 --((
+±h»ad_mu\8bx_t
+ *)(
+lock
+))->
+__d©a
+.
+__couÁ
+;
+
+ )
+
+418 \ 1
+ #__¹ld_lock_lock_»cursive
+(
+NAME
+) \
+
+419
+ `GL
+(
+dl_¹ld_lock_»cursive
+è(&(
+NAME
+).
+mu\8bx
+)
+
+ )
+
+421 \ 1
+ #__¹ld_lock_uÆock_»cursive
+(
+NAME
+) \
+
+422
+ `GL
+(
+dl_¹ld_uÆock_»cursive
+è(&(
+NAME
+).
+mu\8bx
+)
+
+ )
+
+424 \ 1
+ #__¹ld_lock_lock_»cursive
+(
+NAME
+) \
+
+425
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_mu\8bx_lock
+, (&(
+NAME
+).
+mu\8bx
+), 0)
+
+ )
+
+427 \ 1
+ #__¹ld_lock_uÆock_»cursive
+(
+NAME
+) \
+
+428
+ `__libc_maybe_ÿÎ
+ (
+__±h»ad_mu\8bx_uÆock
+, (&(
+NAME
+).
+mu\8bx
+), 0)
+
+ )
+
+432 #ià
+PTHREAD_ONCE_INIT
+ == 0
+
+435 \ 1
+ #__libc_Úû_def\9ae
+(
+CLASS
+,
+NAME
+) \
+
+436
+CLASS
+
+±h»ad_Úû_t
+
+NAME
+
+
+ )
+
+438 \ 1
+ #__libc_Úû_def\9ae
+(
+CLASS
+,
+NAME
+) \
+
+439
+CLASS
+
+±h»ad_Úû_t
+
+NAME
+ =
+PTHREAD_ONCE_INIT
+
+
+ )
+
+443 \ 1
+ #__libc_Úû
+(
+ONCE_CONTROL
+,
+INIT_FUNCTION
+) \
+
+445 ià(
+ `PTFAVAIL
+ (
+__±h»ad_Úû
+)) \
+
+446
+ `__libc_±f_ÿÎ_®ways
+ (
+__±h»ad_Úû
+, (&(
+ONCE_CONTROL
+), \
+
+447
+INIT_FUNCTION
+)); \
+
+448 \vià((
+ONCE_CONTROL
+è=ð
+PTHREAD_ONCE_INIT
+) { \
+
+449
+ `INIT_FUNCTION
+ (); \
+
+450 (
+ONCE_CONTROL
+) |= 2; \
+
+452 } \1f0)
+
+ )
+
+459 \r\1e
+_±h»ad_þ\97nup_push
+ (\19
+_±h»ad_þ\97nup_bufãr
+ *
+bufãr
+,
+
+460 \1e(*
+rout\9ae
+è(\1e*), \1e*
+¬g
+);
+
+461 \r\1e
+ `_±h»ad_þ\97nup_pÝ
+ (\19
+_±h»ad_þ\97nup_bufãr
+ *
+bufãr
+,
+
+462 \12
+execu\8b
+);
+
+463 \r\1e
+ `_±h»ad_þ\97nup_push_deãr
+ (\19
+_±h»ad_þ\97nup_bufãr
+ *
+bufãr
+,
+
+464 \1e(*
+rout\9ae
+è(\1e*), \1e*
+¬g
+);
+
+465 \r\1e
+ `_±h»ad_þ\97nup_pÝ_»¡Üe
+ (\19
+_±h»ad_þ\97nup_bufãr
+ *
+bufãr
+,
+
+466 \12
+execu\8b
+);
+
+469 \ 1
+ #__libc_þ\97nup_»giÚ_¡¬t
+(
+DOIT
+,
+FCT
+,
+ARG
+) \
+
+470 { \19
+_±h»ad_þ\97nup_bufãr
+
+_bufãr
+; \
+
+471 \12
+_ava\9e
+; \
+
+472 ià(
+DOIT
+) { \
+
+473
+_ava\9e
+ =
+ `PTFAVAIL
+ (
+_±h»ad_þ\97nup_push_deãr
+); \
+
+474 ià(
+_ava\9e
+) { \
+
+475
+ `__libc_±f_ÿÎ_®ways
+ (
+_±h»ad_þ\97nup_push_deãr
+, (&
+_bufãr
+,
+FCT
+, \
+
+476
+ARG
+)); \
+
+478
+_bufãr
+.
+__rout\9ae
+ = (
+FCT
+); \
+
+479
+_bufãr
+.
+__¬g
+ = (
+ARG
+); \
+
+482
+_ava\9e
+ = 0; \
+
+483 }
+
+ )
+
+486 \ 1
+ #__libc_þ\97nup_»giÚ_\92d
+(
+DOIT
+) \
+
+487 ià(
+_ava\9e
+) { \
+
+488
+ `__libc_±f_ÿÎ_®ways
+ (
+_±h»ad_þ\97nup_pÝ_»¡Üe
+, (&
+_bufãr
+,
+DOIT
+));\
+
+489 } \vià(
+DOIT
+) \
+
+490
+_bufãr
+.
+ `__rout\9ae
+ (_bufãr.
+__¬g
+); \
+
+491
+ }
+
+ )
+}
+
+494 \ 1
+ #__libc_þ\97nup_\92d
+(
+DOIT
+) \
+
+495 ià(
+_ava\9e
+) { \
+
+496
+ `__libc_±f_ÿÎ_®ways
+ (
+_±h»ad_þ\97nup_pÝ_»¡Üe
+, (&
+_bufãr
+,
+DOIT
+));\
+
+497 } \vià(
+DOIT
+) \
+
+498
+_bufãr
+.
+ `__rout\9ae
+ (_bufãr.
+__¬g
+)
+
+ )
+
+502
+__ex\8bº_\9al\9ae
+ \1e
+
+503
+ $__libc_þ\97nup_rout\9ae
+ (\19
+__±h»ad_þ\97nup_äame
+ *
+f
+)
+
+505 ià(
+f
+->
+__do_\99
+)
+
+506
+f
+->
+ `__ÿnûl_rout\9ae
+ (f->
+__ÿnûl_¬g
+);
+
+507
+ }
+}
+
+509 \ 1
+ #__libc_þ\97nup_push
+(
+fù
+,
+¬g
+) \
+
+511 \19
+__±h»ad_þ\97nup_äame
+
+__þäame
+ \
+
+512
+ `__©\8cibu\8b__
+ ((
+ `__þ\97nup__
+ (
+__libc_þ\97nup_rout\9ae
+))) \
+
+513 ð{ .
+__ÿnûl_rout\9ae
+ = (
+fù
+), .
+__ÿnûl_¬g
+ = (
+¬g
+), \
+
+514 .
+__do_\99
+ = 1 };
+
+ )
+
+516 \ 1
+ #__libc_þ\97nup_pÝ
+(
+execu\8b
+) \
+
+517
+__þäame
+.
+__do_\99
+ = (
+execu\8b
+); \
+
+518 } \1f0)
+
+ )
+
+522 \ 1
+ #__libc_key_ü\97\8b
+(
+KEY
+,
+DESTRUCTOR
+) \
+
+523
+ `__libc_±f_ÿÎ
+ (
+__±h»ad_key_ü\97\8b
+, (
+KEY
+,
+DESTRUCTOR
+), 1)
+
+ )
+
+526 \ 1
+ #__libc_g\91¥ecific
+(
+KEY
+) \
+
+527
+ `__libc_±f_ÿÎ
+ (
+__±h»ad_g\91¥ecific
+, (
+KEY
+),
+NULL
+)
+
+ )
+
+530 \ 1
+ #__libc_£t¥ecific
+(
+KEY
+,
+VALUE
+) \
+
+531
+ `__libc_±f_ÿÎ
+ (
+__±h»ad_£t¥ecific
+, (
+KEY
+,
+VALUE
+), 0)
+
+ )
+
+537 \ 1
+ #__libc_©fÜk
+(
+PREPARE
+,
+PARENT
+,
+CHILD
+) \
+
+538
+ `__»gi¡\94_©fÜk
+ (
+PREPARE
+,
+PARENT
+,
+CHILD
+,
+NULL
+)
+
+ )
+
+539 \r\12
+__»gi¡\94_©fÜk
+ (\1e(*
+__´\95¬e
+) (\1e),
+
+540 \1e(*
+__·»Á
+) (\1e),
+
+541 \1e(*
+__ch\9ed
+) (\1e),
+
+542 \1e*
+__dso_hªdË
+);
+
+547 \r\12
+ `__±h»ad_mu\8bx_\9a\99
+ (
+±h»ad_mu\8bx_t
+ *
+__mu\8bx
+,
+
+548
+__cڡ
+
+±h»ad_mu\8bx©\8c_t
+ *
+__mu\8bx_©\8c
+);
+
+550 \r\12
+ `__±h»ad_mu\8bx_de¡roy
+ (
+±h»ad_mu\8bx_t
+ *
+__mu\8bx
+);
+
+552 \r\12
+ `__±h»ad_mu\8bx_\8cylock
+ (
+±h»ad_mu\8bx_t
+ *
+__mu\8bx
+);
+
+554 \r\12
+ `__±h»ad_mu\8bx_lock
+ (
+±h»ad_mu\8bx_t
+ *
+__mu\8bx
+);
+
+556 \r\12
+ `__±h»ad_mu\8bx_uÆock
+ (
+±h»ad_mu\8bx_t
+ *
+__mu\8bx
+);
+
+558 \r\12
+ `__±h»ad_mu\8bx©\8c_\9a\99
+ (
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+);
+
+560 \r\12
+ `__±h»ad_mu\8bx©\8c_de¡roy
+ (
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+);
+
+562 \r\12
+ `__±h»ad_mu\8bx©\8c_£\89y³
+ (
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+,
+
+563 \12
+__k\9ad
+);
+
+565 #ifdeà
+__USE_UNIX98
+
+
+566 \r\12
+ `__±h»ad_rwlock_\9a\99
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+,
+
+567
+__cڡ
+
+±h»ad_rwlock©\8c_t
+ *
+__©\8c
+);
+
+569 \r\12
+ `__±h»ad_rwlock_de¡roy
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+);
+
+571 \r\12
+ `__±h»ad_rwlock_rdlock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+);
+
+573 \r\12
+ `__±h»ad_rwlock_\8cyrdlock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+);
+
+575 \r\12
+ `__±h»ad_rwlock_w¾ock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+);
+
+577 \r\12
+ `__±h»ad_rwlock_\8cyw¾ock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+);
+
+579 \r\12
+ `__±h»ad_rwlock_uÆock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+);
+
+582 \r\12
+ `__±h»ad_key_ü\97\8b
+ (
+±h»ad_key_t
+ *
+__key
+,
+
+583 \1e(*
+__de¡r_funùiÚ
+) (\1e*));
+
+585 \r\12
+ `__±h»ad_£t¥ecific
+ (
+±h»ad_key_t
+
+__key
+,
+
+586
+__cڡ
+ \1e*
+__po\9a\8br
+);
+
+588 \r\1e*
+ `__±h»ad_g\91¥ecific
+ (
+±h»ad_key_t
+
+__key
+);
+
+590 \r\12
+ `__±h»ad_Úû
+ (
+±h»ad_Úû_t
+ *
+__Úû_cÚ\8cÞ
+,
+
+591 \1e(*
+__\9a\99_rout\9ae
+) (\1e));
+
+593 \r\12
+ `__±h»ad_©fÜk
+ (\1e(*
+__´\95¬e
+) (\1e),
+
+594 \1e(*
+__·»Á
+) (\1e),
+
+595 \1e(*
+__ch\9ed
+) (\1e));
+
+601 #iâdeà
+__NO_WEAK_PTHREAD_ALIASES
+
+
+602 #ifdeà
+w\97k_ex\8bº
+
+
+603 #ià
+_LIBC
+
+
+604 \ 2
+ ~<bp-sym.h
+>
+
+606 \ 1
+ #BP_SYM
+(
+sym
+è
+ )
+sym
+
+608
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_mu\8bx_\9a\99
+))
+
+609
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_mu\8bx_de¡roy
+))
+
+610
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_mu\8bx_lock
+))
+
+611
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_mu\8bx_\8cylock
+))
+
+612
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_mu\8bx_uÆock
+))
+
+613
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_mu\8bx©\8c_\9a\99
+))
+
+614
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_mu\8bx©\8c_de¡roy
+))
+
+615
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_mu\8bx©\8c_£\89y³
+))
+
+616
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_rwlock_\9a\99
+))
+
+617
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_rwlock_de¡roy
+))
+
+618
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_rwlock_rdlock
+))
+
+619
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_rwlock_\8cyrdlock
+))
+
+620
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_rwlock_w¾ock
+))
+
+621
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_rwlock_\8cyw¾ock
+))
+
+622
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_rwlock_uÆock
+))
+
+623
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_key_ü\97\8b
+))
+
+624
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_£t¥ecific
+))
+
+625
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_g\91¥ecific
+))
+
+626
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+__±h»ad_Úû
+))
+
+627
+ $w\97k_ex\8bº
+ (
+__±h»ad_\9a\99\9flize
+)
+
+628
+ $w\97k_ex\8bº
+ (
+__±h»ad_©fÜk
+)
+
+629
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+_±h»ad_þ\97nup_push_deãr
+))
+
+630
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+_±h»ad_þ\97nup_pÝ_»¡Üe
+))
+
+631
+ `w\97k_ex\8bº
+ (
+ $BP_SYM
+ (
+±h»ad_£tÿnûl¡©e
+))
+
+633 #´agm¨
+w\97k
+
+__±h»ad_mu\8bx_\9a\99
+
+
+634 #´agm¨
+w\97k
+
+__±h»ad_mu\8bx_de¡roy
+
+
+635 #´agm¨
+w\97k
+
+__±h»ad_mu\8bx_lock
+
+
+636 #´agm¨
+w\97k
+
+__±h»ad_mu\8bx_\8cylock
+
+
+637 #´agm¨
+w\97k
+
+__±h»ad_mu\8bx_uÆock
+
+
+638 #´agm¨
+w\97k
+
+__±h»ad_mu\8bx©\8c_\9a\99
+
+
+639 #´agm¨
+w\97k
+
+__±h»ad_mu\8bx©\8c_de¡roy
+
+
+640 #´agm¨
+w\97k
+
+__±h»ad_mu\8bx©\8c_£\89y³
+
+
+641 #´agm¨
+w\97k
+
+__±h»ad_rwlock_de¡roy
+
+
+642 #´agm¨
+w\97k
+
+__±h»ad_rwlock_rdlock
+
+
+643 #´agm¨
+w\97k
+
+__±h»ad_rwlock_\8cyrdlock
+
+
+644 #´agm¨
+w\97k
+
+__±h»ad_rwlock_w¾ock
+
+
+645 #´agm¨
+w\97k
+
+__±h»ad_rwlock_\8cyw¾ock
+
+
+646 #´agm¨
+w\97k
+
+__±h»ad_rwlock_uÆock
+
+
+647 #´agm¨
+w\97k
+
+__±h»ad_key_ü\97\8b
+
+
+648 #´agm¨
+w\97k
+
+__±h»ad_£t¥ecific
+
+
+649 #´agm¨
+w\97k
+
+__±h»ad_g\91¥ecific
+
+
+650 #´agm¨
+w\97k
+
+__±h»ad_Úû
+
+
+651 #´agm¨
+w\97k
+
+__±h»ad_\9a\99\9flize
+
+
+652 #´agm¨
+w\97k
+
+__±h»ad_©fÜk
+
+
+653 #´agm¨
+w\97k
+
+_±h»ad_þ\97nup_push_deãr
+
+
+654 #´agm¨
+w\97k
+
+_±h»ad_þ\97nup_pÝ_»¡Üe
+
+
+655 #´agm¨
+w\97k
+
+±h»ad_£tÿnûl¡©e
+
+
+ @/usr/include/bits/select.h
+
+19 #iâdeà
+_SYS_SELECT_H
+
+
+23 \ 2
+ ~<b\99s/wÜdsize.h
+>
+
+26 #ià
+def\9aed
+
+__GNUC__
+ && __GNUC__ >= 2
+
+28 #ià
+__WORDSIZE
+ == 64
+
+29 \ 1
+ #__FD_ZERO_STOS
+ "¡osq"
+
+ )
+
+31 \ 1
+ #__FD_ZERO_STOS
+ "¡o¦"
+
+ )
+
+34 \ 1
+ #__FD_ZERO
+(
+fd¥
+) \
+
+36 \12
+__d0
+,
+__d1
+; \
+
+37
+__asm__
+
+ `__vÞ©\9ee__
+ ("þd;\84\95; "
+__FD_ZERO_STOS
+ \
+
+38 : "=c" (
+__d0
+), "=D" (
+__d1
+) \
+
+39 : "a" (0), "0" (\17 (
+fd_£t
+) \
+
+40 / \17 (
+__fd_mask
+)), \
+
+41 "1" (&
+ `__FDS_BITS
+ (
+fd¥
+)[0]) \
+
+43 } \1f0)
+
+ )
+
+49 \ 1
+ #__FD_ZERO
+(
+£t
+) \
+
+51 \1d\12
+__i
+; \
+
+52
+fd_£t
+ *
+__¬r
+ = (
+£t
+); \
+
+53 \ f
+__i
+ = 0; __\98< \17 (
+fd_£t
+è/ \17 (
+__fd_mask
+); ++__i) \
+
+54
+ `__FDS_BITS
+ (
+__¬r
+)[
+__i
+] = 0; \
+
+55 } \1f0)
+
+ )
+
+59 \ 1
+ #__FD_SET
+(
+d
+,
+£t
+) \
+
+60 ((\1eè(
+ `__FDS_BITS
+ (
+£t
+)[
+ `__FD_ELT
+ (
+d
+)] |ð
+ `__FD_MASK
+ (d)))
+
+ )
+
+61 \ 1
+ #__FD_CLR
+(
+d
+,
+£t
+) \
+
+62 ((\1eè(
+ `__FDS_BITS
+ (
+£t
+)[
+ `__FD_ELT
+ (
+d
+)] &ð~
+ `__FD_MASK
+ (d)))
+
+ )
+
+63 \ 1
+ #__FD_ISSET
+(
+d
+,
+£t
+) \
+
+64 ((
+ `__FDS_BITS
+ (
+£t
+)[
+ `__FD_ELT
+ (
+d
+)] &
+ `__FD_MASK
+ (d)è!ð0)
+
+ )
+
+ @/usr/include/bits/select2.h
+
+20 #iâdeà
+_SYS_SELECT_H
+
+
+25 \r\1d\13\12
+__fd\96t_chk
+ (\1d\13\12
+__d
+);
+
+26 \r\1d\13\12
+ $__fd\96t_w¬n
+ (\1d\13\12
+__d
+)
+
+27
+ `__w‚\89r
+ ("bit outside of fd_set selected");
+
+28 #undeà
+__FD_ELT
+
+
+29 \ 1
+ #__FD_ELT
+(
+d
+) \
+
+30
+__ex\8bnsiÚ__
+ \
+
+31 ({ \1d\13\12
+__d
+ = (
+d
+); \
+
+32 (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__d
+) \
+
+33 ? (
+__d
+ >ð
+__FD_SETSIZE
+ \
+
+34 ?
+ `__fd\96t_w¬n
+ (
+__d
+è: (__d /
+__NFDBITS
+)) \
+
+35 :
+ `__fd\96t_chk
+ (
+__d
+));
+ }
+})
+
+ )
+
+ @/usr/include/bits/sigset.h
+
+21 #iâdef
+_SIGSET_H_ty³s
+
+
+22 \ 1
+ #_SIGSET_H_ty³s
+ 1
+
+ )
+
+24 \e\12
+ t__sig_©omic_t
+;
+
+28 \ 1
+ #_SIGSET_NWORDS
+ (1024 / (8 * \17 (\1d\13\12)))
+
+ )
+
+31 \1d\13\12
+ m__v®
+[
+_SIGSET_NWORDS
+];
+
+32 }
+ t__sig£t_t
+;
+
+43 #ià!
+def\9aed
+
+_SIGSET_H_âs
+ && def\9aed
+_SIGNAL_H
+
+
+44 \ 1
+ #_SIGSET_H_âs
+ 1
+
+ )
+
+46 #iâdeà
+_EXTERN_INLINE
+
+
+47 \ 1
+ #_EXTERN_INLINE
+
+__ex\8bº_\9al\9ae
+
+
+ )
+
+51 \ 1
+ #__sigmask
+(
+sig
+) \
+
+52 (((\1d\13\12è1è<< (((
+sig
+è- 1è% (8 * \17 (\1d\13\12))))
+
+ )
+
+55 \ 1
+ #__sigwÜd
+(
+sig
+è(((sigè- 1è/ (8 * \17 (\1d\13\12)))
+
+ )
+
+57 #ià
+def\9aed
+
+__GNUC__
+ && __GNUC__ >= 2
+
+58 \ 1
+ #__sigem±y£t
+(
+£t
+) \
+
+59 (
+ `__ex\8bnsiÚ__
+ ({ \12
+__út
+ =
+_SIGSET_NWORDS
+; \
+
+60
+sig£t_t
+ *
+__£t
+ = (
+£t
+); \
+
+61 \1f--
+__út
+ >ð0è
+__£t
+->
+__v®
+[__cnt] = 0; \
+
+62 0; }))
+
+ )
+
+63 \ 1
+ #__sigf\9el£t
+(
+£t
+) \
+
+64 (
+ `__ex\8bnsiÚ__
+ ({ \12
+__út
+ =
+_SIGSET_NWORDS
+; \
+
+65
+sig£t_t
+ *
+__£t
+ = (
+£t
+); \
+
+66 \1f--
+__út
+ >ð0è
+__£t
+->
+__v®
+[__cnt] = ~0UL; \
+
+67 0; }))
+
+ )
+
+69 #ifdeà
+__USE_GNU
+
+
+73 \ 1
+ #__sigi£m±y£t
+(
+£t
+) \
+
+74 (
+ `__ex\8bnsiÚ__
+ ({ \12
+__út
+ =
+_SIGSET_NWORDS
+; \
+
+75 cڡ
+sig£t_t
+ *
+__£t
+ = (
+£t
+); \
+
+76 \12
+__»t
+ =
+__£t
+->
+__v®
+[--
+__út
+]; \
+
+77 \1f!
+__»t
+ && --
+__út
+ >= 0) \
+
+78
+__»t
+ =
+__£t
+->
+__v®
+[
+__út
+]; \
+
+79
+__»t
+ =ð0; }))
+
+ )
+
+80 \ 1
+ #__sigªd£t
+(
+de¡
+,
+Ëá
+,
+right
+) \
+
+81 (
+ `__ex\8bnsiÚ__
+ ({ \12
+__út
+ =
+_SIGSET_NWORDS
+; \
+
+82
+sig£t_t
+ *
+__de¡
+ = (
+de¡
+); \
+
+83 cڡ
+sig£t_t
+ *
+__Ëá
+ = (
+Ëá
+); \
+
+84 cڡ
+sig£t_t
+ *
+__right
+ = (
+right
+); \
+
+85 \1f--
+__út
+ >= 0) \
+
+86
+__de¡
+->
+__v®
+[
+__út
+] = (
+__Ëá
+->__val[__cnt] \
+
+87 &
+__right
+->
+__v®
+[
+__út
+]); \
+
+88 0; }))
+
+ )
+
+89 \ 1
+ #__sigܣt
+(
+de¡
+,
+Ëá
+,
+right
+) \
+
+90 (
+ `__ex\8bnsiÚ__
+ ({ \12
+__út
+ =
+_SIGSET_NWORDS
+; \
+
+91
+sig£t_t
+ *
+__de¡
+ = (
+de¡
+); \
+
+92 cڡ
+sig£t_t
+ *
+__Ëá
+ = (
+Ëá
+); \
+
+93 cڡ
+sig£t_t
+ *
+__right
+ = (
+right
+); \
+
+94 \1f--
+__út
+ >= 0) \
+
+95
+__de¡
+->
+__v®
+[
+__út
+] = (
+__Ëá
+->__val[__cnt] \
+
+96 |
+__right
+->
+__v®
+[
+__út
+]); \
+
+97 0; }))
+
+ )
+
+104 \r\12
+__sigismemb\94
+ (
+__cڡ
+
+__sig£t_t
+ *, \12);
+
+105 \r\12
+__sigadd£t
+ (
+__sig£t_t
+ *, \12);
+
+106 \r\12
+__sigd\96£t
+ (
+__sig£t_t
+ *, \12);
+
+108 #ifdeà
+__USE_EXTERN_INLINES
+
+
+109 \ 1
+ #__SIGSETFN
+(
+NAME
+,
+BODY
+,
+CONST
+) \
+
+110
+_EXTERN_INLINE
+ \12\
+
+111
+ `NAME
+ (
+CONST
+
+__sig£t_t
+ *
+__£t
+, \12
+__sig
+) \
+
+113 \1d\13\12
+__mask
+ =
+ `__sigmask
+ (
+__sig
+); \
+
+114 \1d\13\12
+__wÜd
+ =
+ `__sigwÜd
+ (
+__sig
+); \
+
+115 \15
+BODY
+; \
+
+116 }
+
+ )
+
+118
+__SIGSETFN
+ (
+__sigismemb\94
+, (
+__£t
+->
+__v®
+[
+__wÜd
+] &
+__mask
+è? 1 : 0,
+__cڡ
+)
+
+119
+__SIGSETFN
+ (
+__sigadd£t
+, ((
+__£t
+->
+__v®
+[
+__wÜd
+] |ð
+__mask
+), 0), )
+
+120
+__SIGSETFN
+ (
+__sigd\96£t
+, ((
+__£t
+->
+__v®
+[
+__wÜd
+] &ð~
+__mask
+), 0), )
+
+122 #undeà
+__SIGSETFN
+
+
+ @/usr/include/bits/time.h
+
+24 #ià
+def\9aed
+
+__Ãed_timev®
+ || def\9aed
+__USE_GNU
+
+
+25 #iâdeà
+_STRUCT_TIMEVAL
+
+
+26 \ 1
+ #_STRUCT_TIMEVAL
+ 1
+
+ )
+
+27 \ 2
+ ~<b\99s/ty³s.h
+>
+
+31 \19
+ stimev®
+
+
+33
+__time_t
+
+ mtv_£c
+;
+
+34
+__su£cÚds_t
+
+ mtv_u£c
+;
+
+39 #iâdeà
+__Ãed_timev®
+
+
+40 #iâdeà
+_BITS_TIME_H
+
+
+41 \ 1
+ #_BITS_TIME_H
+ 1
+
+ )
+
+49 \ 1
+ #CLOCKS_PER_SEC
+ 1000000l
+
+ )
+
+51 #ià!
+def\9aed
+
+__STRICT_ANSI__
+ && !def\9aed
+__USE_XOPEN2K
+
+
+54 \ 2
+ ~<b\99s/ty³s.h
+>
+
+55 \r\13\12
+__syscÚf
+ (\12);
+
+56 \ 1
+ #CLK_TCK
+ ((
+__þock_t
+è
+ `__syscÚf
+ (2)è
+
+ )
+
+59 #ifdeà
+__USE_POSIX199309
+
+
+61 \ 1
+ #CLOCK_REALTIME
+ 0
+
+ )
+
+63 \ 1
+ #CLOCK_MONOTONIC
+ 1
+
+ )
+
+65 \ 1
+ #CLOCK_PROCESS_CPUTIME_ID
+ 2
+
+ )
+
+67 \ 1
+ #CLOCK_THREAD_CPUTIME_ID
+ 3
+
+ )
+
+69 \ 1
+ #CLOCK_MONOTONIC_RAW
+ 4
+
+ )
+
+71 \ 1
+ #CLOCK_REALTIME_COARSE
+ 5
+
+ )
+
+73 \ 1
+ #CLOCK_MONOTONIC_COARSE
+ 6
+
+ )
+
+75 \ 1
+ #CLOCK_BOOTTIME
+ 7
+
+ )
+
+77 \ 1
+ #CLOCK_REALTIME_ALARM
+ 8
+
+ )
+
+79 \ 1
+ #CLOCK_BOOTTIME_ALARM
+ 9
+
+ )
+
+82 \ 1
+ #TIMER_ABSTIME
+ 1
+
+ )
+
+85 #ifdeà
+__USE_GNU
+
+
+86 \ 2
+ ~<b\99s/timex.h
+>
+
+88
+__BEGIN_DECLS
+
+
+91 \r\12
+ $þock_adjtime
+ (
+__þockid_t
+
+__þock_id
+, \19
+timex
+ *
+__utx
+è
+__THROW
+;
+
+93
+__END_DECLS
+
+
+99 #undeà
+__Ãed_timev®
+
+
+ @/usr/include/gconv.h
+
+23 #iâdeà
+_GCONV_H
+
+
+24 \ 1
+ #_GCONV_H
+ 1
+
+ )
+
+26 \ 2
+ ~<ã©u»s.h
+>
+
+27 \ 1
+ #__Ãed_mb¡©e_t
+
+
+ )
+
+28 \ 1
+ #__Ãed_w\9at_t
+
+
+ )
+
+29 \ 2
+ ~<wch¬.h
+>
+
+30 \ 1
+ #__Ãed_size_t
+
+
+ )
+
+31 \ 1
+ #__Ãed_wch¬_t
+
+
+ )
+
+32 \ 2
+ ~<¡ddef.h
+>
+
+35 \ 1
+ #__UNKNOWN_10646_CHAR
+ ((
+wch¬_t
+è0xfffd)
+
+ )
+
+40
+ m__GCONV_OK
+ = 0,
+
+41
+ m__GCONV_NOCONV
+,
+
+42
+ m__GCONV_NODB
+,
+
+43
+ m__GCONV_NOMEM
+,
+
+45
+ m__GCONV_EMPTY_INPUT
+,
+
+46
+ m__GCONV_FULL_OUTPUT
+,
+
+47
+ m__GCONV_ILLEGAL_INPUT
+,
+
+48
+ m__GCONV_INCOMPLETE_INPUT
+,
+
+50
+ m__GCONV_ILLEGAL_DESCRIPTOR
+,
+
+51
+ m__GCONV_INTERNAL_ERROR
+
+
+58
+ m__GCONV_IS_LAST
+ = 0x0001,
+
+59
+ m__GCONV_IGNORE_ERRORS
+ = 0x0002,
+
+60
+ m__GCONV_SWAP
+ = 0x0004
+
+65 \19
+ g__gcÚv_¡\95
+;
+
+66 \19
+ g__gcÚv_¡\95_d©a
+;
+
+67 \19
+ g__gcÚv_lßded_objeù
+;
+
+68 \19
+ g__gcÚv_\8cªs_d©a
+;
+
+72 \e\12(*
+ t__gcÚv_fù
+è(\19
+ t__gcÚv_¡\95
+ *, \19
+ t__gcÚv_¡\95_d©a
+ *,
+
+73
+ t__cڡ
+ \1d\ 5**, __const \1d\ 5*,
+
+74 \1d\ 5**,
+ tsize_t
+ *, \12, \12);
+
+77 \e
+ $w\9at_t
+ (*
+ t__gcÚv_btowc_fù
+è(\19
+ t__gcÚv_¡\95
+ *, \1d\ 5);
+
+80 \e\12(*
+ t__gcÚv_\9a\99_fù
+è(\19
+ t__gcÚv_¡\95
+ *);
+
+81 \e\1e(*
+ t__gcÚv_\92d_fù
+è(\19
+ t__gcÚv_¡\95
+ *);
+
+85 \e\12(*
+ t__gcÚv_\8cªs_fù
+è(\19
+ t__gcÚv_¡\95
+ *,
+
+86 \19
+ t__gcÚv_¡\95_d©a
+ *, \1e*,
+
+87
+ t__cڡ
+ \1d\ 5*,
+
+88
+ t__cڡ
+ \1d\ 5**,
+
+89
+ t__cڡ
+ \1d\ 5*, \1d\ 5**,
+
+90
+ tsize_t
+ *);
+
+93 \e\12(*
+ t__gcÚv_\8cªs_cÚ\8bxt_fù
+è(\1e*,
+ t__cڡ
+ \1d\ 5*,
+
+94
+ t__cڡ
+ \1d\ 5*,
+
+98 \e\12(*
+ t__gcÚv_\8cªs_qu\94y_fù
+è(
+ t__cڡ
+ \ 5*, __const \ 5***,
+
+99
+ tsize_t
+ *);
+
+102 \e\12(*
+ t__gcÚv_\8cªs_\9a\99_fù
+) (\1e**, const \ 5*);
+
+103 \e\1e(*
+ t__gcÚv_\8cªs_\92d_fù
+) (\1e*);
+
+105 \19
+ s__gcÚv_\8cªs_d©a
+
+
+108
+__gcÚv_\8cªs_fù
+
+__\8cªs_fù
+;
+
+109
+__gcÚv_\8cªs_cÚ\8bxt_fù
+
+__\8cªs_cÚ\8bxt_fù
+;
+
+110
+__gcÚv_\8cªs_\92d_fù
+
+__\8cªs_\92d_fù
+;
+
+111 \1e*
+__d©a
+;
+
+112 \19
+__gcÚv_\8cªs_d©a
+ *
+__Ãxt
+;
+
+117 \19
+ s__gcÚv_¡\95
+
+
+119 \19
+__gcÚv_lßded_objeù
+ *
+__shlib_hªdË
+;
+
+120
+__cڡ
+ \ 5*
+__modÇme
+;
+
+122 \12
+__couÁ\94
+;
+
+124 \ 5*
+__äom_Çme
+;
+
+125 \ 5*
+__to_Çme
+;
+
+127
+__gcÚv_fù
+
+__fù
+;
+
+128
+__gcÚv_btowc_fù
+
+__btowc_fù
+;
+
+129
+__gcÚv_\9a\99_fù
+
+__\9a\99_fù
+;
+
+130
+__gcÚv_\92d_fù
+
+__\92d_fù
+;
+
+134 \12
+__m\9a_Ãeded_äom
+;
+
+135 \12
+__max_Ãeded_äom
+;
+
+136 \12
+__m\9a_Ãeded_to
+;
+
+137 \12
+__max_Ãeded_to
+;
+
+140 \12
+__¡©eful
+;
+
+142 \1e*
+__d©a
+;
+
+147 \19
+ s__gcÚv_¡\95_d©a
+
+
+149 \1d\ 5*
+__outbuf
+;
+
+150 \1d\ 5*
+__outbuãnd
+;
+
+154 \12
+__æags
+;
+
+158 \12
+__\9avoÿtiÚ_couÁ\94
+;
+
+162 \12
+__\9a\8bº®_u£
+;
+
+164
+__mb¡©e_t
+ *
+__¡©\95
+;
+
+165
+__mb¡©e_t
+
+__¡©e
+;
+
+169 \19
+__gcÚv_\8cªs_d©a
+ *
+__\8cªs
+;
+
+174 \e\19
+ s__gcÚv_\9afo
+
+
+176
+size_t
+
+__n¡\95s
+;
+
+177 \19
+__gcÚv_¡\95
+ *
+__¡\95s
+;
+
+178
+__ex\8bnsiÚ__
+ \19
+__gcÚv_¡\95_d©a
+
+__d©a
+
+__æex¬r
+;
+
+179 } *
+ t__gcÚv_t
+;
+
+ @/usr/include/gnu/stubs-32.h
+
+6 #ifdeà
+_LIBC
+
+
+7 #\94rÜ
+AµliÿtiÚs
+
+may
+
+nÙ
+
+def\9ae
+
+the
+
+maüo
+
+_LIBC
+
+
+10 \ 1
+ #__¡ub___k\94Ãl_co¦
+
+
+ )
+
+11 \ 1
+ #__¡ub___k\94Ãl_s\9al
+
+
+ )
+
+12 \ 1
+ #__¡ub___k\94Ãl_\8fÆ
+
+
+ )
+
+13 \ 1
+ #__¡ub_chæags
+
+
+ )
+
+14 \ 1
+ #__¡ub_ç\89ach
+
+
+ )
+
+15 \ 1
+ #__¡ub_fchæags
+
+
+ )
+
+16 \ 1
+ #__¡ub_fd\91ach
+
+
+ )
+
+17 \ 1
+ #__¡ub_g\89y
+
+
+ )
+
+18 \ 1
+ #__¡ub_lchmod
+
+
+ )
+
+19 \ 1
+ #__¡ub_»voke
+
+
+ )
+
+20 \ 1
+ #__¡ub_£\8eog\9a
+
+
+ )
+
+21 \ 1
+ #__¡ub_sig»tuº
+
+
+ )
+
+22 \ 1
+ #__¡ub_s¡k
+
+
+ )
+
+23 \ 1
+ #__¡ub_¡ty
+
+
+ )
+
+ @/usr/include/gnu/stubs-64.h
+
+6 #ifdeà
+_LIBC
+
+
+7 #\94rÜ
+AµliÿtiÚs
+
+may
+
+nÙ
+
+def\9ae
+
+the
+
+maüo
+
+_LIBC
+
+
+10 \ 1
+ #__¡ub_bdæush
+
+
+ )
+
+11 \ 1
+ #__¡ub_chæags
+
+
+ )
+
+12 \ 1
+ #__¡ub_ç\89ach
+
+
+ )
+
+13 \ 1
+ #__¡ub_fchæags
+
+
+ )
+
+14 \ 1
+ #__¡ub_fd\91ach
+
+
+ )
+
+15 \ 1
+ #__¡ub_g\91msg
+
+
+ )
+
+16 \ 1
+ #__¡ub_g\89y
+
+
+ )
+
+17 \ 1
+ #__¡ub_lchmod
+
+
+ )
+
+18 \ 1
+ #__¡ub_putmsg
+
+
+ )
+
+19 \ 1
+ #__¡ub_»voke
+
+
+ )
+
+20 \ 1
+ #__¡ub_£\8eog\9a
+
+
+ )
+
+21 \ 1
+ #__¡ub_sig»tuº
+
+
+ )
+
+22 \ 1
+ #__¡ub_s¡k
+
+
+ )
+
+23 \ 1
+ #__¡ub_¡ty
+
+
+ )
+
+ @/usr/include/linux/limits.h
+
+1 #iâdeà
+_LINUX_LIMITS_H
+
+
+2 \ 1
+ #_LINUX_LIMITS_H
+
+
+ )
+
+4 \ 1
+ #NR_OPEN
+ 1024
+
+ )
+
+6 \ 1
+ #NGROUPS_MAX
+ 65536
+
+ )
+
+7 \ 1
+ #ARG_MAX
+ 131072
+
+ )
+
+8 \ 1
+ #LINK_MAX
+ 127
+
+ )
+
+9 \ 1
+ #MAX_CANON
+ 255
+
+ )
+
+10 \ 1
+ #MAX_INPUT
+ 255
+
+ )
+
+11 \ 1
+ #NAME_MAX
+ 255
+
+ )
+
+12 \ 1
+ #PATH_MAX
+ 4096
+
+ )
+
+13 \ 1
+ #PIPE_BUF
+ 4096
+
+ )
+
+14 \ 1
+ #XATTR_NAME_MAX
+ 255
+
+ )
+
+15 \ 1
+ #XATTR_SIZE_MAX
+ 65536
+
+ )
+
+16 \ 1
+ #XATTR_LIST_MAX
+ 65536
+
+ )
+
+18 \ 1
+ #RTSIG_MAX
+ 32
+
+ )
+
+ @/usr/include/wchar.h
+
+24 #iâdeà
+_WCHAR_H
+
+
+26 #ià!
+def\9aed
+
+__Ãed_mb¡©e_t
+ && !def\9aed
+__Ãed_w\9at_t
+
+
+27 \ 1
+ #_WCHAR_H
+ 1
+
+ )
+
+28 \ 2
+ ~<ã©u»s.h
+>
+
+31 #ifdeà
+_WCHAR_H
+
+
+33 \ 1
+ #__Ãed___FILE
+
+
+ )
+
+34 #ià
+def\9aed
+
+__USE_UNIX98
+ || def\9aed
+__USE_XOPEN2K
+
+
+35 \ 1
+ #__Ãed_FILE
+
+
+ )
+
+37 \ 2
+ ~<¡dio.h
+>
+
+39 \ 1
+ #__Ãed___va_li¡
+
+
+ )
+
+40 \ 2
+ ~<¡d¬g.h
+>
+
+42 \ 2
+ ~<b\99s/wch¬.h
+>
+
+45 \ 1
+ #__Ãed_size_t
+
+
+ )
+
+46 \ 1
+ #__Ãed_wch¬_t
+
+
+ )
+
+47 \ 1
+ #__Ãed_NULL
+
+
+ )
+
+49 #ià
+def\9aed
+
+_WCHAR_H
+ || def\9aed
+__Ãed_w\9at_t
+ || !def\9aed
+__WINT_TYPE__
+
+
+50 #undeà
+__Ãed_w\9at_t
+
+
+51 \ 1
+ #__Ãed_w\9at_t
+
+
+ )
+
+52 \ 2
+ ~<¡ddef.h
+>
+
+56 #iâdeà
+_WINT_T
+
+
+61 \ 1
+ #_WINT_T
+
+
+ )
+
+62 \e\1d\12
+ tw\9at_t
+;
+
+66 #ià
+def\9aed
+
+__ýlu¥lus
+ && def\9aed
+_GLIBCPP_USE_NAMESPACES
+ \
+
+67 &&
+def\9aed
+
+__WINT_TYPE__
+
+
+68
+__BEGIN_NAMESPACE_STD
+
+
+69 \e
+__WINT_TYPE__
+
+ tw\9at_t
+;
+
+70
+ g__END_NAMESPACE_STD
+
+
+75 #ià
+def\9aed
+
+__ýlu¥lus
+ &&
+__GNUC_PREREQ
+ (4, 4)
+
+76 \ 1
+ #__CORRECT_ISO_CPP_WCHAR_H_PROTO
+
+
+ )
+
+80 #ià(
+def\9aed
+
+_WCHAR_H
+ || def\9aed
+__Ãed_mb¡©e_t
+è&& !def\9aed
+__mb¡©e_t_def\9aed
+
+
+81 \ 1
+ #__mb¡©e_t_def\9aed
+ 1
+
+ )
+
+85 \12
+ m__couÁ
+;
+
+88 #ifdeà
+__WINT_TYPE__
+
+
+89
+__WINT_TYPE__
+
+ m__wch
+;
+
+91
+w\9at_t
+
+ m__wch
+;
+
+93 \ 5
+ m__wchb
+[4];
+
+94 }
+ m__v®ue
+;
+
+95 }
+ t__mb¡©e_t
+;
+
+97 #undeà
+__Ãed_mb¡©e_t
+
+
+102 #ifdeà
+_WCHAR_H
+
+
+104
+__BEGIN_NAMESPACE_C99
+
+
+106 \e
+__mb¡©e_t
+
+ tmb¡©e_t
+;
+
+107
+ g__END_NAMESPACE_C99
+
+
+108 #ifdeà
+__USE_GNU
+
+
+109
+ $__USING_NAMESPACE_C99
+(
+mb¡©e_t
+)
+
+112 #iâdeà
+WCHAR_MIN
+
+
+114 \ 1
+ #WCHAR_MIN
+
+__WCHAR_MIN
+
+
+ )
+
+115 \ 1
+ #WCHAR_MAX
+
+__WCHAR_MAX
+
+
+ )
+
+118 #iâdeà
+WEOF
+
+
+119 \ 1
+ #WEOF
+ (0xffffffffu)
+
+ )
+
+124 #ià
+def\9aed
+
+__USE_XOPEN
+ && !def\9aed
+__USE_UNIX98
+
+
+125 \ 2
+ ~<wùy³.h
+>
+
+129
+__BEGIN_DECLS
+
+
+131
+__BEGIN_NAMESPACE_STD
+
+
+134 \19
+tm
+;
+
+135
+__END_NAMESPACE_STD
+
+
+139
+ $__USING_NAMESPACE_STD
+(
+tm
+)
+
+142
+__BEGIN_NAMESPACE_STD
+
+
+144 \r
+wch¬_t
+ *
+ $wcsýy
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+145
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+è
+__THROW
+;
+
+147 \r
+wch¬_t
+ *
+ $wc¢ýy
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+148
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+size_t
+
+__n
+)
+
+149
+__THROW
+;
+
+152 \r
+wch¬_t
+ *
+ $wcsÿt
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+153
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+è
+__THROW
+;
+
+155 \r
+wch¬_t
+ *
+ $wc¢ÿt
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+156
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+size_t
+
+__n
+)
+
+157
+__THROW
+;
+
+160 \r\12
+ $wcscmp
+ (
+__cڡ
+
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_\88*
+__s2
+)
+
+161
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+163 \r\12
+ $wc¢cmp
+ (
+__cڡ
+
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_\88*
+__s2
+,
+size_t
+
+__n
+)
+
+164
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+165
+__END_NAMESPACE_STD
+
+
+167 #ifdeà
+__USE_XOPEN2K8
+
+
+169 \r\12
+ $wcsÿ£cmp
+ (
+__cڡ
+
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_\88*
+__s2
+è
+__THROW
+;
+
+172 \r\12
+ $wc¢ÿ£cmp
+ (
+__cڡ
+
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_\88*
+__s2
+,
+
+173
+size_t
+
+__n
+è
+__THROW
+;
+
+177 \ 2
+ ~<xloÿË.h
+>
+
+179 \r\12
+ $wcsÿ£cmp_l
+ (
+__cڡ
+
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_\88*
+__s2
+,
+
+180
+__loÿË_t
+
+__loc
+è
+__THROW
+;
+
+182 \r\12
+ $wc¢ÿ£cmp_l
+ (
+__cڡ
+
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_\88*
+__s2
+,
+
+183
+size_t
+
+__n
+,
+__loÿË_t
+
+__loc
+è
+__THROW
+;
+
+186
+__BEGIN_NAMESPACE_STD
+
+
+189 \r\12
+ $wcscÞl
+ (
+__cڡ
+
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_\88*
+__s2
+è
+__THROW
+;
+
+193 \r
+size_t
+
+ $wcsxäm
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s1
+,
+
+194
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s2
+,
+size_t
+
+__n
+è
+__THROW
+;
+
+195
+__END_NAMESPACE_STD
+
+
+197 #ifdeà
+__USE_XOPEN2K8
+
+
+203 \r\12
+ $wcscÞl_l
+ (
+__cڡ
+
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_\88*
+__s2
+,
+
+204
+__loÿË_t
+
+__loc
+è
+__THROW
+;
+
+209 \r
+size_t
+
+ $wcsxäm_l
+ (
+wch¬_t
+ *
+__s1
+,
+__cڡ
+ wch¬_\88*
+__s2
+,
+
+210
+size_t
+
+__n
+,
+__loÿË_t
+
+__loc
+è
+__THROW
+;
+
+213 \r
+wch¬_t
+ *
+ $wcsdup
+ (
+__cڡ
+
+wch¬_t
+ *
+__s
+è
+__THROW
+
+__©\8cibu\8b_m®loc__
+;
+
+216
+__BEGIN_NAMESPACE_STD
+
+
+218 #ifdeà
+__CORRECT_ISO_CPP_WCHAR_H_PROTO
+
+
+219 \r"C++"
+wch¬_t
+ *
+ $wcschr
+ (
+wch¬_t
+ *
+__wcs
+, wch¬_\88
+__wc
+)
+
+220
+__THROW
+
+ `__asm
+ ("wcschr"è
+__©\8cibu\8b_pu»__
+;
+
+221 \r"C++"
+__cڡ
+
+wch¬_t
+ *
+ $wcschr
+ (
+__cڡ
+
+wch¬_t
+ *
+__wcs
+, wch¬_\88
+__wc
+)
+
+222
+__THROW
+
+ `__asm
+ ("wcschr"è
+__©\8cibu\8b_pu»__
+;
+
+224 \r
+wch¬_t
+ *
+ $wcschr
+ (
+__cڡ
+
+wch¬_t
+ *
+__wcs
+, wch¬_\88
+__wc
+)
+
+225
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+228 #ifdeà
+__CORRECT_ISO_CPP_WCHAR_H_PROTO
+
+
+229 \r"C++"
+wch¬_t
+ *
+ $wc¤chr
+ (
+wch¬_t
+ *
+__wcs
+, wch¬_\88
+__wc
+)
+
+230
+__THROW
+
+ `__asm
+ ("wc¤chr"è
+__©\8cibu\8b_pu»__
+;
+
+231 \r"C++"
+__cڡ
+
+wch¬_t
+ *
+ $wc¤chr
+ (
+__cڡ
+
+wch¬_t
+ *
+__wcs
+, wch¬_\88
+__wc
+)
+
+232
+__THROW
+
+ `__asm
+ ("wc¤chr"è
+__©\8cibu\8b_pu»__
+;
+
+234 \r
+wch¬_t
+ *
+ $wc¤chr
+ (
+__cڡ
+
+wch¬_t
+ *
+__wcs
+, wch¬_\88
+__wc
+)
+
+235
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+237
+__END_NAMESPACE_STD
+
+
+239 #ifdeà
+__USE_GNU
+
+
+242 \r
+wch¬_t
+ *
+ $wcschºul
+ (
+__cڡ
+
+wch¬_t
+ *
+__s
+, wch¬_\88
+__wc
+)
+
+243
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+246
+__BEGIN_NAMESPACE_STD
+
+
+249 \r
+size_t
+
+ $wcsc¥n
+ (
+__cڡ
+
+wch¬_t
+ *
+__wcs
+, __cÚ¡ wch¬_\88*
+__»jeù
+)
+
+250
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+253 \r
+size_t
+
+ $wcs¥n
+ (
+__cڡ
+
+wch¬_t
+ *
+__wcs
+, __cÚ¡ wch¬_\88*
+__acû±
+)
+
+254
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+256 #ifdeà
+__CORRECT_ISO_CPP_WCHAR_H_PROTO
+
+
+257 \r"C++"
+wch¬_t
+ *
+ $wc¥brk
+ (
+wch¬_t
+ *
+__wcs
+,
+__cڡ
+ wch¬_\88*
+__acû±
+)
+
+258
+__THROW
+
+ `__asm
+ ("wc¥brk"è
+__©\8cibu\8b_pu»__
+;
+
+259 \r"C++"
+__cڡ
+
+wch¬_t
+ *
+ $wc¥brk
+ (
+__cڡ
+
+wch¬_t
+ *
+__wcs
+,
+
+260
+__cڡ
+
+wch¬_t
+ *
+__acû±
+)
+
+261
+__THROW
+
+ `__asm
+ ("wc¥brk"è
+__©\8cibu\8b_pu»__
+;
+
+263 \r
+wch¬_t
+ *
+ $wc¥brk
+ (
+__cڡ
+
+wch¬_t
+ *
+__wcs
+, __cÚ¡ wch¬_\88*
+__acû±
+)
+
+264
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+267 #ifdeà
+__CORRECT_ISO_CPP_WCHAR_H_PROTO
+
+
+268 \r"C++"
+wch¬_t
+ *
+ $wcs¡r
+ (
+wch¬_t
+ *
+__hay¡ack
+,
+__cڡ
+ wch¬_\88*
+__ÃedË
+)
+
+269
+__THROW
+
+ `__asm
+ ("wcs¡r"è
+__©\8cibu\8b_pu»__
+;
+
+270 \r"C++"
+__cڡ
+
+wch¬_t
+ *
+ $wcs¡r
+ (
+__cڡ
+
+wch¬_t
+ *
+__hay¡ack
+,
+
+271
+__cڡ
+
+wch¬_t
+ *
+__ÃedË
+)
+
+272
+__THROW
+
+ `__asm
+ ("wcs¡r"è
+__©\8cibu\8b_pu»__
+;
+
+274 \r
+wch¬_t
+ *
+ $wcs¡r
+ (
+__cڡ
+
+wch¬_t
+ *
+__hay¡ack
+, __cÚ¡ wch¬_\88*
+__ÃedË
+)
+
+275
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+279 \r
+wch¬_t
+ *
+ $wc¡ok
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+
+280
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__d\96im
+,
+
+281
+wch¬_t
+ **
+__»¡riù
+
+__±r
+è
+__THROW
+;
+
+284 \r
+size_t
+
+ $wc¦\92
+ (
+__cڡ
+
+wch¬_t
+ *
+__s
+è
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+285
+__END_NAMESPACE_STD
+
+
+287 #ifdeà
+__USE_XOPEN
+
+
+289 #ifdeà
+__CORRECT_ISO_CPP_WCHAR_H_PROTO
+
+
+290 \r"C++"
+wch¬_t
+ *
+ $wcswcs
+ (
+wch¬_t
+ *
+__hay¡ack
+,
+__cڡ
+ wch¬_\88*
+__ÃedË
+)
+
+291
+__THROW
+
+ `__asm
+ ("wcswcs"è
+__©\8cibu\8b_pu»__
+;
+
+292 \r"C++"
+__cڡ
+
+wch¬_t
+ *
+ $wcswcs
+ (
+__cڡ
+
+wch¬_t
+ *
+__hay¡ack
+,
+
+293
+__cڡ
+
+wch¬_t
+ *
+__ÃedË
+)
+
+294
+__THROW
+
+ `__asm
+ ("wcswcs"è
+__©\8cibu\8b_pu»__
+;
+
+296 \r
+wch¬_t
+ *
+ $wcswcs
+ (
+__cڡ
+
+wch¬_t
+ *
+__hay¡ack
+, __cÚ¡ wch¬_\88*
+__ÃedË
+)
+
+297
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+301 #ifdeà
+__USE_XOPEN2K8
+
+
+303 \r
+size_t
+
+ $wc¢Ën
+ (
+__cڡ
+
+wch¬_t
+ *
+__s
+,
+size_t
+
+__maxËn
+)
+
+304
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+308
+__BEGIN_NAMESPACE_STD
+
+
+310 #ifdeà
+__CORRECT_ISO_CPP_WCHAR_H_PROTO
+
+
+311 \r"C++"
+wch¬_t
+ *
+ $wmemchr
+ (
+wch¬_t
+ *
+__s
+, wch¬_\88
+__c
+,
+size_t
+
+__n
+)
+
+312
+__THROW
+
+ `__asm
+ ("wmemchr"è
+__©\8cibu\8b_pu»__
+;
+
+313 \r"C++"
+__cڡ
+
+wch¬_t
+ *
+ $wmemchr
+ (
+__cڡ
+
+wch¬_t
+ *
+__s
+, wch¬_\88
+__c
+,
+
+314
+size_t
+
+__n
+)
+
+315
+__THROW
+
+ `__asm
+ ("wmemchr"è
+__©\8cibu\8b_pu»__
+;
+
+317 \r
+wch¬_t
+ *
+ $wmemchr
+ (
+__cڡ
+
+wch¬_t
+ *
+__s
+, wch¬_\88
+__c
+,
+size_t
+
+__n
+)
+
+318
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+322 \r\12
+ $wmemcmp
+ (
+__cڡ
+
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_\88*
+__s2
+,
+size_t
+
+__n
+)
+
+323
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+326 \r
+wch¬_t
+ *
+ $wmemýy
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s1
+,
+
+327
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s2
+,
+size_t
+
+__n
+è
+__THROW
+;
+
+331 \r
+wch¬_t
+ *
+ $wmemmove
+ (
+wch¬_t
+ *
+__s1
+,
+__cڡ
+ wch¬_\88*
+__s2
+,
+size_t
+
+__n
+)
+
+332
+__THROW
+;
+
+335 \r
+wch¬_t
+ *
+ $wmem£t
+ (
+wch¬_t
+ *
+__s
+, wch¬_\88
+__c
+,
+size_t
+
+__n
+è
+__THROW
+;
+
+336
+__END_NAMESPACE_STD
+
+
+338 #ifdeà
+__USE_GNU
+
+
+341 \r
+wch¬_t
+ *
+ $wmempýy
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s1
+,
+
+342
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s2
+,
+size_t
+
+__n
+)
+
+343
+__THROW
+;
+
+347
+__BEGIN_NAMESPACE_STD
+
+
+350 \r
+w\9at_t
+
+ $btowc
+ (\12
+__c
+è
+__THROW
+;
+
+354 \r\12
+ $wùob
+ (
+w\9at_t
+
+__c
+è
+__THROW
+;
+
+358 \r\12
+ $mbs\9a\99
+ (
+__cڡ
+
+mb¡©e_t
+ *
+__ps
+è
+__THROW
+
+__©\8cibu\8b_pu»__
+;
+
+362 \r
+size_t
+
+ $mb¹owc
+ (
+wch¬_t
+ *
+__»¡riù
+
+__pwc
+,
+
+363
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+364
+mb¡©e_t
+ *
+__p
+è
+__THROW
+;
+
+367 \r
+size_t
+
+ $wütomb
+ (\ 5*
+__»¡riù
+
+__s
+,
+wch¬_t
+
+__wc
+,
+
+368
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+è
+__THROW
+;
+
+371 \r
+size_t
+
+ $__mb¾\92
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+372
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+è
+__THROW
+;
+
+373 \r
+size_t
+
+ $mb¾\92
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+374
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+è
+__THROW
+;
+
+375
+__END_NAMESPACE_STD
+
+
+377 #ifdeà
+__USE_EXTERN_INLINES
+
+
+383 \r
+w\9at_t
+
+ $__btowc_®\9fs
+ (\12
+__c
+è
+ `__asm
+ ("btowc");
+
+384
+__ex\8bº_\9al\9ae
+
+w\9at_t
+
+
+385
+ `__NTH
+ (
+ $btowc
+ (\12
+__c
+))
+
+386 { \15 (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__c
+) && __c >= '\0' && __c <= '\x7f'
+
+387 ? (
+w\9at_t
+è
+__c
+ :
+ `__btowc_®\9fs
+ (__c));
+ }
+}
+
+389 \r\12
+ $__wùob_®\9fs
+ (
+w\9at_t
+
+__c
+è
+ `__asm
+ ("wctob");
+
+390
+__ex\8bº_\9al\9ae
+ \12
+
+391
+ `__NTH
+ (
+ $wùob
+ (
+w\9at_t
+
+__wc
+))
+
+392 { \15 (
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__wc
+è&& __wø>ð
+L
+'\0' && __wc <= L'\x7f'
+
+393 ? (\12è
+__wc
+ :
+ `__wùob_®\9fs
+ (__wc));
+ }
+}
+
+395
+__ex\8bº_\9al\9ae
+
+size_t
+
+
+396
+__NTH
+ (
+ $mb¾\92
+ (
+__cڡ
+ \ 5*
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+397
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+))
+
+398 { \15 (
+__ps
+ !ð
+NULL
+
+
+399 ?
+ `mb¹owc
+ (
+NULL
+,
+__s
+,
+__n
+,
+__ps
+è:
+ `__mb¾\92
+ (__s, __n, NULL));
+ }
+}
+
+402
+__BEGIN_NAMESPACE_STD
+
+
+405 \r
+size_t
+
+ $mb¤towcs
+ (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+
+406
+__cڡ
+ \ 5**
+__»¡riù
+
+__¤c
+,
+size_t
+
+__Ën
+,
+
+407
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+è
+__THROW
+;
+
+411 \r
+size_t
+
+ $wc¤tombs
+ (\ 5*
+__»¡riù
+
+__d¡
+,
+
+412
+__cڡ
+
+wch¬_t
+ **
+__»¡riù
+
+__¤c
+,
+size_t
+
+__Ën
+,
+
+413
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+è
+__THROW
+;
+
+414
+__END_NAMESPACE_STD
+
+
+417 #ifdef
+__USE_XOPEN2K8
+
+
+420 \r
+size_t
+
+ $mb¢¹owcs
+ (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+
+421
+__cڡ
+ \ 5**
+__»¡riù
+
+__¤c
+,
+size_t
+
+__nmc
+,
+
+422
+size_t
+
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+è
+__THROW
+;
+
+426 \r
+size_t
+
+ $wc¢¹ombs
+ (\ 5*
+__»¡riù
+
+__d¡
+,
+
+427
+__cڡ
+
+wch¬_t
+ **
+__»¡riù
+
+__¤c
+,
+
+428
+size_t
+
+__nwc
+, size_\88
+__Ën
+,
+
+429
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+è
+__THROW
+;
+
+434 #ifdeà
+__USE_XOPEN
+
+
+436 \r\12
+ $wcwidth
+ (
+wch¬_t
+
+__c
+è
+__THROW
+;
+
+440 \r\12
+ $wcswidth
+ (
+__cڡ
+
+wch¬_t
+ *
+__s
+,
+size_t
+
+__n
+è
+__THROW
+;
+
+444
+__BEGIN_NAMESPACE_STD
+
+
+447 \r\b
+ $wc¡od
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+448
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+è
+__THROW
+;
+
+449
+__END_NAMESPACE_STD
+
+
+451 #ifdeà
+__USE_ISOC99
+
+
+452
+__BEGIN_NAMESPACE_C99
+
+
+454 \r\ e
+ $wc¡of
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+455
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+è
+__THROW
+;
+
+456 \r\13\b
+ $wc¡Þd
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+457
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+è
+__THROW
+;
+
+458
+__END_NAMESPACE_C99
+
+
+462
+__BEGIN_NAMESPACE_STD
+
+
+465 \r\13\12
+ $wc¡Þ
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+466
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+è
+__THROW
+;
+
+470 \r\1d\13\12
+ $wc¡oul
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+471
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+)
+
+472
+__THROW
+;
+
+473
+__END_NAMESPACE_STD
+
+
+475 #ià
+def\9aed
+
+__USE_ISOC99
+ || (def\9aed
+__GNUC__
+ && def\9aed
+__USE_GNU
+)
+
+476
+__BEGIN_NAMESPACE_C99
+
+
+479
+__ex\8bnsiÚ__
+
+
+480 \r\13\13\12
+ $wc¡Þl
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+481
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+)
+
+482
+__THROW
+;
+
+486
+__ex\8bnsiÚ__
+
+
+487 \r\1d\13\13\12
+ $wc¡ouÎ
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+488
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+,
+
+489 \12
+__ba£
+è
+__THROW
+;
+
+490
+__END_NAMESPACE_C99
+
+
+493 #ià
+def\9aed
+
+__GNUC__
+ && def\9aed
+__USE_GNU
+
+
+496
+__ex\8bnsiÚ__
+
+
+497 \r\13\13\12
+ $wc¡oq
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+498
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+)
+
+499
+__THROW
+;
+
+503
+__ex\8bnsiÚ__
+
+
+504 \r\1d\13\13\12
+ $wc¡ouq
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+505
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+,
+
+506 \12
+__ba£
+è
+__THROW
+;
+
+509 #ifdeà
+__USE_GNU
+
+
+523 \ 2
+ ~<xloÿË.h
+>
+
+527 \r\13\12
+ $wc¡Þ_l
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+528
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+, \12
+__ba£
+,
+
+529
+__loÿË_t
+
+__loc
+è
+__THROW
+;
+
+531 \r\1d\13\12
+ $wc¡oul_l
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+532
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+,
+
+533 \12
+__ba£
+,
+__loÿË_t
+
+__loc
+è
+__THROW
+;
+
+535
+__ex\8bnsiÚ__
+
+
+536 \r\13\13\12
+ $wc¡Þl_l
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+537
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+,
+
+538 \12
+__ba£
+,
+__loÿË_t
+
+__loc
+è
+__THROW
+;
+
+540
+__ex\8bnsiÚ__
+
+
+541 \r\1d\13\13\12
+ $wc¡ouÎ_l
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+542
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+,
+
+543 \12
+__ba£
+,
+__loÿË_t
+
+__loc
+)
+
+544
+__THROW
+;
+
+546 \r\b
+ $wc¡od_l
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+547
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+,
+__loÿË_t
+
+__loc
+)
+
+548
+__THROW
+;
+
+550 \r\ e
+ $wc¡of_l
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+551
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+,
+__loÿË_t
+
+__loc
+)
+
+552
+__THROW
+;
+
+554 \r\13\b
+ $wc¡Þd_l
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__Ō
+,
+
+555
+wch¬_t
+ **
+__»¡riù
+
+__\92d±r
+,
+
+556
+__loÿË_t
+
+__loc
+è
+__THROW
+;
+
+560 #ifdeà
+__USE_XOPEN2K8
+
+
+563 \r
+wch¬_t
+ *
+ $wýýy
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+564
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+è
+__THROW
+;
+
+568 \r
+wch¬_t
+ *
+ $wýnýy
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+569
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+size_t
+
+__n
+)
+
+570
+__THROW
+;
+
+577 \r
+__FILE
+ *
+ $Ý\92_wmem¡»am
+ (
+wch¬_t
+ **
+__buæoc
+,
+size_t
+ *
+__siz\96oc
+è
+__THROW
+;
+
+580 #ià
+def\9aed
+
+__USE_ISOC95
+ || def\9aed
+__USE_UNIX98
+
+
+581
+__BEGIN_NAMESPACE_STD
+
+
+584 \r\12
+ $fwide
+ (
+__FILE
+ *
+__å
+, \12
+__mode
+è
+__THROW
+;
+
+591 \r\12
+ `fw´\9atf
+ (
+__FILE
+ *
+__»¡riù
+
+__¡»am
+,
+
+592
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...)
+
+598 \r\12
+ `w´\9atf
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...)
+
+601 \r\12
+ $sw´\9atf
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+602
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...)
+
+603
+__THROW
+ ;
+
+609 \r\12
+ `vfw´\9atf
+ (
+__FILE
+ *
+__»¡riù
+
+__s
+,
+
+610
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+611
+__gnuc_va_li¡
+
+__¬g
+)
+
+617 \r\12
+ `vw´\9atf
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+618
+__gnuc_va_li¡
+
+__¬g
+)
+
+622 \r\12
+ $vsw´\9atf
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+623
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+624
+__gnuc_va_li¡
+
+__¬g
+)
+
+625
+__THROW
+ ;
+
+632 \r\12
+ `fwsÿnf
+ (
+__FILE
+ *
+__»¡riù
+
+__¡»am
+,
+
+633
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...)
+
+639 \r\12
+ `wsÿnf
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...)
+
+642 \r\12
+ $swsÿnf
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+
+643
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...)
+
+644
+__THROW
+ ;
+
+646 #ià
+def\9aed
+
+__USE_ISOC99
+ && !def\9aed
+__USE_GNU
+ \
+
+647 && (!
+def\9aed
+
+__LDBL_COMPAT
+ || !def\9aed
+__REDIRECT
+) \
+
+648 && (
+def\9aed
+
+__STRICT_ANSI__
+ || def\9aed
+__USE_XOPEN2K
+)
+
+649 #ifdeà
+__REDIRECT
+
+
+653 \r\12
+ `__REDIRECT
+ (
+fwsÿnf
+, (
+__FILE
+ *
+__»¡riù
+
+__¡»am
+,
+
+654
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...),
+
+655
+__isoc99_fwsÿnf
+)
+
+657 \r\12
+ `__REDIRECT
+ (
+wsÿnf
+, (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...),
+
+658
+__isoc99_wsÿnf
+)
+
+660 \r\12
+ `__REDIRECT_NTH
+ (
+swsÿnf
+, (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+
+661
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+662 ...),
+__isoc99_swsÿnf
+)
+
+665 \r\12
+ `__isoc99_fwsÿnf
+ (
+__FILE
+ *
+__»¡riù
+
+__¡»am
+,
+
+666
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...);
+
+667 \r\12
+ `__isoc99_wsÿnf
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...);
+
+668 \r\12
+ $__isoc99_swsÿnf
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+
+669
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...)
+
+670
+__THROW
+;
+
+671 \ 1
+ #fwsÿnf
+
+__isoc99_fwsÿnf
+
+
+ )
+
+672 \ 1
+ #wsÿnf
+
+__isoc99_wsÿnf
+
+
+ )
+
+673 \ 1
+ #swsÿnf
+
+__isoc99_swsÿnf
+
+
+ )
+
+677
+__END_NAMESPACE_STD
+
+
+680 #ifdeà
+__USE_ISOC99
+
+
+681
+__BEGIN_NAMESPACE_C99
+
+
+686 \r\12
+ `vfwsÿnf
+ (
+__FILE
+ *
+__»¡riù
+
+__s
+,
+
+687
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+688
+__gnuc_va_li¡
+
+__¬g
+)
+
+694 \r\12
+ `vwsÿnf
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+695
+__gnuc_va_li¡
+
+__¬g
+)
+
+698 \r\12
+ $vswsÿnf
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+
+699
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+700
+__gnuc_va_li¡
+
+__¬g
+)
+
+701
+__THROW
+ ;
+
+703 #ià!
+def\9aed
+
+__USE_GNU
+ \
+
+704 && (!
+def\9aed
+
+__LDBL_COMPAT
+ || !def\9aed
+__REDIRECT
+) \
+
+705 && (
+def\9aed
+
+__STRICT_ANSI__
+ || def\9aed
+__USE_XOPEN2K
+)
+
+706 #ifdeà
+__REDIRECT
+
+
+707 \r\12
+ `__REDIRECT
+ (
+vfwsÿnf
+, (
+__FILE
+ *
+__»¡riù
+
+__s
+,
+
+708
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+709
+__gnuc_va_li¡
+
+__¬g
+),
+__isoc99_vfwsÿnf
+)
+
+711 \r\12
+ `__REDIRECT
+ (
+vwsÿnf
+, (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+712
+__gnuc_va_li¡
+
+__¬g
+),
+__isoc99_vwsÿnf
+)
+
+714 \r\12
+ `__REDIRECT_NTH
+ (
+vswsÿnf
+, (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+
+715
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+716
+__gnuc_va_li¡
+
+__¬g
+),
+__isoc99_vswsÿnf
+)
+
+719 \r\12
+ `__isoc99_vfwsÿnf
+ (
+__FILE
+ *
+__»¡riù
+
+__s
+,
+
+720
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+721
+__gnuc_va_li¡
+
+__¬g
+);
+
+722 \r\12
+ `__isoc99_vwsÿnf
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+723
+__gnuc_va_li¡
+
+__¬g
+);
+
+724 \r\12
+ $__isoc99_vswsÿnf
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+
+725
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+726
+__gnuc_va_li¡
+
+__¬g
+è
+__THROW
+;
+
+727 \ 1
+ #vfwsÿnf
+
+__isoc99_vfwsÿnf
+
+
+ )
+
+728 \ 1
+ #vwsÿnf
+
+__isoc99_vwsÿnf
+
+
+ )
+
+729 \ 1
+ #vswsÿnf
+
+__isoc99_vswsÿnf
+
+
+ )
+
+733
+__END_NAMESPACE_C99
+
+
+737
+__BEGIN_NAMESPACE_STD
+
+
+742 \r
+w\9at_t
+
+ `fg\91wc
+ (
+__FILE
+ *
+__¡»am
+);
+
+743 \r
+w\9at_t
+
+ `g\91wc
+ (
+__FILE
+ *
+__¡»am
+);
+
+749 \r
+w\9at_t
+
+ `g\91wch¬
+ (\1e);
+
+756 \r
+w\9at_t
+
+ `åutwc
+ (
+wch¬_t
+
+__wc
+,
+__FILE
+ *
+__¡»am
+);
+
+757 \r
+w\9at_t
+
+ `putwc
+ (
+wch¬_t
+
+__wc
+,
+__FILE
+ *
+__¡»am
+);
+
+763 \r
+w\9at_t
+
+ `putwch¬
+ (
+wch¬_t
+
+__wc
+);
+
+771 \r
+wch¬_t
+ *
+ `fg\91ws
+ (wch¬_\88*
+__»¡riù
+
+__ws
+, \12
+__n
+,
+
+772
+__FILE
+ *
+__»¡riù
+
+__¡»am
+);
+
+778 \r\12
+ `åutws
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__ws
+,
+
+779
+__FILE
+ *
+__»¡riù
+
+__¡»am
+);
+
+786 \r
+w\9at_t
+
+ `ung\91wc
+ (w\9at_\88
+__wc
+,
+__FILE
+ *
+__¡»am
+);
+
+787
+__END_NAMESPACE_STD
+
+
+790 #ifdeà
+__USE_GNU
+
+
+798 \r
+w\9at_t
+
+ `g\91wc_uÆocked
+ (
+__FILE
+ *
+__¡»am
+);
+
+799 \r
+w\9at_t
+
+ `g\91wch¬_uÆocked
+ (\1e);
+
+807 \r
+w\9at_t
+
+ `fg\91wc_uÆocked
+ (
+__FILE
+ *
+__¡»am
+);
+
+815 \r
+w\9at_t
+
+ `åutwc_uÆocked
+ (
+wch¬_t
+
+__wc
+,
+__FILE
+ *
+__¡»am
+);
+
+824 \r
+w\9at_t
+
+ `putwc_uÆocked
+ (
+wch¬_t
+
+__wc
+,
+__FILE
+ *
+__¡»am
+);
+
+825 \r
+w\9at_t
+
+ `putwch¬_uÆocked
+ (
+wch¬_t
+
+__wc
+);
+
+834 \r
+wch¬_t
+ *
+ `fg\91ws_uÆocked
+ (wch¬_\88*
+__»¡riù
+
+__ws
+, \12
+__n
+,
+
+835
+__FILE
+ *
+__»¡riù
+
+__¡»am
+);
+
+843 \r\12
+ `åutws_uÆocked
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__ws
+,
+
+844
+__FILE
+ *
+__»¡riù
+
+__¡»am
+);
+
+848
+__BEGIN_NAMESPACE_C99
+
+
+852 \r
+size_t
+
+ $wcsáime
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__maxsize
+,
+
+853
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+854
+__cڡ
+ \19
+tm
+ *
+__»¡riù
+
+__\8d
+è
+__THROW
+;
+
+855
+__END_NAMESPACE_C99
+
+
+857 #ifdeà
+__USE_GNU
+
+
+858 \ 2
+ ~<xloÿË.h
+>
+
+862 \r
+size_t
+
+ $wcsáime_l
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__maxsize
+,
+
+863
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+864
+__cڡ
+ \19
+tm
+ *
+__»¡riù
+
+__\8d
+,
+
+865
+__loÿË_t
+
+__loc
+è
+__THROW
+;
+
+874 #ià
+def\9aed
+
+__USE_UNIX98
+ && !def\9aed
+__USE_GNU
+
+
+875 \ 1
+ #__Ãed_iswxxx
+
+
+ )
+
+876 \ 2
+ ~<wùy³.h
+>
+
+880 #ià
+__USE_FORTIFY_LEVEL
+ > 0 &&
+def\9aed
+
+__ex\8bº_®ways_\9al\9ae
+
+
+881 \ 2
+ ~<b\99s/wch¬2.h
+>
+
+884 #ifdeà
+__LDBL_COMPAT
+
+
+885 \ 2
+ ~<b\99s/wch¬-ldbl.h
+>
+
+888
+__END_DECLS
+
+
+896 #undeà
+__Ãed_mb¡©e_t
+
+
+897 #undeà
+__Ãed_w\9at_t
+
+
+ @/usr/include/bits/timex.h
+
+19 #iâdef
+_BITS_TIMEX_H
+
+
+20 \ 1
+ #_BITS_TIMEX_H
+ 1
+
+ )
+
+24 \19
+ stimex
+
+
+26 \1d\12
+ mmodes
+;
+
+27 \13\12
+ moff£t
+;
+
+28 \13\12
+ mäeq
+;
+
+29 \13\12
+ mmax\94rÜ
+;
+
+30 \13\12
+ me¡\94rÜ
+;
+
+31 \12
+ m¡©us
+;
+
+32 \13\12
+ mcÚ¡ªt
+;
+
+33 \13\12
+ m´ecisiÚ
+;
+
+34 \13\12
+ mtÞ\94ªû
+;
+
+35 \19
+timev®
+
+ mtime
+;
+
+36 \13\12
+ mtick
+;
+
+38 \13\12
+ mµsäeq
+;
+
+39 \13\12
+ mj\99\8br
+;
+
+40 \12
+ mshiá
+;
+
+41 \13\12
+ m¡ab\9e
+;
+
+42 \13\12
+ mj\99út
+;
+
+43 \13\12
+ mÿlút
+;
+
+44 \13\12
+ m\94rút
+;
+
+45 \13\12
+ m¡bút
+;
+
+47 \12
+ m\8fi
+;
+
+56 \ 1
+ #ADJ_OFFSET
+ 0x0001
+
+ )
+
+57 \ 1
+ #ADJ_FREQUENCY
+ 0x0002
+
+ )
+
+58 \ 1
+ #ADJ_MAXERROR
+ 0x0004
+
+ )
+
+59 \ 1
+ #ADJ_ESTERROR
+ 0x0008
+
+ )
+
+60 \ 1
+ #ADJ_STATUS
+ 0x0010
+
+ )
+
+61 \ 1
+ #ADJ_TIMECONST
+ 0x0020
+
+ )
+
+62 \ 1
+ #ADJ_TAI
+ 0x0080
+
+ )
+
+63 \ 1
+ #ADJ_MICRO
+ 0x1000
+
+ )
+
+64 \ 1
+ #ADJ_NANO
+ 0x2000
+
+ )
+
+65 \ 1
+ #ADJ_TICK
+ 0x4000
+
+ )
+
+66 \ 1
+ #ADJ_OFFSET_SINGLESHOT
+ 0x8001
+
+ )
+
+67 \ 1
+ #ADJ_OFFSET_SS_READ
+ 0xa001
+
+ )
+
+70 \ 1
+ #MOD_OFFSET
+
+ADJ_OFFSET
+
+
+ )
+
+71 \ 1
+ #MOD_FREQUENCY
+
+ADJ_FREQUENCY
+
+
+ )
+
+72 \ 1
+ #MOD_MAXERROR
+
+ADJ_MAXERROR
+
+
+ )
+
+73 \ 1
+ #MOD_ESTERROR
+
+ADJ_ESTERROR
+
+
+ )
+
+74 \ 1
+ #MOD_STATUS
+
+ADJ_STATUS
+
+
+ )
+
+75 \ 1
+ #MOD_TIMECONST
+
+ADJ_TIMECONST
+
+
+ )
+
+76 \ 1
+ #MOD_CLKB
+
+ADJ_TICK
+
+
+ )
+
+77 \ 1
+ #MOD_CLKA
+
+ADJ_OFFSET_SINGLESHOT
+
+
+ )
+
+78 \ 1
+ #MOD_TAI
+
+ADJ_TAI
+
+
+ )
+
+79 \ 1
+ #MOD_MICRO
+
+ADJ_MICRO
+
+
+ )
+
+80 \ 1
+ #MOD_NANO
+
+ADJ_NANO
+
+
+ )
+
+84 \ 1
+ #STA_PLL
+ 0x0001
+
+ )
+
+85 \ 1
+ #STA_PPSFREQ
+ 0x0002
+
+ )
+
+86 \ 1
+ #STA_PPSTIME
+ 0x0004
+
+ )
+
+87 \ 1
+ #STA_FLL
+ 0x0008
+
+ )
+
+89 \ 1
+ #STA_INS
+ 0x0010
+
+ )
+
+90 \ 1
+ #STA_DEL
+ 0x0020
+
+ )
+
+91 \ 1
+ #STA_UNSYNC
+ 0x0040
+
+ )
+
+92 \ 1
+ #STA_FREQHOLD
+ 0x0080
+
+ )
+
+94 \ 1
+ #STA_PPSSIGNAL
+ 0x0100
+
+ )
+
+95 \ 1
+ #STA_PPSJITTER
+ 0x0200
+
+ )
+
+96 \ 1
+ #STA_PPSWANDER
+ 0x0400
+
+ )
+
+97 \ 1
+ #STA_PPSERROR
+ 0x0800
+
+ )
+
+99 \ 1
+ #STA_CLOCKERR
+ 0x1000
+
+ )
+
+100 \ 1
+ #STA_NANO
+ 0x2000
+
+ )
+
+101 \ 1
+ #STA_MODE
+ 0x4000
+
+ )
+
+102 \ 1
+ #STA_CLK
+ 0x8000
+
+ )
+
+105 \ 1
+ #STA_RONLY
+ (
+STA_PPSSIGNAL
+ |
+STA_PPSJITTER
+ |
+STA_PPSWANDER
+ | \
+
+106
+STA_PPSERROR
+ |
+STA_CLOCKERR
+ |
+STA_NANO
+ |
+STA_MODE
+ |
+STA_CLK
+)
+
+ )
+
+ @/usr/include/bits/wchar-ldbl.h
+
+20 #iâdeà
+_WCHAR_H
+
+
+24 #ià
+def\9aed
+
+__USE_ISOC95
+ || def\9aed
+__USE_UNIX98
+
+
+25
+__BEGIN_NAMESPACE_C99
+
+
+26
+__LDBL_REDIR_DECL
+ (
+fw´\9atf
+);
+
+27
+__LDBL_REDIR_DECL
+ (
+w´\9atf
+);
+
+28
+__LDBL_REDIR_DECL
+ (
+sw´\9atf
+);
+
+29
+__LDBL_REDIR_DECL
+ (
+vfw´\9atf
+);
+
+30
+__LDBL_REDIR_DECL
+ (
+vw´\9atf
+);
+
+31
+__LDBL_REDIR_DECL
+ (
+vsw´\9atf
+);
+
+32 #ià
+def\9aed
+
+__USE_ISOC99
+ && !def\9aed
+__USE_GNU
+ \
+
+33 && !
+def\9aed
+
+ g__REDIRECT
+ \
+
+34 && (
+def\9aed
+
+ g__STRICT_ANSI__
+ || def\9aed
+ g__USE_XOPEN2K
+)
+
+35
+ $__LDBL_REDIR1_DECL
+ (
+fwsÿnf
+,
+__Ædbl___isoc99_fwsÿnf
+)
+
+36
+ $__LDBL_REDIR1_DECL
+ (
+wsÿnf
+,
+__Ædbl___isoc99_wsÿnf
+)
+
+37
+ $__LDBL_REDIR1_DECL
+ (
+swsÿnf
+,
+__Ædbl___isoc99_swsÿnf
+)
+
+39
+ `__LDBL_REDIR_DECL
+ (
+fwsÿnf
+);
+
+40
+ `__LDBL_REDIR_DECL
+ (
+wsÿnf
+);
+
+41
+ `__LDBL_REDIR_DECL
+ (
+swsÿnf
+);
+
+43
+__END_NAMESPACE_C99
+
+
+46 #ifdeà
+__USE_ISOC99
+
+
+47
+__BEGIN_NAMESPACE_C99
+
+
+48
+ `__LDBL_REDIR1_DECL
+ (
+wc¡Þd
+,
+wc¡od
+);
+
+49 #ià!
+def\9aed
+
+__USE_GNU
+ && !def\9aed
+__REDIRECT
+ \
+
+50 && (
+def\9aed
+
+__STRICT_ANSI__
+ || def\9aed
+__USE_XOPEN2K
+)
+
+51
+ $__LDBL_REDIR1_DECL
+ (
+vfwsÿnf
+,
+__Ædbl___isoc99_vfwsÿnf
+)
+
+52
+ $__LDBL_REDIR1_DECL
+ (
+vwsÿnf
+,
+__Ædbl___isoc99_vwsÿnf
+)
+
+53
+ $__LDBL_REDIR1_DECL
+ (
+vswsÿnf
+,
+__Ædbl___isoc99_vswsÿnf
+)
+
+55
+ `__LDBL_REDIR_DECL
+ (
+vfwsÿnf
+);
+
+56
+ `__LDBL_REDIR_DECL
+ (
+vwsÿnf
+);
+
+57
+ `__LDBL_REDIR_DECL
+ (
+vswsÿnf
+);
+
+59
+__END_NAMESPACE_C99
+
+
+62 #ifdeà
+__USE_GNU
+
+
+63
+ `__LDBL_REDIR1_DECL
+ (
+wc¡Þd_l
+,
+wc¡od_l
+);
+
+66 #ià
+__USE_FORTIFY_LEVEL
+ > 0 &&
+def\9aed
+
+__ex\8bº_®ways_\9al\9ae
+
+
+67
+ $__LDBL_REDIR_DECL
+ (
+__sw´\9atf_chk
+)
+
+68
+ $__LDBL_REDIR_DECL
+ (
+__vsw´\9atf_chk
+)
+
+69 #ià
+__USE_FORTIFY_LEVEL
+ > 1
+
+70
+ $__LDBL_REDIR_DECL
+ (
+__fw´\9atf_chk
+)
+
+71
+ $__LDBL_REDIR_DECL
+ (
+__w´\9atf_chk
+)
+
+72
+ $__LDBL_REDIR_DECL
+ (
+__vfw´\9atf_chk
+)
+
+73
+ $__LDBL_REDIR_DECL
+ (
+__vw´\9atf_chk
+)
+
+ @/usr/include/bits/wchar.h
+
+20 #iâdeà
+_BITS_WCHAR_H
+
+
+21 \ 1
+ #_BITS_WCHAR_H
+ 1
+
+ )
+
+24 #ifdeà
+__WCHAR_MAX__
+
+
+25 \ 1
+ #__WCHAR_MAX
+
+__WCHAR_MAX__
+
+
+ )
+
+27 \ 1
+ #__WCHAR_MAX
+ (2147483647)
+
+ )
+
+32 #ifdeà
+__WCHAR_UNSIGNED__
+
+
+33 \ 1
+ #__WCHAR_MIN
+
+L
+'\0'
+
+ )
+
+37 #\96ià
+L
+'\0' - 1 > 0
+
+38 \ 1
+ #__WCHAR_MIN
+
+L
+'\0'
+
+ )
+
+40 \ 1
+ #__WCHAR_MIN
+ (-
+__WCHAR_MAX
+ - 1)
+
+ )
+
+ @/usr/include/bits/wchar2.h
+
+20 #iâdeà
+_WCHAR_H
+
+
+25 \r
+wch¬_t
+ *
+ $__wmemýy_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s1
+,
+
+26
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s2
+,
+size_t
+
+__n
+,
+
+27
+size_t
+
+__ns1
+è
+__THROW
+;
+
+28 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wmemýy_®\9fs
+,
+
+29 (
+wch¬_t
+ *
+__»¡riù
+
+__s1
+,
+
+30
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s2
+,
+size_t
+
+__n
+),
+
+31
+wmemýy
+);
+
+32 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wmemýy_chk_w¬n
+,
+
+33 (
+wch¬_t
+ *
+__»¡riù
+
+__s1
+,
+
+34
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s2
+,
+size_t
+
+__n
+,
+
+35
+size_t
+
+__ns1
+),
+__wmemýy_chk
+)
+
+36
+ `__w‚\89r
+ ("wmemcpy called with\86ength bigger\81han size of destination "
+
+39
+__ex\8bº_®ways_\9al\9ae
+
+wch¬_t
+ *
+
+40
+ `__NTH
+ (
+ $wmemýy
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s1
+,
+__cڡ
+ wch¬_\88*__»¡riù
+__s2
+,
+
+41
+size_t
+
+__n
+))
+
+43 ià(
+ `__bos0
+ (
+__s1
+è!ð(
+size_t
+) -1)
+
+45 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+))
+
+46 \15
+ `__wmemýy_chk
+ (
+__s1
+,
+__s2
+,
+__n
+,
+
+47
+ `__bos0
+ (
+__s1
+è/ \17 (
+wch¬_t
+));
+
+49 ià(
+__n
+ >
+ `__bos0
+ (
+__s1
+è/ \17 (
+wch¬_t
+))
+
+50 \15
+ `__wmemýy_chk_w¬n
+ (
+__s1
+,
+__s2
+,
+__n
+,
+
+51
+ `__bos0
+ (
+__s1
+è/ \17 (
+wch¬_t
+));
+
+53 \15
+ `__wmemýy_®\9fs
+ (
+__s1
+,
+__s2
+,
+__n
+);
+
+54
+ }
+}
+
+57 \r
+wch¬_t
+ *
+ $__wmemmove_chk
+ (
+wch¬_t
+ *
+__s1
+,
+__cڡ
+ wch¬_\88*
+__s2
+,
+
+58
+size_t
+
+__n
+, size_\88
+__ns1
+è
+__THROW
+;
+
+59 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wmemmove_®\9fs
+, (wch¬_\88*
+__s1
+,
+
+60
+__cڡ
+
+wch¬_t
+ *
+__s2
+,
+
+61
+size_t
+
+__n
+),
+wmemmove
+);
+
+62 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wmemmove_chk_w¬n
+,
+
+63 (
+wch¬_t
+ *
+__s1
+,
+__cڡ
+ wch¬_\88*
+__s2
+,
+
+64
+size_t
+
+__n
+, size_\88
+__ns1
+),
+__wmemmove_chk
+)
+
+65
+ `__w‚\89r
+ ("wmemmove called with\86ength bigger\81han size of destination "
+
+68
+__ex\8bº_®ways_\9al\9ae
+
+wch¬_t
+ *
+
+69
+ `__NTH
+ (
+ $wmemmove
+ (
+wch¬_t
+ *
+__s1
+,
+__cڡ
+ wch¬_\88*
+__s2
+,
+size_t
+
+__n
+))
+
+71 ià(
+ `__bos0
+ (
+__s1
+è!ð(
+size_t
+) -1)
+
+73 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+))
+
+74 \15
+ `__wmemmove_chk
+ (
+__s1
+,
+__s2
+,
+__n
+,
+
+75
+ `__bos0
+ (
+__s1
+è/ \17 (
+wch¬_t
+));
+
+77 ià(
+__n
+ >
+ `__bos0
+ (
+__s1
+è/ \17 (
+wch¬_t
+))
+
+78 \15
+ `__wmemmove_chk_w¬n
+ (
+__s1
+,
+__s2
+,
+__n
+,
+
+79
+ `__bos0
+ (
+__s1
+è/ \17 (
+wch¬_t
+));
+
+81 \15
+ `__wmemmove_®\9fs
+ (
+__s1
+,
+__s2
+,
+__n
+);
+
+82
+ }
+}
+
+85 #ifdeà
+__USE_GNU
+
+
+86 \r
+wch¬_t
+ *
+ $__wmempýy_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s1
+,
+
+87
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s2
+,
+size_t
+
+__n
+,
+
+88
+size_t
+
+__ns1
+è
+__THROW
+;
+
+89 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wmempýy_®\9fs
+,
+
+90 (
+wch¬_t
+ *
+__»¡riù
+
+__s1
+,
+
+91
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s2
+,
+
+92
+size_t
+
+__n
+),
+wmempýy
+);
+
+93 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wmempýy_chk_w¬n
+,
+
+94 (
+wch¬_t
+ *
+__»¡riù
+
+__s1
+,
+
+95
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__s2
+,
+size_t
+
+__n
+,
+
+96
+size_t
+
+__ns1
+),
+__wmempýy_chk
+)
+
+97
+ `__w‚\89r
+ ("wmempcpy called with\86ength bigger\81han size of destination "
+
+100
+__ex\8bº_®ways_\9al\9ae
+
+wch¬_t
+ *
+
+101
+ `__NTH
+ (
+ $wmempýy
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s1
+,
+__cڡ
+ wch¬_\88*__»¡riù
+__s2
+,
+
+102
+size_t
+
+__n
+))
+
+104 ià(
+ `__bos0
+ (
+__s1
+è!ð(
+size_t
+) -1)
+
+106 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+))
+
+107 \15
+ `__wmempýy_chk
+ (
+__s1
+,
+__s2
+,
+__n
+,
+
+108
+ `__bos0
+ (
+__s1
+è/ \17 (
+wch¬_t
+));
+
+110 ià(
+__n
+ >
+ `__bos0
+ (
+__s1
+è/ \17 (
+wch¬_t
+))
+
+111 \15
+ `__wmempýy_chk_w¬n
+ (
+__s1
+,
+__s2
+,
+__n
+,
+
+112
+ `__bos0
+ (
+__s1
+è/ \17 (
+wch¬_t
+));
+
+114 \15
+ `__wmempýy_®\9fs
+ (
+__s1
+,
+__s2
+,
+__n
+);
+
+115
+ }
+}
+
+119 \r
+wch¬_t
+ *
+ $__wmem£t_chk
+ (
+wch¬_t
+ *
+__s
+, wch¬_\88
+__c
+,
+size_t
+
+__n
+,
+
+120
+size_t
+
+__ns
+è
+__THROW
+;
+
+121 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wmem£t_®\9fs
+, (wch¬_\88*
+__s
+, wch¬_\88
+__c
+,
+
+122
+size_t
+
+__n
+),
+wmem£t
+);
+
+123 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wmem£t_chk_w¬n
+,
+
+124 (
+wch¬_t
+ *
+__s
+, wch¬_\88
+__c
+,
+size_t
+
+__n
+,
+
+125
+size_t
+
+__ns
+),
+__wmem£t_chk
+)
+
+126
+ `__w‚\89r
+ ("wmemset called with\86ength bigger\81han size of destination "
+
+129
+__ex\8bº_®ways_\9al\9ae
+
+wch¬_t
+ *
+
+130
+ `__NTH
+ (
+ $wmem£t
+ (
+wch¬_t
+ *
+__s
+, wch¬_\88
+__c
+,
+size_t
+
+__n
+))
+
+132 ià(
+ `__bos0
+ (
+__s
+è!ð(
+size_t
+) -1)
+
+134 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+))
+
+135 \15
+ `__wmem£t_chk
+ (
+__s
+,
+__c
+,
+__n
+,
+ `__bos0
+ (__sè/ \17 (
+wch¬_t
+));
+
+137 ià(
+__n
+ >
+ `__bos0
+ (
+__s
+è/ \17 (
+wch¬_t
+))
+
+138 \15
+ `__wmem£t_chk_w¬n
+ (
+__s
+,
+__c
+,
+__n
+,
+
+139
+ `__bos0
+ (
+__s
+è/ \17 (
+wch¬_t
+));
+
+141 \15
+ `__wmem£t_®\9fs
+ (
+__s
+,
+__c
+,
+__n
+);
+
+142
+ }
+}
+
+145 \r
+wch¬_t
+ *
+ $__wcsýy_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+146
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+
+147
+size_t
+
+__n
+è
+__THROW
+;
+
+148 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wcsýy_®\9fs
+,
+
+149 (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+150
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+),
+wcsýy
+);
+
+152
+__ex\8bº_®ways_\9al\9ae
+
+wch¬_t
+ *
+
+153
+ `__NTH
+ (
+ $wcsýy
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+__cڡ
+ wch¬_\88*__»¡riù
+__¤c
+))
+
+155 ià(
+ `__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1)
+
+156 \15
+ `__wcsýy_chk
+ (
+__de¡
+,
+__¤c
+,
+ `__bos
+ (__de¡è/ \17 (
+wch¬_t
+));
+
+157 \15
+ `__wcsýy_®\9fs
+ (
+__de¡
+,
+__¤c
+);
+
+158
+ }
+}
+
+161 \r
+wch¬_t
+ *
+ $__wýýy_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+162
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+
+163
+size_t
+
+__de¡Ën
+è
+__THROW
+;
+
+164 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wýýy_®\9fs
+,
+
+165 (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+166
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+),
+wýýy
+);
+
+168
+__ex\8bº_®ways_\9al\9ae
+
+wch¬_t
+ *
+
+169
+ `__NTH
+ (
+ $wýýy
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+__cڡ
+ wch¬_\88*__»¡riù
+__¤c
+))
+
+171 ià(
+ `__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1)
+
+172 \15
+ `__wýýy_chk
+ (
+__de¡
+,
+__¤c
+,
+ `__bos
+ (__de¡è/ \17 (
+wch¬_t
+));
+
+173 \15
+ `__wýýy_®\9fs
+ (
+__de¡
+,
+__¤c
+);
+
+174
+ }
+}
+
+177 \r
+wch¬_t
+ *
+ $__wc¢ýy_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+178
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+size_t
+
+__n
+,
+
+179
+size_t
+
+__de¡Ën
+è
+__THROW
+;
+
+180 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wc¢ýy_®\9fs
+,
+
+181 (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+182
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+
+183
+size_t
+
+__n
+),
+wc¢ýy
+);
+
+184 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wc¢ýy_chk_w¬n
+,
+
+185 (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+186
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+
+187
+size_t
+
+__n
+, size_\88
+__de¡Ën
+),
+__wc¢ýy_chk
+)
+
+188
+ `__w‚\89r
+ ("wcsncpy called with\86ength bigger\81han size of destination "
+
+191
+__ex\8bº_®ways_\9al\9ae
+
+wch¬_t
+ *
+
+192
+ `__NTH
+ (
+ $wc¢ýy
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+__cڡ
+ wch¬_\88*__»¡riù
+__¤c
+,
+
+193
+size_t
+
+__n
+))
+
+195 ià(
+ `__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1)
+
+197 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+))
+
+198 \15
+ `__wc¢ýy_chk
+ (
+__de¡
+,
+__¤c
+,
+__n
+,
+
+199
+ `__bos
+ (
+__de¡
+è/ \17 (
+wch¬_t
+));
+
+200 ià(
+__n
+ >
+ `__bos
+ (
+__de¡
+è/ \17 (
+wch¬_t
+))
+
+201 \15
+ `__wc¢ýy_chk_w¬n
+ (
+__de¡
+,
+__¤c
+,
+__n
+,
+
+202
+ `__bos
+ (
+__de¡
+è/ \17 (
+wch¬_t
+));
+
+204 \15
+ `__wc¢ýy_®\9fs
+ (
+__de¡
+,
+__¤c
+,
+__n
+);
+
+205
+ }
+}
+
+208 \r
+wch¬_t
+ *
+ $__wýnýy_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+209
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+size_t
+
+__n
+,
+
+210
+size_t
+
+__de¡Ën
+è
+__THROW
+;
+
+211 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wýnýy_®\9fs
+,
+
+212 (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+213
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+
+214
+size_t
+
+__n
+),
+wýnýy
+);
+
+215 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wýnýy_chk_w¬n
+,
+
+216 (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+217
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+
+218
+size_t
+
+__n
+, size_\88
+__de¡Ën
+),
+__wýnýy_chk
+)
+
+219
+ `__w‚\89r
+ ("wcpncpy called with\86ength bigger\81han size of destination "
+
+222
+__ex\8bº_®ways_\9al\9ae
+
+wch¬_t
+ *
+
+223
+ `__NTH
+ (
+ $wýnýy
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+__cڡ
+ wch¬_\88*__»¡riù
+__¤c
+,
+
+224
+size_t
+
+__n
+))
+
+226 ià(
+ `__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1)
+
+228 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+))
+
+229 \15
+ `__wýnýy_chk
+ (
+__de¡
+,
+__¤c
+,
+__n
+,
+
+230
+ `__bos
+ (
+__de¡
+è/ \17 (
+wch¬_t
+));
+
+231 ià(
+__n
+ >
+ `__bos
+ (
+__de¡
+è/ \17 (
+wch¬_t
+))
+
+232 \15
+ `__wýnýy_chk_w¬n
+ (
+__de¡
+,
+__¤c
+,
+__n
+,
+
+233
+ `__bos
+ (
+__de¡
+è/ \17 (
+wch¬_t
+));
+
+235 \15
+ `__wýnýy_®\9fs
+ (
+__de¡
+,
+__¤c
+,
+__n
+);
+
+236
+ }
+}
+
+239 \r
+wch¬_t
+ *
+ $__wcsÿt_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+240
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+
+241
+size_t
+
+__de¡Ën
+è
+__THROW
+;
+
+242 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wcsÿt_®\9fs
+,
+
+243 (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+244
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+),
+wcsÿt
+);
+
+246
+__ex\8bº_®ways_\9al\9ae
+
+wch¬_t
+ *
+
+247
+ `__NTH
+ (
+ $wcsÿt
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+__cڡ
+ wch¬_\88*__»¡riù
+__¤c
+))
+
+249 ià(
+ `__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1)
+
+250 \15
+ `__wcsÿt_chk
+ (
+__de¡
+,
+__¤c
+,
+ `__bos
+ (__de¡è/ \17 (
+wch¬_t
+));
+
+251 \15
+ `__wcsÿt_®\9fs
+ (
+__de¡
+,
+__¤c
+);
+
+252
+ }
+}
+
+255 \r
+wch¬_t
+ *
+ $__wc¢ÿt_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+256
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+
+257
+size_t
+
+__n
+, size_\88
+__de¡Ën
+è
+__THROW
+;
+
+258 \r
+wch¬_t
+ *
+ `__REDIRECT_NTH
+ (
+__wc¢ÿt_®\9fs
+,
+
+259 (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+
+260
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__¤c
+,
+
+261
+size_t
+
+__n
+),
+wc¢ÿt
+);
+
+263
+__ex\8bº_®ways_\9al\9ae
+
+wch¬_t
+ *
+
+264
+ `__NTH
+ (
+ $wc¢ÿt
+ (
+wch¬_t
+ *
+__»¡riù
+
+__de¡
+,
+__cڡ
+ wch¬_\88*__»¡riù
+__¤c
+,
+
+265
+size_t
+
+__n
+))
+
+267 ià(
+ `__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1)
+
+268 \15
+ `__wc¢ÿt_chk
+ (
+__de¡
+,
+__¤c
+,
+__n
+,
+
+269
+ `__bos
+ (
+__de¡
+è/ \17 (
+wch¬_t
+));
+
+270 \15
+ `__wc¢ÿt_®\9fs
+ (
+__de¡
+,
+__¤c
+,
+__n
+);
+
+271
+ }
+}
+
+274 \r\12
+ $__sw´\9atf_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+275 \12
+__æag
+,
+size_t
+
+__s_Ën
+,
+
+276
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...)
+
+277
+__THROW
+ ;
+
+279 \r\12
+ `__REDIRECT_NTH_LDBL
+ (
+__sw´\9atf_®\9fs
+,
+
+280 (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+281
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fmt
+, ...),
+
+282
+sw´\9atf
+);
+
+284 #ifdeà
+__va_¬g_·ck
+
+
+285
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+286
+ `__NTH
+ (
+ $sw´\9atf
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+287
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fmt
+, ...))
+
+289 ià(
+ `__bos
+ (
+__s
+è!ð(
+size_t
+è-1 ||
+__USE_FORTIFY_LEVEL
+ > 1)
+
+290 \15
+ `__sw´\9atf_chk
+ (
+__s
+,
+__n
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+
+291
+ `__bos
+ (
+__s
+è/ \17 (
+wch¬_t
+),
+
+292
+__fmt
+,
+ `__va_¬g_·ck
+ ());
+
+293 \15
+ `__sw´\9atf_®\9fs
+ (
+__s
+,
+__n
+,
+__fmt
+,
+ `__va_¬g_·ck
+ ());
+
+294
+ }
+}
+
+295 #\96ià!
+def\9aed
+
+__ýlu¥lus
+
+
+297 \ 1
+ #sw´\9atf
+(
+s
+,
+n
+, ...) \
+
+298 (
+ `__bos
+ (
+s
+è!ð(
+size_t
+è-1 ||
+__USE_FORTIFY_LEVEL
+ > 1 \
+
+299 ?
+ `__sw´\9atf_chk
+ (
+s
+,
+n
+,
+__USE_FORTIFY_LEVEL
+ - 1, \
+
+300
+ `__bos
+ (
+s
+è/ \17 (
+wch¬_t
+),
+__VA_ARGS__
+) \
+
+301 :
+ `sw´\9atf
+ (
+s
+,
+n
+,
+__VA_ARGS__
+))
+
+ )
+
+304 \r\12
+ $__vsw´\9atf_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+305 \12
+__æag
+,
+size_t
+
+__s_Ën
+,
+
+306
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+307
+__gnuc_va_li¡
+
+__¬g
+)
+
+308
+__THROW
+ ;
+
+310 \r\12
+ `__REDIRECT_NTH_LDBL
+ (
+__vsw´\9atf_®\9fs
+,
+
+311 (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+312
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fmt
+,
+
+313
+__gnuc_va_li¡
+
+__
+),
+vsw´\9atf
+);
+
+315
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+316
+ `__NTH
+ (
+ $vsw´\9atf
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__n
+,
+
+317
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fmt
+,
+__gnuc_va_li¡
+
+__
+))
+
+319 ià(
+ `__bos
+ (
+__s
+è!ð(
+size_t
+è-1 ||
+__USE_FORTIFY_LEVEL
+ > 1)
+
+320 \15
+ `__vsw´\9atf_chk
+ (
+__s
+,
+__n
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+
+321
+ `__bos
+ (
+__s
+è/ \17 (
+wch¬_t
+),
+__fmt
+,
+__
+);
+
+322 \15
+ `__vsw´\9atf_®\9fs
+ (
+__s
+,
+__n
+,
+__fmt
+,
+__
+);
+
+323
+ }
+}
+
+326 #ià
+__USE_FORTIFY_LEVEL
+ > 1
+
+328 \r\12
+__fw´\9atf_chk
+ (
+__FILE
+ *
+__»¡riù
+
+__¡»am
+, \12
+__æag
+,
+
+329
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+, ...);
+
+330 \r\12
+__w´\9atf_chk
+ (\12
+__æag
+,
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+332 \r\12
+__vfw´\9atf_chk
+ (
+__FILE
+ *
+__»¡riù
+
+__¡»am
+, \12
+__æag
+,
+
+333
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+334
+__gnuc_va_li¡
+
+__
+);
+
+335 \r\12
+__vw´\9atf_chk
+ (\12
+__æag
+,
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fÜm©
+,
+
+336
+__gnuc_va_li¡
+
+__
+);
+
+338 #ifdeà
+__va_¬g_·ck
+
+
+339
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+340
+ $w´\9atf
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fmt
+, ...)
+
+342 \15
+ `__w´\9atf_chk
+ (
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+ `__va_¬g_·ck
+ ());
+
+343
+ }
+}
+
+345
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+346
+ $fw´\9atf
+ (
+__FILE
+ *
+__»¡riù
+
+__¡»am
+,
+__cڡ
+
+wch¬_t
+ *__»¡riù
+__fmt
+, ...)
+
+348 \15
+ `__fw´\9atf_chk
+ (
+__¡»am
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+
+349
+ `__va_¬g_·ck
+ ());
+
+350
+ }
+}
+
+351 #\96ià!
+def\9aed
+
+__ýlu¥lus
+
+
+352 \ 1
+ #w´\9atf
+(...) \
+
+353
+ `__w´\9atf_chk
+ (
+__USE_FORTIFY_LEVEL
+ - 1,
+__VA_ARGS__
+)
+
+ )
+
+354 \ 1
+ #fw´\9atf
+(
+¡»am
+, ...) \
+
+355
+ `__fw´\9atf_chk
+ (
+¡»am
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__VA_ARGS__
+)
+
+ )
+
+358
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+359
+ $vw´\9atf
+ (
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fmt
+,
+__gnuc_va_li¡
+
+__
+)
+
+361 \15
+ `__vw´\9atf_chk
+ (
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+__
+);
+
+362
+ }
+}
+
+364
+__ex\8bº_®ways_\9al\9ae
+ \12
+
+365
+ $vfw´\9atf
+ (
+__FILE
+ *
+__»¡riù
+
+__¡»am
+,
+
+366
+__cڡ
+
+wch¬_t
+ *
+__»¡riù
+
+__fmt
+,
+__gnuc_va_li¡
+
+__
+)
+
+368 \15
+ `__vfw´\9atf_chk
+ (
+__¡»am
+,
+__USE_FORTIFY_LEVEL
+ - 1,
+__fmt
+,
+__
+);
+
+369
+ }
+}
+
+373 \r
+wch¬_t
+ *
+ $__fg\91ws_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__size
+, \12
+__n
+,
+
+374
+__FILE
+ *
+__»¡riù
+
+__¡»am
+è
+__wur
+;
+
+375 \r
+wch¬_t
+ *
+ `__REDIRECT
+ (
+__fg\91ws_®\9fs
+,
+
+376 (
+wch¬_t
+ *
+__»¡riù
+
+__s
+, \12
+__n
+,
+
+377
+__FILE
+ *
+__»¡riù
+
+__¡»am
+),
+fg\91ws
+è
+__wur
+;
+
+378 \r
+wch¬_t
+ *
+ `__REDIRECT
+ (
+__fg\91ws_chk_w¬n
+,
+
+379 (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__size
+, \12
+__n
+,
+
+380
+__FILE
+ *
+__»¡riù
+
+__¡»am
+),
+__fg\91ws_chk
+)
+
+381
+__wur
+
+ `__w‚\89r
+ ("fgetws called with bigger size\81han\86ength "
+
+384
+__ex\8bº_®ways_\9al\9ae
+
+__wur
+
+wch¬_t
+ *
+
+385
+ $fg\91ws
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+, \12
+__n
+,
+__FILE
+ *__»¡riù
+__¡»am
+)
+
+387 ià(
+ `__bos
+ (
+__s
+è!ð(
+size_t
+) -1)
+
+389 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+) || __n <= 0)
+
+390 \15
+ `__fg\91ws_chk
+ (
+__s
+,
+ `__bos
+ (__sè/ \17 (
+wch¬_t
+),
+
+391
+__n
+,
+__¡»am
+);
+
+393 ià((
+size_t
+è
+__n
+ >
+ `__bos
+ (
+__s
+è/ \17 (
+wch¬_t
+))
+
+394 \15
+ `__fg\91ws_chk_w¬n
+ (
+__s
+,
+ `__bos
+ (__sè/ \17 (
+wch¬_t
+),
+
+395
+__n
+,
+__¡»am
+);
+
+397 \15
+ `__fg\91ws_®\9fs
+ (
+__s
+,
+__n
+,
+__¡»am
+);
+
+398
+ }
+}
+
+400 #ifdeà
+__USE_GNU
+
+
+401 \r
+wch¬_t
+ *
+ $__fg\91ws_uÆocked_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__size
+,
+
+402 \12
+__n
+,
+__FILE
+ *
+__»¡riù
+
+__¡»am
+)
+
+403
+__wur
+;
+
+404 \r
+wch¬_t
+ *
+ `__REDIRECT
+ (
+__fg\91ws_uÆocked_®\9fs
+,
+
+405 (
+wch¬_t
+ *
+__»¡riù
+
+__s
+, \12
+__n
+,
+
+406
+__FILE
+ *
+__»¡riù
+
+__¡»am
+),
+fg\91ws_uÆocked
+)
+
+407
+__wur
+;
+
+408 \r
+wch¬_t
+ *
+ `__REDIRECT
+ (
+__fg\91ws_uÆocked_chk_w¬n
+,
+
+409 (
+wch¬_t
+ *
+__»¡riù
+
+__s
+,
+size_t
+
+__size
+, \12
+__n
+,
+
+410
+__FILE
+ *
+__»¡riù
+
+__¡»am
+),
+
+411
+__fg\91ws_uÆocked_chk
+)
+
+412
+__wur
+
+ `__w‚\89r
+ ("fgetws_unlocked called with bigger size\81han\86ength "
+
+415
+__ex\8bº_®ways_\9al\9ae
+
+__wur
+
+wch¬_t
+ *
+
+416
+ $fg\91ws_uÆocked
+ (
+wch¬_t
+ *
+__»¡riù
+
+__s
+, \12
+__n
+,
+__FILE
+ *__»¡riù
+__¡»am
+)
+
+418 ià(
+ `__bos
+ (
+__s
+è!ð(
+size_t
+) -1)
+
+420 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__n
+) || __n <= 0)
+
+421 \15
+ `__fg\91ws_uÆocked_chk
+ (
+__s
+,
+ `__bos
+ (__sè/ \17 (
+wch¬_t
+),
+
+422
+__n
+,
+__¡»am
+);
+
+424 ià((
+size_t
+è
+__n
+ >
+ `__bos
+ (
+__s
+è/ \17 (
+wch¬_t
+))
+
+425 \15
+ `__fg\91ws_uÆocked_chk_w¬n
+ (
+__s
+,
+ `__bos
+ (__sè/ \17 (
+wch¬_t
+),
+
+426
+__n
+,
+__¡»am
+);
+
+428 \15
+ `__fg\91ws_uÆocked_®\9fs
+ (
+__s
+,
+__n
+,
+__¡»am
+);
+
+429
+ }
+}
+
+433 \r
+size_t
+
+ $__wütomb_chk
+ (\ 5*
+__»¡riù
+
+__s
+,
+wch¬_t
+
+__wch¬
+,
+
+434
+mb¡©e_t
+ *
+__»¡riù
+
+__p
+,
+
+435
+size_t
+
+__buæ\92
+è
+__THROW
+
+__wur
+;
+
+436 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__wütomb_®\9fs
+,
+
+437 (\ 5*
+__»¡riù
+
+__s
+,
+wch¬_t
+
+__wch¬
+,
+
+438
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+),
+wütomb
+è
+__wur
+;
+
+440
+__ex\8bº_®ways_\9al\9ae
+
+__wur
+
+size_t
+
+
+441
+ `__NTH
+ (
+ $wütomb
+ (\ 5*
+__»¡riù
+
+__s
+,
+wch¬_t
+
+__wch¬
+,
+
+442
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+))
+
+447 \ 1
+ #__WCHAR_MB_LEN_MAX
+ 16
+
+ )
+
+448 #ià
+def\9aed
+
+MB_LEN_MAX
+ && MB_LEN_MAX !ð
+__WCHAR_MB_LEN_MAX
+
+
+451 ià(
+ `__bos
+ (
+__s
+è!ð(
+size_t
+è-1 &&
+__WCHAR_MB_LEN_MAX
+ > __bos (__s))
+
+452 \15
+ `__wütomb_chk
+ (
+__s
+,
+__wch¬
+,
+__ps
+,
+ `__bos
+ (__s));
+
+453 \15
+ `__wütomb_®\9fs
+ (
+__s
+,
+__wch¬
+,
+__ps
+);
+
+454
+ }
+}
+
+457 \r
+size_t
+
+ $__mb¤towcs_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+
+458
+__cڡ
+ \ 5**
+__»¡riù
+
+__¤c
+,
+
+459
+size_t
+
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+,
+
+460
+size_t
+
+__d¡Ën
+è
+__THROW
+;
+
+461 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__mb¤towcs_®\9fs
+,
+
+462 (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+
+463
+__cڡ
+ \ 5**
+__»¡riù
+
+__¤c
+,
+
+464
+size_t
+
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+),
+
+465
+mb¤towcs
+);
+
+466 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__mb¤towcs_chk_w¬n
+,
+
+467 (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+
+468
+__cڡ
+ \ 5**
+__»¡riù
+
+__¤c
+,
+
+469
+size_t
+
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+,
+
+470
+size_t
+
+__d¡Ën
+),
+__mb¤towcs_chk
+)
+
+471
+ `__w‚\89r
+ ("mbsrtowcs called with dst buffer smaller\81han\86en "
+
+474
+__ex\8bº_®ways_\9al\9ae
+
+size_t
+
+
+475
+ `__NTH
+ (
+ $mb¤towcs
+ (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+__cڡ
+ \ 5**__»¡riù
+__¤c
+,
+
+476
+size_t
+
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+))
+
+478 ià(
+ `__bos
+ (
+__d¡
+è!ð(
+size_t
+) -1)
+
+480 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__Ën
+))
+
+481 \15
+ `__mb¤towcs_chk
+ (
+__d¡
+,
+__¤c
+,
+__Ën
+,
+__ps
+,
+
+482
+ `__bos
+ (
+__d¡
+è/ \17 (
+wch¬_t
+));
+
+484 ià(
+__Ën
+ >
+ `__bos
+ (
+__d¡
+è/ \17 (
+wch¬_t
+))
+
+485 \15
+ `__mb¤towcs_chk_w¬n
+ (
+__d¡
+,
+__¤c
+,
+__Ën
+,
+__ps
+,
+
+486
+ `__bos
+ (
+__d¡
+è/ \17 (
+wch¬_t
+));
+
+488 \15
+ `__mb¤towcs_®\9fs
+ (
+__d¡
+,
+__¤c
+,
+__Ën
+,
+__ps
+);
+
+489
+ }
+}
+
+492 \r
+size_t
+
+ $__wc¤tombs_chk
+ (\ 5*
+__»¡riù
+
+__d¡
+,
+
+493
+__cڡ
+
+wch¬_t
+ **
+__»¡riù
+
+__¤c
+,
+
+494
+size_t
+
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+,
+
+495
+size_t
+
+__d¡Ën
+è
+__THROW
+;
+
+496 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__wc¤tombs_®\9fs
+,
+
+497 (\ 5*
+__»¡riù
+
+__d¡
+,
+
+498
+__cڡ
+
+wch¬_t
+ **
+__»¡riù
+
+__¤c
+,
+
+499
+size_t
+
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+),
+
+500
+wc¤tombs
+);
+
+501 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__wc¤tombs_chk_w¬n
+,
+
+502 (\ 5*
+__»¡riù
+
+__d¡
+,
+
+503
+__cڡ
+
+wch¬_t
+ **
+__»¡riù
+
+__¤c
+,
+
+504
+size_t
+
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+,
+
+505
+size_t
+
+__d¡Ën
+),
+__wc¤tombs_chk
+)
+
+506
+ `__w‚\89r
+ ("wcsrtombs called with dst buffer smaller\81han\86en");
+
+508
+__ex\8bº_®ways_\9al\9ae
+
+size_t
+
+
+509
+ `__NTH
+ (
+ $wc¤tombs
+ (\ 5*
+__»¡riù
+
+__d¡
+,
+__cڡ
+
+wch¬_t
+ **__»¡riù
+__¤c
+,
+
+510
+size_t
+
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+))
+
+512 ià(
+ `__bos
+ (
+__d¡
+è!ð(
+size_t
+) -1)
+
+514 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__Ën
+))
+
+515 \15
+ `__wc¤tombs_chk
+ (
+__d¡
+,
+__¤c
+,
+__Ën
+,
+__ps
+,
+ `__bos
+ (__dst));
+
+517 ià(
+__Ën
+ >
+ `__bos
+ (
+__d¡
+))
+
+518 \15
+ `__wc¤tombs_chk_w¬n
+ (
+__d¡
+,
+__¤c
+,
+__Ën
+,
+__ps
+,
+ `__bos
+ (__dst));
+
+520 \15
+ `__wc¤tombs_®\9fs
+ (
+__d¡
+,
+__¤c
+,
+__Ën
+,
+__ps
+);
+
+521
+ }
+}
+
+524 #ifdeà
+__USE_GNU
+
+
+525 \r
+size_t
+
+ $__mb¢¹owcs_chk
+ (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+
+526
+__cڡ
+ \ 5**
+__»¡riù
+
+__¤c
+,
+size_t
+
+__nmc
+,
+
+527
+size_t
+
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+,
+
+528
+size_t
+
+__d¡Ën
+è
+__THROW
+;
+
+529 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__mb¢¹owcs_®\9fs
+,
+
+530 (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+
+531
+__cڡ
+ \ 5**
+__»¡riù
+
+__¤c
+,
+size_t
+
+__nmc
+,
+
+532
+size_t
+
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+),
+
+533
+mb¢¹owcs
+);
+
+534 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__mb¢¹owcs_chk_w¬n
+,
+
+535 (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+
+536
+__cڡ
+ \ 5**
+__»¡riù
+
+__¤c
+,
+size_t
+
+__nmc
+,
+
+537
+size_t
+
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+,
+
+538
+size_t
+
+__d¡Ën
+),
+__mb¢¹owcs_chk
+)
+
+539
+ `__w‚\89r
+ ("mbsnrtowcs called with dst buffer smaller\81han\86en "
+
+542
+__ex\8bº_®ways_\9al\9ae
+
+size_t
+
+
+543
+ `__NTH
+ (
+ $mb¢¹owcs
+ (
+wch¬_t
+ *
+__»¡riù
+
+__d¡
+,
+__cڡ
+ \ 5**__»¡riù
+__¤c
+,
+
+544
+size_t
+
+__nmc
+, size_\88
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+))
+
+546 ià(
+ `__bos
+ (
+__d¡
+è!ð(
+size_t
+) -1)
+
+548 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__Ën
+))
+
+549 \15
+ `__mb¢¹owcs_chk
+ (
+__d¡
+,
+__¤c
+,
+__nmc
+,
+__Ën
+,
+__ps
+,
+
+550
+ `__bos
+ (
+__d¡
+è/ \17 (
+wch¬_t
+));
+
+552 ià(
+__Ën
+ >
+ `__bos
+ (
+__d¡
+è/ \17 (
+wch¬_t
+))
+
+553 \15
+ `__mb¢¹owcs_chk_w¬n
+ (
+__d¡
+,
+__¤c
+,
+__nmc
+,
+__Ën
+,
+__ps
+,
+
+554
+ `__bos
+ (
+__d¡
+è/ \17 (
+wch¬_t
+));
+
+556 \15
+ `__mb¢¹owcs_®\9fs
+ (
+__d¡
+,
+__¤c
+,
+__nmc
+,
+__Ën
+,
+__ps
+);
+
+557
+ }
+}
+
+560 \r
+size_t
+
+ $__wc¢¹ombs_chk
+ (\ 5*
+__»¡riù
+
+__d¡
+,
+
+561
+__cڡ
+
+wch¬_t
+ **
+__»¡riù
+
+__¤c
+,
+
+562
+size_t
+
+__nwc
+, size_\88
+__Ën
+,
+
+563
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+,
+size_t
+
+__d¡Ën
+)
+
+564
+__THROW
+;
+
+565 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__wc¢¹ombs_®\9fs
+,
+
+566 (\ 5*
+__»¡riù
+
+__d¡
+,
+
+567
+__cڡ
+
+wch¬_t
+ **
+__»¡riù
+
+__¤c
+,
+
+568
+size_t
+
+__nwc
+, size_\88
+__Ën
+,
+
+569
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+),
+wc¢¹ombs
+);
+
+570 \r
+size_t
+
+ `__REDIRECT_NTH
+ (
+__wc¢¹ombs_chk_w¬n
+,
+
+571 (\ 5*
+__»¡riù
+
+__d¡
+,
+
+572
+__cڡ
+
+wch¬_t
+ **
+__»¡riù
+
+__¤c
+,
+
+573
+size_t
+
+__nwc
+, size_\88
+__Ën
+,
+
+574
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+,
+
+575
+size_t
+
+__d¡Ën
+),
+__wc¢¹ombs_chk
+)
+
+576
+ `__w‚\89r
+ ("wcsnrtombs called with dst buffer smaller\81han\86en");
+
+578
+__ex\8bº_®ways_\9al\9ae
+
+size_t
+
+
+579
+ `__NTH
+ (
+ $wc¢¹ombs
+ (\ 5*
+__»¡riù
+
+__d¡
+,
+__cڡ
+
+wch¬_t
+ **__»¡riù
+__¤c
+,
+
+580
+size_t
+
+__nwc
+, size_\88
+__Ën
+,
+mb¡©e_t
+ *
+__»¡riù
+
+__ps
+))
+
+582 ià(
+ `__bos
+ (
+__d¡
+è!ð(
+size_t
+) -1)
+
+584 ià(!
+ `__bu\9et\9a_cÚ¡ªt_p
+ (
+__Ën
+))
+
+585 \15
+ `__wc¢¹ombs_chk
+ (
+__d¡
+,
+__¤c
+,
+__nwc
+,
+__Ën
+,
+__ps
+,
+
+586
+ `__bos
+ (
+__d¡
+));
+
+588 ià(
+__Ën
+ >
+ `__bos
+ (
+__d¡
+))
+
+589 \15
+ `__wc¢¹ombs_chk_w¬n
+ (
+__d¡
+,
+__¤c
+,
+__nwc
+,
+__Ën
+,
+__ps
+,
+
+590
+ `__bos
+ (
+__d¡
+));
+
+592 \15
+ `__wc¢¹ombs_®\9fs
+ (
+__d¡
+,
+__¤c
+,
+__nwc
+,
+__Ën
+,
+__ps
+);
+
+593
+ }
+}
+
+ @/usr/include/errno.h
+
+23 #iâdef
+_ERRNO_H
+
+
+27 #iâdef
+__Ãed_Em©h
+
+
+28 \ 1
+ #_ERRNO_H
+ 1
+
+ )
+
+29 \ 2
+ ~<ã©u»s.h
+>
+
+32
+ g__BEGIN_DECLS
+
+
+36 \ 2
+ ~<b\99s/\94ºo.h
+>
+
+37 #undeà
+__Ãed_Em©h
+
+
+39 #ifdef
+_ERRNO_H
+
+
+46 #iâdef
+\94ºo
+
+
+47 \r\12
+\94ºo
+;
+
+50 #ifdeà
+__USE_GNU
+
+
+55 \r\ 5*
+´og¿m_\9avoÿtiÚ_Çme
+, *
+´og¿m_\9avoÿtiÚ_shÜt_Çme
+;
+
+59
+ g__END_DECLS
+
+
+67 #ià
+def\9aed
+
+__USE_GNU
+ || def\9aed
+__Ãed_\94rÜ_t
+
+
+68 #iâdeà
+__\94rÜ_t_def\9aed
+
+
+69 \e\12
+ t\94rÜ_t
+;
+
+70 \ 1
+ #__\94rÜ_t_def\9aed
+ 1
+
+ )
+
+72 #undeà
+__Ãed_\94rÜ_t
+
+
+ @/usr/include/gnu/option-groups.h
+
+10 #iâdeà
+__GNU_OPTION_GROUPS_H
+
+
+11 \ 1
+ #__GNU_OPTION_GROUPS_H
+
+
+ )
+
+13 \ 1
+ #__OPTION_EGLIBC_ADVANCED_INET6
+ 1
+
+ )
+
+14 \ 1
+ #__OPTION_EGLIBC_BACKTRACE
+ 1
+
+ )
+
+15 \ 1
+ #__OPTION_EGLIBC_BIG_MACROS
+ 1
+
+ )
+
+16 \ 1
+ #__OPTION_EGLIBC_BSD
+ 1
+
+ )
+
+17 \ 1
+ #__OPTION_EGLIBC_CATGETS
+ 1
+
+ )
+
+18 \ 1
+ #__OPTION_EGLIBC_CHARSETS
+ 1
+
+ )
+
+19 \ 1
+ #__OPTION_EGLIBC_CRYPT
+ 1
+
+ )
+
+20 \ 1
+ #__OPTION_EGLIBC_CRYPT_UFC
+ 1
+
+ )
+
+21 \ 1
+ #__OPTION_EGLIBC_CXX_TESTS
+ 1
+
+ )
+
+22 \ 1
+ #__OPTION_EGLIBC_DB_ALIASES
+ 1
+
+ )
+
+23 \ 1
+ #__OPTION_EGLIBC_ENVZ
+ 1
+
+ )
+
+24 \ 1
+ #__OPTION_EGLIBC_FCVT
+ 1
+
+ )
+
+25 \ 1
+ #__OPTION_EGLIBC_FMTMSG
+ 1
+
+ )
+
+26 \ 1
+ #__OPTION_EGLIBC_FSTAB
+ 1
+
+ )
+
+27 \ 1
+ #__OPTION_EGLIBC_FTRAVERSE
+ 1
+
+ )
+
+28 \ 1
+ #__OPTION_EGLIBC_GETLOGIN
+ 1
+
+ )
+
+29 \ 1
+ #__OPTION_EGLIBC_IDN
+ 1
+
+ )
+
+30 \ 1
+ #__OPTION_EGLIBC_INET
+ 1
+
+ )
+
+31 \ 1
+ #__OPTION_EGLIBC_INET_ANL
+ 1
+
+ )
+
+32 \ 1
+ #__OPTION_EGLIBC_LIBM
+ 1
+
+ )
+
+33 \ 1
+ #__OPTION_EGLIBC_LIBM_BIG
+ 1
+
+ )
+
+34 \ 1
+ #__OPTION_EGLIBC_LOCALES
+ 1
+
+ )
+
+35 \ 1
+ #__OPTION_EGLIBC_LOCALE_CODE
+ 1
+
+ )
+
+36 \ 1
+ #__OPTION_EGLIBC_MEMUSAGE
+ 1
+
+ )
+
+37 \ 1
+ #__OPTION_EGLIBC_NIS
+ 1
+
+ )
+
+38 \ 1
+ #__OPTION_EGLIBC_NSSWITCH
+ 1
+
+ )
+
+39 \ 1
+ #__OPTION_EGLIBC_RCMD
+ 1
+
+ )
+
+40 \ 1
+ #__OPTION_EGLIBC_RTLD_DEBUG
+ 1
+
+ )
+
+41 \ 1
+ #__OPTION_EGLIBC_SPAWN
+ 1
+
+ )
+
+42 \ 1
+ #__OPTION_EGLIBC_STREAMS
+ 1
+
+ )
+
+43 \ 1
+ #__OPTION_EGLIBC_SUNRPC
+ 1
+
+ )
+
+44 \ 1
+ #__OPTION_EGLIBC_UTMP
+ 1
+
+ )
+
+45 \ 1
+ #__OPTION_EGLIBC_UTMPX
+ 1
+
+ )
+
+46 \ 1
+ #__OPTION_EGLIBC_WORDEXP
+ 1
+
+ )
+
+47 \ 1
+ #__OPTION_POSIX_C_LANG_WIDE_CHAR
+ 1
+
+ )
+
+48 \ 1
+ #__OPTION_POSIX_REGEXP
+ 1
+
+ )
+
+49 \ 1
+ #__OPTION_POSIX_REGEXP_GLIBC
+ 1
+
+ )
+
+50 \ 1
+ #__OPTION_POSIX_WIDE_CHAR_DEVICE_IO
+ 1
+
+ )
+
+ @/usr/include/pthread.h
+
+20 #iâdeà
+_PTHREAD_H
+
+
+21 \ 1
+ #_PTHREAD_H
+ 1
+
+ )
+
+23 \ 2
+ ~<ã©u»s.h
+>
+
+24 \ 2
+ ~<\92d\9fn.h
+>
+
+25 \ 2
+ ~<sched.h
+>
+
+26 \ 2
+ ~<time.h
+>
+
+28 \ 2
+ ~<b\99s/±h»adty³s.h
+>
+
+29 \ 2
+ ~<b\99s/£tjmp.h
+>
+
+30 \ 2
+ ~<b\99s/wÜdsize.h
+>
+
+36
+ mPTHREAD_CREATE_JOINABLE
+,
+
+37 \ 1
+ #PTHREAD_CREATE_JOINABLE
+
+PTHREAD_CREATE_JOINABLE
+
+
+ )
+
+38
+ mPTHREAD_CREATE_DETACHED
+
+
+39 \ 1
+ #PTHREAD_CREATE_DETACHED
+
+PTHREAD_CREATE_DETACHED
+
+
+ )
+
+46
+ mPTHREAD_MUTEX_TIMED_NP
+,
+
+47
+ mPTHREAD_MUTEX_RECURSIVE_NP
+,
+
+48
+ mPTHREAD_MUTEX_ERRORCHECK_NP
+,
+
+49
+ mPTHREAD_MUTEX_ADAPTIVE_NP
+
+
+50 #ià
+def\9aed
+
+__USE_UNIX98
+ || def\9aed
+__USE_XOPEN2K8
+
+
+52
+ mPTHREAD_MUTEX_NORMAL
+ =
+PTHREAD_MUTEX_TIMED_NP
+,
+
+53
+ mPTHREAD_MUTEX_RECURSIVE
+ =
+PTHREAD_MUTEX_RECURSIVE_NP
+,
+
+54
+ mPTHREAD_MUTEX_ERRORCHECK
+ =
+PTHREAD_MUTEX_ERRORCHECK_NP
+,
+
+55
+ mPTHREAD_MUTEX_DEFAULT
+ =
+PTHREAD_MUTEX_NORMAL
+
+
+57 #ifdeà
+__USE_GNU
+
+
+59 ,
+ mPTHREAD_MUTEX_FAST_NP
+ =
+PTHREAD_MUTEX_TIMED_NP
+
+
+64 #ifdeà
+__USE_XOPEN2K
+
+
+68
+ mPTHREAD_MUTEX_STALLED
+,
+
+69
+ mPTHREAD_MUTEX_STALLED_NP
+ =
+PTHREAD_MUTEX_STALLED
+,
+
+70
+ mPTHREAD_MUTEX_ROBUST
+,
+
+71
+ mPTHREAD_MUTEX_ROBUST_NP
+ =
+PTHREAD_MUTEX_ROBUST
+
+
+76 #ifdeà
+__USE_UNIX98
+
+
+80
+ mPTHREAD_PRIO_NONE
+,
+
+81
+ mPTHREAD_PRIO_INHERIT
+,
+
+82
+ mPTHREAD_PRIO_PROTECT
+
+
+88 #ià
+__WORDSIZE
+ == 64
+
+89 \ 1
+ #PTHREAD_MUTEX_INITIALIZER
+ \
+
+90 { { 0, 0, 0, 0, 0, 0, { 0, 0 } } }
+
+ )
+
+91 #ifdeà
+__USE_GNU
+
+
+92 \ 1
+ #PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
+ \
+
+93 { { 0, 0, 0, 0,
+PTHREAD_MUTEX_RECURSIVE_NP
+, 0, { 0, 0 } } }
+
+ )
+
+94 \ 1
+ #PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
+ \
+
+95 { { 0, 0, 0, 0,
+PTHREAD_MUTEX_ERRORCHECK_NP
+, 0, { 0, 0 } } }
+
+ )
+
+96 \ 1
+ #PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
+ \
+
+97 { { 0, 0, 0, 0,
+PTHREAD_MUTEX_ADAPTIVE_NP
+, 0, { 0, 0 } } }
+
+ )
+
+100 \ 1
+ #PTHREAD_MUTEX_INITIALIZER
+ \
+
+101 { { 0, 0, 0, 0, 0, { 0 } } }
+
+ )
+
+102 #ifdeà
+__USE_GNU
+
+
+103 \ 1
+ #PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
+ \
+
+104 { { 0, 0, 0,
+PTHREAD_MUTEX_RECURSIVE_NP
+, 0, { 0 } } }
+
+ )
+
+105 \ 1
+ #PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
+ \
+
+106 { { 0, 0, 0,
+PTHREAD_MUTEX_ERRORCHECK_NP
+, 0, { 0 } } }
+
+ )
+
+107 \ 1
+ #PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
+ \
+
+108 { { 0, 0, 0,
+PTHREAD_MUTEX_ADAPTIVE_NP
+, 0, { 0 } } }
+
+ )
+
+114 #ià
+def\9aed
+
+__USE_UNIX98
+ || def\9aed
+__USE_XOPEN2K
+
+
+117
+ mPTHREAD_RWLOCK_PREFER_READER_NP
+,
+
+118
+ mPTHREAD_RWLOCK_PREFER_WRITER_NP
+,
+
+119
+ mPTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP
+,
+
+120
+ mPTHREAD_RWLOCK_DEFAULT_NP
+ =
+PTHREAD_RWLOCK_PREFER_READER_NP
+
+
+124 \ 1
+ #PTHREAD_RWLOCK_INITIALIZER
+ \
+
+125 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
+
+ )
+
+126 #ifdeà
+__USE_GNU
+
+
+127 #ià
+__WORDSIZE
+ == 64
+
+128 \ 1
+ #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP
+ \
+
+130
+PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP
+ } }
+
+ )
+
+132 #ià
+__BYTE_ORDER
+ =ð
+__LITTLE_ENDIAN
+
+
+133 \ 1
+ #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP
+ \
+
+134 { { 0, 0, 0, 0, 0, 0,
+PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP
+, \
+
+135 0, 0, 0, 0 } }
+
+ )
+
+137 \ 1
+ #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP
+ \
+
+138 { { 0, 0, 0, 0, 0, 0, 0, 0, 0,
+PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP
+,\
+
+139 0 } }
+
+ )
+
+149
+ mPTHREAD_INHERIT_SCHED
+,
+
+150 \ 1
+ #PTHREAD_INHERIT_SCHED
+
+PTHREAD_INHERIT_SCHED
+
+
+ )
+
+151
+ mPTHREAD_EXPLICIT_SCHED
+
+
+152 \ 1
+ #PTHREAD_EXPLICIT_SCHED
+
+PTHREAD_EXPLICIT_SCHED
+
+
+ )
+
+159
+ mPTHREAD_SCOPE_SYSTEM
+,
+
+160 \ 1
+ #PTHREAD_SCOPE_SYSTEM
+
+PTHREAD_SCOPE_SYSTEM
+
+
+ )
+
+161
+ mPTHREAD_SCOPE_PROCESS
+
+
+162 \ 1
+ #PTHREAD_SCOPE_PROCESS
+
+PTHREAD_SCOPE_PROCESS
+
+
+ )
+
+169
+ mPTHREAD_PROCESS_PRIVATE
+,
+
+170 \ 1
+ #PTHREAD_PROCESS_PRIVATE
+
+PTHREAD_PROCESS_PRIVATE
+
+
+ )
+
+171
+ mPTHREAD_PROCESS_SHARED
+
+
+172 \ 1
+ #PTHREAD_PROCESS_SHARED
+
+PTHREAD_PROCESS_SHARED
+
+
+ )
+
+178 \ 1
+ #PTHREAD_COND_INITIALIZER
+ { { 0, 0, 0, 0, 0, (\1e*è0, 0, 0 } }
+
+ )
+
+182 \19
+ s_±h»ad_þ\97nup_bufãr
+
+
+184 \1e(*
+ m__rout\9ae
+) (\1e*);
+
+185 \1e*
+ m__¬g
+;
+
+186 \12
+ m__ÿnûÉy³
+;
+
+187 \19
+_±h»ad_þ\97nup_bufãr
+ *
+ m__´ev
+;
+
+193
+ mPTHREAD_CANCEL_ENABLE
+,
+
+194 \ 1
+ #PTHREAD_CANCEL_ENABLE
+
+PTHREAD_CANCEL_ENABLE
+
+
+ )
+
+195
+ mPTHREAD_CANCEL_DISABLE
+
+
+196 \ 1
+ #PTHREAD_CANCEL_DISABLE
+
+PTHREAD_CANCEL_DISABLE
+
+
+ )
+
+200
+ mPTHREAD_CANCEL_DEFERRED
+,
+
+201 \ 1
+ #PTHREAD_CANCEL_DEFERRED
+
+PTHREAD_CANCEL_DEFERRED
+
+
+ )
+
+202
+ mPTHREAD_CANCEL_ASYNCHRONOUS
+
+
+203 \ 1
+ #PTHREAD_CANCEL_ASYNCHRONOUS
+
+PTHREAD_CANCEL_ASYNCHRONOUS
+
+
+ )
+
+205 \ 1
+ #PTHREAD_CANCELED
+ ((\1e*è-1)
+
+ )
+
+209 \ 1
+ #PTHREAD_ONCE_INIT
+ 0
+
+ )
+
+212 #ifdeà
+__USE_XOPEN2K
+
+
+216 \ 1
+ #PTHREAD_BARRIER_SERIAL_THREAD
+ -1
+
+ )
+
+220
+__BEGIN_DECLS
+
+
+225 \r\12
+±h»ad_ü\97\8b
+ (
+±h»ad_t
+ *
+__»¡riù
+
+__Ãwth»ad
+,
+
+226
+__cڡ
+
+±h»ad_©\8c_t
+ *
+__»¡riù
+
+__©\8c
+,
+
+227 \1e*(*
+__¡¬t_rout\9ae
+) (\1e*),
+
+228 \1e*
+__»¡riù
+
+__¬g
+è
+__THROWNL
+
+__nÚnuÎ
+ ((1, 3));
+
+234 \r\1e
+ $±h»ad_ex\99
+ (\1e*
+__»tv®
+è
+ `__©\8cibu\8b__
+ ((
+__nÜ\91uº__
+));
+
+242 \r\12
+ `±h»ad_jo\9a
+ (
+±h»ad_t
+
+__th
+, \1e**
+__th»ad_»tuº
+);
+
+244 #ifdeà
+__USE_GNU
+
+
+247 \r\12
+ $±h»ad_\8cyjo\9a_Å
+ (
+±h»ad_t
+
+__th
+, \1e**
+__th»ad_»tuº
+è
+__THROW
+;
+
+255 \r\12
+ `±h»ad_timedjo\9a_Å
+ (
+±h»ad_t
+
+__th
+, \1e**
+__th»ad_»tuº
+,
+
+256
+__cڡ
+ \19
+time¥ec
+ *
+__ab¡ime
+);
+
+263 \r\12
+ $±h»ad_d\91ach
+ (
+±h»ad_t
+
+__th
+è
+__THROW
+;
+
+267 \r
+±h»ad_t
+
+ $±h»ad_£lf
+ (\1eè
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+));
+
+270 \r\12
+ $±h»ad_equ®
+ (
+±h»ad_t
+
+__th»ad1
+,\85th»ad_\88
+__th»ad2
+è
+__THROW
+;
+
+278 \r\12
+ $±h»ad_©\8c_\9a\99
+ (
+±h»ad_©\8c_t
+ *
+__©\8c
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+281 \r\12
+ $±h»ad_©\8c_de¡roy
+ (
+±h»ad_©\8c_t
+ *
+__©\8c
+)
+
+282
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+285 \r\12
+ $±h»ad_©\8c_g\91d\91ach¡©e
+ (
+__cڡ
+
+±h»ad_©\8c_t
+ *
+__©\8c
+,
+
+286 \12*
+__d\91ach¡©e
+)
+
+287
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+290 \r\12
+ $±h»ad_©\8c_£td\91ach¡©e
+ (
+±h»ad_©\8c_t
+ *
+__©\8c
+,
+
+291 \12
+__d\91ach¡©e
+)
+
+292
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+296 \r\12
+ $±h»ad_©\8c_g\91gu¬dsize
+ (
+__cڡ
+
+±h»ad_©\8c_t
+ *
+__©\8c
+,
+
+297
+size_t
+ *
+__gu¬dsize
+)
+
+298
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+301 \r\12
+ $±h»ad_©\8c_£tgu¬dsize
+ (
+±h»ad_©\8c_t
+ *
+__©\8c
+,
+
+302
+size_t
+
+__gu¬dsize
+)
+
+303
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+307 \r\12
+ $±h»ad_©\8c_g\91sched·¿m
+ (
+__cڡ
+
+±h»ad_©\8c_t
+ *
+__»¡riù
+
+
+308
+__©\8c
+,
+
+309 \19
+sched_·¿m
+ *
+__»¡riù
+
+__·¿m
+)
+
+310
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+313 \r\12
+ $±h»ad_©\8c_£tsched·¿m
+ (
+±h»ad_©\8c_t
+ *
+__»¡riù
+
+__©\8c
+,
+
+314
+__cڡ
+ \19
+sched_·¿m
+ *
+__»¡riù
+
+
+315
+__·¿m
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+318 \r\12
+ $±h»ad_©\8c_g\91schedpÞicy
+ (
+__cڡ
+
+±h»ad_©\8c_t
+ *
+__»¡riù
+
+
+319
+__©\8c
+, \12*
+__»¡riù
+
+__pÞicy
+)
+
+320
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+323 \r\12
+ $±h»ad_©\8c_£tschedpÞicy
+ (
+±h»ad_©\8c_t
+ *
+__©\8c
+, \12
+__pÞicy
+)
+
+324
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+327 \r\12
+ $±h»ad_©\8c_g\91\9ah\94\99sched
+ (
+__cڡ
+
+±h»ad_©\8c_t
+ *
+__»¡riù
+
+
+328
+__©\8c
+, \12*
+__»¡riù
+
+__\9ah\94\99
+)
+
+329
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+332 \r\12
+ $±h»ad_©\8c_£t\9ah\94\99sched
+ (
+±h»ad_©\8c_t
+ *
+__©\8c
+,
+
+333 \12
+__\9ah\94\99
+)
+
+334
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+338 \r\12
+ $±h»ad_©\8c_g\91scÝe
+ (
+__cڡ
+
+±h»ad_©\8c_t
+ *
+__»¡riù
+
+__©\8c
+,
+
+339 \12*
+__»¡riù
+
+__scÝe
+)
+
+340
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+343 \r\12
+ $±h»ad_©\8c_£tscÝe
+ (
+±h»ad_©\8c_t
+ *
+__©\8c
+, \12
+__scÝe
+)
+
+344
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+347 \r\12
+ $±h»ad_©\8c_g\91¡ackaddr
+ (
+__cڡ
+
+±h»ad_©\8c_t
+ *
+__»¡riù
+
+
+348
+__©\8c
+, \1e**
+__»¡riù
+
+__¡ackaddr
+)
+
+349
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2)è
+__©\8cibu\8b_d\95»ÿ\8bd__
+;
+
+355 \r\12
+ $±h»ad_©\8c_£t¡ackaddr
+ (
+±h»ad_©\8c_t
+ *
+__©\8c
+,
+
+356 \1e*
+__¡ackaddr
+)
+
+357
+__THROW
+
+ `__nÚnuÎ
+ ((1)è
+__©\8cibu\8b_d\95»ÿ\8bd__
+;
+
+360 \r\12
+ $±h»ad_©\8c_g\91¡acksize
+ (
+__cڡ
+
+±h»ad_©\8c_t
+ *
+__»¡riù
+
+
+361
+__©\8c
+,
+size_t
+ *
+__»¡riù
+
+__¡acksize
+)
+
+362
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+367 \r\12
+ $±h»ad_©\8c_£t¡acksize
+ (
+±h»ad_©\8c_t
+ *
+__©\8c
+,
+
+368
+size_t
+
+__¡acksize
+)
+
+369
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+371 #ifdeà
+__USE_XOPEN2K
+
+
+373 \r\12
+ $±h»ad_©\8c_g\91¡ack
+ (
+__cڡ
+
+±h»ad_©\8c_t
+ *
+__»¡riù
+
+__©\8c
+,
+
+374 \1e**
+__»¡riù
+
+__¡ackaddr
+,
+
+375
+size_t
+ *
+__»¡riù
+
+__¡acksize
+)
+
+376
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2, 3));
+
+381 \r\12
+ $±h»ad_©\8c_£t¡ack
+ (
+±h»ad_©\8c_t
+ *
+__©\8c
+, \1e*
+__¡ackaddr
+,
+
+382
+size_t
+
+__¡acksize
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+385 #ifdeà
+__USE_GNU
+
+
+388 \r\12
+ $±h»ad_©\8c_£\8fff\9a\99y_Å
+ (
+±h»ad_©\8c_t
+ *
+__©\8c
+,
+
+389
+size_t
+
+__ýu£tsize
+,
+
+390
+__cڡ
+
+ýu_£t_t
+ *
+__ýu£t
+)
+
+391
+__THROW
+
+ `__nÚnuÎ
+ ((1, 3));
+
+395 \r\12
+ $±h»ad_©\8c_g\91aff\9a\99y_Å
+ (
+__cڡ
+
+±h»ad_©\8c_t
+ *
+__©\8c
+,
+
+396
+size_t
+
+__ýu£tsize
+,
+
+397
+ýu_£t_t
+ *
+__ýu£t
+)
+
+398
+__THROW
+
+ `__nÚnuÎ
+ ((1, 3));
+
+404 \r\12
+ $±h»ad_g\91©\8c_Å
+ (
+±h»ad_t
+
+__th
+,
+±h»ad_©\8c_t
+ *
+__©\8c
+)
+
+405
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+413 \r\12
+ $±h»ad_£tsched·¿m
+ (
+±h»ad_t
+
+__\8frg\91_th»ad
+, \12
+__pÞicy
+,
+
+414
+__cڡ
+ \19
+sched_·¿m
+ *
+__·¿m
+)
+
+415
+__THROW
+
+ `__nÚnuÎ
+ ((3));
+
+418 \r\12
+ $±h»ad_g\91sched·¿m
+ (
+±h»ad_t
+
+__\8frg\91_th»ad
+,
+
+419 \12*
+__»¡riù
+
+__pÞicy
+,
+
+420 \19
+sched_·¿m
+ *
+__»¡riù
+
+__·¿m
+)
+
+421
+__THROW
+
+ `__nÚnuÎ
+ ((2, 3));
+
+424 \r\12
+ $±h»ad_£tsched´io
+ (
+±h»ad_t
+
+__\8frg\91_th»ad
+, \12
+__´io
+)
+
+425
+__THROW
+;
+
+428 #ifdeà
+__USE_GNU
+
+
+430 \r\12
+ $±h»ad_g\91Çme_Å
+ (
+±h»ad_t
+
+__\8frg\91_th»ad
+, \ 5*
+__buf
+,
+
+431
+size_t
+
+__buæ\92
+)
+
+432
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+435 \r\12
+ $±h»ad_£\8aame_Å
+ (
+±h»ad_t
+
+__\8frg\91_th»ad
+,
+__cڡ
+ \ 5*
+__Çme
+)
+
+436
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+440 #ifdeà
+__USE_UNIX98
+
+
+442 \r\12
+ $±h»ad_g\91cÚcu¼\92cy
+ (\1eè
+__THROW
+;
+
+445 \r\12
+ $±h»ad_£tcÚcu¼\92cy
+ (\12
+__Ëv\96
+è
+__THROW
+;
+
+448 #ifdeà
+__USE_GNU
+
+
+453 \r\12
+ $±h»ad_y\9bld
+ (\1eè
+__THROW
+;
+
+458 \r\12
+ $±h»ad_£\8fff\9a\99y_Å
+ (
+±h»ad_t
+
+__th
+,
+size_t
+
+__ýu£tsize
+,
+
+459
+__cڡ
+
+ýu_£t_t
+ *
+__ýu£t
+)
+
+460
+__THROW
+
+ `__nÚnuÎ
+ ((3));
+
+463 \r\12
+ $±h»ad_g\91aff\9a\99y_Å
+ (
+±h»ad_t
+
+__th
+,
+size_t
+
+__ýu£tsize
+,
+
+464
+ýu_£t_t
+ *
+__ýu£t
+)
+
+465
+__THROW
+
+ `__nÚnuÎ
+ ((3));
+
+478 \r\12
+ `±h»ad_Úû
+ (
+±h»ad_Úû_t
+ *
+__Úû_cÚ\8cÞ
+,
+
+479 \1e(*
+__\9a\99_rout\9ae
+è(\1e)è
+ `__nÚnuÎ
+ ((1, 2));
+
+490 \r\12
+ `±h»ad_£tÿnûl¡©e
+ (\12
+__¡©e
+, \12*
+__Þd¡©e
+);
+
+494 \r\12
+ `±h»ad_£tÿnûÉy³
+ (\12
+__ty³
+, \12*
+__Þdty³
+);
+
+497 \r\12
+ `±h»ad_ÿnûl
+ (
+±h»ad_t
+
+__th
+);
+
+502 \r\1e
+ `±h»ad_\8b¡ÿnûl
+ (\1e);
+
+511
+__jmp_buf
+
+__ÿnûl_jmp_buf
+;
+
+512 \12
+__mask_was_§ved
+;
+
+513 }
+__ÿnûl_jmp_buf
+[1];
+
+514 \1e*
+__·d
+[4];
+
+515 }
+ t__±h»ad_unw\9ad_buf_t
+
+ t__©\8cibu\8b__
+ ((
+ t__®igÃd__
+));
+
+518 #iâdeà
+__þ\97nup_fù_©\8cibu\8b
+
+
+519 \ 1
+ #__þ\97nup_fù_©\8cibu\8b
+
+
+ )
+
+524 \19
+ s__±h»ad_þ\97nup_äame
+
+
+526 \1e(*
+__ÿnûl_rout\9ae
+) (\1e*);
+
+527 \1e*
+__ÿnûl_¬g
+;
+
+528 \12
+__do_\99
+;
+
+529 \12
+__ÿnûl_ty³
+;
+
+532 #ià
+def\9aed
+
+__GNUC__
+ && def\9aed
+__EXCEPTIONS
+
+
+533 #ifdeà
+__ýlu¥lus
+
+
+535 þas
+ c__±h»ad_þ\97nup_þass
+
+
+537 \1e(*
+__ÿnûl_rout\9ae
+) (\1e*);
+
+538 \1e*
+__ÿnûl_¬g
+;
+
+539 \12
+__do_\99
+;
+
+540 \12
+__ÿnûl_ty³
+;
+
+542
+public
+:
+
+543
+ `__±h»ad_þ\97nup_þass
+ (\1e(*
+__fù
+è(\1e*), \1e*
+__¬g
+)
+
+544 :
+ `__ÿnûl_rout\9ae
+ (
+__fù
+),
+ `__ÿnûl_¬g
+ (
+__¬g
+),
+ $__do_\99
+ (1) { }
+
+545 ~
+ $__±h»ad_þ\97nup_þass
+ (è{ ià(
+__do_\99
+è
+ `__ÿnûl_rout\9ae
+ (
+__ÿnûl_¬g
+);
+ }
+}
+
+546 \1e
+ $__£tdo\99
+ (\12
+__Ãwv®
+è{
+__do_\99
+ = __Ãwv®;
+ }
+}
+
+547 \1e
+ $__deãr
+ (è{
+ `±h»ad_£tÿnûÉy³
+ (
+PTHREAD_CANCEL_DEFERRED
+,
+
+548 &
+__ÿnûl_ty³
+);
+ }
+}
+
+549 \1e
+ $__»¡Üe
+ (ècÚ¡ {
+ `±h»ad_£tÿnûÉy³
+ (
+__ÿnûl_ty³
+, 0);
+ }
+}
+
+559 \ 1
+ #±h»ad_þ\97nup_push
+(
+rout\9ae
+,
+¬g
+) \
+
+561
+__±h»ad_þ\97nup_þass
+
+ `__þäame
+ (
+rout\9ae
+,
+¬g
+)
+
+ )
+
+565 \ 1
+ #±h»ad_þ\97nup_pÝ
+(
+execu\8b
+) \
+
+566
+__þäame
+.
+ `__£tdo\99
+ (
+execu\8b
+); \
+
+567 } \1f0)
+
+ )
+
+569 #ifdeà
+__USE_GNU
+
+
+573 \ 1
+ #±h»ad_þ\97nup_push_deãr_Å
+(
+rout\9ae
+,
+¬g
+) \
+
+575
+__±h»ad_þ\97nup_þass
+
+ `__þäame
+ (
+rout\9ae
+,
+¬g
+); \
+
+576
+__þäame
+.
+ `__deãr
+ ()
+
+ )
+
+581 \ 1
+ #±h»ad_þ\97nup_pÝ_»¡Üe_Å
+(
+execu\8b
+) \
+
+582
+__þäame
+.
+ `__»¡Üe
+ (); \
+
+583
+__þäame
+.
+ `__£tdo\99
+ (
+execu\8b
+); \
+
+584 } \1f0)
+
+ )
+
+591
+__ex\8bº_\9al\9ae
+ \1e
+
+592
+ $__±h»ad_þ\97nup_rout\9ae
+ (\19
+__±h»ad_þ\97nup_äame
+ *
+__äame
+)
+
+594 ià(
+__äame
+->
+__do_\99
+)
+
+595
+__äame
+->
+ `__ÿnûl_rout\9ae
+ (__äame->
+__ÿnûl_¬g
+);
+
+596
+ }
+}
+
+605 \ 1
+ #±h»ad_þ\97nup_push
+(
+rout\9ae
+,
+¬g
+) \
+
+607 \19
+__±h»ad_þ\97nup_äame
+
+__þäame
+ \
+
+608
+ `__©\8cibu\8b__
+ ((
+ `__þ\97nup__
+ (
+__±h»ad_þ\97nup_rout\9ae
+))) \
+
+609 ð{ .
+__ÿnûl_rout\9ae
+ = (
+rout\9ae
+), .
+__ÿnûl_¬g
+ = (
+¬g
+), \
+
+610 .
+__do_\99
+ = 1 };
+
+ )
+
+614 \ 1
+ #±h»ad_þ\97nup_pÝ
+(
+execu\8b
+) \
+
+615
+__þäame
+.
+__do_\99
+ = (
+execu\8b
+); \
+
+616 } \1f0)
+
+ )
+
+618 #ifdeà
+__USE_GNU
+
+
+622 \ 1
+ #±h»ad_þ\97nup_push_deãr_Å
+(
+rout\9ae
+,
+¬g
+) \
+
+624 \19
+__±h»ad_þ\97nup_äame
+
+__þäame
+ \
+
+625
+ `__©\8cibu\8b__
+ ((
+ `__þ\97nup__
+ (
+__±h»ad_þ\97nup_rout\9ae
+))) \
+
+626 ð{ .
+__ÿnûl_rout\9ae
+ = (
+rout\9ae
+), .
+__ÿnûl_¬g
+ = (
+¬g
+), \
+
+627 .
+__do_\99
+ = 1 }; \
+
+628 (\1eè
+ `±h»ad_£tÿnûÉy³
+ (
+PTHREAD_CANCEL_DEFERRED
+, \
+
+629 &
+__þäame
+.
+__ÿnûl_ty³
+)
+
+ )
+
+634 \ 1
+ #±h»ad_þ\97nup_pÝ_»¡Üe_Å
+(
+execu\8b
+) \
+
+635 (\1eè
+ `±h»ad_£tÿnûÉy³
+ (
+__þäame
+.
+__ÿnûl_ty³
+,
+NULL
+); \
+
+636
+__þäame
+.
+__do_\99
+ = (
+execu\8b
+); \
+
+637 } \1f0)
+
+ )
+
+648 \ 1
+ #±h»ad_þ\97nup_push
+(
+rout\9ae
+,
+¬g
+) \
+
+650
+__±h»ad_unw\9ad_buf_t
+
+__ÿnûl_buf
+; \
+
+651 \1e(*
+__ÿnûl_rout\9ae
+è(\1e*èð(
+rout\9ae
+); \
+
+652 \1e*
+__ÿnûl_¬g
+ = (
+¬g
+); \
+
+653 \12
+__nÙ_f\9c¡_ÿÎ
+ =
+ `__sig£tjmp
+ ((\19
+__jmp_buf_\8fg
+ *) (\1e*) \
+
+654
+__ÿnûl_buf
+.
+__ÿnûl_jmp_buf
+, 0); \
+
+655 ià(
+ `__bu\9et\9a_ex³ù
+ (
+__nÙ_f\9c¡_ÿÎ
+, 0)) \
+
+657
+ `__ÿnûl_rout\9ae
+ (
+__ÿnûl_¬g
+); \
+
+658
+ `__±h»ad_unw\9ad_Ãxt
+ (&
+__ÿnûl_buf
+); \
+
+662
+ `__±h»ad_»gi¡\94_ÿnûl
+ (&
+__ÿnûl_buf
+); \
+
+663 dØ{
+
+ )
+
+664 \r\1e
+__±h»ad_»gi¡\94_ÿnûl
+ (
+__±h»ad_unw\9ad_buf_t
+ *
+__buf
+)
+
+665
+__þ\97nup_fù_©\8cibu\8b
+;
+
+669 \ 1
+ #±h»ad_þ\97nup_pÝ
+(
+execu\8b
+) \
+
+672
+ `__±h»ad_uÄegi¡\94_ÿnûl
+ (&
+__ÿnûl_buf
+); \
+
+673 ià(
+execu\8b
+) \
+
+674
+ `__ÿnûl_rout\9ae
+ (
+__ÿnûl_¬g
+); \
+
+675 } \1f0)
+
+ )
+
+676 \r\1e
+ $__±h»ad_uÄegi¡\94_ÿnûl
+ (
+__±h»ad_unw\9ad_buf_t
+ *
+__buf
+)
+
+677
+__þ\97nup_fù_©\8cibu\8b
+;
+
+679 #ifdeà
+__USE_GNU
+
+
+683 \ 1
+ #±h»ad_þ\97nup_push_deãr_Å
+(
+rout\9ae
+,
+¬g
+) \
+
+685
+__±h»ad_unw\9ad_buf_t
+
+__ÿnûl_buf
+; \
+
+686 \1e(*
+__ÿnûl_rout\9ae
+è(\1e*èð(
+rout\9ae
+); \
+
+687 \1e*
+__ÿnûl_¬g
+ = (
+¬g
+); \
+
+688 \12
+__nÙ_f\9c¡_ÿÎ
+ =
+ `__sig£tjmp
+ ((\19
+__jmp_buf_\8fg
+ *) (\1e*) \
+
+689
+__ÿnûl_buf
+.
+__ÿnûl_jmp_buf
+, 0); \
+
+690 ià(
+ `__bu\9et\9a_ex³ù
+ (
+__nÙ_f\9c¡_ÿÎ
+, 0)) \
+
+692
+ `__ÿnûl_rout\9ae
+ (
+__ÿnûl_¬g
+); \
+
+693
+ `__±h»ad_unw\9ad_Ãxt
+ (&
+__ÿnûl_buf
+); \
+
+697
+ `__±h»ad_»gi¡\94_ÿnûl_deãr
+ (&
+__ÿnûl_buf
+); \
+
+698 dØ{
+
+ )
+
+699 \r\1e
+ `__±h»ad_»gi¡\94_ÿnûl_deãr
+ (
+__±h»ad_unw\9ad_buf_t
+ *
+__buf
+)
+
+700
+__þ\97nup_fù_©\8cibu\8b
+;
+
+705 \ 1
+ #±h»ad_þ\97nup_pÝ_»¡Üe_Å
+(
+execu\8b
+) \
+
+708
+ `__±h»ad_uÄegi¡\94_ÿnûl_»¡Üe
+ (&
+__ÿnûl_buf
+); \
+
+709 ià(
+execu\8b
+) \
+
+710
+ `__ÿnûl_rout\9ae
+ (
+__ÿnûl_¬g
+); \
+
+711
+ }
+} \1f0)
+
+ )
+
+712 \r\1e
+ $__±h»ad_uÄegi¡\94_ÿnûl_»¡Üe
+ (
+__±h»ad_unw\9ad_buf_t
+ *
+__buf
+)
+
+713
+__þ\97nup_fù_©\8cibu\8b
+;
+
+717 \r\1e
+ $__±h»ad_unw\9ad_Ãxt
+ (
+__±h»ad_unw\9ad_buf_t
+ *
+__buf
+)
+
+718
+__þ\97nup_fù_©\8cibu\8b
+
+ `__©\8cibu\8b__
+ ((
+__nÜ\91uº__
+))
+
+719 #iâdeà
+SHARED
+
+
+720
+ `__©\8cibu\8b__
+ ((
+__w\97k__
+))
+
+726 \19
+__jmp_buf_\8fg
+;
+
+727 \r\12
+ $__sig£tjmp
+ (\19
+__jmp_buf_\8fg
+ *
+__\92v
+, \12
+__§vemask
+è
+__THROW
+;
+
+733 \r\12
+ $±h»ad_mu\8bx_\9a\99
+ (
+±h»ad_mu\8bx_t
+ *
+__mu\8bx
+,
+
+734
+__cڡ
+
+±h»ad_mu\8bx©\8c_t
+ *
+__mu\8bx©\8c
+)
+
+735
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+738 \r\12
+ $±h»ad_mu\8bx_de¡roy
+ (
+±h»ad_mu\8bx_t
+ *
+__mu\8bx
+)
+
+739
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+742 \r\12
+ $±h»ad_mu\8bx_\8cylock
+ (
+±h»ad_mu\8bx_t
+ *
+__mu\8bx
+)
+
+743
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+746 \r\12
+ $±h»ad_mu\8bx_lock
+ (
+±h»ad_mu\8bx_t
+ *
+__mu\8bx
+)
+
+747
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+749 #ifdeà
+__USE_XOPEN2K
+
+
+751 \r\12
+ $±h»ad_mu\8bx_timedlock
+ (
+±h»ad_mu\8bx_t
+ *
+__»¡riù
+
+__mu\8bx
+,
+
+752
+__cڡ
+ \19
+time¥ec
+ *
+__»¡riù
+
+
+753
+__ab¡ime
+è
+__THROWNL
+
+ `__nÚnuÎ
+ ((1, 2));
+
+757 \r\12
+ $±h»ad_mu\8bx_uÆock
+ (
+±h»ad_mu\8bx_t
+ *
+__mu\8bx
+)
+
+758
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+762 \r\12
+ $±h»ad_mu\8bx_g\91´ioû\9e\9ag
+ (
+__cڡ
+
+±h»ad_mu\8bx_t
+ *
+
+763
+__»¡riù
+
+__mu\8bx
+,
+
+764 \12*
+__»¡riù
+
+__´ioû\9e\9ag
+)
+
+765
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+769 \r\12
+ $±h»ad_mu\8bx_£\8drioû\9e\9ag
+ (
+±h»ad_mu\8bx_t
+ *
+__»¡riù
+
+__mu\8bx
+,
+
+770 \12
+__´ioû\9e\9ag
+,
+
+771 \12*
+__»¡riù
+
+__Þd_û\9e\9ag
+)
+
+772
+__THROW
+
+ `__nÚnuÎ
+ ((1, 3));
+
+775 #ifdeà
+__USE_XOPEN2K8
+
+
+777 \r\12
+ $±h»ad_mu\8bx_cÚsi¡\92t
+ (
+±h»ad_mu\8bx_t
+ *
+__mu\8bx
+)
+
+778
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+779 #ifdeà
+__USE_GNU
+
+
+780 \r\12
+ $±h»ad_mu\8bx_cÚsi¡\92t_Å
+ (
+±h»ad_mu\8bx_t
+ *
+__mu\8bx
+)
+
+781
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+790 \r\12
+ $±h»ad_mu\8bx©\8c_\9a\99
+ (
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+)
+
+791
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+794 \r\12
+ $±h»ad_mu\8bx©\8c_de¡roy
+ (
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+)
+
+795
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+798 \r\12
+ $±h»ad_mu\8bx©\8c_g\91psh¬ed
+ (
+__cڡ
+
+±h»ad_mu\8bx©\8c_t
+ *
+
+799
+__»¡riù
+
+__©\8c
+,
+
+800 \12*
+__»¡riù
+
+__psh¬ed
+)
+
+801
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+804 \r\12
+ $±h»ad_mu\8bx©\8c_£\8dsh¬ed
+ (
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+,
+
+805 \12
+__psh¬ed
+)
+
+806
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+808 #ià
+def\9aed
+
+__USE_UNIX98
+ || def\9aed
+__USE_XOPEN2K8
+
+
+810 \r\12
+ $±h»ad_mu\8bx©\8c_g\91ty³
+ (
+__cڡ
+
+±h»ad_mu\8bx©\8c_t
+ *
+__»¡riù
+
+
+811
+__©\8c
+, \12*
+__»¡riù
+
+__k\9ad
+)
+
+812
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+817 \r\12
+ $±h»ad_mu\8bx©\8c_£\89y³
+ (
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+, \12
+__k\9ad
+)
+
+818
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+822 \r\12
+ $±h»ad_mu\8bx©\8c_g\91´ÙocÞ
+ (
+__cڡ
+
+±h»ad_mu\8bx©\8c_t
+ *
+
+823
+__»¡riù
+
+__©\8c
+,
+
+824 \12*
+__»¡riù
+
+__´ÙocÞ
+)
+
+825
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+829 \r\12
+ $±h»ad_mu\8bx©\8c_£\8drÙocÞ
+ (
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+,
+
+830 \12
+__´ÙocÞ
+)
+
+831
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+834 \r\12
+ $±h»ad_mu\8bx©\8c_g\91´ioû\9e\9ag
+ (
+__cڡ
+
+±h»ad_mu\8bx©\8c_t
+ *
+
+835
+__»¡riù
+
+__©\8c
+,
+
+836 \12*
+__»¡riù
+
+__´ioû\9e\9ag
+)
+
+837
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+840 \r\12
+ $±h»ad_mu\8bx©\8c_£\8drioû\9e\9ag
+ (
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+,
+
+841 \12
+__´ioû\9e\9ag
+)
+
+842
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+844 #ifdeà
+__USE_XOPEN2K
+
+
+846 \r\12
+ $±h»ad_mu\8bx©\8c_g\91robu¡
+ (
+__cڡ
+
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+,
+
+847 \12*
+__robu¡Ãss
+)
+
+848
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+849 #ifdeà
+__USE_GNU
+
+
+850 \r\12
+ $±h»ad_mu\8bx©\8c_g\91robu¡_Å
+ (
+__cڡ
+
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+,
+
+851 \12*
+__robu¡Ãss
+)
+
+852
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+856 \r\12
+ $±h»ad_mu\8bx©\8c_£\8cobu¡
+ (
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+,
+
+857 \12
+__robu¡Ãss
+)
+
+858
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+859 #ifdeà
+__USE_GNU
+
+
+860 \r\12
+ $±h»ad_mu\8bx©\8c_£\8cobu¡_Å
+ (
+±h»ad_mu\8bx©\8c_t
+ *
+__©\8c
+,
+
+861 \12
+__robu¡Ãss
+)
+
+862
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+867 #ià
+def\9aed
+
+__USE_UNIX98
+ || def\9aed
+__USE_XOPEN2K
+
+
+872 \r\12
+ $±h»ad_rwlock_\9a\99
+ (
+±h»ad_rwlock_t
+ *
+__»¡riù
+
+__rwlock
+,
+
+873
+__cڡ
+
+±h»ad_rwlock©\8c_t
+ *
+__»¡riù
+
+
+874
+__©\8c
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+877 \r\12
+ $±h»ad_rwlock_de¡roy
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+)
+
+878
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+881 \r\12
+ $±h»ad_rwlock_rdlock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+)
+
+882
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+885 \r\12
+ $±h»ad_rwlock_\8cyrdlock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+)
+
+886
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+888 #ifdeà
+__USE_XOPEN2K
+
+
+890 \r\12
+ $±h»ad_rwlock_timedrdlock
+ (
+±h»ad_rwlock_t
+ *
+__»¡riù
+
+__rwlock
+,
+
+891
+__cڡ
+ \19
+time¥ec
+ *
+__»¡riù
+
+
+892
+__ab¡ime
+è
+__THROWNL
+
+ `__nÚnuÎ
+ ((1, 2));
+
+896 \r\12
+ $±h»ad_rwlock_w¾ock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+)
+
+897
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+900 \r\12
+ $±h»ad_rwlock_\8cyw¾ock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+)
+
+901
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+903 #ifdeà
+__USE_XOPEN2K
+
+
+905 \r\12
+ $±h»ad_rwlock_timedw¾ock
+ (
+±h»ad_rwlock_t
+ *
+__»¡riù
+
+__rwlock
+,
+
+906
+__cڡ
+ \19
+time¥ec
+ *
+__»¡riù
+
+
+907
+__ab¡ime
+è
+__THROWNL
+
+ `__nÚnuÎ
+ ((1, 2));
+
+911 \r\12
+ $±h»ad_rwlock_uÆock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+)
+
+912
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+918 \r\12
+ $±h»ad_rwlock©\8c_\9a\99
+ (
+±h»ad_rwlock©\8c_t
+ *
+__©\8c
+)
+
+919
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+922 \r\12
+ $±h»ad_rwlock©\8c_de¡roy
+ (
+±h»ad_rwlock©\8c_t
+ *
+__©\8c
+)
+
+923
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+926 \r\12
+ $±h»ad_rwlock©\8c_g\91psh¬ed
+ (
+__cڡ
+
+±h»ad_rwlock©\8c_t
+ *
+
+927
+__»¡riù
+
+__©\8c
+,
+
+928 \12*
+__»¡riù
+
+__psh¬ed
+)
+
+929
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+932 \r\12
+ $±h»ad_rwlock©\8c_£\8dsh¬ed
+ (
+±h»ad_rwlock©\8c_t
+ *
+__©\8c
+,
+
+933 \12
+__psh¬ed
+)
+
+934
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+937 \r\12
+ $±h»ad_rwlock©\8c_g\91k\9ad_Å
+ (
+__cڡ
+
+±h»ad_rwlock©\8c_t
+ *
+
+938
+__»¡riù
+
+__©\8c
+,
+
+939 \12*
+__»¡riù
+
+__´ef
+)
+
+940
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+943 \r\12
+ $±h»ad_rwlock©\8c_£tk\9ad_Å
+ (
+±h»ad_rwlock©\8c_t
+ *
+__©\8c
+,
+
+944 \12
+__´ef
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+952 \r\12
+ $±h»ad_cÚd_\9a\99
+ (
+±h»ad_cÚd_t
+ *
+__»¡riù
+
+__cÚd
+,
+
+953
+__cڡ
+
+±h»ad_cÚd©\8c_t
+ *
+__»¡riù
+
+
+954
+__cÚd_©\8c
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+957 \r\12
+ $±h»ad_cÚd_de¡roy
+ (
+±h»ad_cÚd_t
+ *
+__cÚd
+)
+
+958
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+961 \r\12
+ $±h»ad_cÚd_sigÇl
+ (
+±h»ad_cÚd_t
+ *
+__cÚd
+)
+
+962
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+965 \r\12
+ $±h»ad_cÚd_brßdÿ¡
+ (
+±h»ad_cÚd_t
+ *
+__cÚd
+)
+
+966
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+973 \r\12
+ $±h»ad_cÚd_wa\99
+ (
+±h»ad_cÚd_t
+ *
+__»¡riù
+
+__cÚd
+,
+
+974
+±h»ad_mu\8bx_t
+ *
+__»¡riù
+
+__mu\8bx
+)
+
+975
+ `__nÚnuÎ
+ ((1, 2));
+
+984 \r\12
+ $±h»ad_cÚd_timedwa\99
+ (
+±h»ad_cÚd_t
+ *
+__»¡riù
+
+__cÚd
+,
+
+985
+±h»ad_mu\8bx_t
+ *
+__»¡riù
+
+__mu\8bx
+,
+
+986
+__cڡ
+ \19
+time¥ec
+ *
+__»¡riù
+
+
+987
+__ab¡ime
+è
+ `__nÚnuÎ
+ ((1, 2, 3));
+
+992 \r\12
+ $±h»ad_cÚd©\8c_\9a\99
+ (
+±h»ad_cÚd©\8c_t
+ *
+__©\8c
+)
+
+993
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+996 \r\12
+ $±h»ad_cÚd©\8c_de¡roy
+ (
+±h»ad_cÚd©\8c_t
+ *
+__©\8c
+)
+
+997
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+1000 \r\12
+ $±h»ad_cÚd©\8c_g\91psh¬ed
+ (
+__cڡ
+
+±h»ad_cÚd©\8c_t
+ *
+
+1001
+__»¡riù
+
+__©\8c
+,
+
+1002 \12*
+__»¡riù
+
+__psh¬ed
+)
+
+1003
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+1006 \r\12
+ $±h»ad_cÚd©\8c_£\8dsh¬ed
+ (
+±h»ad_cÚd©\8c_t
+ *
+__©\8c
+,
+
+1007 \12
+__psh¬ed
+è
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+1009 #ifdeà
+__USE_XOPEN2K
+
+
+1011 \r\12
+ $±h»ad_cÚd©\8c_g\91þock
+ (
+__cڡ
+
+±h»ad_cÚd©\8c_t
+ *
+
+1012
+__»¡riù
+
+__©\8c
+,
+
+1013
+__þockid_t
+ *
+__»¡riù
+
+__þock_id
+)
+
+1014
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+1017 \r\12
+ $±h»ad_cÚd©\8c_£tþock
+ (
+±h»ad_cÚd©\8c_t
+ *
+__©\8c
+,
+
+1018
+__þockid_t
+
+__þock_id
+)
+
+1019
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+1023 #ifdeà
+__USE_XOPEN2K
+
+
+1028 \r\12
+ $±h»ad_¥\9a_\9a\99
+ (
+±h»ad_¥\9alock_t
+ *
+__lock
+, \12
+__psh¬ed
+)
+
+1029
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+1032 \r\12
+ $±h»ad_¥\9a_de¡roy
+ (
+±h»ad_¥\9alock_t
+ *
+__lock
+)
+
+1033
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+1036 \r\12
+ $±h»ad_¥\9a_lock
+ (
+±h»ad_¥\9alock_t
+ *
+__lock
+)
+
+1037
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+1040 \r\12
+ $±h»ad_¥\9a_\8cylock
+ (
+±h»ad_¥\9alock_t
+ *
+__lock
+)
+
+1041
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+1044 \r\12
+ $±h»ad_¥\9a_uÆock
+ (
+±h»ad_¥\9alock_t
+ *
+__lock
+)
+
+1045
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+1052 \r\12
+ $±h»ad_b¬r\9br_\9a\99
+ (
+±h»ad_b¬r\9br_t
+ *
+__»¡riù
+
+__b¬r\9br
+,
+
+1053
+__cڡ
+
+±h»ad_b¬r\9b¿\89r_t
+ *
+__»¡riù
+
+
+1054
+__©\8c
+, \1d\12
+__couÁ
+)
+
+1055
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+1058 \r\12
+ $±h»ad_b¬r\9br_de¡roy
+ (
+±h»ad_b¬r\9br_t
+ *
+__b¬r\9br
+)
+
+1059
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+1062 \r\12
+ $±h»ad_b¬r\9br_wa\99
+ (
+±h»ad_b¬r\9br_t
+ *
+__b¬r\9br
+)
+
+1063
+__THROWNL
+
+ `__nÚnuÎ
+ ((1));
+
+1067 \r\12
+ $±h»ad_b¬r\9b¿\89r_\9a\99
+ (
+±h»ad_b¬r\9b¿\89r_t
+ *
+__©\8c
+)
+
+1068
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+1071 \r\12
+ $±h»ad_b¬r\9b¿\89r_de¡roy
+ (
+±h»ad_b¬r\9b¿\89r_t
+ *
+__©\8c
+)
+
+1072
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+1075 \r\12
+ $±h»ad_b¬r\9b¿\89r_g\91psh¬ed
+ (
+__cڡ
+
+±h»ad_b¬r\9b¿\89r_t
+ *
+
+1076
+__»¡riù
+
+__©\8c
+,
+
+1077 \12*
+__»¡riù
+
+__psh¬ed
+)
+
+1078
+__THROW
+
+ `__nÚnuÎ
+ ((1, 2));
+
+1081 \r\12
+ $±h»ad_b¬r\9b¿\89r_£\8dsh¬ed
+ (
+±h»ad_b¬r\9b¿\89r_t
+ *
+__©\8c
+,
+
+1082 \12
+__psh¬ed
+)
+
+1083
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+1095 \r\12
+ `±h»ad_key_ü\97\8b
+ (
+±h»ad_key_t
+ *
+__key
+,
+
+1096 \1e(*
+__de¡r_funùiÚ
+) (\1e*))
+
+1097
+__THROW
+
+ `__nÚnuÎ
+ ((1));
+
+1100 \r\12
+ $±h»ad_key_d\96\91e
+ (
+±h»ad_key_t
+
+__key
+è
+__THROW
+;
+
+1103 \r\1e*
+ $±h»ad_g\91¥ecific
+ (
+±h»ad_key_t
+
+__key
+è
+__THROW
+;
+
+1106 \r\12
+ $±h»ad_£t¥ecific
+ (
+±h»ad_key_t
+
+__key
+,
+
+1107
+__cڡ
+ \1e*
+__po\9a\8br
+è
+__THROW
+ ;
+
+1110 #ifdeà
+__USE_XOPEN2K
+
+
+1112 \r\12
+ $±h»ad_g\91ýuþockid
+ (
+±h»ad_t
+
+__th»ad_id
+,
+
+1113
+__þockid_t
+ *
+__þock_id
+)
+
+1114
+__THROW
+
+ `__nÚnuÎ
+ ((2));
+
+1129 \r\12
+ `±h»ad_©fÜk
+ (\1e(*
+__´\95¬e
+) (\1e),
+
+1130 \1e(*
+__·»Á
+) (\1e),
+
+1131 \1e(*
+__ch\9ed
+è(\1e)è
+__THROW
+;
+
+1134 #ifdeà
+__USE_EXTERN_INLINES
+
+
+1136
+__ex\8bº_\9al\9ae
+ \12
+
+1137
+ `__NTH
+ (
+ $±h»ad_equ®
+ (
+±h»ad_t
+
+__th»ad1
+,\85th»ad_\88
+__th»ad2
+))
+
+1139 \15
+__th»ad1
+ =ð
+__th»ad2
+;
+
+1140
+ }
+}
+
+1143
+ g__END_DECLS
+
+
+ @/usr/include/wctype.h
+
+24 #iâdeà
+_WCTYPE_H
+
+
+26 \ 2
+ ~<ã©u»s.h
+>
+
+27 \ 2
+ ~<b\99s/ty³s.h
+>
+
+29 #iâdeà
+__Ãed_iswxxx
+
+
+30 \ 1
+ #_WCTYPE_H
+ 1
+
+ )
+
+33 \ 1
+ #__Ãed_w\9at_t
+
+
+ )
+
+34 \ 2
+ ~<wch¬.h
+>
+
+38 #iâdeà
+WEOF
+
+
+39 \ 1
+ #WEOF
+ (0xffffffffu)
+
+ )
+
+42 #undeà
+__Ãed_iswxxx
+
+
+47 #iâdeà
+__iswxxx_def\9aed
+
+
+48 \ 1
+ #__iswxxx_def\9aed
+ 1
+
+ )
+
+50
+__BEGIN_NAMESPACE_C99
+
+
+53 \e\1d\13\12
+ twùy³_t
+;
+
+54
+ g__END_NAMESPACE_C99
+
+
+56 #iâdeà
+_ISwb\99
+
+
+61 \ 2
+ ~<\92d\9fn.h
+>
+
+62 #ià
+__BYTE_ORDER
+ =ð
+__BIG_ENDIAN
+
+
+63 \ 1
+ #_ISwb\99
+(
+b\99
+è(1 << (b\99))
+
+ )
+
+65 \ 1
+ #_ISwb\99
+(
+b\99
+) \
+
+66 ((
+b\99
+) < 8 ? (\12) ((1UL << (bit)) << 24) \
+
+67 : ((
+b\99
+) < 16 ? (\12) ((1UL << (bit)) << 8) \
+
+68 : ((
+b\99
+) < 24 ? (\12) ((1UL << (bit)) >> 8) \
+
+69 : (\12è((1UL << (
+b\99
+)è>> 24))))
+
+ )
+
+74
+ m__ISwuµ\94
+ = 0,
+
+75
+ m__ISwlow\94
+ = 1,
+
+76
+ m__ISw®pha
+ = 2,
+
+77
+ m__ISwdig\99
+ = 3,
+
+78
+ m__ISwxdig\99
+ = 4,
+
+79
+ m__ISw¥aû
+ = 5,
+
+80
+ m__ISw´\9at
+ = 6,
+
+81
+ m__ISwg¿ph
+ = 7,
+
+82
+ m__ISwbÏnk
+ = 8,
+
+83
+ m__ISwú\8cl
+ = 9,
+
+84
+ m__ISwpunù
+ = 10,
+
+85
+ m__ISw®num
+ = 11,
+
+87
+ m_ISwuµ\94
+ =
+_ISwb\99
+ (
+__ISwuµ\94
+),
+
+88
+ m_ISwlow\94
+ =
+_ISwb\99
+ (
+__ISwlow\94
+),
+
+89
+ m_ISw®pha
+ =
+_ISwb\99
+ (
+__ISw®pha
+),
+
+90
+ m_ISwdig\99
+ =
+_ISwb\99
+ (
+__ISwdig\99
+),
+
+91
+ m_ISwxdig\99
+ =
+_ISwb\99
+ (
+__ISwxdig\99
+),
+
+92
+ m_ISw¥aû
+ =
+_ISwb\99
+ (
+__ISw¥aû
+),
+
+93
+ m_ISw´\9at
+ =
+_ISwb\99
+ (
+__ISw´\9at
+),
+
+94
+ m_ISwg¿ph
+ =
+_ISwb\99
+ (
+__ISwg¿ph
+),
+
+95
+ m_ISwbÏnk
+ =
+_ISwb\99
+ (
+__ISwbÏnk
+),
+
+96
+ m_ISwú\8cl
+ =
+_ISwb\99
+ (
+__ISwú\8cl
+),
+
+97
+ m_ISwpunù
+ =
+_ISwb\99
+ (
+__ISwpunù
+),
+
+98
+ m_ISw®num
+ =
+_ISwb\99
+ (
+__ISw®num
+)
+
+103
+__BEGIN_DECLS
+
+
+105
+__BEGIN_NAMESPACE_C99
+
+
+112 \r\12
+ $isw®num
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+118 \r\12
+ $isw®pha
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+121 \r\12
+ $iswú\8cl
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+125 \r\12
+ $iswdig\99
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+129 \r\12
+ $iswg¿ph
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+134 \r\12
+ $iswlow\94
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+137 \r\12
+ $isw´\9at
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+142 \r\12
+ $iswpunù
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+147 \r\12
+ $isw¥aû
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+152 \r\12
+ $iswuµ\94
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+157 \r\12
+ $iswxdig\99
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+162 #ifdeà
+__USE_ISOC99
+
+
+163 \r\12
+ $iswbÏnk
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+172 \r
+wùy³_t
+
+ $wùy³
+ (
+__cڡ
+ \ 5*
+__´Ý\94ty
+è
+__THROW
+;
+
+176 \r\12
+ $iswùy³
+ (
+w\9at_t
+
+__wc
+,
+wùy³_t
+
+__desc
+è
+__THROW
+;
+
+177
+__END_NAMESPACE_C99
+
+
+184
+__BEGIN_NAMESPACE_C99
+
+
+187 \e
+__cڡ
+
+ t__\9at32_t
+ *
+ twù¿ns_t
+;
+
+188
+__END_NAMESPACE_C99
+
+
+189 #ifdeà
+__USE_GNU
+
+
+190
+ $__USING_NAMESPACE_C99
+(
+wù¿ns_t
+)
+
+193
+__BEGIN_NAMESPACE_C99
+
+
+195 \r
+w\9at_t
+
+ $towlow\94
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+198 \r
+w\9at_t
+
+ $towuµ\94
+ (
+w\9at_t
+
+__wc
+è
+__THROW
+;
+
+199
+__END_NAMESPACE_C99
+
+
+201
+__END_DECLS
+
+
+208 #ifdeà
+_WCTYPE_H
+
+
+214
+__BEGIN_DECLS
+
+
+216
+__BEGIN_NAMESPACE_C99
+
+
+219 \r
+wù¿ns_t
+
+ $wù¿ns
+ (
+__cڡ
+ \ 5*
+__´Ý\94ty
+è
+__THROW
+;
+
+222 \r
+w\9at_t
+
+ $towù¿ns
+ (
+w\9at_t
+
+__wc
+,
+wù¿ns_t
+
+__desc
+è
+__THROW
+;
+
+223
+__END_NAMESPACE_C99
+
+
+225 #ifdeà
+__USE_XOPEN2K8
+
+
+227 \ 2
+ ~<xloÿË.h
+>
+
+231 \r\12
+ $isw®num_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+237 \r\12
+ $isw®pha_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+240 \r\12
+ $iswú\8cl_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+244 \r\12
+ $iswdig\99_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+248 \r\12
+ $iswg¿ph_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+253 \r\12
+ $iswlow\94_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+256 \r\12
+ $isw´\9at_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+261 \r\12
+ $iswpunù_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+266 \r\12
+ $isw¥aû_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+271 \r\12
+ $iswuµ\94_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+276 \r\12
+ $iswxdig\99_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+281 \r\12
+ $iswbÏnk_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+285 \r
+wùy³_t
+
+ $wùy³_l
+ (
+__cڡ
+ \ 5*
+__´Ý\94ty
+,
+__loÿË_t
+
+__loÿË
+)
+
+286
+__THROW
+;
+
+290 \r\12
+ $iswùy³_l
+ (
+w\9at_t
+
+__wc
+,
+wùy³_t
+
+__desc
+,
+__loÿË_t
+
+__loÿË
+)
+
+291
+__THROW
+;
+
+299 \r
+w\9at_t
+
+ $towlow\94_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+302 \r
+w\9at_t
+
+ $towuµ\94_l
+ (
+w\9at_t
+
+__wc
+,
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+306 \r
+wù¿ns_t
+
+ $wù¿ns_l
+ (
+__cڡ
+ \ 5*
+__´Ý\94ty
+,
+__loÿË_t
+
+__loÿË
+)
+
+307
+__THROW
+;
+
+310 \r
+w\9at_t
+
+ $towù¿ns_l
+ (
+w\9at_t
+
+__wc
+,
+wù¿ns_t
+
+__desc
+,
+
+311
+__loÿË_t
+
+__loÿË
+è
+__THROW
+;
+
+315
+__END_DECLS
+
+
+ @/usr/include/bits/errno.h
+
+20 #ifdeà
+_ERRNO_H
+
+
+22 #undeà
+EDOM
+
+
+23 #undeà
+EILSEQ
+
+
+24 #undeà
+ERANGE
+
+
+25 \ 2
+ ~<l\9aux/\94ºo.h
+>
+
+28 \ 1
+ #ENOTSUP
+
+EOPNOTSUPP
+
+
+ )
+
+31 #iâdeà
+ECANCELED
+
+
+32 \ 1
+ #ECANCELED
+ 125
+
+ )
+
+36 #iâdeà
+EOWNERDEAD
+
+
+37 \ 1
+ #EOWNERDEAD
+ 130
+
+ )
+
+38 \ 1
+ #ENOTRECOVERABLE
+ 131
+
+ )
+
+41 #iâdeà
+ERFKILL
+
+
+42 \ 1
+ #ERFKILL
+ 132
+
+ )
+
+45 #iâdeà
+__ASSEMBLER__
+
+
+47 \r\12*
+ $__\94ºo_loÿtiÚ
+ (\1eè
+__THROW
+
+ `__©\8cibu\8b__
+ ((
+__cڡ__
+));
+
+49 #ià!
+def\9aed
+
+_LIBC
+ || def\9aed
+_LIBC_REENTRANT
+
+
+51 \ 1
+ #\94ºo
+ (*
+ `__\94ºo_loÿtiÚ
+ ())
+
+ )
+
+56 #ià!
+def\9aed
+
+_ERRNO_H
+ && def\9aed
+__Ãed_Em©h
+
+
+60 \ 1
+ #EDOM
+ 33
+
+ )
+
+61 \ 1
+ #EILSEQ
+ 84
+
+ )
+
+62 \ 1
+ #ERANGE
+ 34
+
+ )
+
+ @/usr/include/bits/setjmp.h
+
+20 #iâdeà
+_BITS_SETJMP_H
+
+
+21 \ 1
+ #_BITS_SETJMP_H
+ 1
+
+ )
+
+23 #ià!
+def\9aed
+
+_SETJMP_H
+ && !def\9aed
+_PTHREAD_H
+
+
+27 \ 2
+ ~<b\99s/wÜdsize.h
+>
+
+29 #iâdeà
+_ASM
+
+
+31 #ià
+__WORDSIZE
+ == 64
+
+32 \e\13\12
+ t__jmp_buf
+[8];
+
+34 \e\12
+ t__jmp_buf
+[6];
+
+ @/usr/include/sched.h
+
+21 #iâdef
+_SCHED_H
+
+
+22 \ 1
+ #_SCHED_H
+ 1
+
+ )
+
+24 \ 2
+ ~<ã©u»s.h
+>
+
+27 \ 2
+ ~<b\99s/ty³s.h
+>
+
+29 \ 1
+ #__Ãed_size_t
+
+
+ )
+
+30 \ 2
+ ~<¡ddef.h
+>
+
+32 \ 1
+ #__Ãed_time_t
+
+
+ )
+
+33 \ 1
+ #__Ãed_time¥ec
+
+
+ )
+
+34 \ 2
+ ~<time.h
+>
+
+36 #iâdeà
+__pid_t_def\9aed
+
+
+37 \e
+__pid_t
+
+ tpid_t
+;
+
+38 \ 1
+ #__pid_t_def\9aed
+
+
+ )
+
+43 \ 2
+ ~<b\99s/sched.h
+>
+
+45 \ 1
+ #sched_´iÜ\99y
+
+__sched_´iÜ\99y
+
+
+ )
+
+48
+__BEGIN_DECLS
+
+
+51 \r\12
+ $sched_£\8d¬am
+ (
+__pid_t
+
+__pid
+,
+__cڡ
+ \19
+sched_·¿m
+ *
+__·¿m
+)
+
+52
+__THROW
+;
+
+55 \r\12
+ $sched_g\91·¿m
+ (
+__pid_t
+
+__pid
+, \19
+sched_·¿m
+ *
+__·¿m
+è
+__THROW
+;
+
+58 \r\12
+ $sched_£tscheduËr
+ (
+__pid_t
+
+__pid
+, \12
+__pÞicy
+,
+
+59
+__cڡ
+ \19
+sched_·¿m
+ *
+__·¿m
+è
+__THROW
+;
+
+62 \r\12
+ $sched_g\91scheduËr
+ (
+__pid_t
+
+__pid
+è
+__THROW
+;
+
+65 \r\12
+ $sched_y\9bld
+ (\1eè
+__THROW
+;
+
+68 \r\12
+ $sched_g\91_´iÜ\99y_max
+ (\12
+__®gÜ\99hm
+è
+__THROW
+;
+
+71 \r\12
+ $sched_g\91_´iÜ\99y_m\9a
+ (\12
+__®gÜ\99hm
+è
+__THROW
+;
+
+74 \r\12
+ $sched_¼_g\91_\9a\8brv®
+ (
+__pid_t
+
+__pid
+, \19
+time¥ec
+ *
+__t
+è
+__THROW
+;
+
+77 #ifdeà
+__USE_GNU
+
+
+79 \ 1
+ #CPU_SETSIZE
+
+__CPU_SETSIZE
+
+
+ )
+
+80 \ 1
+ #CPU_SET
+(
+ýu
+,
+ýu£\8d
+è
+ `__CPU_SET_S
+ (ýu, \17 (
+ýu_£t_t
+), cpu£\8d)
+
+ )
+
+81 \ 1
+ #CPU_CLR
+(
+ýu
+,
+ýu£\8d
+è
+ `__CPU_CLR_S
+ (ýu, \17 (
+ýu_£t_t
+), cpu£\8d)
+
+ )
+
+82 \ 1
+ #CPU_ISSET
+(
+ýu
+,
+ýu£\8d
+è
+ `__CPU_ISSET_S
+ (ýu, \17 (
+ýu_£t_t
+), \
+
+83
+ýu£\8d
+)
+
+ )
+
+84 \ 1
+ #CPU_ZERO
+(
+ýu£\8d
+è
+ `__CPU_ZERO_S
+ (\17 (
+ýu_£t_t
+), cpu£\8d)
+
+ )
+
+85 \ 1
+ #CPU_COUNT
+(
+ýu£\8d
+è
+ `__CPU_COUNT_S
+ (\17 (
+ýu_£t_t
+), cpu£\8d)
+
+ )
+
+87 \ 1
+ #CPU_SET_S
+(
+ýu
+,
+£tsize
+,
+ýu£\8d
+è
+ `__CPU_SET_S
+ (ýu, s\91size, cpu£\8d)
+
+ )
+
+88 \ 1
+ #CPU_CLR_S
+(
+ýu
+,
+£tsize
+,
+ýu£\8d
+è
+ `__CPU_CLR_S
+ (ýu, s\91size, cpu£\8d)
+
+ )
+
+89 \ 1
+ #CPU_ISSET_S
+(
+ýu
+,
+£tsize
+,
+ýu£\8d
+è
+ `__CPU_ISSET_S
+ (cpu, setsize, \
+
+90
+ýu£\8d
+)
+
+ )
+
+91 \ 1
+ #CPU_ZERO_S
+(
+£tsize
+,
+ýu£\8d
+è
+ `__CPU_ZERO_S
+ (£tsize, cpu£\8d)
+
+ )
+
+92 \ 1
+ #CPU_COUNT_S
+(
+£tsize
+,
+ýu£\8d
+è
+ `__CPU_COUNT_S
+ (£tsize, cpu£\8d)
+
+ )
+
+94 \ 1
+ #CPU_EQUAL
+(
+ýu£\8d1
+,
+ýu£\8d2
+) \
+
+95
+ `__CPU_EQUAL_S
+ (\17 (
+ýu_£t_t
+),
+ýu£\8d1
+,
+ýu£\8d2
+)
+
+ )
+
+96 \ 1
+ #CPU_EQUAL_S
+(
+£tsize
+,
+ýu£\8d1
+,
+ýu£\8d2
+) \
+
+97
+ `__CPU_EQUAL_S
+ (
+£tsize
+,
+ýu£\8d1
+,
+ýu£\8d2
+)
+
+ )
+
+99 \ 1
+ #CPU_AND
+(
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+) \
+
+100
+ `__CPU_OP_S
+ (\17 (
+ýu_£t_t
+),
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+, &)
+
+ )
+
+101 \ 1
+ #CPU_OR
+(
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+) \
+
+102
+ `__CPU_OP_S
+ (\17 (
+ýu_£t_t
+),
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+, |)
+
+ )
+
+103 \ 1
+ #CPU_XOR
+(
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+) \
+
+104
+ `__CPU_OP_S
+ (\17 (
+ýu_£t_t
+),
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+, ^)
+
+ )
+
+105 \ 1
+ #CPU_AND_S
+(
+£tsize
+,
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+) \
+
+106
+ `__CPU_OP_S
+ (
+£tsize
+,
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+, &)
+
+ )
+
+107 \ 1
+ #CPU_OR_S
+(
+£tsize
+,
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+) \
+
+108
+ `__CPU_OP_S
+ (
+£tsize
+,
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+, |)
+
+ )
+
+109 \ 1
+ #CPU_XOR_S
+(
+£tsize
+,
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+) \
+
+110
+ `__CPU_OP_S
+ (
+£tsize
+,
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+, ^)
+
+ )
+
+112 \ 1
+ #CPU_ALLOC_SIZE
+(
+couÁ
+è
+ `__CPU_ALLOC_SIZE
+ (couÁ)
+
+ )
+
+113 \ 1
+ #CPU_ALLOC
+(
+couÁ
+è
+ `__CPU_ALLOC
+ (couÁ)
+
+ )
+
+114 \ 1
+ #CPU_FREE
+(
+ýu£t
+è
+ `__CPU_FREE
+ (ýu£t)
+
+ )
+
+118 \r\12
+ $sched_£\8fff\9a\99y
+ (
+__pid_t
+
+__pid
+,
+size_t
+
+__ýu£tsize
+,
+
+119
+__cڡ
+
+ýu_£t_t
+ *
+__ýu£t
+è
+__THROW
+;
+
+122 \r\12
+ $sched_g\91aff\9a\99y
+ (
+__pid_t
+
+__pid
+,
+size_t
+
+__ýu£tsize
+,
+
+123
+ýu_£t_t
+ *
+__ýu£t
+è
+__THROW
+;
+
+126
+__END_DECLS
+
+
+ @/usr/include/bits/sched.h
+
+22 #iâdeà
+__Ãed_sched·¿m
+
+
+24 #iâdeà
+_SCHED_H
+
+
+30 \ 1
+ #SCHED_OTHER
+ 0
+
+ )
+
+31 \ 1
+ #SCHED_FIFO
+ 1
+
+ )
+
+32 \ 1
+ #SCHED_RR
+ 2
+
+ )
+
+33 #ifdeà
+__USE_GNU
+
+
+34 \ 1
+ #SCHED_BATCH
+ 3
+
+ )
+
+35 \ 1
+ #SCHED_IDLE
+ 5
+
+ )
+
+37 \ 1
+ #SCHED_RESET_ON_FORK
+ 0x40000000
+
+ )
+
+40 #ifdeà
+__USE_GNU
+
+
+42 \ 1
+ #CSIGNAL
+ 0x000000fà
+
+ )
+
+43 \ 1
+ #CLONE_VM
+ 0x00000100
+
+ )
+
+44 \ 1
+ #CLONE_FS
+ 0x00000200
+
+ )
+
+45 \ 1
+ #CLONE_FILES
+ 0x00000400
+
+ )
+
+46 \ 1
+ #CLONE_SIGHAND
+ 0x00000800
+
+ )
+
+47 \ 1
+ #CLONE_PTRACE
+ 0x00002000
+
+ )
+
+48 \ 1
+ #CLONE_VFORK
+ 0x00004000
+
+ )
+
+50 \ 1
+ #CLONE_PARENT
+ 0x00008000
+
+ )
+
+52 \ 1
+ #CLONE_THREAD
+ 0x00010000
+
+ )
+
+53 \ 1
+ #CLONE_NEWNS
+ 0x00020000
+
+ )
+
+54 \ 1
+ #CLONE_SYSVSEM
+ 0x00040000
+
+ )
+
+55 \ 1
+ #CLONE_SETTLS
+ 0x00080000
+
+ )
+
+56 \ 1
+ #CLONE_PARENT_SETTID
+ 0x00100000
+
+ )
+
+58 \ 1
+ #CLONE_CHILD_CLEARTID
+ 0x00200000
+
+ )
+
+60 \ 1
+ #CLONE_DETACHED
+ 0x00400000
+
+ )
+
+61 \ 1
+ #CLONE_UNTRACED
+ 0x00800000
+
+ )
+
+63 \ 1
+ #CLONE_CHILD_SETTID
+ 0x01000000
+
+ )
+
+65 \ 1
+ #CLONE_NEWUTS
+ 0x04000000
+
+ )
+
+66 \ 1
+ #CLONE_NEWIPC
+ 0x08000000
+
+ )
+
+67 \ 1
+ #CLONE_NEWUSER
+ 0x10000000
+
+ )
+
+68 \ 1
+ #CLONE_NEWPID
+ 0x20000000
+
+ )
+
+69 \ 1
+ #CLONE_NEWNET
+ 0x40000000
+
+ )
+
+70 \ 1
+ #CLONE_IO
+ 0x80000000
+
+ )
+
+74 \19
+ ssched_·¿m
+
+
+76 \12
+ m__sched_´iÜ\99y
+;
+
+79
+ g__BEGIN_DECLS
+
+
+81 #ifdeà
+__USE_GNU
+
+
+83 \r\12
+þÚe
+ (\12(*
+__â
+è(\1e*
+__¬g
+), \1e*
+__ch\9ed_¡ack
+,
+
+84 \12
+__æags
+, \1e*
+__¬g
+, ...è
+__THROW
+;
+
+87 \r\12
+ $unsh¬e
+ (\12
+__æags
+è
+__THROW
+;
+
+90 \r\12
+ $sched_g\91ýu
+ (\1eè
+__THROW
+;
+
+93 \r\12
+ $£\8as
+ (\12
+__fd
+, \12
+__n¡y³
+è
+__THROW
+;
+
+97
+__END_DECLS
+
+
+101 #ià!
+def\9aed
+
+__def\9aed_sched·¿m
+ \
+
+102 && (
+def\9aed
+
+__Ãed_sched·¿m
+ || def\9aed
+_SCHED_H
+)
+
+103 \ 1
+ #__def\9aed_sched·¿m
+ 1
+
+ )
+
+105 \19
+ s__sched_·¿m
+
+
+107 \12
+__sched_´iÜ\99y
+;
+
+109 #undeà
+__Ãed_sched·¿m
+
+
+113 #ià
+def\9aed
+
+_SCHED_H
+ && !def\9aed
+__ýu_£t_t_def\9aed
+
+
+114 \ 1
+ #__ýu_£t_t_def\9aed
+
+
+ )
+
+116 \ 1
+ #__CPU_SETSIZE
+ 1024
+
+ )
+
+117 \ 1
+ #__NCPUBITS
+ (8 * \17 (
+__ýu_mask
+))
+
+ )
+
+120 \e\1d\13\12
+ t__ýu_mask
+;
+
+123 \ 1
+ #__CPUELT
+(
+ýu
+è((ýuè/
+__NCPUBITS
+)
+
+ )
+
+124 \ 1
+ #__CPUMASK
+(
+ýu
+è((
+__ýu_mask
+è1 << ((ýuè%
+__NCPUBITS
+))
+
+ )
+
+129
+__ýu_mask
+
+__b\99s
+[
+__CPU_SETSIZE
+ /
+__NCPUBITS
+];
+
+130 }
+ týu_£t_t
+;
+
+133 #ià
+ `__GNUC_PREREQ
+ (2, 91)
+
+134 \ 1
+ #__CPU_ZERO_S
+(
+£tsize
+,
+ýu£\8d
+) \
+
+135 dØ
+ `__bu\9et\9a_mem£t
+ (
+ýu£\8d
+, '\0',
+£tsize
+); \1f0)
+
+ )
+
+137 \ 1
+ #__CPU_ZERO_S
+(
+£tsize
+,
+ýu£\8d
+) \
+
+139
+size_t
+
+__i
+; \
+
+140
+size_t
+
+__imax
+ = (
+£tsize
+è/ \17 (
+__ýu_mask
+); \
+
+141
+__ýu_mask
+ *
+__b\99s
+ = (
+ýu£\8d
+)->__bits; \
+
+142 \ f
+__i
+ = 0; __\98<
+__imax
+; ++__i) \
+
+143
+__b\99s
+[
+__i
+] = 0; \
+
+144
+ }
+} \1f0)
+
+ )
+
+146 \ 1
+ #__CPU_SET_S
+(
+ýu
+,
+£tsize
+,
+ýu£\8d
+) \
+
+147 (
+__ex\8bnsiÚ__
+ \
+
+148 ({
+size_t
+
+__ýu
+ = (
+ýu
+); \
+
+149
+__ýu
+ < 8 * (
+£tsize
+) \
+
+150 ? (((
+__ýu_mask
+ *è((
+ýu£\8d
+)->
+__b\99s
+))[
+ `__CPUELT
+ (
+__ýu
+)] \
+
+151 |ð
+ `__CPUMASK
+ (
+__ýu
+)) \
+
+152 : 0; }))
+
+ )
+
+153 \ 1
+ #__CPU_CLR_S
+(
+ýu
+,
+£tsize
+,
+ýu£\8d
+) \
+
+154 (
+__ex\8bnsiÚ__
+ \
+
+155 ({
+size_t
+
+__ýu
+ = (
+ýu
+); \
+
+156
+__ýu
+ < 8 * (
+£tsize
+) \
+
+157 ? (((
+__ýu_mask
+ *è((
+ýu£\8d
+)->
+__b\99s
+))[
+ `__CPUELT
+ (
+__ýu
+)] \
+
+158 &ð~
+ `__CPUMASK
+ (
+__ýu
+)) \
+
+159 : 0; }))
+
+ )
+
+160 \ 1
+ #__CPU_ISSET_S
+(
+ýu
+,
+£tsize
+,
+ýu£\8d
+) \
+
+161 (
+__ex\8bnsiÚ__
+ \
+
+162 ({
+size_t
+
+__ýu
+ = (
+ýu
+); \
+
+163
+__ýu
+ < 8 * (
+£tsize
+) \
+
+164 ? ((((
+__cڡ
+
+__ýu_mask
+ *è((
+ýu£\8d
+)->
+__b\99s
+))[
+ `__CPUELT
+ (
+__ýu
+)] \
+
+165 &
+ `__CPUMASK
+ (
+__ýu
+))) != 0 \
+
+166 : 0; }))
+
+ )
+
+168 \ 1
+ #__CPU_COUNT_S
+(
+£tsize
+,
+ýu£\8d
+) \
+
+169
+ `__sched_ýucouÁ
+ (
+£tsize
+,
+ýu£\8d
+)
+
+ )
+
+171 #ià
+__GNUC_PREREQ
+ (2, 91)
+
+172 \ 1
+ #__CPU_EQUAL_S
+(
+£tsize
+,
+ýu£\8d1
+,
+ýu£\8d2
+) \
+
+173 (
+ `__bu\9et\9a_memcmp
+ (
+ýu£\8d1
+,
+ýu£\8d2
+,
+£tsize
+è=ð0)
+
+ )
+
+175 \ 1
+ #__CPU_EQUAL_S
+(
+£tsize
+,
+ýu£\8d1
+,
+ýu£\8d2
+) \
+
+176 (
+__ex\8bnsiÚ__
+ \
+
+177 ({
+__cڡ
+
+__ýu_mask
+ *
+__¬r1
+ = (
+ýu£\8d1
+)->
+__b\99s
+; \
+
+178
+__cڡ
+
+__ýu_mask
+ *
+__¬r2
+ = (
+ýu£\8d2
+)->
+__b\99s
+; \
+
+179
+size_t
+
+__imax
+ = (
+£tsize
+è/ \17 (
+__ýu_mask
+); \
+
+180
+size_t
+
+__i
+; \
+
+181 \ f
+__i
+ = 0; __\98<
+__imax
+; ++__i) \
+
+182 ià(
+__¬r1
+[
+__i
+] !ð
+__¬r2
+[__i]) \
+
+184
+__i
+ =ð
+__imax
+; }))
+
+ )
+
+187 \ 1
+ #__CPU_OP_S
+(
+£tsize
+,
+de¡£t
+,
+¤c£t1
+,
+¤c£t2
+,
+Ý
+) \
+
+188 (
+__ex\8bnsiÚ__
+ \
+
+189 ({
+ýu_£t_t
+ *
+__de¡
+ = (
+de¡£t
+); \
+
+190
+__cڡ
+
+__ýu_mask
+ *
+__¬r1
+ = (
+¤c£t1
+)->
+__b\99s
+; \
+
+191
+__cڡ
+
+__ýu_mask
+ *
+__¬r2
+ = (
+¤c£t2
+)->
+__b\99s
+; \
+
+192
+size_t
+
+__imax
+ = (
+£tsize
+è/ \17 (
+__ýu_mask
+); \
+
+193
+size_t
+
+__i
+; \
+
+194 \ f
+__i
+ = 0; __\98<
+__imax
+; ++__i) \
+
+195 ((
+__ýu_mask
+ *è
+__de¡
+->
+__b\99s
+)[
+__i
+] =
+__¬r1
+[__i]
+Ý
+
+__¬r2
+[__i]; \
+
+196
+__de¡
+; }))
+
+ )
+
+198 \ 1
+ #__CPU_ALLOC_SIZE
+(
+couÁ
+) \
+
+199 ((((
+couÁ
+è+
+__NCPUBITS
+ - 1è/ __NCPUBITSè* \17 (
+__ýu_mask
+))
+
+ )
+
+200 \ 1
+ #__CPU_ALLOC
+(
+couÁ
+è
+ `__sched_ýu®loc
+ (couÁ)
+
+ )
+
+201 \ 1
+ #__CPU_FREE
+(
+ýu£t
+è
+ `__sched_ýuä\93
+ (ýu£t)
+
+ )
+
+203
+__BEGIN_DECLS
+
+
+205 \r\12
+ $__sched_ýucouÁ
+ (
+size_t
+
+__£tsize
+, cڡ
+ýu_£t_t
+ *
+__£\8d
+)
+
+206
+__THROW
+;
+
+207 \r
+ýu_£t_t
+ *
+ $__sched_ýu®loc
+ (
+size_t
+
+__couÁ
+è
+__THROW
+
+__wur
+;
+
+208 \r\1e
+ $__sched_ýuä\93
+ (
+ýu_£t_t
+ *
+__£t
+è
+__THROW
+;
+
+210
+__END_DECLS
+
+
+ @/usr/include/linux/errno.h
+
+1 #iâdeà
+_LINUX_ERRNO_H
+
+
+2 \ 1
+ #_LINUX_ERRNO_H
+
+
+ )
+
+4 \ 2
+ ~<asm/\94ºo.h
+>
+
+ @/usr/include/asm/errno.h
+
+1 \ 2
+ ~<asm-g\92\94ic/\94ºo.h
+>
+
+ @/usr/include/asm-generic/errno.h
+
+1 #iâdeà
+_ASM_GENERIC_ERRNO_H
+
+
+2 \ 1
+ #_ASM_GENERIC_ERRNO_H
+
+
+ )
+
+4 \ 2
+ ~<asm-g\92\94ic/\94ºo-ba£.h
+>
+
+6 \ 1
+ #EDEADLK
+ 35
+
+ )
+
+7 \ 1
+ #ENAMETOOLONG
+ 36
+
+ )
+
+8 \ 1
+ #ENOLCK
+ 37
+
+ )
+
+9 \ 1
+ #ENOSYS
+ 38
+
+ )
+
+10 \ 1
+ #ENOTEMPTY
+ 39
+
+ )
+
+11 \ 1
+ #ELOOP
+ 40
+
+ )
+
+12 \ 1
+ #EWOULDBLOCK
+
+EAGAIN
+
+
+ )
+
+13 \ 1
+ #ENOMSG
+ 42
+
+ )
+
+14 \ 1
+ #EIDRM
+ 43
+
+ )
+
+15 \ 1
+ #ECHRNG
+ 44
+
+ )
+
+16 \ 1
+ #EL2NSYNC
+ 45
+
+ )
+
+17 \ 1
+ #EL3HLT
+ 46
+
+ )
+
+18 \ 1
+ #EL3RST
+ 47
+
+ )
+
+19 \ 1
+ #ELNRNG
+ 48
+
+ )
+
+20 \ 1
+ #EUNATCH
+ 49
+
+ )
+
+21 \ 1
+ #ENOCSI
+ 50
+
+ )
+
+22 \ 1
+ #EL2HLT
+ 51
+
+ )
+
+23 \ 1
+ #EBADE
+ 52
+
+ )
+
+24 \ 1
+ #EBADR
+ 53
+
+ )
+
+25 \ 1
+ #EXFULL
+ 54
+
+ )
+
+26 \ 1
+ #ENOANO
+ 55
+
+ )
+
+27 \ 1
+ #EBADRQC
+ 56
+
+ )
+
+28 \ 1
+ #EBADSLT
+ 57
+
+ )
+
+30 \ 1
+ #EDEADLOCK
+
+EDEADLK
+
+
+ )
+
+32 \ 1
+ #EBFONT
+ 59
+
+ )
+
+33 \ 1
+ #ENOSTR
+ 60
+
+ )
+
+34 \ 1
+ #ENODATA
+ 61
+
+ )
+
+35 \ 1
+ #ETIME
+ 62
+
+ )
+
+36 \ 1
+ #ENOSR
+ 63
+
+ )
+
+37 \ 1
+ #ENONET
+ 64
+
+ )
+
+38 \ 1
+ #ENOPKG
+ 65
+
+ )
+
+39 \ 1
+ #EREMOTE
+ 66
+
+ )
+
+40 \ 1
+ #ENOLINK
+ 67
+
+ )
+
+41 \ 1
+ #EADV
+ 68
+
+ )
+
+42 \ 1
+ #ESRMNT
+ 69
+
+ )
+
+43 \ 1
+ #ECOMM
+ 70
+
+ )
+
+44 \ 1
+ #EPROTO
+ 71
+
+ )
+
+45 \ 1
+ #EMULTIHOP
+ 72
+
+ )
+
+46 \ 1
+ #EDOTDOT
+ 73
+
+ )
+
+47 \ 1
+ #EBADMSG
+ 74
+
+ )
+
+48 \ 1
+ #EOVERFLOW
+ 75
+
+ )
+
+49 \ 1
+ #ENOTUNIQ
+ 76
+
+ )
+
+50 \ 1
+ #EBADFD
+ 77
+
+ )
+
+51 \ 1
+ #EREMCHG
+ 78
+
+ )
+
+52 \ 1
+ #ELIBACC
+ 79
+
+ )
+
+53 \ 1
+ #ELIBBAD
+ 80
+
+ )
+
+54 \ 1
+ #ELIBSCN
+ 81
+
+ )
+
+55 \ 1
+ #ELIBMAX
+ 82
+
+ )
+
+56 \ 1
+ #ELIBEXEC
+ 83
+
+ )
+
+57 \ 1
+ #EILSEQ
+ 84
+
+ )
+
+58 \ 1
+ #ERESTART
+ 85
+
+ )
+
+59 \ 1
+ #ESTRPIPE
+ 86
+
+ )
+
+60 \ 1
+ #EUSERS
+ 87
+
+ )
+
+61 \ 1
+ #ENOTSOCK
+ 88
+
+ )
+
+62 \ 1
+ #EDESTADDRREQ
+ 89
+
+ )
+
+63 \ 1
+ #EMSGSIZE
+ 90
+
+ )
+
+64 \ 1
+ #EPROTOTYPE
+ 91
+
+ )
+
+65 \ 1
+ #ENOPROTOOPT
+ 92
+
+ )
+
+66 \ 1
+ #EPROTONOSUPPORT
+ 93
+
+ )
+
+67 \ 1
+ #ESOCKTNOSUPPORT
+ 94
+
+ )
+
+68 \ 1
+ #EOPNOTSUPP
+ 95
+
+ )
+
+69 \ 1
+ #EPFNOSUPPORT
+ 96
+
+ )
+
+70 \ 1
+ #EAFNOSUPPORT
+ 97
+
+ )
+
+71 \ 1
+ #EADDRINUSE
+ 98
+
+ )
+
+72 \ 1
+ #EADDRNOTAVAIL
+ 99
+
+ )
+
+73 \ 1
+ #ENETDOWN
+ 100
+
+ )
+
+74 \ 1
+ #ENETUNREACH
+ 101
+
+ )
+
+75 \ 1
+ #ENETRESET
+ 102
+
+ )
+
+76 \ 1
+ #ECONNABORTED
+ 103
+
+ )
+
+77 \ 1
+ #ECONNRESET
+ 104
+
+ )
+
+78 \ 1
+ #ENOBUFS
+ 105
+
+ )
+
+79 \ 1
+ #EISCONN
+ 106
+
+ )
+
+80 \ 1
+ #ENOTCONN
+ 107
+
+ )
+
+81 \ 1
+ #ESHUTDOWN
+ 108
+
+ )
+
+82 \ 1
+ #ETOOMANYREFS
+ 109
+
+ )
+
+83 \ 1
+ #ETIMEDOUT
+ 110
+
+ )
+
+84 \ 1
+ #ECONNREFUSED
+ 111
+
+ )
+
+85 \ 1
+ #EHOSTDOWN
+ 112
+
+ )
+
+86 \ 1
+ #EHOSTUNREACH
+ 113
+
+ )
+
+87 \ 1
+ #EALREADY
+ 114
+
+ )
+
+88 \ 1
+ #EINPROGRESS
+ 115
+
+ )
+
+89 \ 1
+ #ESTALE
+ 116
+
+ )
+
+90 \ 1
+ #EUCLEAN
+ 117
+
+ )
+
+91 \ 1
+ #ENOTNAM
+ 118
+
+ )
+
+92 \ 1
+ #ENAVAIL
+ 119
+
+ )
+
+93 \ 1
+ #EISNAM
+ 120
+
+ )
+
+94 \ 1
+ #EREMOTEIO
+ 121
+
+ )
+
+95 \ 1
+ #EDQUOT
+ 122
+
+ )
+
+97 \ 1
+ #ENOMEDIUM
+ 123
+
+ )
+
+98 \ 1
+ #EMEDIUMTYPE
+ 124
+
+ )
+
+99 \ 1
+ #ECANCELED
+ 125
+
+ )
+
+100 \ 1
+ #ENOKEY
+ 126
+
+ )
+
+101 \ 1
+ #EKEYEXPIRED
+ 127
+
+ )
+
+102 \ 1
+ #EKEYREVOKED
+ 128
+
+ )
+
+103 \ 1
+ #EKEYREJECTED
+ 129
+
+ )
+
+106 \ 1
+ #EOWNERDEAD
+ 130
+
+ )
+
+107 \ 1
+ #ENOTRECOVERABLE
+ 131
+
+ )
+
+109 \ 1
+ #ERFKILL
+ 132
+
+ )
+
+111 \ 1
+ #EHWPOISON
+ 133
+
+ )
+
+ @/usr/include/asm-generic/errno-base.h
+
+1 #iâdeà
+_ASM_GENERIC_ERRNO_BASE_H
+
+
+2 \ 1
+ #_ASM_GENERIC_ERRNO_BASE_H
+
+
+ )
+
+4 \ 1
+ #EPERM
+ 1
+
+ )
+
+5 \ 1
+ #ENOENT
+ 2
+
+ )
+
+6 \ 1
+ #ESRCH
+ 3
+
+ )
+
+7 \ 1
+ #EINTR
+ 4
+
+ )
+
+8 \ 1
+ #EIO
+ 5
+
+ )
+
+9 \ 1
+ #ENXIO
+ 6
+
+ )
+
+10 \ 1
+ #E2BIG
+ 7
+
+ )
+
+11 \ 1
+ #ENOEXEC
+ 8
+
+ )
+
+12 \ 1
+ #EBADF
+ 9
+
+ )
+
+13 \ 1
+ #ECHILD
+ 10
+
+ )
+
+14 \ 1
+ #EAGAIN
+ 11
+
+ )
+
+15 \ 1
+ #ENOMEM
+ 12
+
+ )
+
+16 \ 1
+ #EACCES
+ 13
+
+ )
+
+17 \ 1
+ #EFAULT
+ 14
+
+ )
+
+18 \ 1
+ #ENOTBLK
+ 15
+
+ )
+
+19 \ 1
+ #EBUSY
+ 16
+
+ )
+
+20 \ 1
+ #EEXIST
+ 17
+
+ )
+
+21 \ 1
+ #EXDEV
+ 18
+
+ )
+
+22 \ 1
+ #ENODEV
+ 19
+
+ )
+
+23 \ 1
+ #ENOTDIR
+ 20
+
+ )
+
+24 \ 1
+ #EISDIR
+ 21
+
+ )
+
+25 \ 1
+ #EINVAL
+ 22
+
+ )
+
+26 \ 1
+ #ENFILE
+ 23
+
+ )
+
+27 \ 1
+ #EMFILE
+ 24
+
+ )
+
+28 \ 1
+ #ENOTTY
+ 25
+
+ )
+
+29 \ 1
+ #ETXTBSY
+ 26
+
+ )
+
+30 \ 1
+ #EFBIG
+ 27
+
+ )
+
+31 \ 1
+ #ENOSPC
+ 28
+
+ )
+
+32 \ 1
+ #ESPIPE
+ 29
+
+ )
+
+33 \ 1
+ #EROFS
+ 30
+
+ )
+
+34 \ 1
+ #EMLINK
+ 31
+
+ )
+
+35 \ 1
+ #EPIPE
+ 32
+
+ )
+
+36 \ 1
+ #EDOM
+ 33
+
+ )
+
+37 \ 1
+ #ERANGE
+ 34
+
+ )
+
+ @
+1
+.
+1
+/usr/include
+100
+2434
+assembler-ppc-inl.h
+assembler-ppc.cc
+assembler-ppc.h
+builtins-ppc.cc
+code-stubs-ppc.cc
+code-stubs-ppc.h
+codegen-ppc.cc
+codegen-ppc.h
+constants-ppc.cc
+constants-ppc.h
+cpu-ppc.cc
+debug-ppc.cc
+deoptimizer-ppc.cc
+disasm-ppc.cc
+frames-ppc.cc
+frames-ppc.h
+full-codegen-ppc.cc
+interface-descriptors-ppc.cc
+lithium-codegen-ppc.cc
+lithium-codegen-ppc.h
+lithium-gap-resolver-ppc.cc
+lithium-gap-resolver-ppc.h
+lithium-ppc.cc
+lithium-ppc.h
+macro-assembler-ppc.cc
+macro-assembler-ppc.h
+regexp-macro-assembler-ppc.cc
+regexp-macro-assembler-ppc.h
+simulator-ppc.cc
+simulator-ppc.h
+/usr/include/assert.h
+/usr/include/limits.h
+/usr/include/stdio.h
+/usr/include/stdlib.h
+/usr/include/string.h
+/usr/include/alloca.h
+/usr/include/bits/posix1_lim.h
+/usr/include/bits/posix2_lim.h
+/usr/include/bits/stdio-ldbl.h
+/usr/include/bits/stdio.h
+/usr/include/bits/stdio2.h
+/usr/include/bits/stdio_lim.h
+/usr/include/bits/stdlib-ldbl.h
+/usr/include/bits/stdlib.h
+/usr/include/bits/string.h
+/usr/include/bits/string2.h
+/usr/include/bits/string3.h
+/usr/include/bits/sys_errlist.h
+/usr/include/bits/types.h
+/usr/include/bits/waitflags.h
+/usr/include/bits/waitstatus.h
+/usr/include/bits/wordsize.h
+/usr/include/bits/xopen_lim.h
+/usr/include/features.h
+/usr/include/getopt.h
+/usr/include/libio.h
+/usr/include/sys/types.h
+/usr/include/xlocale.h
+/usr/include/_G_config.h
+/usr/include/bits/libio-ldbl.h
+/usr/include/bits/local_lim.h
+/usr/include/bits/predefs.h
+/usr/include/bits/pthreadtypes.h
+/usr/include/bits/stdio-lock.h
+/usr/include/bits/typesizes.h
+/usr/include/ctype.h
+/usr/include/endian.h
+/usr/include/gnu/stubs.h
+/usr/include/sys/cdefs.h
+/usr/include/sys/select.h
+/usr/include/sys/sysmacros.h
+/usr/include/time.h
+/usr/include/bits/byteswap.h
+/usr/include/bits/endian.h
+/usr/include/bits/libc-lock.h
+/usr/include/bits/select.h
+/usr/include/bits/select2.h
+/usr/include/bits/sigset.h
+/usr/include/bits/time.h
+/usr/include/gconv.h
+/usr/include/gnu/stubs-32.h
+/usr/include/gnu/stubs-64.h
+/usr/include/linux/limits.h
+/usr/include/wchar.h
+/usr/include/bits/timex.h
+/usr/include/bits/wchar-ldbl.h
+/usr/include/bits/wchar.h
+/usr/include/bits/wchar2.h
+/usr/include/errno.h
+/usr/include/gnu/option-groups.h
+/usr/include/pthread.h
+/usr/include/wctype.h
+/usr/include/bits/errno.h
+/usr/include/bits/setjmp.h
+/usr/include/sched.h
+/usr/include/bits/sched.h
+/usr/include/linux/errno.h
+/usr/include/asm/errno.h
+/usr/include/asm-generic/errno.h
+/usr/include/asm-generic/errno-base.h
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/codegen.h"
+#include "src/debug.h"
+
+namespace v8 {
+namespace internal {
+
+bool BreakLocationIterator::IsDebugBreakAtReturn() {
+ return Debug::IsDebugBreakAtReturn(rinfo());
+}
+
+
+void BreakLocationIterator::SetDebugBreakAtReturn() {
+ // Patch the code changing the return from JS function sequence from
+ //
+ // LeaveFrame
+ // blr
+ //
+ // to a call to the debug break return code.
+ // this uses a FIXED_SEQUENCE to load an address constant
+ //
+ // mov r0, <address>
+ // mtlr r0
+ // blrl
+ // bkpt
+ //
+ CodePatcher patcher(rinfo()->pc(), Assembler::kJSReturnSequenceInstructions);
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(patcher.masm());
+ patcher.masm()->mov(
+ v8::internal::r0,
+ Operand(reinterpret_cast<intptr_t>(debug_info_->GetIsolate()
+ ->builtins()
+ ->Return_DebugBreak()
+ ->entry())));
+ patcher.masm()->mtctr(v8::internal::r0);
+ patcher.masm()->bctrl();
+ patcher.masm()->bkpt(0);
+}
+
+
+// Restore the JS frame exit code.
+void BreakLocationIterator::ClearDebugBreakAtReturn() {
+ rinfo()->PatchCode(original_rinfo()->pc(),
+ Assembler::kJSReturnSequenceInstructions);
+}
+
+
+// A debug break in the frame exit code is identified by the JS frame exit code
+// having been patched with a call instruction.
+bool Debug::IsDebugBreakAtReturn(RelocInfo* rinfo) {
+ DCHECK(RelocInfo::IsJSReturn(rinfo->rmode()));
+ return rinfo->IsPatchedReturnSequence();
+}
+
+
+bool BreakLocationIterator::IsDebugBreakAtSlot() {
+ DCHECK(IsDebugBreakSlot());
+ // Check whether the debug break slot instructions have been patched.
+ return rinfo()->IsPatchedDebugBreakSlotSequence();
+}
+
+
+void BreakLocationIterator::SetDebugBreakAtSlot() {
+ DCHECK(IsDebugBreakSlot());
+ // Patch the code changing the debug break slot code from
+ //
+ // ori r3, r3, 0
+ // ori r3, r3, 0
+ // ori r3, r3, 0
+ // ori r3, r3, 0
+ // ori r3, r3, 0
+ //
+ // to a call to the debug break code, using a FIXED_SEQUENCE.
+ //
+ // mov r0, <address>
+ // mtlr r0
+ // blrl
+ //
+ CodePatcher patcher(rinfo()->pc(), Assembler::kDebugBreakSlotInstructions);
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(patcher.masm());
+ patcher.masm()->mov(
+ v8::internal::r0,
+ Operand(reinterpret_cast<intptr_t>(
+ debug_info_->GetIsolate()->builtins()->Slot_DebugBreak()->entry())));
+ patcher.masm()->mtctr(v8::internal::r0);
+ patcher.masm()->bctrl();
+}
+
+
+void BreakLocationIterator::ClearDebugBreakAtSlot() {
+ DCHECK(IsDebugBreakSlot());
+ rinfo()->PatchCode(original_rinfo()->pc(),
+ Assembler::kDebugBreakSlotInstructions);
+}
+
+
+#define __ ACCESS_MASM(masm)
+
+
+static void Generate_DebugBreakCallHelper(MacroAssembler* masm,
+ RegList object_regs,
+ RegList non_object_regs) {
+ {
+ FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+
+ // Load padding words on stack.
+ __ LoadSmiLiteral(ip, Smi::FromInt(LiveEdit::kFramePaddingValue));
+ for (int i = 0; i < LiveEdit::kFramePaddingInitialSize; i++) {
+ __ push(ip);
+ }
+ __ LoadSmiLiteral(ip, Smi::FromInt(LiveEdit::kFramePaddingInitialSize));
+ __ push(ip);
+
+ // Store the registers containing live values on the expression stack to
+ // make sure that these are correctly updated during GC. Non object values
+ // are stored as a smi causing it to be untouched by GC.
+ DCHECK((object_regs & ~kJSCallerSaved) == 0);
+ DCHECK((non_object_regs & ~kJSCallerSaved) == 0);
+ DCHECK((object_regs & non_object_regs) == 0);
+ if ((object_regs | non_object_regs) != 0) {
+ for (int i = 0; i < kNumJSCallerSaved; i++) {
+ int r = JSCallerSavedCode(i);
+ Register reg = {r};
+ if ((non_object_regs & (1 << r)) != 0) {
+ if (FLAG_debug_code) {
+ __ TestUnsignedSmiCandidate(reg, r0);
+ __ Assert(eq, kUnableToEncodeValueAsSmi, cr0);
+ }
+ __ SmiTag(reg);
+ }
+ }
+ __ MultiPush(object_regs | non_object_regs);
+ }
+
+#ifdef DEBUG
+ __ RecordComment("// Calling from debug break to runtime - come in - over");
+#endif
+ __ mov(r3, Operand::Zero()); // no arguments
+ __ mov(r4, Operand(ExternalReference::debug_break(masm->isolate())));
+
+ CEntryStub ceb(masm->isolate(), 1);
+ __ CallStub(&ceb);
+
+ // Restore the register values from the expression stack.
+ if ((object_regs | non_object_regs) != 0) {
+ __ MultiPop(object_regs | non_object_regs);
+ for (int i = 0; i < kNumJSCallerSaved; i++) {
+ int r = JSCallerSavedCode(i);
+ Register reg = {r};
+ if ((non_object_regs & (1 << r)) != 0) {
+ __ SmiUntag(reg);
+ }
+ if (FLAG_debug_code &&
+ (((object_regs | non_object_regs) & (1 << r)) == 0)) {
+ __ mov(reg, Operand(kDebugZapValue));
+ }
+ }
+ }
+
+ // Don't bother removing padding bytes pushed on the stack
+ // as the frame is going to be restored right away.
+
+ // Leave the internal frame.
+ }
+
+ // Now that the break point has been handled, resume normal execution by
+ // jumping to the target address intended by the caller and that was
+ // overwritten by the address of DebugBreakXXX.
+ ExternalReference after_break_target =
+ ExternalReference::debug_after_break_target_address(masm->isolate());
+ __ mov(ip, Operand(after_break_target));
+ __ LoadP(ip, MemOperand(ip));
+ __ JumpToJSEntry(ip);
+}
+
+
+void DebugCodegen::GenerateCallICStubDebugBreak(MacroAssembler* masm) {
+ // Register state for CallICStub
+ // ----------- S t a t e -------------
+ // -- r4 : function
+ // -- r6 : slot in feedback array (smi)
+ // -----------------------------------
+ Generate_DebugBreakCallHelper(masm, r4.bit() | r6.bit(), 0);
+}
+
+
+void DebugCodegen::GenerateLoadICDebugBreak(MacroAssembler* masm) {
+ // Calling convention for IC load (from ic-ppc.cc).
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ Register name = LoadDescriptor::NameRegister();
+ RegList regs = receiver.bit() | name.bit();
+ if (FLAG_vector_ics) {
+ regs |= VectorLoadICTrampolineDescriptor::SlotRegister().bit();
+ }
+ Generate_DebugBreakCallHelper(masm, regs, 0);
+}
+
+
+void DebugCodegen::GenerateStoreICDebugBreak(MacroAssembler* masm) {
+ // Calling convention for IC store (from ic-ppc.cc).
+ Register receiver = StoreDescriptor::ReceiverRegister();
+ Register name = StoreDescriptor::NameRegister();
+ Register value = StoreDescriptor::ValueRegister();
+ Generate_DebugBreakCallHelper(masm, receiver.bit() | name.bit() | value.bit(),
+ 0);
+}
+
+
+void DebugCodegen::GenerateKeyedLoadICDebugBreak(MacroAssembler* masm) {
+ // Calling convention for keyed IC load (from ic-ppc.cc).
+ GenerateLoadICDebugBreak(masm);
+}
+
+
+void DebugCodegen::GenerateKeyedStoreICDebugBreak(MacroAssembler* masm) {
+ // Calling convention for IC keyed store call (from ic-ppc.cc).
+ Register receiver = StoreDescriptor::ReceiverRegister();
+ Register name = StoreDescriptor::NameRegister();
+ Register value = StoreDescriptor::ValueRegister();
+ Generate_DebugBreakCallHelper(masm, receiver.bit() | name.bit() | value.bit(),
+ 0);
+}
+
+
+void DebugCodegen::GenerateCompareNilICDebugBreak(MacroAssembler* masm) {
+ // Register state for CompareNil IC
+ // ----------- S t a t e -------------
+ // -- r3 : value
+ // -----------------------------------
+ Generate_DebugBreakCallHelper(masm, r3.bit(), 0);
+}
+
+
+void DebugCodegen::GenerateReturnDebugBreak(MacroAssembler* masm) {
+ // In places other than IC call sites it is expected that r3 is TOS which
+ // is an object - this is not generally the case so this should be used with
+ // care.
+ Generate_DebugBreakCallHelper(masm, r3.bit(), 0);
+}
+
+
+void DebugCodegen::GenerateCallFunctionStubDebugBreak(MacroAssembler* masm) {
+ // Register state for CallFunctionStub (from code-stubs-ppc.cc).
+ // ----------- S t a t e -------------
+ // -- r4 : function
+ // -----------------------------------
+ Generate_DebugBreakCallHelper(masm, r4.bit(), 0);
+}
+
+
+void DebugCodegen::GenerateCallConstructStubDebugBreak(MacroAssembler* masm) {
+ // Calling convention for CallConstructStub (from code-stubs-ppc.cc)
+ // ----------- S t a t e -------------
+ // -- r3 : number of arguments (not smi)
+ // -- r4 : constructor function
+ // -----------------------------------
+ Generate_DebugBreakCallHelper(masm, r4.bit(), r3.bit());
+}
+
+
+void DebugCodegen::GenerateCallConstructStubRecordDebugBreak(
+ MacroAssembler* masm) {
+ // Calling convention for CallConstructStub (from code-stubs-ppc.cc)
+ // ----------- S t a t e -------------
+ // -- r3 : number of arguments (not smi)
+ // -- r4 : constructor function
+ // -- r5 : feedback array
+ // -- r6 : feedback slot (smi)
+ // -----------------------------------
+ Generate_DebugBreakCallHelper(masm, r4.bit() | r5.bit() | r6.bit(), r3.bit());
+}
+
+
+void DebugCodegen::GenerateSlot(MacroAssembler* masm) {
+ // Generate enough nop's to make space for a call instruction. Avoid emitting
+ // the trampoline pool in the debug break slot code.
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm);
+ Label check_codesize;
+ __ bind(&check_codesize);
+ __ RecordDebugBreakSlot();
+ for (int i = 0; i < Assembler::kDebugBreakSlotInstructions; i++) {
+ __ nop(MacroAssembler::DEBUG_BREAK_NOP);
+ }
+ DCHECK_EQ(Assembler::kDebugBreakSlotInstructions,
+ masm->InstructionsGeneratedSince(&check_codesize));
+}
+
+
+void DebugCodegen::GenerateSlotDebugBreak(MacroAssembler* masm) {
+ // In the places where a debug break slot is inserted no registers can contain
+ // object pointers.
+ Generate_DebugBreakCallHelper(masm, 0, 0);
+}
+
+
+void DebugCodegen::GeneratePlainReturnLiveEdit(MacroAssembler* masm) {
+ __ Ret();
+}
+
+
+void DebugCodegen::GenerateFrameDropperLiveEdit(MacroAssembler* masm) {
+ ExternalReference restarter_frame_function_slot =
+ ExternalReference::debug_restarter_frame_function_pointer_address(
+ masm->isolate());
+ __ mov(ip, Operand(restarter_frame_function_slot));
+ __ li(r4, Operand::Zero());
+ __ StoreP(r4, MemOperand(ip, 0));
+
+ // Load the function pointer off of our current stack frame.
+ __ LoadP(r4, MemOperand(fp, StandardFrameConstants::kConstantPoolOffset -
+ kPointerSize));
+
+ // Pop return address, frame and constant pool pointer (if
+ // FLAG_enable_ool_constant_pool).
+ __ LeaveFrame(StackFrame::INTERNAL);
+
+ // Load context from the function.
+ __ LoadP(cp, FieldMemOperand(r4, JSFunction::kContextOffset));
+
+ // Get function code.
+ __ LoadP(ip, FieldMemOperand(r4, JSFunction::kSharedFunctionInfoOffset));
+ __ LoadP(ip, FieldMemOperand(ip, SharedFunctionInfo::kCodeOffset));
+ __ addi(ip, ip, Operand(Code::kHeaderSize - kHeapObjectTag));
+
+ // Re-run JSFunction, r4 is function, cp is context.
+ __ Jump(ip);
+}
+
+
+const bool LiveEdit::kFrameDropperSupported = true;
+
+#undef __
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#include "src/codegen.h"
+#include "src/deoptimizer.h"
+#include "src/full-codegen.h"
+#include "src/safepoint-table.h"
+
+namespace v8 {
+namespace internal {
+
+const int Deoptimizer::table_entry_size_ = 8;
+
+
+int Deoptimizer::patch_size() {
+#if V8_TARGET_ARCH_PPC64
+ const int kCallInstructionSizeInWords = 7;
+#else
+ const int kCallInstructionSizeInWords = 4;
+#endif
+ return kCallInstructionSizeInWords * Assembler::kInstrSize;
+}
+
+
+void Deoptimizer::PatchCodeForDeoptimization(Isolate* isolate, Code* code) {
+ Address code_start_address = code->instruction_start();
+
+ // Invalidate the relocation information, as it will become invalid by the
+ // code patching below, and is not needed any more.
+ code->InvalidateRelocation();
+
+ if (FLAG_zap_code_space) {
+ // Fail hard and early if we enter this code object again.
+ byte* pointer = code->FindCodeAgeSequence();
+ if (pointer != NULL) {
+ pointer += kNoCodeAgeSequenceLength;
+ } else {
+ pointer = code->instruction_start();
+ }
+ CodePatcher patcher(pointer, 1);
+ patcher.masm()->bkpt(0);
+
+ DeoptimizationInputData* data =
+ DeoptimizationInputData::cast(code->deoptimization_data());
+ int osr_offset = data->OsrPcOffset()->value();
+ if (osr_offset > 0) {
+ CodePatcher osr_patcher(code->instruction_start() + osr_offset, 1);
+ osr_patcher.masm()->bkpt(0);
+ }
+ }
+
+ DeoptimizationInputData* deopt_data =
+ DeoptimizationInputData::cast(code->deoptimization_data());
+#ifdef DEBUG
+ Address prev_call_address = NULL;
+#endif
+ // For each LLazyBailout instruction insert a call to the corresponding
+ // deoptimization entry.
+ for (int i = 0; i < deopt_data->DeoptCount(); i++) {
+ if (deopt_data->Pc(i)->value() == -1) continue;
+ Address call_address = code_start_address + deopt_data->Pc(i)->value();
+ Address deopt_entry = GetDeoptimizationEntry(isolate, i, LAZY);
+ // We need calls to have a predictable size in the unoptimized code, but
+ // this is optimized code, so we don't have to have a predictable size.
+ int call_size_in_bytes = MacroAssembler::CallSizeNotPredictableCodeSize(
+ deopt_entry, kRelocInfo_NONEPTR);
+ int call_size_in_words = call_size_in_bytes / Assembler::kInstrSize;
+ DCHECK(call_size_in_bytes % Assembler::kInstrSize == 0);
+ DCHECK(call_size_in_bytes <= patch_size());
+ CodePatcher patcher(call_address, call_size_in_words);
+ patcher.masm()->Call(deopt_entry, kRelocInfo_NONEPTR);
+ DCHECK(prev_call_address == NULL ||
+ call_address >= prev_call_address + patch_size());
+ DCHECK(call_address + patch_size() <= code->instruction_end());
+#ifdef DEBUG
+ prev_call_address = call_address;
+#endif
+ }
+}
+
+
+void Deoptimizer::FillInputFrame(Address tos, JavaScriptFrame* frame) {
+ // Set the register values. The values are not important as there are no
+ // callee saved registers in JavaScript frames, so all registers are
+ // spilled. Registers fp and sp are set to the correct values though.
+
+ for (int i = 0; i < Register::kNumRegisters; i++) {
+ input_->SetRegister(i, i * 4);
+ }
+ input_->SetRegister(sp.code(), reinterpret_cast<intptr_t>(frame->sp()));
+ input_->SetRegister(fp.code(), reinterpret_cast<intptr_t>(frame->fp()));
+ for (int i = 0; i < DoubleRegister::NumAllocatableRegisters(); i++) {
+ input_->SetDoubleRegister(i, 0.0);
+ }
+
+ // Fill the frame content from the actual data on the frame.
+ for (unsigned i = 0; i < input_->GetFrameSize(); i += kPointerSize) {
+ input_->SetFrameSlot(
+ i, reinterpret_cast<intptr_t>(Memory::Address_at(tos + i)));
+ }
+}
+
+
+void Deoptimizer::SetPlatformCompiledStubRegisters(
+ FrameDescription* output_frame, CodeStubDescriptor* descriptor) {
+ ApiFunction function(descriptor->deoptimization_handler());
+ ExternalReference xref(&function, ExternalReference::BUILTIN_CALL, isolate_);
+ intptr_t handler = reinterpret_cast<intptr_t>(xref.address());
+ int params = descriptor->GetHandlerParameterCount();
+ output_frame->SetRegister(r3.code(), params);
+ output_frame->SetRegister(r4.code(), handler);
+}
+
+
+void Deoptimizer::CopyDoubleRegisters(FrameDescription* output_frame) {
+ for (int i = 0; i < DoubleRegister::kMaxNumRegisters; ++i) {
+ double double_value = input_->GetDoubleRegister(i);
+ output_frame->SetDoubleRegister(i, double_value);
+ }
+}
+
+
+bool Deoptimizer::HasAlignmentPadding(JSFunction* function) {
+ // There is no dynamic alignment padding on PPC in the input frame.
+ return false;
+}
+
+
+#define __ masm()->
+
+// This code tries to be close to ia32 code so that any changes can be
+// easily ported.
+void Deoptimizer::EntryGenerator::Generate() {
+ GeneratePrologue();
+
+ // Unlike on ARM we don't save all the registers, just the useful ones.
+ // For the rest, there are gaps on the stack, so the offsets remain the same.
+ const int kNumberOfRegisters = Register::kNumRegisters;
+
+ RegList restored_regs = kJSCallerSaved | kCalleeSaved;
+ RegList saved_regs = restored_regs | sp.bit();
+
+ const int kDoubleRegsSize =
+ kDoubleSize * DoubleRegister::kMaxNumAllocatableRegisters;
+
+ // Save all FPU registers before messing with them.
+ __ subi(sp, sp, Operand(kDoubleRegsSize));
+ for (int i = 0; i < DoubleRegister::kMaxNumAllocatableRegisters; ++i) {
+ DoubleRegister fpu_reg = DoubleRegister::FromAllocationIndex(i);
+ int offset = i * kDoubleSize;
+ __ stfd(fpu_reg, MemOperand(sp, offset));
+ }
+
+ // Push saved_regs (needed to populate FrameDescription::registers_).
+ // Leave gaps for other registers.
+ __ subi(sp, sp, Operand(kNumberOfRegisters * kPointerSize));
+ for (int16_t i = kNumberOfRegisters - 1; i >= 0; i--) {
+ if ((saved_regs & (1 << i)) != 0) {
+ __ StoreP(ToRegister(i), MemOperand(sp, kPointerSize * i));
+ }
+ }
+
+ const int kSavedRegistersAreaSize =
+ (kNumberOfRegisters * kPointerSize) + kDoubleRegsSize;
+
+ // Get the bailout id from the stack.
+ __ LoadP(r5, MemOperand(sp, kSavedRegistersAreaSize));
+
+ // Get the address of the location in the code object (r6) (return
+ // address for lazy deoptimization) and compute the fp-to-sp delta in
+ // register r7.
+ __ mflr(r6);
+ // Correct one word for bailout id.
+ __ addi(r7, sp, Operand(kSavedRegistersAreaSize + (1 * kPointerSize)));
+ __ sub(r7, fp, r7);
+
+ // Allocate a new deoptimizer object.
+ // Pass six arguments in r3 to r8.
+ __ PrepareCallCFunction(6, r8);
+ __ LoadP(r3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ __ li(r4, Operand(type())); // bailout type,
+ // r5: bailout id already loaded.
+ // r6: code address or 0 already loaded.
+ // r7: Fp-to-sp delta.
+ __ mov(r8, Operand(ExternalReference::isolate_address(isolate())));
+ // Call Deoptimizer::New().
+ {
+ AllowExternalCallThatCantCauseGC scope(masm());
+ __ CallCFunction(ExternalReference::new_deoptimizer_function(isolate()), 6);
+ }
+
+ // Preserve "deoptimizer" object in register r3 and get the input
+ // frame descriptor pointer to r4 (deoptimizer->input_);
+ __ LoadP(r4, MemOperand(r3, Deoptimizer::input_offset()));
+
+ // Copy core registers into FrameDescription::registers_[kNumRegisters].
+ DCHECK(Register::kNumRegisters == kNumberOfRegisters);
+ for (int i = 0; i < kNumberOfRegisters; i++) {
+ int offset = (i * kPointerSize) + FrameDescription::registers_offset();
+ __ LoadP(r5, MemOperand(sp, i * kPointerSize));
+ __ StoreP(r5, MemOperand(r4, offset));
+ }
+
+ int double_regs_offset = FrameDescription::double_registers_offset();
+ // Copy VFP registers to
+ // double_registers_[DoubleRegister::kNumAllocatableRegisters]
+ for (int i = 0; i < DoubleRegister::NumAllocatableRegisters(); ++i) {
+ int dst_offset = i * kDoubleSize + double_regs_offset;
+ int src_offset = i * kDoubleSize + kNumberOfRegisters * kPointerSize;
+ __ lfd(d0, MemOperand(sp, src_offset));
+ __ stfd(d0, MemOperand(r4, dst_offset));
+ }
+
+ // Remove the bailout id and the saved registers from the stack.
+ __ addi(sp, sp, Operand(kSavedRegistersAreaSize + (1 * kPointerSize)));
+
+ // Compute a pointer to the unwinding limit in register r5; that is
+ // the first stack slot not part of the input frame.
+ __ LoadP(r5, MemOperand(r4, FrameDescription::frame_size_offset()));
+ __ add(r5, r5, sp);
+
+ // Unwind the stack down to - but not including - the unwinding
+ // limit and copy the contents of the activation frame to the input
+ // frame description.
+ __ addi(r6, r4, Operand(FrameDescription::frame_content_offset()));
+ Label pop_loop;
+ Label pop_loop_header;
+ __ b(&pop_loop_header);
+ __ bind(&pop_loop);
+ __ pop(r7);
+ __ StoreP(r7, MemOperand(r6, 0));
+ __ addi(r6, r6, Operand(kPointerSize));
+ __ bind(&pop_loop_header);
+ __ cmp(r5, sp);
+ __ bne(&pop_loop);
+
+ // Compute the output frame in the deoptimizer.
+ __ push(r3); // Preserve deoptimizer object across call.
+ // r3: deoptimizer object; r4: scratch.
+ __ PrepareCallCFunction(1, r4);
+ // Call Deoptimizer::ComputeOutputFrames().
+ {
+ AllowExternalCallThatCantCauseGC scope(masm());
+ __ CallCFunction(
+ ExternalReference::compute_output_frames_function(isolate()), 1);
+ }
+ __ pop(r3); // Restore deoptimizer object (class Deoptimizer).
+
+ // Replace the current (input) frame with the output frames.
+ Label outer_push_loop, inner_push_loop, outer_loop_header, inner_loop_header;
+ // Outer loop state: r7 = current "FrameDescription** output_",
+ // r4 = one past the last FrameDescription**.
+ __ lwz(r4, MemOperand(r3, Deoptimizer::output_count_offset()));
+ __ LoadP(r7, MemOperand(r3, Deoptimizer::output_offset())); // r7 is output_.
+ __ ShiftLeftImm(r4, r4, Operand(kPointerSizeLog2));
+ __ add(r4, r7, r4);
+ __ b(&outer_loop_header);
+
+ __ bind(&outer_push_loop);
+ // Inner loop state: r5 = current FrameDescription*, r6 = loop index.
+ __ LoadP(r5, MemOperand(r7, 0)); // output_[ix]
+ __ LoadP(r6, MemOperand(r5, FrameDescription::frame_size_offset()));
+ __ b(&inner_loop_header);
+
+ __ bind(&inner_push_loop);
+ __ addi(r6, r6, Operand(-sizeof(intptr_t)));
+ __ add(r9, r5, r6);
+ __ LoadP(r9, MemOperand(r9, FrameDescription::frame_content_offset()));
+ __ push(r9);
+
+ __ bind(&inner_loop_header);
+ __ cmpi(r6, Operand::Zero());
+ __ bne(&inner_push_loop); // test for gt?
+
+ __ addi(r7, r7, Operand(kPointerSize));
+ __ bind(&outer_loop_header);
+ __ cmp(r7, r4);
+ __ blt(&outer_push_loop);
+
+ __ LoadP(r4, MemOperand(r3, Deoptimizer::input_offset()));
+ for (int i = 0; i < DoubleRegister::kMaxNumAllocatableRegisters; ++i) {
+ const DoubleRegister dreg = DoubleRegister::FromAllocationIndex(i);
+ int src_offset = i * kDoubleSize + double_regs_offset;
+ __ lfd(dreg, MemOperand(r4, src_offset));
+ }
+
+ // Push state, pc, and continuation from the last output frame.
+ __ LoadP(r9, MemOperand(r5, FrameDescription::state_offset()));
+ __ push(r9);
+ __ LoadP(r9, MemOperand(r5, FrameDescription::pc_offset()));
+ __ push(r9);
+ __ LoadP(r9, MemOperand(r5, FrameDescription::continuation_offset()));
+ __ push(r9);
+
+ // Restore the registers from the last output frame.
+ DCHECK(!(ip.bit() & restored_regs));
+ __ mr(ip, r5);
+ for (int i = kNumberOfRegisters - 1; i >= 0; i--) {
+ int offset = (i * kPointerSize) + FrameDescription::registers_offset();
+ if ((restored_regs & (1 << i)) != 0) {
+ __ LoadP(ToRegister(i), MemOperand(ip, offset));
+ }
+ }
+
+ __ InitializeRootRegister();
+
+ __ pop(ip); // get continuation, leave pc on stack
+ __ pop(r0);
+ __ mtlr(r0);
+ __ Jump(ip);
+ __ stop("Unreachable.");
+}
+
+
+void Deoptimizer::TableEntryGenerator::GeneratePrologue() {
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm());
+
+ // Create a sequence of deoptimization entries.
+ // Note that registers are still live when jumping to an entry.
+ Label done;
+ for (int i = 0; i < count(); i++) {
+ int start = masm()->pc_offset();
+ USE(start);
+ __ li(ip, Operand(i));
+ __ b(&done);
+ DCHECK(masm()->pc_offset() - start == table_entry_size_);
+ }
+ __ bind(&done);
+ __ push(ip);
+}
+
+
+void FrameDescription::SetCallerPc(unsigned offset, intptr_t value) {
+ SetFrameSlot(offset, value);
+}
+
+
+void FrameDescription::SetCallerFp(unsigned offset, intptr_t value) {
+ SetFrameSlot(offset, value);
+}
+
+
+void FrameDescription::SetCallerConstantPool(unsigned offset, intptr_t value) {
+#if V8_OOL_CONSTANT_POOL
+ DCHECK(FLAG_enable_ool_constant_pool);
+ SetFrameSlot(offset, value);
+#else
+ // No out-of-line constant pool support.
+ UNREACHABLE();
+#endif
+}
+
+
+#undef __
+}
+} // namespace v8::internal
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// A Disassembler object is used to disassemble a block of code instruction by
+// instruction. The default implementation of the NameConverter object can be
+// overriden to modify register names or to do symbol lookup on addresses.
+//
+// The example below will disassemble a block of code and print it to stdout.
+//
+// NameConverter converter;
+// Disassembler d(converter);
+// for (byte* pc = begin; pc < end;) {
+// v8::internal::EmbeddedVector<char, 256> buffer;
+// byte* prev_pc = pc;
+// pc += d.InstructionDecode(buffer, pc);
+// printf("%p %08x %s\n",
+// prev_pc, *reinterpret_cast<int32_t*>(prev_pc), buffer);
+// }
+//
+// The Disassembler class also has a convenience method to disassemble a block
+// of code into a FILE*, meaning that the above functionality could also be
+// achieved by just calling Disassembler::Disassemble(stdout, begin, end);
+
+
+#include <assert.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/base/platform/platform.h"
+#include "src/disasm.h"
+#include "src/macro-assembler.h"
+#include "src/ppc/constants-ppc.h"
+
+
+namespace v8 {
+namespace internal {
+
+
+//------------------------------------------------------------------------------
+
+// Decoder decodes and disassembles instructions into an output buffer.
+// It uses the converter to convert register names and call destinations into
+// more informative description.
+class Decoder {
+ public:
+ Decoder(const disasm::NameConverter& converter, Vector<char> out_buffer)
+ : converter_(converter), out_buffer_(out_buffer), out_buffer_pos_(0) {
+ out_buffer_[out_buffer_pos_] = '\0';
+ }
+
+ ~Decoder() {}
+
+ // Writes one disassembled instruction into 'buffer' (0-terminated).
+ // Returns the length of the disassembled machine instruction in bytes.
+ int InstructionDecode(byte* instruction);
+
+ private:
+ // Bottleneck functions to print into the out_buffer.
+ void PrintChar(const char ch);
+ void Print(const char* str);
+
+ // Printing of common values.
+ void PrintRegister(int reg);
+ void PrintDRegister(int reg);
+ int FormatFPRegister(Instruction* instr, const char* format);
+ void PrintSoftwareInterrupt(SoftwareInterruptCodes svc);
+
+ // Handle formatting of instructions and their options.
+ int FormatRegister(Instruction* instr, const char* option);
+ int FormatOption(Instruction* instr, const char* option);
+ void Format(Instruction* instr, const char* format);
+ void Unknown(Instruction* instr);
+ void UnknownFormat(Instruction* instr, const char* opcname);
+ void MarkerFormat(Instruction* instr, const char* opcname, int id);
+
+ void DecodeExt1(Instruction* instr);
+ void DecodeExt2(Instruction* instr);
+ void DecodeExt4(Instruction* instr);
+ void DecodeExt5(Instruction* instr);
+
+ const disasm::NameConverter& converter_;
+ Vector<char> out_buffer_;
+ int out_buffer_pos_;
+
+ DISALLOW_COPY_AND_ASSIGN(Decoder);
+};
+
+
+// Support for assertions in the Decoder formatting functions.
+#define STRING_STARTS_WITH(string, compare_string) \
+ (strncmp(string, compare_string, strlen(compare_string)) == 0)
+
+
+// Append the ch to the output buffer.
+void Decoder::PrintChar(const char ch) { out_buffer_[out_buffer_pos_++] = ch; }
+
+
+// Append the str to the output buffer.
+void Decoder::Print(const char* str) {
+ char cur = *str++;
+ while (cur != '\0' && (out_buffer_pos_ < (out_buffer_.length() - 1))) {
+ PrintChar(cur);
+ cur = *str++;
+ }
+ out_buffer_[out_buffer_pos_] = 0;
+}
+
+
+// Print the register name according to the active name converter.
+void Decoder::PrintRegister(int reg) {
+ Print(converter_.NameOfCPURegister(reg));
+}
+
+
+// Print the double FP register name according to the active name converter.
+void Decoder::PrintDRegister(int reg) { Print(FPRegisters::Name(reg)); }
+
+
+// Print SoftwareInterrupt codes. Factoring this out reduces the complexity of
+// the FormatOption method.
+void Decoder::PrintSoftwareInterrupt(SoftwareInterruptCodes svc) {
+ switch (svc) {
+ case kCallRtRedirected:
+ Print("call rt redirected");
+ return;
+ case kBreakpoint:
+ Print("breakpoint");
+ return;
+ default:
+ if (svc >= kStopCode) {
+ out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d - 0x%x",
+ svc & kStopCodeMask, svc & kStopCodeMask);
+ } else {
+ out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", svc);
+ }
+ return;
+ }
+}
+
+
+// Handle all register based formatting in this function to reduce the
+// complexity of FormatOption.
+int Decoder::FormatRegister(Instruction* instr, const char* format) {
+ DCHECK(format[0] == 'r');
+
+ if ((format[1] == 't') || (format[1] == 's')) { // 'rt & 'rs register
+ int reg = instr->RTValue();
+ PrintRegister(reg);
+ return 2;
+ } else if (format[1] == 'a') { // 'ra: RA register
+ int reg = instr->RAValue();
+ PrintRegister(reg);
+ return 2;
+ } else if (format[1] == 'b') { // 'rb: RB register
+ int reg = instr->RBValue();
+ PrintRegister(reg);
+ return 2;
+ }
+
+ UNREACHABLE();
+ return -1;
+}
+
+
+// Handle all FP register based formatting in this function to reduce the
+// complexity of FormatOption.
+int Decoder::FormatFPRegister(Instruction* instr, const char* format) {
+ DCHECK(format[0] == 'D');
+
+ int retval = 2;
+ int reg = -1;
+ if (format[1] == 't') {
+ reg = instr->RTValue();
+ } else if (format[1] == 'a') {
+ reg = instr->RAValue();
+ } else if (format[1] == 'b') {
+ reg = instr->RBValue();
+ } else if (format[1] == 'c') {
+ reg = instr->RCValue();
+ } else {
+ UNREACHABLE();
+ }
+
+ PrintDRegister(reg);
+
+ return retval;
+}
+
+
+// FormatOption takes a formatting string and interprets it based on
+// the current instructions. The format string points to the first
+// character of the option string (the option escape has already been
+// consumed by the caller.) FormatOption returns the number of
+// characters that were consumed from the formatting string.
+int Decoder::FormatOption(Instruction* instr, const char* format) {
+ switch (format[0]) {
+ case 'o': {
+ if (instr->Bit(10) == 1) {
+ Print("o");
+ }
+ return 1;
+ }
+ case '.': {
+ if (instr->Bit(0) == 1) {
+ Print(".");
+ } else {
+ Print(" "); // ensure consistent spacing
+ }
+ return 1;
+ }
+ case 'r': {
+ return FormatRegister(instr, format);
+ }
+ case 'D': {
+ return FormatFPRegister(instr, format);
+ }
+ case 'i': { // int16
+ int32_t value = (instr->Bits(15, 0) << 16) >> 16;
+ out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
+ return 5;
+ }
+ case 'u': { // uint16
+ int32_t value = instr->Bits(15, 0);
+ out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
+ return 6;
+ }
+ case 'l': {
+ // Link (LK) Bit 0
+ if (instr->Bit(0) == 1) {
+ Print("l");
+ }
+ return 1;
+ }
+ case 'a': {
+ // Absolute Address Bit 1
+ if (instr->Bit(1) == 1) {
+ Print("a");
+ }
+ return 1;
+ }
+ case 't': { // 'target: target of branch instructions
+ // target26 or target16
+ DCHECK(STRING_STARTS_WITH(format, "target"));
+ if ((format[6] == '2') && (format[7] == '6')) {
+ int off = ((instr->Bits(25, 2)) << 8) >> 6;
+ out_buffer_pos_ += SNPrintF(
+ out_buffer_ + out_buffer_pos_, "%+d -> %s", off,
+ converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + off));
+ return 8;
+ } else if ((format[6] == '1') && (format[7] == '6')) {
+ int off = ((instr->Bits(15, 2)) << 18) >> 16;
+ out_buffer_pos_ += SNPrintF(
+ out_buffer_ + out_buffer_pos_, "%+d -> %s", off,
+ converter_.NameOfAddress(reinterpret_cast<byte*>(instr) + off));
+ return 8;
+ }
+ case 's': {
+ DCHECK(format[1] == 'h');
+ int32_t value = 0;
+ int32_t opcode = instr->OpcodeValue() << 26;
+ int32_t sh = instr->Bits(15, 11);
+ if (opcode == EXT5 ||
+ (opcode == EXT2 && instr->Bits(10, 2) << 2 == SRADIX)) {
+ // SH Bits 1 and 15-11 (split field)
+ value = (sh | (instr->Bit(1) << 5));
+ } else {
+ // SH Bits 15-11
+ value = (sh << 26) >> 26;
+ }
+ out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
+ return 2;
+ }
+ case 'm': {
+ int32_t value = 0;
+ if (format[1] == 'e') {
+ if (instr->OpcodeValue() << 26 != EXT5) {
+ // ME Bits 10-6
+ value = (instr->Bits(10, 6) << 26) >> 26;
+ } else {
+ // ME Bits 5 and 10-6 (split field)
+ value = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
+ }
+ } else if (format[1] == 'b') {
+ if (instr->OpcodeValue() << 26 != EXT5) {
+ // MB Bits 5-1
+ value = (instr->Bits(5, 1) << 26) >> 26;
+ } else {
+ // MB Bits 5 and 10-6 (split field)
+ value = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
+ }
+ } else {
+ UNREACHABLE(); // bad format
+ }
+ out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
+ return 2;
+ }
+ }
+#if V8_TARGET_ARCH_PPC64
+ case 'd': { // ds value for offset
+ int32_t value = SIGN_EXT_IMM16(instr->Bits(15, 0) & ~3);
+ out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%d", value);
+ return 1;
+ }
+#endif
+ default: {
+ UNREACHABLE();
+ break;
+ }
+ }
+
+ UNREACHABLE();
+ return -1;
+}
+
+
+// Format takes a formatting string for a whole instruction and prints it into
+// the output buffer. All escaped options are handed to FormatOption to be
+// parsed further.
+void Decoder::Format(Instruction* instr, const char* format) {
+ char cur = *format++;
+ while ((cur != 0) && (out_buffer_pos_ < (out_buffer_.length() - 1))) {
+ if (cur == '\'') { // Single quote is used as the formatting escape.
+ format += FormatOption(instr, format);
+ } else {
+ out_buffer_[out_buffer_pos_++] = cur;
+ }
+ cur = *format++;
+ }
+ out_buffer_[out_buffer_pos_] = '\0';
+}
+
+
+// The disassembler may end up decoding data inlined in the code. We do not want
+// it to crash if the data does not ressemble any known instruction.
+#define VERIFY(condition) \
+ if (!(condition)) { \
+ Unknown(instr); \
+ return; \
+ }
+
+
+// For currently unimplemented decodings the disassembler calls Unknown(instr)
+// which will just print "unknown" of the instruction bits.
+void Decoder::Unknown(Instruction* instr) { Format(instr, "unknown"); }
+
+
+// For currently unimplemented decodings the disassembler calls
+// UnknownFormat(instr) which will just print opcode name of the
+// instruction bits.
+void Decoder::UnknownFormat(Instruction* instr, const char* name) {
+ char buffer[100];
+ snprintf(buffer, sizeof(buffer), "%s (unknown-format)", name);
+ Format(instr, buffer);
+}
+
+
+void Decoder::MarkerFormat(Instruction* instr, const char* name, int id) {
+ char buffer[100];
+ snprintf(buffer, sizeof(buffer), "%s %d", name, id);
+ Format(instr, buffer);
+}
+
+
+void Decoder::DecodeExt1(Instruction* instr) {
+ switch (instr->Bits(10, 1) << 1) {
+ case MCRF: {
+ UnknownFormat(instr, "mcrf"); // not used by V8
+ break;
+ }
+ case BCLRX: {
+ switch (instr->Bits(25, 21) << 21) {
+ case DCBNZF: {
+ UnknownFormat(instr, "bclrx-dcbnzf");
+ break;
+ }
+ case DCBEZF: {
+ UnknownFormat(instr, "bclrx-dcbezf");
+ break;
+ }
+ case BF: {
+ UnknownFormat(instr, "bclrx-bf");
+ break;
+ }
+ case DCBNZT: {
+ UnknownFormat(instr, "bclrx-dcbbzt");
+ break;
+ }
+ case DCBEZT: {
+ UnknownFormat(instr, "bclrx-dcbnezt");
+ break;
+ }
+ case BT: {
+ UnknownFormat(instr, "bclrx-bt");
+ break;
+ }
+ case DCBNZ: {
+ UnknownFormat(instr, "bclrx-dcbnz");
+ break;
+ }
+ case DCBEZ: {
+ UnknownFormat(instr, "bclrx-dcbez"); // not used by V8
+ break;
+ }
+ case BA: {
+ if (instr->Bit(0) == 1) {
+ Format(instr, "blrl");
+ } else {
+ Format(instr, "blr");
+ }
+ break;
+ }
+ }
+ break;
+ }
+ case BCCTRX: {
+ switch (instr->Bits(25, 21) << 21) {
+ case DCBNZF: {
+ UnknownFormat(instr, "bcctrx-dcbnzf");
+ break;
+ }
+ case DCBEZF: {
+ UnknownFormat(instr, "bcctrx-dcbezf");
+ break;
+ }
+ case BF: {
+ UnknownFormat(instr, "bcctrx-bf");
+ break;
+ }
+ case DCBNZT: {
+ UnknownFormat(instr, "bcctrx-dcbnzt");
+ break;
+ }
+ case DCBEZT: {
+ UnknownFormat(instr, "bcctrx-dcbezf");
+ break;
+ }
+ case BT: {
+ UnknownFormat(instr, "bcctrx-bt");
+ break;
+ }
+ case DCBNZ: {
+ UnknownFormat(instr, "bcctrx-dcbnz");
+ break;
+ }
+ case DCBEZ: {
+ UnknownFormat(instr, "bcctrx-dcbez");
+ break;
+ }
+ case BA: {
+ if (instr->Bit(0) == 1) {
+ Format(instr, "bctrl");
+ } else {
+ Format(instr, "bctr");
+ }
+ break;
+ }
+ default: { UNREACHABLE(); }
+ }
+ break;
+ }
+ case CRNOR: {
+ Format(instr, "crnor (stuff)");
+ break;
+ }
+ case RFI: {
+ Format(instr, "rfi (stuff)");
+ break;
+ }
+ case CRANDC: {
+ Format(instr, "crandc (stuff)");
+ break;
+ }
+ case ISYNC: {
+ Format(instr, "isync (stuff)");
+ break;
+ }
+ case CRXOR: {
+ Format(instr, "crxor (stuff)");
+ break;
+ }
+ case CRNAND: {
+ UnknownFormat(instr, "crnand");
+ break;
+ }
+ case CRAND: {
+ UnknownFormat(instr, "crand");
+ break;
+ }
+ case CREQV: {
+ UnknownFormat(instr, "creqv");
+ break;
+ }
+ case CRORC: {
+ UnknownFormat(instr, "crorc");
+ break;
+ }
+ case CROR: {
+ UnknownFormat(instr, "cror");
+ break;
+ }
+ default: {
+ Unknown(instr); // not used by V8
+ }
+ }
+}
+
+
+void Decoder::DecodeExt2(Instruction* instr) {
+ // Some encodings are 10-1 bits, handle those first
+ switch (instr->Bits(10, 1) << 1) {
+ case SRWX: {
+ Format(instr, "srw'. 'ra, 'rs, 'rb");
+ return;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case SRDX: {
+ Format(instr, "srd'. 'ra, 'rs, 'rb");
+ return;
+ }
+#endif
+ case SRAW: {
+ Format(instr, "sraw'. 'ra, 'rs, 'rb");
+ return;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case SRAD: {
+ Format(instr, "srad'. 'ra, 'rs, 'rb");
+ return;
+ }
+#endif
+ case SRAWIX: {
+ Format(instr, "srawi'. 'ra,'rs,'sh");
+ return;
+ }
+ case EXTSH: {
+ Format(instr, "extsh'. 'ra, 'rs");
+ return;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case EXTSW: {
+ Format(instr, "extsw'. 'ra, 'rs");
+ return;
+ }
+#endif
+ case EXTSB: {
+ Format(instr, "extsb'. 'ra, 'rs");
+ return;
+ }
+ case LFSX: {
+ Format(instr, "lfsx 'rt, 'ra, 'rb");
+ return;
+ }
+ case LFSUX: {
+ Format(instr, "lfsux 'rt, 'ra, 'rb");
+ return;
+ }
+ case LFDX: {
+ Format(instr, "lfdx 'rt, 'ra, 'rb");
+ return;
+ }
+ case LFDUX: {
+ Format(instr, "lfdux 'rt, 'ra, 'rb");
+ return;
+ }
+ case STFSX: {
+ Format(instr, "stfsx 'rs, 'ra, 'rb");
+ return;
+ }
+ case STFSUX: {
+ Format(instr, "stfsux 'rs, 'ra, 'rb");
+ return;
+ }
+ case STFDX: {
+ Format(instr, "stfdx 'rs, 'ra, 'rb");
+ return;
+ }
+ case STFDUX: {
+ Format(instr, "stfdux 'rs, 'ra, 'rb");
+ return;
+ }
+ }
+
+ switch (instr->Bits(10, 2) << 2) {
+ case SRADIX: {
+ Format(instr, "sradi'. 'ra,'rs,'sh");
+ return;
+ }
+ }
+
+ // ?? are all of these xo_form?
+ switch (instr->Bits(9, 1) << 1) {
+ case CMP: {
+#if V8_TARGET_ARCH_PPC64
+ if (instr->Bit(21)) {
+#endif
+ Format(instr, "cmp 'ra, 'rb");
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ Format(instr, "cmpw 'ra, 'rb");
+ }
+#endif
+ break;
+ }
+ case SLWX: {
+ Format(instr, "slw'. 'ra, 'rs, 'rb");
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case SLDX: {
+ Format(instr, "sld'. 'ra, 'rs, 'rb");
+ break;
+ }
+#endif
+ case SUBFCX: {
+ Format(instr, "subfc'. 'rt, 'ra, 'rb");
+ break;
+ }
+ case ADDCX: {
+ Format(instr, "addc'. 'rt, 'ra, 'rb");
+ break;
+ }
+ case CNTLZWX: {
+ Format(instr, "cntlzw'. 'ra, 'rs");
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case CNTLZDX: {
+ Format(instr, "cntlzd'. 'ra, 'rs");
+ break;
+ }
+#endif
+ case ANDX: {
+ Format(instr, "and'. 'ra, 'rs, 'rb");
+ break;
+ }
+ case ANDCX: {
+ Format(instr, "andc'. 'ra, 'rs, 'rb");
+ break;
+ }
+ case CMPL: {
+#if V8_TARGET_ARCH_PPC64
+ if (instr->Bit(21)) {
+#endif
+ Format(instr, "cmpl 'ra, 'rb");
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ Format(instr, "cmplw 'ra, 'rb");
+ }
+#endif
+ break;
+ }
+ case NEGX: {
+ Format(instr, "neg'. 'rt, 'ra");
+ break;
+ }
+ case NORX: {
+ Format(instr, "nor'. 'rt, 'ra, 'rb");
+ break;
+ }
+ case SUBFX: {
+ Format(instr, "subf'. 'rt, 'ra, 'rb");
+ break;
+ }
+ case MULHWX: {
+ Format(instr, "mulhw'o'. 'rt, 'ra, 'rb");
+ break;
+ }
+ case ADDZEX: {
+ Format(instr, "addze'. 'rt, 'ra");
+ break;
+ }
+ case MULLW: {
+ Format(instr, "mullw'o'. 'rt, 'ra, 'rb");
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case MULLD: {
+ Format(instr, "mulld'o'. 'rt, 'ra, 'rb");
+ break;
+ }
+#endif
+ case DIVW: {
+ Format(instr, "divw'o'. 'rt, 'ra, 'rb");
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case DIVD: {
+ Format(instr, "divd'o'. 'rt, 'ra, 'rb");
+ break;
+ }
+#endif
+ case ADDX: {
+ Format(instr, "add'o 'rt, 'ra, 'rb");
+ break;
+ }
+ case XORX: {
+ Format(instr, "xor'. 'ra, 'rs, 'rb");
+ break;
+ }
+ case ORX: {
+ if (instr->RTValue() == instr->RBValue()) {
+ Format(instr, "mr 'ra, 'rb");
+ } else {
+ Format(instr, "or 'ra, 'rs, 'rb");
+ }
+ break;
+ }
+ case MFSPR: {
+ int spr = instr->Bits(20, 11);
+ if (256 == spr) {
+ Format(instr, "mflr 'rt");
+ } else {
+ Format(instr, "mfspr 'rt ??");
+ }
+ break;
+ }
+ case MTSPR: {
+ int spr = instr->Bits(20, 11);
+ if (256 == spr) {
+ Format(instr, "mtlr 'rt");
+ } else if (288 == spr) {
+ Format(instr, "mtctr 'rt");
+ } else {
+ Format(instr, "mtspr 'rt ??");
+ }
+ break;
+ }
+ case MFCR: {
+ Format(instr, "mfcr 'rt");
+ break;
+ }
+ case STWX: {
+ Format(instr, "stwx 'rs, 'ra, 'rb");
+ break;
+ }
+ case STWUX: {
+ Format(instr, "stwux 'rs, 'ra, 'rb");
+ break;
+ }
+ case STBX: {
+ Format(instr, "stbx 'rs, 'ra, 'rb");
+ break;
+ }
+ case STBUX: {
+ Format(instr, "stbux 'rs, 'ra, 'rb");
+ break;
+ }
+ case STHX: {
+ Format(instr, "sthx 'rs, 'ra, 'rb");
+ break;
+ }
+ case STHUX: {
+ Format(instr, "sthux 'rs, 'ra, 'rb");
+ break;
+ }
+ case LWZX: {
+ Format(instr, "lwzx 'rt, 'ra, 'rb");
+ break;
+ }
+ case LWZUX: {
+ Format(instr, "lwzux 'rt, 'ra, 'rb");
+ break;
+ }
+ case LBZX: {
+ Format(instr, "lbzx 'rt, 'ra, 'rb");
+ break;
+ }
+ case LBZUX: {
+ Format(instr, "lbzux 'rt, 'ra, 'rb");
+ break;
+ }
+ case LHZX: {
+ Format(instr, "lhzx 'rt, 'ra, 'rb");
+ break;
+ }
+ case LHZUX: {
+ Format(instr, "lhzux 'rt, 'ra, 'rb");
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case LDX: {
+ Format(instr, "ldx 'rt, 'ra, 'rb");
+ break;
+ }
+ case LDUX: {
+ Format(instr, "ldux 'rt, 'ra, 'rb");
+ break;
+ }
+ case STDX: {
+ Format(instr, "stdx 'rt, 'ra, 'rb");
+ break;
+ }
+ case STDUX: {
+ Format(instr, "stdux 'rt, 'ra, 'rb");
+ break;
+ }
+ case MFVSRD: {
+ Format(instr, "mffprd 'ra, 'Dt");
+ break;
+ }
+ case MFVSRWZ: {
+ Format(instr, "mffprwz 'ra, 'Dt");
+ break;
+ }
+ case MTVSRD: {
+ Format(instr, "mtfprd 'Dt, 'ra");
+ break;
+ }
+ case MTVSRWA: {
+ Format(instr, "mtfprwa 'Dt, 'ra");
+ break;
+ }
+ case MTVSRWZ: {
+ Format(instr, "mtfprwz 'Dt, 'ra");
+ break;
+ }
+#endif
+ default: {
+ Unknown(instr); // not used by V8
+ }
+ }
+}
+
+
+void Decoder::DecodeExt4(Instruction* instr) {
+ switch (instr->Bits(5, 1) << 1) {
+ case FDIV: {
+ Format(instr, "fdiv'. 'Dt, 'Da, 'Db");
+ return;
+ }
+ case FSUB: {
+ Format(instr, "fsub'. 'Dt, 'Da, 'Db");
+ return;
+ }
+ case FADD: {
+ Format(instr, "fadd'. 'Dt, 'Da, 'Db");
+ return;
+ }
+ case FSQRT: {
+ Format(instr, "fsqrt'. 'Dt, 'Db");
+ return;
+ }
+ case FSEL: {
+ Format(instr, "fsel'. 'Dt, 'Da, 'Dc, 'Db");
+ return;
+ }
+ case FMUL: {
+ Format(instr, "fmul'. 'Dt, 'Da, 'Dc");
+ return;
+ }
+ case FMSUB: {
+ Format(instr, "fmsub'. 'Dt, 'Da, 'Dc, 'Db");
+ return;
+ }
+ case FMADD: {
+ Format(instr, "fmadd'. 'Dt, 'Da, 'Dc, 'Db");
+ return;
+ }
+ }
+
+ switch (instr->Bits(10, 1) << 1) {
+ case FCMPU: {
+ Format(instr, "fcmpu 'Da, 'Db");
+ break;
+ }
+ case FRSP: {
+ Format(instr, "frsp'. 'Dt, 'Db");
+ break;
+ }
+ case FCFID: {
+ Format(instr, "fcfid'. 'Dt, 'Db");
+ break;
+ }
+ case FCTID: {
+ Format(instr, "fctid 'Dt, 'Db");
+ break;
+ }
+ case FCTIDZ: {
+ Format(instr, "fctidz 'Dt, 'Db");
+ break;
+ }
+ case FCTIW: {
+ Format(instr, "fctiw'. 'Dt, 'Db");
+ break;
+ }
+ case FCTIWZ: {
+ Format(instr, "fctiwz'. 'Dt, 'Db");
+ break;
+ }
+ case FMR: {
+ Format(instr, "fmr'. 'Dt, 'Db");
+ break;
+ }
+ case MTFSFI: {
+ Format(instr, "mtfsfi'. ?,?");
+ break;
+ }
+ case MFFS: {
+ Format(instr, "mffs'. 'Dt");
+ break;
+ }
+ case MTFSF: {
+ Format(instr, "mtfsf'. 'Db ?,?,?");
+ break;
+ }
+ case FABS: {
+ Format(instr, "fabs'. 'Dt, 'Db");
+ break;
+ }
+ case FRIM: {
+ Format(instr, "frim 'Dt, 'Db");
+ break;
+ }
+ case FNEG: {
+ Format(instr, "fneg'. 'Dt, 'Db");
+ break;
+ }
+ default: {
+ Unknown(instr); // not used by V8
+ }
+ }
+}
+
+
+void Decoder::DecodeExt5(Instruction* instr) {
+ switch (instr->Bits(4, 2) << 2) {
+ case RLDICL: {
+ Format(instr, "rldicl'. 'ra, 'rs, 'sh, 'mb");
+ return;
+ }
+ case RLDICR: {
+ Format(instr, "rldicr'. 'ra, 'rs, 'sh, 'me");
+ return;
+ }
+ case RLDIC: {
+ Format(instr, "rldic'. 'ra, 'rs, 'sh, 'mb");
+ return;
+ }
+ case RLDIMI: {
+ Format(instr, "rldimi'. 'ra, 'rs, 'sh, 'mb");
+ return;
+ }
+ }
+ switch (instr->Bits(4, 1) << 1) {
+ case RLDCL: {
+ Format(instr, "rldcl'. 'ra, 'rs, 'sb, 'mb");
+ return;
+ }
+ }
+ Unknown(instr); // not used by V8
+}
+
+#undef VERIFIY
+
+// Disassemble the instruction at *instr_ptr into the output buffer.
+int Decoder::InstructionDecode(byte* instr_ptr) {
+ Instruction* instr = Instruction::At(instr_ptr);
+ // Print raw instruction bytes.
+ out_buffer_pos_ += SNPrintF(out_buffer_ + out_buffer_pos_, "%08x ",
+ instr->InstructionBits());
+
+ switch (instr->OpcodeValue() << 26) {
+ case TWI: {
+ PrintSoftwareInterrupt(instr->SvcValue());
+ break;
+ }
+ case MULLI: {
+ UnknownFormat(instr, "mulli");
+ break;
+ }
+ case SUBFIC: {
+ Format(instr, "subfic 'rt, 'ra, 'int16");
+ break;
+ }
+ case CMPLI: {
+#if V8_TARGET_ARCH_PPC64
+ if (instr->Bit(21)) {
+#endif
+ Format(instr, "cmpli 'ra, 'uint16");
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ Format(instr, "cmplwi 'ra, 'uint16");
+ }
+#endif
+ break;
+ }
+ case CMPI: {
+#if V8_TARGET_ARCH_PPC64
+ if (instr->Bit(21)) {
+#endif
+ Format(instr, "cmpi 'ra, 'int16");
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ Format(instr, "cmpwi 'ra, 'int16");
+ }
+#endif
+ break;
+ }
+ case ADDIC: {
+ Format(instr, "addic 'rt, 'ra, 'int16");
+ break;
+ }
+ case ADDICx: {
+ UnknownFormat(instr, "addicx");
+ break;
+ }
+ case ADDI: {
+ if (instr->RAValue() == 0) {
+ // this is load immediate
+ Format(instr, "li 'rt, 'int16");
+ } else {
+ Format(instr, "addi 'rt, 'ra, 'int16");
+ }
+ break;
+ }
+ case ADDIS: {
+ if (instr->RAValue() == 0) {
+ Format(instr, "lis 'rt, 'int16");
+ } else {
+ Format(instr, "addis 'rt, 'ra, 'int16");
+ }
+ break;
+ }
+ case BCX: {
+ int bo = instr->Bits(25, 21) << 21;
+ int bi = instr->Bits(20, 16);
+ switch (bi) {
+ case 2:
+ case 30:
+ if (BT == bo) {
+ Format(instr, "beq'l'a 'target16");
+ break;
+ }
+ if (BF == bo) {
+ Format(instr, "bne'l'a 'target16");
+ break;
+ }
+ Format(instr, "bc'l'a 'target16");
+ break;
+ case 29:
+ if (BT == bo) {
+ Format(instr, "bgt'l'a 'target16");
+ break;
+ }
+ if (BF == bo) {
+ Format(instr, "ble'l'a 'target16");
+ break;
+ }
+ Format(instr, "bc'l'a 'target16");
+ break;
+ case 28:
+ if (BT == bo) {
+ Format(instr, "blt'l'a 'target16");
+ break;
+ }
+ if (BF == bo) {
+ Format(instr, "bge'l'a 'target16");
+ break;
+ }
+ Format(instr, "bc'l'a 'target16");
+ break;
+ default:
+ Format(instr, "bc'l'a 'target16");
+ break;
+ }
+ break;
+ }
+ case SC: {
+ UnknownFormat(instr, "sc");
+ break;
+ }
+ case BX: {
+ Format(instr, "b'l'a 'target26");
+ break;
+ }
+ case EXT1: {
+ DecodeExt1(instr);
+ break;
+ }
+ case RLWIMIX: {
+ Format(instr, "rlwimi'. 'ra, 'rs, 'sh, 'me, 'mb");
+ break;
+ }
+ case RLWINMX: {
+ Format(instr, "rlwinm'. 'ra, 'rs, 'sh, 'me, 'mb");
+ break;
+ }
+ case RLWNMX: {
+ Format(instr, "rlwnm'. 'ra, 'rs, 'rb, 'me, 'mb");
+ break;
+ }
+ case ORI: {
+ Format(instr, "ori 'ra, 'rs, 'uint16");
+ break;
+ }
+ case ORIS: {
+ Format(instr, "oris 'ra, 'rs, 'uint16");
+ break;
+ }
+ case XORI: {
+ Format(instr, "xori 'ra, 'rs, 'uint16");
+ break;
+ }
+ case XORIS: {
+ Format(instr, "xoris 'ra, 'rs, 'uint16");
+ break;
+ }
+ case ANDIx: {
+ Format(instr, "andi. 'ra, 'rs, 'uint16");
+ break;
+ }
+ case ANDISx: {
+ Format(instr, "andis. 'ra, 'rs, 'uint16");
+ break;
+ }
+ case EXT2: {
+ DecodeExt2(instr);
+ break;
+ }
+ case LWZ: {
+ Format(instr, "lwz 'rt, 'int16('ra)");
+ break;
+ }
+ case LWZU: {
+ Format(instr, "lwzu 'rt, 'int16('ra)");
+ break;
+ }
+ case LBZ: {
+ Format(instr, "lbz 'rt, 'int16('ra)");
+ break;
+ }
+ case LBZU: {
+ Format(instr, "lbzu 'rt, 'int16('ra)");
+ break;
+ }
+ case STW: {
+ Format(instr, "stw 'rs, 'int16('ra)");
+ break;
+ }
+ case STWU: {
+ Format(instr, "stwu 'rs, 'int16('ra)");
+ break;
+ }
+ case STB: {
+ Format(instr, "stb 'rs, 'int16('ra)");
+ break;
+ }
+ case STBU: {
+ Format(instr, "stbu 'rs, 'int16('ra)");
+ break;
+ }
+ case LHZ: {
+ Format(instr, "lhz 'rt, 'int16('ra)");
+ break;
+ }
+ case LHZU: {
+ Format(instr, "lhzu 'rt, 'int16('ra)");
+ break;
+ }
+ case LHA: {
+ Format(instr, "lha 'rt, 'int16('ra)");
+ break;
+ }
+ case LHAU: {
+ Format(instr, "lhau 'rt, 'int16('ra)");
+ break;
+ }
+ case STH: {
+ Format(instr, "sth 'rs, 'int16('ra)");
+ break;
+ }
+ case STHU: {
+ Format(instr, "sthu 'rs, 'int16('ra)");
+ break;
+ }
+ case LMW: {
+ UnknownFormat(instr, "lmw");
+ break;
+ }
+ case STMW: {
+ UnknownFormat(instr, "stmw");
+ break;
+ }
+ case LFS: {
+ Format(instr, "lfs 'Dt, 'int16('ra)");
+ break;
+ }
+ case LFSU: {
+ Format(instr, "lfsu 'Dt, 'int16('ra)");
+ break;
+ }
+ case LFD: {
+ Format(instr, "lfd 'Dt, 'int16('ra)");
+ break;
+ }
+ case LFDU: {
+ Format(instr, "lfdu 'Dt, 'int16('ra)");
+ break;
+ }
+ case STFS: {
+ Format(instr, "stfs 'Dt, 'int16('ra)");
+ break;
+ }
+ case STFSU: {
+ Format(instr, "stfsu 'Dt, 'int16('ra)");
+ break;
+ }
+ case STFD: {
+ Format(instr, "stfd 'Dt, 'int16('ra)");
+ break;
+ }
+ case STFDU: {
+ Format(instr, "stfdu 'Dt, 'int16('ra)");
+ break;
+ }
+ case EXT3:
+ case EXT4: {
+ DecodeExt4(instr);
+ break;
+ }
+ case EXT5: {
+ DecodeExt5(instr);
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case LD: {
+ switch (instr->Bits(1, 0)) {
+ case 0:
+ Format(instr, "ld 'rt, 'd('ra)");
+ break;
+ case 1:
+ Format(instr, "ldu 'rt, 'd('ra)");
+ break;
+ case 2:
+ Format(instr, "lwa 'rt, 'd('ra)");
+ break;
+ }
+ break;
+ }
+ case STD: { // could be STD or STDU
+ if (instr->Bit(0) == 0) {
+ Format(instr, "std 'rs, 'd('ra)");
+ } else {
+ Format(instr, "stdu 'rs, 'd('ra)");
+ }
+ break;
+ }
+#endif
+
+ case FAKE_OPCODE: {
+ if (instr->Bits(MARKER_SUBOPCODE_BIT, MARKER_SUBOPCODE_BIT) == 1) {
+ int marker_code = instr->Bits(STUB_MARKER_HIGH_BIT, 0);
+ DCHECK(marker_code < F_NEXT_AVAILABLE_STUB_MARKER);
+ MarkerFormat(instr, "stub-marker ", marker_code);
+ } else {
+ int fake_opcode = instr->Bits(FAKE_OPCODE_HIGH_BIT, 0);
+ MarkerFormat(instr, "faker-opcode ", fake_opcode);
+ }
+ break;
+ }
+ default: {
+ Unknown(instr);
+ break;
+ }
+ }
+
+ return Instruction::kInstrSize;
+}
+}
+} // namespace v8::internal
+
+
+//------------------------------------------------------------------------------
+
+namespace disasm {
+
+
+const char* NameConverter::NameOfAddress(byte* addr) const {
+ v8::internal::SNPrintF(tmp_buffer_, "%p", addr);
+ return tmp_buffer_.start();
+}
+
+
+const char* NameConverter::NameOfConstant(byte* addr) const {
+ return NameOfAddress(addr);
+}
+
+
+const char* NameConverter::NameOfCPURegister(int reg) const {
+ return v8::internal::Registers::Name(reg);
+}
+
+const char* NameConverter::NameOfByteCPURegister(int reg) const {
+ UNREACHABLE(); // PPC does not have the concept of a byte register
+ return "nobytereg";
+}
+
+
+const char* NameConverter::NameOfXMMRegister(int reg) const {
+ UNREACHABLE(); // PPC does not have any XMM registers
+ return "noxmmreg";
+}
+
+const char* NameConverter::NameInCode(byte* addr) const {
+ // The default name converter is called for unknown code. So we will not try
+ // to access any memory.
+ return "";
+}
+
+
+//------------------------------------------------------------------------------
+
+Disassembler::Disassembler(const NameConverter& converter)
+ : converter_(converter) {}
+
+
+Disassembler::~Disassembler() {}
+
+
+int Disassembler::InstructionDecode(v8::internal::Vector<char> buffer,
+ byte* instruction) {
+ v8::internal::Decoder d(converter_, buffer);
+ return d.InstructionDecode(instruction);
+}
+
+
+// The PPC assembler does not currently use constant pools.
+int Disassembler::ConstantPoolSizeAt(byte* instruction) { return -1; }
+
+
+void Disassembler::Disassemble(FILE* f, byte* begin, byte* end) {
+ NameConverter converter;
+ Disassembler d(converter);
+ for (byte* pc = begin; pc < end;) {
+ v8::internal::EmbeddedVector<char, 128> buffer;
+ buffer[0] = '\0';
+ byte* prev_pc = pc;
+ pc += d.InstructionDecode(buffer, pc);
+ v8::internal::PrintF(f, "%p %08x %s\n", prev_pc,
+ *reinterpret_cast<int32_t*>(prev_pc), buffer.start());
+ }
+}
+
+
+} // namespace disasm
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/assembler.h"
+#include "src/frames.h"
+#include "src/macro-assembler.h"
+
+#include "src/ppc/assembler-ppc.h"
+#include "src/ppc/assembler-ppc-inl.h"
+#include "src/ppc/macro-assembler-ppc.h"
+
+namespace v8 {
+namespace internal {
+
+
+Register JavaScriptFrame::fp_register() { return v8::internal::fp; }
+Register JavaScriptFrame::context_register() { return cp; }
+Register JavaScriptFrame::constant_pool_pointer_register() {
+#if V8_OOL_CONSTANT_POOL
+ DCHECK(FLAG_enable_ool_constant_pool);
+ return kConstantPoolRegister;
+#else
+ UNREACHABLE();
+ return no_reg;
+#endif
+}
+
+
+Register StubFailureTrampolineFrame::fp_register() { return v8::internal::fp; }
+Register StubFailureTrampolineFrame::context_register() { return cp; }
+Register StubFailureTrampolineFrame::constant_pool_pointer_register() {
+#if V8_OOL_CONSTANT_POOL
+ DCHECK(FLAG_enable_ool_constant_pool);
+ return kConstantPoolRegister;
+#else
+ UNREACHABLE();
+ return no_reg;
+#endif
+}
+
+
+Object*& ExitFrame::constant_pool_slot() const {
+#if V8_OOL_CONSTANT_POOL
+ DCHECK(FLAG_enable_ool_constant_pool);
+ const int offset = ExitFrameConstants::kConstantPoolOffset;
+ return Memory::Object_at(fp() + offset);
+#else
+ UNREACHABLE();
+ return Memory::Object_at(NULL);
+#endif
+}
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_PPC_FRAMES_PPC_H_
+#define V8_PPC_FRAMES_PPC_H_
+
+namespace v8 {
+namespace internal {
+
+
+// Register list in load/store instructions
+// Note that the bit values must match those used in actual instruction encoding
+const int kNumRegs = 32;
+
+
+// Caller-saved/arguments registers
+const RegList kJSCallerSaved = 1 << 3 | // r3 a1
+ 1 << 4 | // r4 a2
+ 1 << 5 | // r5 a3
+ 1 << 6 | // r6 a4
+ 1 << 7 | // r7 a5
+ 1 << 8 | // r8 a6
+ 1 << 9 | // r9 a7
+ 1 << 10 | // r10 a8
+ 1 << 11;
+
+const int kNumJSCallerSaved = 9;
+
+// Return the code of the n-th caller-saved register available to JavaScript
+// e.g. JSCallerSavedReg(0) returns r0.code() == 0
+int JSCallerSavedCode(int n);
+
+
+// Callee-saved registers preserved when switching from C to JavaScript
+const RegList kCalleeSaved = 1 << 14 | // r14
+ 1 << 15 | // r15
+ 1 << 16 | // r16
+ 1 << 17 | // r17
+ 1 << 18 | // r18
+ 1 << 19 | // r19
+ 1 << 20 | // r20
+ 1 << 21 | // r21
+ 1 << 22 | // r22
+ 1 << 23 | // r23
+ 1 << 24 | // r24
+ 1 << 25 | // r25
+ 1 << 26 | // r26
+ 1 << 27 | // r27
+ 1 << 28 | // r28
+ 1 << 29 | // r29
+ 1 << 30 | // r20
+ 1 << 31; // r31
+
+
+const int kNumCalleeSaved = 18;
+
+// Number of registers for which space is reserved in safepoints. Must be a
+// multiple of 8.
+// TODO(regis): Only 8 registers may actually be sufficient. Revisit.
+const int kNumSafepointRegisters = 32;
+
+// Define the list of registers actually saved at safepoints.
+// Note that the number of saved registers may be smaller than the reserved
+// space, i.e. kNumSafepointSavedRegisters <= kNumSafepointRegisters.
+const RegList kSafepointSavedRegisters = kJSCallerSaved | kCalleeSaved;
+const int kNumSafepointSavedRegisters = kNumJSCallerSaved + kNumCalleeSaved;
+
+// The following constants describe the stack frame linkage area as
+// defined by the ABI. Note that kNumRequiredStackFrameSlots must
+// satisfy alignment requirements (rounding up if required).
+#if V8_TARGET_ARCH_PPC64 && V8_TARGET_LITTLE_ENDIAN
+// [0] back chain
+// [1] condition register save area
+// [2] link register save area
+// [3] TOC save area
+// [4] Parameter1 save area
+// ...
+// [11] Parameter8 save area
+// [12] Parameter9 slot (if necessary)
+// ...
+const int kNumRequiredStackFrameSlots = 12;
+const int kStackFrameLRSlot = 2;
+const int kStackFrameExtraParamSlot = 12;
+#elif V8_OS_AIX || V8_TARGET_ARCH_PPC64
+// [0] back chain
+// [1] condition register save area
+// [2] link register save area
+// [3] reserved for compiler
+// [4] reserved by binder
+// [5] TOC save area
+// [6] Parameter1 save area
+// ...
+// [13] Parameter8 save area
+// [14] Parameter9 slot (if necessary)
+// ...
+#if V8_TARGET_ARCH_PPC64
+const int kNumRequiredStackFrameSlots = 14;
+#else
+const int kNumRequiredStackFrameSlots = 16;
+#endif
+const int kStackFrameLRSlot = 2;
+const int kStackFrameExtraParamSlot = 14;
+#else
+// [0] back chain
+// [1] link register save area
+// [2] Parameter9 slot (if necessary)
+// ...
+const int kNumRequiredStackFrameSlots = 4;
+const int kStackFrameLRSlot = 1;
+const int kStackFrameExtraParamSlot = 2;
+#endif
+
+// ----------------------------------------------------
+
+
+class EntryFrameConstants : public AllStatic {
+ public:
+ static const int kCallerFPOffset =
+ -(StandardFrameConstants::kFixedFrameSizeFromFp + kPointerSize);
+};
+
+
+class ExitFrameConstants : public AllStatic {
+ public:
+#if V8_OOL_CONSTANT_POOL
+ static const int kFrameSize = 3 * kPointerSize;
+ static const int kConstantPoolOffset = -3 * kPointerSize;
+#else
+ static const int kFrameSize = 2 * kPointerSize;
+ static const int kConstantPoolOffset = 0; // Not used.
+#endif
+ static const int kCodeOffset = -2 * kPointerSize;
+ static const int kSPOffset = -1 * kPointerSize;
+
+ // The caller fields are below the frame pointer on the stack.
+ static const int kCallerFPOffset = 0 * kPointerSize;
+ // The calling JS function is below FP.
+ static const int kCallerPCOffset = 1 * kPointerSize;
+
+ // FP-relative displacement of the caller's SP. It points just
+ // below the saved PC.
+ static const int kCallerSPDisplacement = 2 * kPointerSize;
+};
+
+
+class JavaScriptFrameConstants : public AllStatic {
+ public:
+ // FP-relative.
+ static const int kLocal0Offset = StandardFrameConstants::kExpressionsOffset;
+ static const int kLastParameterOffset = +2 * kPointerSize;
+ static const int kFunctionOffset = StandardFrameConstants::kMarkerOffset;
+
+ // Caller SP-relative.
+ static const int kParam0Offset = -2 * kPointerSize;
+ static const int kReceiverOffset = -1 * kPointerSize;
+};
+
+
+class ArgumentsAdaptorFrameConstants : public AllStatic {
+ public:
+ // FP-relative.
+ static const int kLengthOffset = StandardFrameConstants::kExpressionsOffset;
+
+ static const int kFrameSize =
+ StandardFrameConstants::kFixedFrameSize + kPointerSize;
+};
+
+
+class ConstructFrameConstants : public AllStatic {
+ public:
+ // FP-relative.
+ static const int kImplicitReceiverOffset = -6 * kPointerSize;
+ static const int kConstructorOffset = -5 * kPointerSize;
+ static const int kLengthOffset = -4 * kPointerSize;
+ static const int kCodeOffset = StandardFrameConstants::kExpressionsOffset;
+
+ static const int kFrameSize =
+ StandardFrameConstants::kFixedFrameSize + 4 * kPointerSize;
+};
+
+
+class InternalFrameConstants : public AllStatic {
+ public:
+ // FP-relative.
+ static const int kCodeOffset = StandardFrameConstants::kExpressionsOffset;
+};
+
+
+inline Object* JavaScriptFrame::function_slot_object() const {
+ const int offset = JavaScriptFrameConstants::kFunctionOffset;
+ return Memory::Object_at(fp() + offset);
+}
+
+
+inline void StackHandler::SetFp(Address slot, Address fp) {
+ Memory::Address_at(slot) = fp;
+}
+}
+} // namespace v8::internal
+
+#endif // V8_PPC_FRAMES_PPC_H_
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/code-factory.h"
+#include "src/code-stubs.h"
+#include "src/codegen.h"
+#include "src/compiler.h"
+#include "src/debug.h"
+#include "src/full-codegen.h"
+#include "src/ic/ic.h"
+#include "src/isolate-inl.h"
+#include "src/parser.h"
+#include "src/scopes.h"
+
+#include "src/ppc/code-stubs-ppc.h"
+#include "src/ppc/macro-assembler-ppc.h"
+
+namespace v8 {
+namespace internal {
+
+#define __ ACCESS_MASM(masm_)
+
+// A patch site is a location in the code which it is possible to patch. This
+// class has a number of methods to emit the code which is patchable and the
+// method EmitPatchInfo to record a marker back to the patchable code. This
+// marker is a cmpi rx, #yyy instruction, and x * 0x0000ffff + yyy (raw 16 bit
+// immediate value is used) is the delta from the pc to the first instruction of
+// the patchable code.
+// See PatchInlinedSmiCode in ic-ppc.cc for the code that patches it
+class JumpPatchSite BASE_EMBEDDED {
+ public:
+ explicit JumpPatchSite(MacroAssembler* masm) : masm_(masm) {
+#ifdef DEBUG
+ info_emitted_ = false;
+#endif
+ }
+
+ ~JumpPatchSite() { DCHECK(patch_site_.is_bound() == info_emitted_); }
+
+ // When initially emitting this ensure that a jump is always generated to skip
+ // the inlined smi code.
+ void EmitJumpIfNotSmi(Register reg, Label* target) {
+ DCHECK(!patch_site_.is_bound() && !info_emitted_);
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);
+ __ bind(&patch_site_);
+ __ cmp(reg, reg, cr0);
+ __ beq(target, cr0); // Always taken before patched.
+ }
+
+ // When initially emitting this ensure that a jump is never generated to skip
+ // the inlined smi code.
+ void EmitJumpIfSmi(Register reg, Label* target) {
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);
+ DCHECK(!patch_site_.is_bound() && !info_emitted_);
+ __ bind(&patch_site_);
+ __ cmp(reg, reg, cr0);
+ __ bne(target, cr0); // Never taken before patched.
+ }
+
+ void EmitPatchInfo() {
+ if (patch_site_.is_bound()) {
+ int delta_to_patch_site = masm_->InstructionsGeneratedSince(&patch_site_);
+ Register reg;
+ // I believe this is using reg as the high bits of of the offset
+ reg.set_code(delta_to_patch_site / kOff16Mask);
+ __ cmpi(reg, Operand(delta_to_patch_site % kOff16Mask));
+#ifdef DEBUG
+ info_emitted_ = true;
+#endif
+ } else {
+ __ nop(); // Signals no inlined code.
+ }
+ }
+
+ private:
+ MacroAssembler* masm_;
+ Label patch_site_;
+#ifdef DEBUG
+ bool info_emitted_;
+#endif
+};
+
+
+// Generate code for a JS function. On entry to the function the receiver
+// and arguments have been pushed on the stack left to right. The actual
+// argument count matches the formal parameter count expected by the
+// function.
+//
+// The live registers are:
+// o r4: the JS function object being called (i.e., ourselves)
+// o cp: our context
+// o fp: our caller's frame pointer (aka r31)
+// o sp: stack pointer
+// o lr: return address
+// o ip: our own function entry (required by the prologue)
+//
+// The function builds a JS frame. Please see JavaScriptFrameConstants in
+// frames-ppc.h for its layout.
+void FullCodeGenerator::Generate() {
+ CompilationInfo* info = info_;
+ handler_table_ =
+ isolate()->factory()->NewFixedArray(function()->handler_count(), TENURED);
+
+ profiling_counter_ = isolate()->factory()->NewCell(
+ Handle<Smi>(Smi::FromInt(FLAG_interrupt_budget), isolate()));
+ SetFunctionPosition(function());
+ Comment cmnt(masm_, "[ function compiled by full code generator");
+
+ ProfileEntryHookStub::MaybeCallEntryHook(masm_);
+
+#ifdef DEBUG
+ if (strlen(FLAG_stop_at) > 0 &&
+ info->function()->name()->IsUtf8EqualTo(CStrVector(FLAG_stop_at))) {
+ __ stop("stop-at");
+ }
+#endif
+
+ // Sloppy mode functions and builtins need to replace the receiver with the
+ // global proxy when called as functions (without an explicit receiver
+ // object).
+ if (info->strict_mode() == SLOPPY && !info->is_native()) {
+ Label ok;
+ int receiver_offset = info->scope()->num_parameters() * kPointerSize;
+ __ LoadP(r5, MemOperand(sp, receiver_offset), r0);
+ __ CompareRoot(r5, Heap::kUndefinedValueRootIndex);
+ __ bne(&ok);
+
+ __ LoadP(r5, GlobalObjectOperand());
+ __ LoadP(r5, FieldMemOperand(r5, GlobalObject::kGlobalProxyOffset));
+
+ __ StoreP(r5, MemOperand(sp, receiver_offset), r0);
+
+ __ bind(&ok);
+ }
+
+ // Open a frame scope to indicate that there is a frame on the stack. The
+ // MANUAL indicates that the scope shouldn't actually generate code to set up
+ // the frame (that is done below).
+ FrameScope frame_scope(masm_, StackFrame::MANUAL);
+ int prologue_offset = masm_->pc_offset();
+
+ if (prologue_offset) {
+ // Prologue logic requires it's starting address in ip and the
+ // corresponding offset from the function entry.
+ prologue_offset += Instruction::kInstrSize;
+ __ addi(ip, ip, Operand(prologue_offset));
+ }
+ info->set_prologue_offset(prologue_offset);
+ __ Prologue(info->IsCodePreAgingActive(), prologue_offset);
+ info->AddNoFrameRange(0, masm_->pc_offset());
+
+ {
+ Comment cmnt(masm_, "[ Allocate locals");
+ int locals_count = info->scope()->num_stack_slots();
+ // Generators allocate locals, if any, in context slots.
+ DCHECK(!info->function()->is_generator() || locals_count == 0);
+ if (locals_count > 0) {
+ if (locals_count >= 128) {
+ Label ok;
+ __ Add(ip, sp, -(locals_count * kPointerSize), r0);
+ __ LoadRoot(r5, Heap::kRealStackLimitRootIndex);
+ __ cmpl(ip, r5);
+ __ bc_short(ge, &ok);
+ __ InvokeBuiltin(Builtins::STACK_OVERFLOW, CALL_FUNCTION);
+ __ bind(&ok);
+ }
+ __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
+ int kMaxPushes = FLAG_optimize_for_size ? 4 : 32;
+ if (locals_count >= kMaxPushes) {
+ int loop_iterations = locals_count / kMaxPushes;
+ __ mov(r5, Operand(loop_iterations));
+ __ mtctr(r5);
+ Label loop_header;
+ __ bind(&loop_header);
+ // Do pushes.
+ for (int i = 0; i < kMaxPushes; i++) {
+ __ push(ip);
+ }
+ // Continue loop if not done.
+ __ bdnz(&loop_header);
+ }
+ int remaining = locals_count % kMaxPushes;
+ // Emit the remaining pushes.
+ for (int i = 0; i < remaining; i++) {
+ __ push(ip);
+ }
+ }
+ }
+
+ bool function_in_register = true;
+
+ // Possibly allocate a local context.
+ int heap_slots = info->scope()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
+ if (heap_slots > 0) {
+ // Argument to NewContext is the function, which is still in r4.
+ Comment cmnt(masm_, "[ Allocate context");
+ bool need_write_barrier = true;
+ if (FLAG_harmony_scoping && info->scope()->is_global_scope()) {
+ __ push(r4);
+ __ Push(info->scope()->GetScopeInfo());
+ __ CallRuntime(Runtime::kNewGlobalContext, 2);
+ } else if (heap_slots <= FastNewContextStub::kMaximumSlots) {
+ FastNewContextStub stub(isolate(), heap_slots);
+ __ CallStub(&stub);
+ // Result of FastNewContextStub is always in new space.
+ need_write_barrier = false;
+ } else {
+ __ push(r4);
+ __ CallRuntime(Runtime::kNewFunctionContext, 1);
+ }
+ function_in_register = false;
+ // Context is returned in r3. It replaces the context passed to us.
+ // It's saved in the stack and kept live in cp.
+ __ mr(cp, r3);
+ __ StoreP(r3, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ // Copy any necessary parameters into the context.
+ int num_parameters = info->scope()->num_parameters();
+ for (int i = 0; i < num_parameters; i++) {
+ Variable* var = scope()->parameter(i);
+ if (var->IsContextSlot()) {
+ int parameter_offset = StandardFrameConstants::kCallerSPOffset +
+ (num_parameters - 1 - i) * kPointerSize;
+ // Load parameter from stack.
+ __ LoadP(r3, MemOperand(fp, parameter_offset), r0);
+ // Store it in the context.
+ MemOperand target = ContextOperand(cp, var->index());
+ __ StoreP(r3, target, r0);
+
+ // Update the write barrier.
+ if (need_write_barrier) {
+ __ RecordWriteContextSlot(cp, target.offset(), r3, r6,
+ kLRHasBeenSaved, kDontSaveFPRegs);
+ } else if (FLAG_debug_code) {
+ Label done;
+ __ JumpIfInNewSpace(cp, r3, &done);
+ __ Abort(kExpectedNewSpaceObject);
+ __ bind(&done);
+ }
+ }
+ }
+ }
+
+ Variable* arguments = scope()->arguments();
+ if (arguments != NULL) {
+ // Function uses arguments object.
+ Comment cmnt(masm_, "[ Allocate arguments object");
+ if (!function_in_register) {
+ // Load this again, if it's used by the local context below.
+ __ LoadP(r6, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ } else {
+ __ mr(r6, r4);
+ }
+ // Receiver is just before the parameters on the caller's stack.
+ int num_parameters = info->scope()->num_parameters();
+ int offset = num_parameters * kPointerSize;
+ __ addi(r5, fp, Operand(StandardFrameConstants::kCallerSPOffset + offset));
+ __ LoadSmiLiteral(r4, Smi::FromInt(num_parameters));
+ __ Push(r6, r5, r4);
+
+ // Arguments to ArgumentsAccessStub:
+ // function, receiver address, parameter count.
+ // The stub will rewrite receiever and parameter count if the previous
+ // stack frame was an arguments adapter frame.
+ ArgumentsAccessStub::Type type;
+ if (strict_mode() == STRICT) {
+ type = ArgumentsAccessStub::NEW_STRICT;
+ } else if (function()->has_duplicate_parameters()) {
+ type = ArgumentsAccessStub::NEW_SLOPPY_SLOW;
+ } else {
+ type = ArgumentsAccessStub::NEW_SLOPPY_FAST;
+ }
+ ArgumentsAccessStub stub(isolate(), type);
+ __ CallStub(&stub);
+
+ SetVar(arguments, r3, r4, r5);
+ }
+
+ if (FLAG_trace) {
+ __ CallRuntime(Runtime::kTraceEnter, 0);
+ }
+
+ // Visit the declarations and body unless there is an illegal
+ // redeclaration.
+ if (scope()->HasIllegalRedeclaration()) {
+ Comment cmnt(masm_, "[ Declarations");
+ scope()->VisitIllegalRedeclaration(this);
+
+ } else {
+ PrepareForBailoutForId(BailoutId::FunctionEntry(), NO_REGISTERS);
+ {
+ Comment cmnt(masm_, "[ Declarations");
+ // For named function expressions, declare the function name as a
+ // constant.
+ if (scope()->is_function_scope() && scope()->function() != NULL) {
+ VariableDeclaration* function = scope()->function();
+ DCHECK(function->proxy()->var()->mode() == CONST ||
+ function->proxy()->var()->mode() == CONST_LEGACY);
+ DCHECK(function->proxy()->var()->location() != Variable::UNALLOCATED);
+ VisitVariableDeclaration(function);
+ }
+ VisitDeclarations(scope()->declarations());
+ }
+
+ {
+ Comment cmnt(masm_, "[ Stack check");
+ PrepareForBailoutForId(BailoutId::Declarations(), NO_REGISTERS);
+ Label ok;
+ __ LoadRoot(ip, Heap::kStackLimitRootIndex);
+ __ cmpl(sp, ip);
+ __ bc_short(ge, &ok);
+ __ Call(isolate()->builtins()->StackCheck(), RelocInfo::CODE_TARGET);
+ __ bind(&ok);
+ }
+
+ {
+ Comment cmnt(masm_, "[ Body");
+ DCHECK(loop_depth() == 0);
+ VisitStatements(function()->body());
+ DCHECK(loop_depth() == 0);
+ }
+ }
+
+ // Always emit a 'return undefined' in case control fell off the end of
+ // the body.
+ {
+ Comment cmnt(masm_, "[ return <undefined>;");
+ __ LoadRoot(r3, Heap::kUndefinedValueRootIndex);
+ }
+ EmitReturnSequence();
+}
+
+
+void FullCodeGenerator::ClearAccumulator() {
+ __ LoadSmiLiteral(r3, Smi::FromInt(0));
+}
+
+
+void FullCodeGenerator::EmitProfilingCounterDecrement(int delta) {
+ __ mov(r5, Operand(profiling_counter_));
+ __ LoadP(r6, FieldMemOperand(r5, Cell::kValueOffset));
+ __ SubSmiLiteral(r6, r6, Smi::FromInt(delta), r0);
+ __ StoreP(r6, FieldMemOperand(r5, Cell::kValueOffset), r0);
+}
+
+
+void FullCodeGenerator::EmitProfilingCounterReset() {
+ int reset_value = FLAG_interrupt_budget;
+ if (info_->is_debug()) {
+ // Detect debug break requests as soon as possible.
+ reset_value = FLAG_interrupt_budget >> 4;
+ }
+ __ mov(r5, Operand(profiling_counter_));
+ __ LoadSmiLiteral(r6, Smi::FromInt(reset_value));
+ __ StoreP(r6, FieldMemOperand(r5, Cell::kValueOffset), r0);
+}
+
+
+void FullCodeGenerator::EmitBackEdgeBookkeeping(IterationStatement* stmt,
+ Label* back_edge_target) {
+ Comment cmnt(masm_, "[ Back edge bookkeeping");
+ Label ok;
+
+ DCHECK(back_edge_target->is_bound());
+ int distance = masm_->SizeOfCodeGeneratedSince(back_edge_target) +
+ kCodeSizeMultiplier / 2;
+ int weight = Min(kMaxBackEdgeWeight, Max(1, distance / kCodeSizeMultiplier));
+ EmitProfilingCounterDecrement(weight);
+ {
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);
+ // BackEdgeTable::PatchAt manipulates this sequence.
+ __ cmpi(r6, Operand::Zero());
+ __ bc_short(ge, &ok);
+ __ Call(isolate()->builtins()->InterruptCheck(), RelocInfo::CODE_TARGET);
+
+ // Record a mapping of this PC offset to the OSR id. This is used to find
+ // the AST id from the unoptimized code in order to use it as a key into
+ // the deoptimization input data found in the optimized code.
+ RecordBackEdge(stmt->OsrEntryId());
+ }
+ EmitProfilingCounterReset();
+
+ __ bind(&ok);
+ PrepareForBailoutForId(stmt->EntryId(), NO_REGISTERS);
+ // Record a mapping of the OSR id to this PC. This is used if the OSR
+ // entry becomes the target of a bailout. We don't expect it to be, but
+ // we want it to work if it is.
+ PrepareForBailoutForId(stmt->OsrEntryId(), NO_REGISTERS);
+}
+
+
+void FullCodeGenerator::EmitReturnSequence() {
+ Comment cmnt(masm_, "[ Return sequence");
+ if (return_label_.is_bound()) {
+ __ b(&return_label_);
+ } else {
+ __ bind(&return_label_);
+ if (FLAG_trace) {
+ // Push the return value on the stack as the parameter.
+ // Runtime::TraceExit returns its parameter in r3
+ __ push(r3);
+ __ CallRuntime(Runtime::kTraceExit, 1);
+ }
+ // Pretend that the exit is a backwards jump to the entry.
+ int weight = 1;
+ if (info_->ShouldSelfOptimize()) {
+ weight = FLAG_interrupt_budget / FLAG_self_opt_count;
+ } else {
+ int distance = masm_->pc_offset() + kCodeSizeMultiplier / 2;
+ weight = Min(kMaxBackEdgeWeight, Max(1, distance / kCodeSizeMultiplier));
+ }
+ EmitProfilingCounterDecrement(weight);
+ Label ok;
+ __ cmpi(r6, Operand::Zero());
+ __ bge(&ok);
+ __ push(r3);
+ __ Call(isolate()->builtins()->InterruptCheck(), RelocInfo::CODE_TARGET);
+ __ pop(r3);
+ EmitProfilingCounterReset();
+ __ bind(&ok);
+
+#ifdef DEBUG
+ // Add a label for checking the size of the code used for returning.
+ Label check_exit_codesize;
+ __ bind(&check_exit_codesize);
+#endif
+ // Make sure that the constant pool is not emitted inside of the return
+ // sequence.
+ {
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);
+ int32_t sp_delta = (info_->scope()->num_parameters() + 1) * kPointerSize;
+ CodeGenerator::RecordPositions(masm_, function()->end_position() - 1);
+ __ RecordJSReturn();
+ int no_frame_start = __ LeaveFrame(StackFrame::JAVA_SCRIPT, sp_delta);
+#if V8_TARGET_ARCH_PPC64
+ // With 64bit we may need nop() instructions to ensure we have
+ // enough space to SetDebugBreakAtReturn()
+ if (is_int16(sp_delta)) {
+#if !V8_OOL_CONSTANT_POOL
+ masm_->nop();
+#endif
+ masm_->nop();
+ }
+#endif
+ __ blr();
+ info_->AddNoFrameRange(no_frame_start, masm_->pc_offset());
+ }
+
+#ifdef DEBUG
+ // Check that the size of the code used for returning is large enough
+ // for the debugger's requirements.
+ DCHECK(Assembler::kJSReturnSequenceInstructions <=
+ masm_->InstructionsGeneratedSince(&check_exit_codesize));
+#endif
+ }
+}
+
+
+void FullCodeGenerator::EffectContext::Plug(Variable* var) const {
+ DCHECK(var->IsStackAllocated() || var->IsContextSlot());
+}
+
+
+void FullCodeGenerator::AccumulatorValueContext::Plug(Variable* var) const {
+ DCHECK(var->IsStackAllocated() || var->IsContextSlot());
+ codegen()->GetVar(result_register(), var);
+}
+
+
+void FullCodeGenerator::StackValueContext::Plug(Variable* var) const {
+ DCHECK(var->IsStackAllocated() || var->IsContextSlot());
+ codegen()->GetVar(result_register(), var);
+ __ push(result_register());
+}
+
+
+void FullCodeGenerator::TestContext::Plug(Variable* var) const {
+ DCHECK(var->IsStackAllocated() || var->IsContextSlot());
+ // For simplicity we always test the accumulator register.
+ codegen()->GetVar(result_register(), var);
+ codegen()->PrepareForBailoutBeforeSplit(condition(), false, NULL, NULL);
+ codegen()->DoTest(this);
+}
+
+
+void FullCodeGenerator::EffectContext::Plug(Heap::RootListIndex index) const {}
+
+
+void FullCodeGenerator::AccumulatorValueContext::Plug(
+ Heap::RootListIndex index) const {
+ __ LoadRoot(result_register(), index);
+}
+
+
+void FullCodeGenerator::StackValueContext::Plug(
+ Heap::RootListIndex index) const {
+ __ LoadRoot(result_register(), index);
+ __ push(result_register());
+}
+
+
+void FullCodeGenerator::TestContext::Plug(Heap::RootListIndex index) const {
+ codegen()->PrepareForBailoutBeforeSplit(condition(), true, true_label_,
+ false_label_);
+ if (index == Heap::kUndefinedValueRootIndex ||
+ index == Heap::kNullValueRootIndex ||
+ index == Heap::kFalseValueRootIndex) {
+ if (false_label_ != fall_through_) __ b(false_label_);
+ } else if (index == Heap::kTrueValueRootIndex) {
+ if (true_label_ != fall_through_) __ b(true_label_);
+ } else {
+ __ LoadRoot(result_register(), index);
+ codegen()->DoTest(this);
+ }
+}
+
+
+void FullCodeGenerator::EffectContext::Plug(Handle<Object> lit) const {}
+
+
+void FullCodeGenerator::AccumulatorValueContext::Plug(
+ Handle<Object> lit) const {
+ __ mov(result_register(), Operand(lit));
+}
+
+
+void FullCodeGenerator::StackValueContext::Plug(Handle<Object> lit) const {
+ // Immediates cannot be pushed directly.
+ __ mov(result_register(), Operand(lit));
+ __ push(result_register());
+}
+
+
+void FullCodeGenerator::TestContext::Plug(Handle<Object> lit) const {
+ codegen()->PrepareForBailoutBeforeSplit(condition(), true, true_label_,
+ false_label_);
+ DCHECK(!lit->IsUndetectableObject()); // There are no undetectable literals.
+ if (lit->IsUndefined() || lit->IsNull() || lit->IsFalse()) {
+ if (false_label_ != fall_through_) __ b(false_label_);
+ } else if (lit->IsTrue() || lit->IsJSObject()) {
+ if (true_label_ != fall_through_) __ b(true_label_);
+ } else if (lit->IsString()) {
+ if (String::cast(*lit)->length() == 0) {
+ if (false_label_ != fall_through_) __ b(false_label_);
+ } else {
+ if (true_label_ != fall_through_) __ b(true_label_);
+ }
+ } else if (lit->IsSmi()) {
+ if (Smi::cast(*lit)->value() == 0) {
+ if (false_label_ != fall_through_) __ b(false_label_);
+ } else {
+ if (true_label_ != fall_through_) __ b(true_label_);
+ }
+ } else {
+ // For simplicity we always test the accumulator register.
+ __ mov(result_register(), Operand(lit));
+ codegen()->DoTest(this);
+ }
+}
+
+
+void FullCodeGenerator::EffectContext::DropAndPlug(int count,
+ Register reg) const {
+ DCHECK(count > 0);
+ __ Drop(count);
+}
+
+
+void FullCodeGenerator::AccumulatorValueContext::DropAndPlug(
+ int count, Register reg) const {
+ DCHECK(count > 0);
+ __ Drop(count);
+ __ Move(result_register(), reg);
+}
+
+
+void FullCodeGenerator::StackValueContext::DropAndPlug(int count,
+ Register reg) const {
+ DCHECK(count > 0);
+ if (count > 1) __ Drop(count - 1);
+ __ StoreP(reg, MemOperand(sp, 0));
+}
+
+
+void FullCodeGenerator::TestContext::DropAndPlug(int count,
+ Register reg) const {
+ DCHECK(count > 0);
+ // For simplicity we always test the accumulator register.
+ __ Drop(count);
+ __ Move(result_register(), reg);
+ codegen()->PrepareForBailoutBeforeSplit(condition(), false, NULL, NULL);
+ codegen()->DoTest(this);
+}
+
+
+void FullCodeGenerator::EffectContext::Plug(Label* materialize_true,
+ Label* materialize_false) const {
+ DCHECK(materialize_true == materialize_false);
+ __ bind(materialize_true);
+}
+
+
+void FullCodeGenerator::AccumulatorValueContext::Plug(
+ Label* materialize_true, Label* materialize_false) const {
+ Label done;
+ __ bind(materialize_true);
+ __ LoadRoot(result_register(), Heap::kTrueValueRootIndex);
+ __ b(&done);
+ __ bind(materialize_false);
+ __ LoadRoot(result_register(), Heap::kFalseValueRootIndex);
+ __ bind(&done);
+}
+
+
+void FullCodeGenerator::StackValueContext::Plug(
+ Label* materialize_true, Label* materialize_false) const {
+ Label done;
+ __ bind(materialize_true);
+ __ LoadRoot(ip, Heap::kTrueValueRootIndex);
+ __ b(&done);
+ __ bind(materialize_false);
+ __ LoadRoot(ip, Heap::kFalseValueRootIndex);
+ __ bind(&done);
+ __ push(ip);
+}
+
+
+void FullCodeGenerator::TestContext::Plug(Label* materialize_true,
+ Label* materialize_false) const {
+ DCHECK(materialize_true == true_label_);
+ DCHECK(materialize_false == false_label_);
+}
+
+
+void FullCodeGenerator::EffectContext::Plug(bool flag) const {}
+
+
+void FullCodeGenerator::AccumulatorValueContext::Plug(bool flag) const {
+ Heap::RootListIndex value_root_index =
+ flag ? Heap::kTrueValueRootIndex : Heap::kFalseValueRootIndex;
+ __ LoadRoot(result_register(), value_root_index);
+}
+
+
+void FullCodeGenerator::StackValueContext::Plug(bool flag) const {
+ Heap::RootListIndex value_root_index =
+ flag ? Heap::kTrueValueRootIndex : Heap::kFalseValueRootIndex;
+ __ LoadRoot(ip, value_root_index);
+ __ push(ip);
+}
+
+
+void FullCodeGenerator::TestContext::Plug(bool flag) const {
+ codegen()->PrepareForBailoutBeforeSplit(condition(), true, true_label_,
+ false_label_);
+ if (flag) {
+ if (true_label_ != fall_through_) __ b(true_label_);
+ } else {
+ if (false_label_ != fall_through_) __ b(false_label_);
+ }
+}
+
+
+void FullCodeGenerator::DoTest(Expression* condition, Label* if_true,
+ Label* if_false, Label* fall_through) {
+ Handle<Code> ic = ToBooleanStub::GetUninitialized(isolate());
+ CallIC(ic, condition->test_id());
+ __ cmpi(result_register(), Operand::Zero());
+ Split(ne, if_true, if_false, fall_through);
+}
+
+
+void FullCodeGenerator::Split(Condition cond, Label* if_true, Label* if_false,
+ Label* fall_through, CRegister cr) {
+ if (if_false == fall_through) {
+ __ b(cond, if_true, cr);
+ } else if (if_true == fall_through) {
+ __ b(NegateCondition(cond), if_false, cr);
+ } else {
+ __ b(cond, if_true, cr);
+ __ b(if_false);
+ }
+}
+
+
+MemOperand FullCodeGenerator::StackOperand(Variable* var) {
+ DCHECK(var->IsStackAllocated());
+ // Offset is negative because higher indexes are at lower addresses.
+ int offset = -var->index() * kPointerSize;
+ // Adjust by a (parameter or local) base offset.
+ if (var->IsParameter()) {
+ offset += (info_->scope()->num_parameters() + 1) * kPointerSize;
+ } else {
+ offset += JavaScriptFrameConstants::kLocal0Offset;
+ }
+ return MemOperand(fp, offset);
+}
+
+
+MemOperand FullCodeGenerator::VarOperand(Variable* var, Register scratch) {
+ DCHECK(var->IsContextSlot() || var->IsStackAllocated());
+ if (var->IsContextSlot()) {
+ int context_chain_length = scope()->ContextChainLength(var->scope());
+ __ LoadContext(scratch, context_chain_length);
+ return ContextOperand(scratch, var->index());
+ } else {
+ return StackOperand(var);
+ }
+}
+
+
+void FullCodeGenerator::GetVar(Register dest, Variable* var) {
+ // Use destination as scratch.
+ MemOperand location = VarOperand(var, dest);
+ __ LoadP(dest, location, r0);
+}
+
+
+void FullCodeGenerator::SetVar(Variable* var, Register src, Register scratch0,
+ Register scratch1) {
+ DCHECK(var->IsContextSlot() || var->IsStackAllocated());
+ DCHECK(!scratch0.is(src));
+ DCHECK(!scratch0.is(scratch1));
+ DCHECK(!scratch1.is(src));
+ MemOperand location = VarOperand(var, scratch0);
+ __ StoreP(src, location, r0);
+
+ // Emit the write barrier code if the location is in the heap.
+ if (var->IsContextSlot()) {
+ __ RecordWriteContextSlot(scratch0, location.offset(), src, scratch1,
+ kLRHasBeenSaved, kDontSaveFPRegs);
+ }
+}
+
+
+void FullCodeGenerator::PrepareForBailoutBeforeSplit(Expression* expr,
+ bool should_normalize,
+ Label* if_true,
+ Label* if_false) {
+ // Only prepare for bailouts before splits if we're in a test
+ // context. Otherwise, we let the Visit function deal with the
+ // preparation to avoid preparing with the same AST id twice.
+ if (!context()->IsTest() || !info_->IsOptimizable()) return;
+
+ Label skip;
+ if (should_normalize) __ b(&skip);
+ PrepareForBailout(expr, TOS_REG);
+ if (should_normalize) {
+ __ LoadRoot(ip, Heap::kTrueValueRootIndex);
+ __ cmp(r3, ip);
+ Split(eq, if_true, if_false, NULL);
+ __ bind(&skip);
+ }
+}
+
+
+void FullCodeGenerator::EmitDebugCheckDeclarationContext(Variable* variable) {
+ // The variable in the declaration always resides in the current function
+ // context.
+ DCHECK_EQ(0, scope()->ContextChainLength(variable->scope()));
+ if (generate_debug_code_) {
+ // Check that we're not inside a with or catch context.
+ __ LoadP(r4, FieldMemOperand(cp, HeapObject::kMapOffset));
+ __ CompareRoot(r4, Heap::kWithContextMapRootIndex);
+ __ Check(ne, kDeclarationInWithContext);
+ __ CompareRoot(r4, Heap::kCatchContextMapRootIndex);
+ __ Check(ne, kDeclarationInCatchContext);
+ }
+}
+
+
+void FullCodeGenerator::VisitVariableDeclaration(
+ VariableDeclaration* declaration) {
+ // If it was not possible to allocate the variable at compile time, we
+ // need to "declare" it at runtime to make sure it actually exists in the
+ // local context.
+ VariableProxy* proxy = declaration->proxy();
+ VariableMode mode = declaration->mode();
+ Variable* variable = proxy->var();
+ bool hole_init = mode == LET || mode == CONST || mode == CONST_LEGACY;
+ switch (variable->location()) {
+ case Variable::UNALLOCATED:
+ globals_->Add(variable->name(), zone());
+ globals_->Add(variable->binding_needs_init()
+ ? isolate()->factory()->the_hole_value()
+ : isolate()->factory()->undefined_value(),
+ zone());
+ break;
+
+ case Variable::PARAMETER:
+ case Variable::LOCAL:
+ if (hole_init) {
+ Comment cmnt(masm_, "[ VariableDeclaration");
+ __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
+ __ StoreP(ip, StackOperand(variable));
+ }
+ break;
+
+ case Variable::CONTEXT:
+ if (hole_init) {
+ Comment cmnt(masm_, "[ VariableDeclaration");
+ EmitDebugCheckDeclarationContext(variable);
+ __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
+ __ StoreP(ip, ContextOperand(cp, variable->index()), r0);
+ // No write barrier since the_hole_value is in old space.
+ PrepareForBailoutForId(proxy->id(), NO_REGISTERS);
+ }
+ break;
+
+ case Variable::LOOKUP: {
+ Comment cmnt(masm_, "[ VariableDeclaration");
+ __ mov(r5, Operand(variable->name()));
+ // Declaration nodes are always introduced in one of four modes.
+ DCHECK(IsDeclaredVariableMode(mode));
+ PropertyAttributes attr =
+ IsImmutableVariableMode(mode) ? READ_ONLY : NONE;
+ __ LoadSmiLiteral(r4, Smi::FromInt(attr));
+ // Push initial value, if any.
+ // Note: For variables we must not push an initial value (such as
+ // 'undefined') because we may have a (legal) redeclaration and we
+ // must not destroy the current value.
+ if (hole_init) {
+ __ LoadRoot(r3, Heap::kTheHoleValueRootIndex);
+ __ Push(cp, r5, r4, r3);
+ } else {
+ __ LoadSmiLiteral(r3, Smi::FromInt(0)); // Indicates no initial value.
+ __ Push(cp, r5, r4, r3);
+ }
+ __ CallRuntime(Runtime::kDeclareLookupSlot, 4);
+ break;
+ }
+ }
+}
+
+
+void FullCodeGenerator::VisitFunctionDeclaration(
+ FunctionDeclaration* declaration) {
+ VariableProxy* proxy = declaration->proxy();
+ Variable* variable = proxy->var();
+ switch (variable->location()) {
+ case Variable::UNALLOCATED: {
+ globals_->Add(variable->name(), zone());
+ Handle<SharedFunctionInfo> function =
+ Compiler::BuildFunctionInfo(declaration->fun(), script(), info_);
+ // Check for stack-overflow exception.
+ if (function.is_null()) return SetStackOverflow();
+ globals_->Add(function, zone());
+ break;
+ }
+
+ case Variable::PARAMETER:
+ case Variable::LOCAL: {
+ Comment cmnt(masm_, "[ FunctionDeclaration");
+ VisitForAccumulatorValue(declaration->fun());
+ __ StoreP(result_register(), StackOperand(variable));
+ break;
+ }
+
+ case Variable::CONTEXT: {
+ Comment cmnt(masm_, "[ FunctionDeclaration");
+ EmitDebugCheckDeclarationContext(variable);
+ VisitForAccumulatorValue(declaration->fun());
+ __ StoreP(result_register(), ContextOperand(cp, variable->index()), r0);
+ int offset = Context::SlotOffset(variable->index());
+ // We know that we have written a function, which is not a smi.
+ __ RecordWriteContextSlot(cp, offset, result_register(), r5,
+ kLRHasBeenSaved, kDontSaveFPRegs,
+ EMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
+ PrepareForBailoutForId(proxy->id(), NO_REGISTERS);
+ break;
+ }
+
+ case Variable::LOOKUP: {
+ Comment cmnt(masm_, "[ FunctionDeclaration");
+ __ mov(r5, Operand(variable->name()));
+ __ LoadSmiLiteral(r4, Smi::FromInt(NONE));
+ __ Push(cp, r5, r4);
+ // Push initial value for function declaration.
+ VisitForStackValue(declaration->fun());
+ __ CallRuntime(Runtime::kDeclareLookupSlot, 4);
+ break;
+ }
+ }
+}
+
+
+void FullCodeGenerator::VisitModuleDeclaration(ModuleDeclaration* declaration) {
+ Variable* variable = declaration->proxy()->var();
+ DCHECK(variable->location() == Variable::CONTEXT);
+ DCHECK(variable->interface()->IsFrozen());
+
+ Comment cmnt(masm_, "[ ModuleDeclaration");
+ EmitDebugCheckDeclarationContext(variable);
+
+ // Load instance object.
+ __ LoadContext(r4, scope_->ContextChainLength(scope_->GlobalScope()));
+ __ LoadP(r4, ContextOperand(r4, variable->interface()->Index()));
+ __ LoadP(r4, ContextOperand(r4, Context::EXTENSION_INDEX));
+
+ // Assign it.
+ __ StoreP(r4, ContextOperand(cp, variable->index()), r0);
+ // We know that we have written a module, which is not a smi.
+ __ RecordWriteContextSlot(cp, Context::SlotOffset(variable->index()), r4, r6,
+ kLRHasBeenSaved, kDontSaveFPRegs,
+ EMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
+ PrepareForBailoutForId(declaration->proxy()->id(), NO_REGISTERS);
+
+ // Traverse into body.
+ Visit(declaration->module());
+}
+
+
+void FullCodeGenerator::VisitImportDeclaration(ImportDeclaration* declaration) {
+ VariableProxy* proxy = declaration->proxy();
+ Variable* variable = proxy->var();
+ switch (variable->location()) {
+ case Variable::UNALLOCATED:
+ // TODO(rossberg)
+ break;
+
+ case Variable::CONTEXT: {
+ Comment cmnt(masm_, "[ ImportDeclaration");
+ EmitDebugCheckDeclarationContext(variable);
+ // TODO(rossberg)
+ break;
+ }
+
+ case Variable::PARAMETER:
+ case Variable::LOCAL:
+ case Variable::LOOKUP:
+ UNREACHABLE();
+ }
+}
+
+
+void FullCodeGenerator::VisitExportDeclaration(ExportDeclaration* declaration) {
+ // TODO(rossberg)
+}
+
+
+void FullCodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
+ // Call the runtime to declare the globals.
+ // The context is the first argument.
+ __ mov(r4, Operand(pairs));
+ __ LoadSmiLiteral(r3, Smi::FromInt(DeclareGlobalsFlags()));
+ __ Push(cp, r4, r3);
+ __ CallRuntime(Runtime::kDeclareGlobals, 3);
+ // Return value is ignored.
+}
+
+
+void FullCodeGenerator::DeclareModules(Handle<FixedArray> descriptions) {
+ // Call the runtime to declare the modules.
+ __ Push(descriptions);
+ __ CallRuntime(Runtime::kDeclareModules, 1);
+ // Return value is ignored.
+}
+
+
+void FullCodeGenerator::VisitSwitchStatement(SwitchStatement* stmt) {
+ Comment cmnt(masm_, "[ SwitchStatement");
+ Breakable nested_statement(this, stmt);
+ SetStatementPosition(stmt);
+
+ // Keep the switch value on the stack until a case matches.
+ VisitForStackValue(stmt->tag());
+ PrepareForBailoutForId(stmt->EntryId(), NO_REGISTERS);
+
+ ZoneList<CaseClause*>* clauses = stmt->cases();
+ CaseClause* default_clause = NULL; // Can occur anywhere in the list.
+
+ Label next_test; // Recycled for each test.
+ // Compile all the tests with branches to their bodies.
+ for (int i = 0; i < clauses->length(); i++) {
+ CaseClause* clause = clauses->at(i);
+ clause->body_target()->Unuse();
+
+ // The default is not a test, but remember it as final fall through.
+ if (clause->is_default()) {
+ default_clause = clause;
+ continue;
+ }
+
+ Comment cmnt(masm_, "[ Case comparison");
+ __ bind(&next_test);
+ next_test.Unuse();
+
+ // Compile the label expression.
+ VisitForAccumulatorValue(clause->label());
+
+ // Perform the comparison as if via '==='.
+ __ LoadP(r4, MemOperand(sp, 0)); // Switch value.
+ bool inline_smi_code = ShouldInlineSmiCase(Token::EQ_STRICT);
+ JumpPatchSite patch_site(masm_);
+ if (inline_smi_code) {
+ Label slow_case;
+ __ orx(r5, r4, r3);
+ patch_site.EmitJumpIfNotSmi(r5, &slow_case);
+
+ __ cmp(r4, r3);
+ __ bne(&next_test);
+ __ Drop(1); // Switch value is no longer needed.
+ __ b(clause->body_target());
+ __ bind(&slow_case);
+ }
+
+ // Record position before stub call for type feedback.
+ SetSourcePosition(clause->position());
+ Handle<Code> ic =
+ CodeFactory::CompareIC(isolate(), Token::EQ_STRICT).code();
+ CallIC(ic, clause->CompareId());
+ patch_site.EmitPatchInfo();
+
+ Label skip;
+ __ b(&skip);
+ PrepareForBailout(clause, TOS_REG);
+ __ LoadRoot(ip, Heap::kTrueValueRootIndex);
+ __ cmp(r3, ip);
+ __ bne(&next_test);
+ __ Drop(1);
+ __ b(clause->body_target());
+ __ bind(&skip);
+
+ __ cmpi(r3, Operand::Zero());
+ __ bne(&next_test);
+ __ Drop(1); // Switch value is no longer needed.
+ __ b(clause->body_target());
+ }
+
+ // Discard the test value and jump to the default if present, otherwise to
+ // the end of the statement.
+ __ bind(&next_test);
+ __ Drop(1); // Switch value is no longer needed.
+ if (default_clause == NULL) {
+ __ b(nested_statement.break_label());
+ } else {
+ __ b(default_clause->body_target());
+ }
+
+ // Compile all the case bodies.
+ for (int i = 0; i < clauses->length(); i++) {
+ Comment cmnt(masm_, "[ Case body");
+ CaseClause* clause = clauses->at(i);
+ __ bind(clause->body_target());
+ PrepareForBailoutForId(clause->EntryId(), NO_REGISTERS);
+ VisitStatements(clause->statements());
+ }
+
+ __ bind(nested_statement.break_label());
+ PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);
+}
+
+
+void FullCodeGenerator::VisitForInStatement(ForInStatement* stmt) {
+ Comment cmnt(masm_, "[ ForInStatement");
+ FeedbackVectorSlot slot = stmt->ForInFeedbackSlot();
+ SetStatementPosition(stmt);
+
+ Label loop, exit;
+ ForIn loop_statement(this, stmt);
+ increment_loop_depth();
+
+ // Get the object to enumerate over. If the object is null or undefined, skip
+ // over the loop. See ECMA-262 version 5, section 12.6.4.
+ VisitForAccumulatorValue(stmt->enumerable());
+ __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
+ __ cmp(r3, ip);
+ __ beq(&exit);
+ Register null_value = r7;
+ __ LoadRoot(null_value, Heap::kNullValueRootIndex);
+ __ cmp(r3, null_value);
+ __ beq(&exit);
+
+ PrepareForBailoutForId(stmt->PrepareId(), TOS_REG);
+
+ // Convert the object to a JS object.
+ Label convert, done_convert;
+ __ JumpIfSmi(r3, &convert);
+ __ CompareObjectType(r3, r4, r4, FIRST_SPEC_OBJECT_TYPE);
+ __ bge(&done_convert);
+ __ bind(&convert);
+ __ push(r3);
+ __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
+ __ bind(&done_convert);
+ PrepareForBailoutForId(stmt->ToObjectId(), TOS_REG);
+ __ push(r3);
+
+ // Check for proxies.
+ Label call_runtime;
+ STATIC_ASSERT(FIRST_JS_PROXY_TYPE == FIRST_SPEC_OBJECT_TYPE);
+ __ CompareObjectType(r3, r4, r4, LAST_JS_PROXY_TYPE);
+ __ ble(&call_runtime);
+
+ // Check cache validity in generated code. This is a fast case for
+ // the JSObject::IsSimpleEnum cache validity checks. If we cannot
+ // guarantee cache validity, call the runtime system to check cache
+ // validity or get the property names in a fixed array.
+ __ CheckEnumCache(null_value, &call_runtime);
+
+ // The enum cache is valid. Load the map of the object being
+ // iterated over and use the cache for the iteration.
+ Label use_cache;
+ __ LoadP(r3, FieldMemOperand(r3, HeapObject::kMapOffset));
+ __ b(&use_cache);
+
+ // Get the set of properties to enumerate.
+ __ bind(&call_runtime);
+ __ push(r3); // Duplicate the enumerable object on the stack.
+ __ CallRuntime(Runtime::kGetPropertyNamesFast, 1);
+ PrepareForBailoutForId(stmt->EnumId(), TOS_REG);
+
+ // If we got a map from the runtime call, we can do a fast
+ // modification check. Otherwise, we got a fixed array, and we have
+ // to do a slow check.
+ Label fixed_array;
+ __ LoadP(r5, FieldMemOperand(r3, HeapObject::kMapOffset));
+ __ LoadRoot(ip, Heap::kMetaMapRootIndex);
+ __ cmp(r5, ip);
+ __ bne(&fixed_array);
+
+ // We got a map in register r3. Get the enumeration cache from it.
+ Label no_descriptors;
+ __ bind(&use_cache);
+
+ __ EnumLength(r4, r3);
+ __ CmpSmiLiteral(r4, Smi::FromInt(0), r0);
+ __ beq(&no_descriptors);
+
+ __ LoadInstanceDescriptors(r3, r5);
+ __ LoadP(r5, FieldMemOperand(r5, DescriptorArray::kEnumCacheOffset));
+ __ LoadP(r5,
+ FieldMemOperand(r5, DescriptorArray::kEnumCacheBridgeCacheOffset));
+
+ // Set up the four remaining stack slots.
+ __ push(r3); // Map.
+ __ LoadSmiLiteral(r3, Smi::FromInt(0));
+ // Push enumeration cache, enumeration cache length (as smi) and zero.
+ __ Push(r5, r4, r3);
+ __ b(&loop);
+
+ __ bind(&no_descriptors);
+ __ Drop(1);
+ __ b(&exit);
+
+ // We got a fixed array in register r3. Iterate through that.
+ Label non_proxy;
+ __ bind(&fixed_array);
+
+ __ Move(r4, FeedbackVector());
+ __ mov(r5, Operand(TypeFeedbackVector::MegamorphicSentinel(isolate())));
+ int vector_index = FeedbackVector()->GetIndex(slot);
+ __ StoreP(
+ r5, FieldMemOperand(r4, FixedArray::OffsetOfElementAt(vector_index)), r0);
+
+ __ LoadSmiLiteral(r4, Smi::FromInt(1)); // Smi indicates slow check
+ __ LoadP(r5, MemOperand(sp, 0 * kPointerSize)); // Get enumerated object
+ STATIC_ASSERT(FIRST_JS_PROXY_TYPE == FIRST_SPEC_OBJECT_TYPE);
+ __ CompareObjectType(r5, r6, r6, LAST_JS_PROXY_TYPE);
+ __ bgt(&non_proxy);
+ __ LoadSmiLiteral(r4, Smi::FromInt(0)); // Zero indicates proxy
+ __ bind(&non_proxy);
+ __ Push(r4, r3); // Smi and array
+ __ LoadP(r4, FieldMemOperand(r3, FixedArray::kLengthOffset));
+ __ LoadSmiLiteral(r3, Smi::FromInt(0));
+ __ Push(r4, r3); // Fixed array length (as smi) and initial index.
+
+ // Generate code for doing the condition check.
+ PrepareForBailoutForId(stmt->BodyId(), NO_REGISTERS);
+ __ bind(&loop);
+ // Load the current count to r3, load the length to r4.
+ __ LoadP(r3, MemOperand(sp, 0 * kPointerSize));
+ __ LoadP(r4, MemOperand(sp, 1 * kPointerSize));
+ __ cmpl(r3, r4); // Compare to the array length.
+ __ bge(loop_statement.break_label());
+
+ // Get the current entry of the array into register r6.
+ __ LoadP(r5, MemOperand(sp, 2 * kPointerSize));
+ __ addi(r5, r5, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ __ SmiToPtrArrayOffset(r6, r3);
+ __ LoadPX(r6, MemOperand(r6, r5));
+
+ // Get the expected map from the stack or a smi in the
+ // permanent slow case into register r5.
+ __ LoadP(r5, MemOperand(sp, 3 * kPointerSize));
+
+ // Check if the expected map still matches that of the enumerable.
+ // If not, we may have to filter the key.
+ Label update_each;
+ __ LoadP(r4, MemOperand(sp, 4 * kPointerSize));
+ __ LoadP(r7, FieldMemOperand(r4, HeapObject::kMapOffset));
+ __ cmp(r7, r5);
+ __ beq(&update_each);
+
+ // For proxies, no filtering is done.
+ // TODO(rossberg): What if only a prototype is a proxy? Not specified yet.
+ __ CmpSmiLiteral(r5, Smi::FromInt(0), r0);
+ __ beq(&update_each);
+
+ // Convert the entry to a string or (smi) 0 if it isn't a property
+ // any more. If the property has been removed while iterating, we
+ // just skip it.
+ __ Push(r4, r6); // Enumerable and current entry.
+ __ InvokeBuiltin(Builtins::FILTER_KEY, CALL_FUNCTION);
+ __ mr(r6, r3);
+ __ cmpi(r6, Operand::Zero());
+ __ beq(loop_statement.continue_label());
+
+ // Update the 'each' property or variable from the possibly filtered
+ // entry in register r6.
+ __ bind(&update_each);
+ __ mr(result_register(), r6);
+ // Perform the assignment as if via '='.
+ {
+ EffectContext context(this);
+ EmitAssignment(stmt->each());
+ }
+
+ // Generate code for the body of the loop.
+ Visit(stmt->body());
+
+ // Generate code for the going to the next element by incrementing
+ // the index (smi) stored on top of the stack.
+ __ bind(loop_statement.continue_label());
+ __ pop(r3);
+ __ AddSmiLiteral(r3, r3, Smi::FromInt(1), r0);
+ __ push(r3);
+
+ EmitBackEdgeBookkeeping(stmt, &loop);
+ __ b(&loop);
+
+ // Remove the pointers stored on the stack.
+ __ bind(loop_statement.break_label());
+ __ Drop(5);
+
+ // Exit and decrement the loop depth.
+ PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);
+ __ bind(&exit);
+ decrement_loop_depth();
+}
+
+
+void FullCodeGenerator::VisitForOfStatement(ForOfStatement* stmt) {
+ Comment cmnt(masm_, "[ ForOfStatement");
+ SetStatementPosition(stmt);
+
+ Iteration loop_statement(this, stmt);
+ increment_loop_depth();
+
+ // var iterator = iterable[Symbol.iterator]();
+ VisitForEffect(stmt->assign_iterator());
+
+ // Loop entry.
+ __ bind(loop_statement.continue_label());
+
+ // result = iterator.next()
+ VisitForEffect(stmt->next_result());
+
+ // if (result.done) break;
+ Label result_not_done;
+ VisitForControl(stmt->result_done(), loop_statement.break_label(),
+ &result_not_done, &result_not_done);
+ __ bind(&result_not_done);
+
+ // each = result.value
+ VisitForEffect(stmt->assign_each());
+
+ // Generate code for the body of the loop.
+ Visit(stmt->body());
+
+ // Check stack before looping.
+ PrepareForBailoutForId(stmt->BackEdgeId(), NO_REGISTERS);
+ EmitBackEdgeBookkeeping(stmt, loop_statement.continue_label());
+ __ b(loop_statement.continue_label());
+
+ // Exit and decrement the loop depth.
+ PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);
+ __ bind(loop_statement.break_label());
+ decrement_loop_depth();
+}
+
+
+void FullCodeGenerator::EmitNewClosure(Handle<SharedFunctionInfo> info,
+ bool pretenure) {
+ // Use the fast case closure allocation code that allocates in new
+ // space for nested functions that don't need literals cloning. If
+ // we're running with the --always-opt or the --prepare-always-opt
+ // flag, we need to use the runtime function so that the new function
+ // we are creating here gets a chance to have its code optimized and
+ // doesn't just get a copy of the existing unoptimized code.
+ if (!FLAG_always_opt && !FLAG_prepare_always_opt && !pretenure &&
+ scope()->is_function_scope() && info->num_literals() == 0) {
+ FastNewClosureStub stub(isolate(), info->strict_mode(), info->kind());
+ __ mov(r5, Operand(info));
+ __ CallStub(&stub);
+ } else {
+ __ mov(r3, Operand(info));
+ __ LoadRoot(
+ r4, pretenure ? Heap::kTrueValueRootIndex : Heap::kFalseValueRootIndex);
+ __ Push(cp, r3, r4);
+ __ CallRuntime(Runtime::kNewClosure, 3);
+ }
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::VisitVariableProxy(VariableProxy* expr) {
+ Comment cmnt(masm_, "[ VariableProxy");
+ EmitVariableLoad(expr);
+}
+
+
+void FullCodeGenerator::EmitLoadHomeObject(SuperReference* expr) {
+ Comment cnmt(masm_, "[ SuperReference ");
+
+ __ LoadP(LoadDescriptor::ReceiverRegister(),
+ MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+
+ Handle<Symbol> home_object_symbol(isolate()->heap()->home_object_symbol());
+ __ Move(LoadDescriptor::NameRegister(), home_object_symbol);
+
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(expr->HomeObjectFeedbackSlot())));
+ CallLoadIC(NOT_CONTEXTUAL);
+ } else {
+ CallLoadIC(NOT_CONTEXTUAL, expr->HomeObjectFeedbackId());
+ }
+
+ __ Cmpi(r3, Operand(isolate()->factory()->undefined_value()), r0);
+ Label done;
+ __ bne(&done);
+ __ CallRuntime(Runtime::kThrowNonMethodError, 0);
+ __ bind(&done);
+}
+
+
+void FullCodeGenerator::EmitLoadGlobalCheckExtensions(VariableProxy* proxy,
+ TypeofState typeof_state,
+ Label* slow) {
+ Register current = cp;
+ Register next = r4;
+ Register temp = r5;
+
+ Scope* s = scope();
+ while (s != NULL) {
+ if (s->num_heap_slots() > 0) {
+ if (s->calls_sloppy_eval()) {
+ // Check that extension is NULL.
+ __ LoadP(temp, ContextOperand(current, Context::EXTENSION_INDEX));
+ __ cmpi(temp, Operand::Zero());
+ __ bne(slow);
+ }
+ // Load next context in chain.
+ __ LoadP(next, ContextOperand(current, Context::PREVIOUS_INDEX));
+ // Walk the rest of the chain without clobbering cp.
+ current = next;
+ }
+ // If no outer scope calls eval, we do not need to check more
+ // context extensions.
+ if (!s->outer_scope_calls_sloppy_eval() || s->is_eval_scope()) break;
+ s = s->outer_scope();
+ }
+
+ if (s->is_eval_scope()) {
+ Label loop, fast;
+ if (!current.is(next)) {
+ __ Move(next, current);
+ }
+ __ bind(&loop);
+ // Terminate at native context.
+ __ LoadP(temp, FieldMemOperand(next, HeapObject::kMapOffset));
+ __ LoadRoot(ip, Heap::kNativeContextMapRootIndex);
+ __ cmp(temp, ip);
+ __ beq(&fast);
+ // Check that extension is NULL.
+ __ LoadP(temp, ContextOperand(next, Context::EXTENSION_INDEX));
+ __ cmpi(temp, Operand::Zero());
+ __ bne(slow);
+ // Load next context in chain.
+ __ LoadP(next, ContextOperand(next, Context::PREVIOUS_INDEX));
+ __ b(&loop);
+ __ bind(&fast);
+ }
+
+ __ LoadP(LoadDescriptor::ReceiverRegister(), GlobalObjectOperand());
+ __ mov(LoadDescriptor::NameRegister(), Operand(proxy->var()->name()));
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(proxy->VariableFeedbackSlot())));
+ }
+
+ ContextualMode mode =
+ (typeof_state == INSIDE_TYPEOF) ? NOT_CONTEXTUAL : CONTEXTUAL;
+ CallLoadIC(mode);
+}
+
+
+MemOperand FullCodeGenerator::ContextSlotOperandCheckExtensions(Variable* var,
+ Label* slow) {
+ DCHECK(var->IsContextSlot());
+ Register context = cp;
+ Register next = r6;
+ Register temp = r7;
+
+ for (Scope* s = scope(); s != var->scope(); s = s->outer_scope()) {
+ if (s->num_heap_slots() > 0) {
+ if (s->calls_sloppy_eval()) {
+ // Check that extension is NULL.
+ __ LoadP(temp, ContextOperand(context, Context::EXTENSION_INDEX));
+ __ cmpi(temp, Operand::Zero());
+ __ bne(slow);
+ }
+ __ LoadP(next, ContextOperand(context, Context::PREVIOUS_INDEX));
+ // Walk the rest of the chain without clobbering cp.
+ context = next;
+ }
+ }
+ // Check that last extension is NULL.
+ __ LoadP(temp, ContextOperand(context, Context::EXTENSION_INDEX));
+ __ cmpi(temp, Operand::Zero());
+ __ bne(slow);
+
+ // This function is used only for loads, not stores, so it's safe to
+ // return an cp-based operand (the write barrier cannot be allowed to
+ // destroy the cp register).
+ return ContextOperand(context, var->index());
+}
+
+
+void FullCodeGenerator::EmitDynamicLookupFastCase(VariableProxy* proxy,
+ TypeofState typeof_state,
+ Label* slow, Label* done) {
+ // Generate fast-case code for variables that might be shadowed by
+ // eval-introduced variables. Eval is used a lot without
+ // introducing variables. In those cases, we do not want to
+ // perform a runtime call for all variables in the scope
+ // containing the eval.
+ Variable* var = proxy->var();
+ if (var->mode() == DYNAMIC_GLOBAL) {
+ EmitLoadGlobalCheckExtensions(proxy, typeof_state, slow);
+ __ b(done);
+ } else if (var->mode() == DYNAMIC_LOCAL) {
+ Variable* local = var->local_if_not_shadowed();
+ __ LoadP(r3, ContextSlotOperandCheckExtensions(local, slow));
+ if (local->mode() == LET || local->mode() == CONST ||
+ local->mode() == CONST_LEGACY) {
+ __ CompareRoot(r3, Heap::kTheHoleValueRootIndex);
+ __ bne(done);
+ if (local->mode() == CONST_LEGACY) {
+ __ LoadRoot(r3, Heap::kUndefinedValueRootIndex);
+ } else { // LET || CONST
+ __ mov(r3, Operand(var->name()));
+ __ push(r3);
+ __ CallRuntime(Runtime::kThrowReferenceError, 1);
+ }
+ }
+ __ b(done);
+ }
+}
+
+
+void FullCodeGenerator::EmitVariableLoad(VariableProxy* proxy) {
+ // Record position before possible IC call.
+ SetSourcePosition(proxy->position());
+ Variable* var = proxy->var();
+
+ // Three cases: global variables, lookup variables, and all other types of
+ // variables.
+ switch (var->location()) {
+ case Variable::UNALLOCATED: {
+ Comment cmnt(masm_, "[ Global variable");
+ __ LoadP(LoadDescriptor::ReceiverRegister(), GlobalObjectOperand());
+ __ mov(LoadDescriptor::NameRegister(), Operand(var->name()));
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(proxy->VariableFeedbackSlot())));
+ }
+ CallLoadIC(CONTEXTUAL);
+ context()->Plug(r3);
+ break;
+ }
+
+ case Variable::PARAMETER:
+ case Variable::LOCAL:
+ case Variable::CONTEXT: {
+ Comment cmnt(masm_, var->IsContextSlot() ? "[ Context variable"
+ : "[ Stack variable");
+ if (var->binding_needs_init()) {
+ // var->scope() may be NULL when the proxy is located in eval code and
+ // refers to a potential outside binding. Currently those bindings are
+ // always looked up dynamically, i.e. in that case
+ // var->location() == LOOKUP.
+ // always holds.
+ DCHECK(var->scope() != NULL);
+
+ // Check if the binding really needs an initialization check. The check
+ // can be skipped in the following situation: we have a LET or CONST
+ // binding in harmony mode, both the Variable and the VariableProxy have
+ // the same declaration scope (i.e. they are both in global code, in the
+ // same function or in the same eval code) and the VariableProxy is in
+ // the source physically located after the initializer of the variable.
+ //
+ // We cannot skip any initialization checks for CONST in non-harmony
+ // mode because const variables may be declared but never initialized:
+ // if (false) { const x; }; var y = x;
+ //
+ // The condition on the declaration scopes is a conservative check for
+ // nested functions that access a binding and are called before the
+ // binding is initialized:
+ // function() { f(); let x = 1; function f() { x = 2; } }
+ //
+ bool skip_init_check;
+ if (var->scope()->DeclarationScope() != scope()->DeclarationScope()) {
+ skip_init_check = false;
+ } else {
+ // Check that we always have valid source position.
+ DCHECK(var->initializer_position() != RelocInfo::kNoPosition);
+ DCHECK(proxy->position() != RelocInfo::kNoPosition);
+ skip_init_check = var->mode() != CONST_LEGACY &&
+ var->initializer_position() < proxy->position();
+ }
+
+ if (!skip_init_check) {
+ Label done;
+ // Let and const need a read barrier.
+ GetVar(r3, var);
+ __ CompareRoot(r3, Heap::kTheHoleValueRootIndex);
+ __ bne(&done);
+ if (var->mode() == LET || var->mode() == CONST) {
+ // Throw a reference error when using an uninitialized let/const
+ // binding in harmony mode.
+ __ mov(r3, Operand(var->name()));
+ __ push(r3);
+ __ CallRuntime(Runtime::kThrowReferenceError, 1);
+ } else {
+ // Uninitalized const bindings outside of harmony mode are unholed.
+ DCHECK(var->mode() == CONST_LEGACY);
+ __ LoadRoot(r3, Heap::kUndefinedValueRootIndex);
+ }
+ __ bind(&done);
+ context()->Plug(r3);
+ break;
+ }
+ }
+ context()->Plug(var);
+ break;
+ }
+
+ case Variable::LOOKUP: {
+ Comment cmnt(masm_, "[ Lookup variable");
+ Label done, slow;
+ // Generate code for loading from variables potentially shadowed
+ // by eval-introduced variables.
+ EmitDynamicLookupFastCase(proxy, NOT_INSIDE_TYPEOF, &slow, &done);
+ __ bind(&slow);
+ __ mov(r4, Operand(var->name()));
+ __ Push(cp, r4); // Context and name.
+ __ CallRuntime(Runtime::kLoadLookupSlot, 2);
+ __ bind(&done);
+ context()->Plug(r3);
+ }
+ }
+}
+
+
+void FullCodeGenerator::VisitRegExpLiteral(RegExpLiteral* expr) {
+ Comment cmnt(masm_, "[ RegExpLiteral");
+ Label materialized;
+ // Registers will be used as follows:
+ // r8 = materialized value (RegExp literal)
+ // r7 = JS function, literals array
+ // r6 = literal index
+ // r5 = RegExp pattern
+ // r4 = RegExp flags
+ // r3 = RegExp literal clone
+ __ LoadP(r3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ __ LoadP(r7, FieldMemOperand(r3, JSFunction::kLiteralsOffset));
+ int literal_offset =
+ FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
+ __ LoadP(r8, FieldMemOperand(r7, literal_offset), r0);
+ __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
+ __ cmp(r8, ip);
+ __ bne(&materialized);
+
+ // Create regexp literal using runtime function.
+ // Result will be in r3.
+ __ LoadSmiLiteral(r6, Smi::FromInt(expr->literal_index()));
+ __ mov(r5, Operand(expr->pattern()));
+ __ mov(r4, Operand(expr->flags()));
+ __ Push(r7, r6, r5, r4);
+ __ CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
+ __ mr(r8, r3);
+
+ __ bind(&materialized);
+ int size = JSRegExp::kSize + JSRegExp::kInObjectFieldCount * kPointerSize;
+ Label allocated, runtime_allocate;
+ __ Allocate(size, r3, r5, r6, &runtime_allocate, TAG_OBJECT);
+ __ b(&allocated);
+
+ __ bind(&runtime_allocate);
+ __ LoadSmiLiteral(r3, Smi::FromInt(size));
+ __ Push(r8, r3);
+ __ CallRuntime(Runtime::kAllocateInNewSpace, 1);
+ __ pop(r8);
+
+ __ bind(&allocated);
+ // After this, registers are used as follows:
+ // r3: Newly allocated regexp.
+ // r8: Materialized regexp.
+ // r5: temp.
+ __ CopyFields(r3, r8, r5.bit(), size / kPointerSize);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitAccessor(Expression* expression) {
+ if (expression == NULL) {
+ __ LoadRoot(r4, Heap::kNullValueRootIndex);
+ __ push(r4);
+ } else {
+ VisitForStackValue(expression);
+ }
+}
+
+
+void FullCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
+ Comment cmnt(masm_, "[ ObjectLiteral");
+
+ expr->BuildConstantProperties(isolate());
+ Handle<FixedArray> constant_properties = expr->constant_properties();
+ __ LoadP(r6, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ __ LoadP(r6, FieldMemOperand(r6, JSFunction::kLiteralsOffset));
+ __ LoadSmiLiteral(r5, Smi::FromInt(expr->literal_index()));
+ __ mov(r4, Operand(constant_properties));
+ int flags = expr->fast_elements() ? ObjectLiteral::kFastElements
+ : ObjectLiteral::kNoFlags;
+ flags |= expr->has_function() ? ObjectLiteral::kHasFunction
+ : ObjectLiteral::kNoFlags;
+ __ LoadSmiLiteral(r3, Smi::FromInt(flags));
+ int properties_count = constant_properties->length() / 2;
+ if (expr->may_store_doubles() || expr->depth() > 1 ||
+ masm()->serializer_enabled() || flags != ObjectLiteral::kFastElements ||
+ properties_count > FastCloneShallowObjectStub::kMaximumClonedProperties) {
+ __ Push(r6, r5, r4, r3);
+ __ CallRuntime(Runtime::kCreateObjectLiteral, 4);
+ } else {
+ FastCloneShallowObjectStub stub(isolate(), properties_count);
+ __ CallStub(&stub);
+ }
+ PrepareForBailoutForId(expr->CreateLiteralId(), TOS_REG);
+
+ // If result_saved is true the result is on top of the stack. If
+ // result_saved is false the result is in r3.
+ bool result_saved = false;
+
+ // Mark all computed expressions that are bound to a key that
+ // is shadowed by a later occurrence of the same key. For the
+ // marked expressions, no store code is emitted.
+ expr->CalculateEmitStore(zone());
+
+ AccessorTable accessor_table(zone());
+ for (int i = 0; i < expr->properties()->length(); i++) {
+ ObjectLiteral::Property* property = expr->properties()->at(i);
+ if (property->IsCompileTimeValue()) continue;
+
+ Literal* key = property->key();
+ Expression* value = property->value();
+ if (!result_saved) {
+ __ push(r3); // Save result on stack
+ result_saved = true;
+ }
+ switch (property->kind()) {
+ case ObjectLiteral::Property::CONSTANT:
+ UNREACHABLE();
+ case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+ DCHECK(!CompileTimeValue::IsCompileTimeValue(property->value()));
+ // Fall through.
+ case ObjectLiteral::Property::COMPUTED:
+ // It is safe to use [[Put]] here because the boilerplate already
+ // contains computed properties with an uninitialized value.
+ if (key->value()->IsInternalizedString()) {
+ if (property->emit_store()) {
+ VisitForAccumulatorValue(value);
+ DCHECK(StoreDescriptor::ValueRegister().is(r3));
+ __ mov(StoreDescriptor::NameRegister(), Operand(key->value()));
+ __ LoadP(StoreDescriptor::ReceiverRegister(), MemOperand(sp));
+ CallStoreIC(key->LiteralFeedbackId());
+ PrepareForBailoutForId(key->id(), NO_REGISTERS);
+ } else {
+ VisitForEffect(value);
+ }
+ break;
+ }
+ // Duplicate receiver on stack.
+ __ LoadP(r3, MemOperand(sp));
+ __ push(r3);
+ VisitForStackValue(key);
+ VisitForStackValue(value);
+ if (property->emit_store()) {
+ __ LoadSmiLiteral(r3, Smi::FromInt(SLOPPY)); // PropertyAttributes
+ __ push(r3);
+ __ CallRuntime(Runtime::kSetProperty, 4);
+ } else {
+ __ Drop(3);
+ }
+ break;
+ case ObjectLiteral::Property::PROTOTYPE:
+ // Duplicate receiver on stack.
+ __ LoadP(r3, MemOperand(sp));
+ __ push(r3);
+ VisitForStackValue(value);
+ if (property->emit_store()) {
+ __ CallRuntime(Runtime::kInternalSetPrototype, 2);
+ } else {
+ __ Drop(2);
+ }
+ break;
+ case ObjectLiteral::Property::GETTER:
+ accessor_table.lookup(key)->second->getter = value;
+ break;
+ case ObjectLiteral::Property::SETTER:
+ accessor_table.lookup(key)->second->setter = value;
+ break;
+ }
+ }
+
+ // Emit code to define accessors, using only a single call to the runtime for
+ // each pair of corresponding getters and setters.
+ for (AccessorTable::Iterator it = accessor_table.begin();
+ it != accessor_table.end(); ++it) {
+ __ LoadP(r3, MemOperand(sp)); // Duplicate receiver.
+ __ push(r3);
+ VisitForStackValue(it->first);
+ EmitAccessor(it->second->getter);
+ EmitAccessor(it->second->setter);
+ __ LoadSmiLiteral(r3, Smi::FromInt(NONE));
+ __ push(r3);
+ __ CallRuntime(Runtime::kDefineAccessorPropertyUnchecked, 5);
+ }
+
+ if (expr->has_function()) {
+ DCHECK(result_saved);
+ __ LoadP(r3, MemOperand(sp));
+ __ push(r3);
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+ }
+
+ if (result_saved) {
+ context()->PlugTOS();
+ } else {
+ context()->Plug(r3);
+ }
+}
+
+
+void FullCodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
+ Comment cmnt(masm_, "[ ArrayLiteral");
+
+ expr->BuildConstantElements(isolate());
+ int flags = expr->depth() == 1 ? ArrayLiteral::kShallowElements
+ : ArrayLiteral::kNoFlags;
+
+ ZoneList<Expression*>* subexprs = expr->values();
+ int length = subexprs->length();
+ Handle<FixedArray> constant_elements = expr->constant_elements();
+ DCHECK_EQ(2, constant_elements->length());
+ ElementsKind constant_elements_kind =
+ static_cast<ElementsKind>(Smi::cast(constant_elements->get(0))->value());
+ bool has_fast_elements = IsFastObjectElementsKind(constant_elements_kind);
+ Handle<FixedArrayBase> constant_elements_values(
+ FixedArrayBase::cast(constant_elements->get(1)));
+
+ AllocationSiteMode allocation_site_mode = TRACK_ALLOCATION_SITE;
+ if (has_fast_elements && !FLAG_allocation_site_pretenuring) {
+ // If the only customer of allocation sites is transitioning, then
+ // we can turn it off if we don't have anywhere else to transition to.
+ allocation_site_mode = DONT_TRACK_ALLOCATION_SITE;
+ }
+
+ __ LoadP(r6, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ __ LoadP(r6, FieldMemOperand(r6, JSFunction::kLiteralsOffset));
+ __ LoadSmiLiteral(r5, Smi::FromInt(expr->literal_index()));
+ __ mov(r4, Operand(constant_elements));
+ if (expr->depth() > 1 || length > JSObject::kInitialMaxFastElementArray) {
+ __ LoadSmiLiteral(r3, Smi::FromInt(flags));
+ __ Push(r6, r5, r4, r3);
+ __ CallRuntime(Runtime::kCreateArrayLiteral, 4);
+ } else {
+ FastCloneShallowArrayStub stub(isolate(), allocation_site_mode);
+ __ CallStub(&stub);
+ }
+
+ bool result_saved = false; // Is the result saved to the stack?
+
+ // Emit code to evaluate all the non-constant subexpressions and to store
+ // them into the newly cloned array.
+ for (int i = 0; i < length; i++) {
+ Expression* subexpr = subexprs->at(i);
+ // If the subexpression is a literal or a simple materialized literal it
+ // is already set in the cloned array.
+ if (CompileTimeValue::IsCompileTimeValue(subexpr)) continue;
+
+ if (!result_saved) {
+ __ push(r3);
+ __ Push(Smi::FromInt(expr->literal_index()));
+ result_saved = true;
+ }
+ VisitForAccumulatorValue(subexpr);
+
+ if (IsFastObjectElementsKind(constant_elements_kind)) {
+ int offset = FixedArray::kHeaderSize + (i * kPointerSize);
+ __ LoadP(r8, MemOperand(sp, kPointerSize)); // Copy of array literal.
+ __ LoadP(r4, FieldMemOperand(r8, JSObject::kElementsOffset));
+ __ StoreP(result_register(), FieldMemOperand(r4, offset), r0);
+ // Update the write barrier for the array store.
+ __ RecordWriteField(r4, offset, result_register(), r5, kLRHasBeenSaved,
+ kDontSaveFPRegs, EMIT_REMEMBERED_SET,
+ INLINE_SMI_CHECK);
+ } else {
+ __ LoadSmiLiteral(r6, Smi::FromInt(i));
+ StoreArrayLiteralElementStub stub(isolate());
+ __ CallStub(&stub);
+ }
+
+ PrepareForBailoutForId(expr->GetIdForElement(i), NO_REGISTERS);
+ }
+
+ if (result_saved) {
+ __ pop(); // literal index
+ context()->PlugTOS();
+ } else {
+ context()->Plug(r3);
+ }
+}
+
+
+void FullCodeGenerator::VisitAssignment(Assignment* expr) {
+ DCHECK(expr->target()->IsValidReferenceExpression());
+
+ Comment cmnt(masm_, "[ Assignment");
+
+ Property* property = expr->target()->AsProperty();
+ LhsKind assign_type = GetAssignType(property);
+
+ // Evaluate LHS expression.
+ switch (assign_type) {
+ case VARIABLE:
+ // Nothing to do here.
+ break;
+ case NAMED_PROPERTY:
+ if (expr->is_compound()) {
+ // We need the receiver both on the stack and in the register.
+ VisitForStackValue(property->obj());
+ __ LoadP(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
+ } else {
+ VisitForStackValue(property->obj());
+ }
+ break;
+ case NAMED_SUPER_PROPERTY:
+ VisitForStackValue(property->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(property->obj()->AsSuperReference());
+ __ Push(result_register());
+ if (expr->is_compound()) {
+ const Register scratch = r4;
+ __ LoadP(scratch, MemOperand(sp, kPointerSize));
+ __ Push(scratch, result_register());
+ }
+ break;
+ case KEYED_SUPER_PROPERTY: {
+ const Register scratch = r4;
+ VisitForStackValue(property->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(property->obj()->AsSuperReference());
+ __ Move(scratch, result_register());
+ VisitForAccumulatorValue(property->key());
+ __ Push(scratch, result_register());
+ if (expr->is_compound()) {
+ const Register scratch1 = r5;
+ __ LoadP(scratch1, MemOperand(sp, 2 * kPointerSize));
+ __ Push(scratch1, scratch, result_register());
+ }
+ break;
+ }
+ case KEYED_PROPERTY:
+ if (expr->is_compound()) {
+ VisitForStackValue(property->obj());
+ VisitForStackValue(property->key());
+ __ LoadP(LoadDescriptor::ReceiverRegister(),
+ MemOperand(sp, 1 * kPointerSize));
+ __ LoadP(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
+ } else {
+ VisitForStackValue(property->obj());
+ VisitForStackValue(property->key());
+ }
+ break;
+ }
+
+ // For compound assignments we need another deoptimization point after the
+ // variable/property load.
+ if (expr->is_compound()) {
+ {
+ AccumulatorValueContext context(this);
+ switch (assign_type) {
+ case VARIABLE:
+ EmitVariableLoad(expr->target()->AsVariableProxy());
+ PrepareForBailout(expr->target(), TOS_REG);
+ break;
+ case NAMED_PROPERTY:
+ EmitNamedPropertyLoad(property);
+ PrepareForBailoutForId(property->LoadId(), TOS_REG);
+ break;
+ case NAMED_SUPER_PROPERTY:
+ EmitNamedSuperPropertyLoad(property);
+ PrepareForBailoutForId(property->LoadId(), TOS_REG);
+ break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyLoad(property);
+ PrepareForBailoutForId(property->LoadId(), TOS_REG);
+ break;
+ case KEYED_PROPERTY:
+ EmitKeyedPropertyLoad(property);
+ PrepareForBailoutForId(property->LoadId(), TOS_REG);
+ break;
+ }
+ }
+
+ Token::Value op = expr->binary_op();
+ __ push(r3); // Left operand goes on the stack.
+ VisitForAccumulatorValue(expr->value());
+
+ OverwriteMode mode = expr->value()->ResultOverwriteAllowed()
+ ? OVERWRITE_RIGHT
+ : NO_OVERWRITE;
+ SetSourcePosition(expr->position() + 1);
+ AccumulatorValueContext context(this);
+ if (ShouldInlineSmiCase(op)) {
+ EmitInlineSmiBinaryOp(expr->binary_operation(), op, mode, expr->target(),
+ expr->value());
+ } else {
+ EmitBinaryOp(expr->binary_operation(), op, mode);
+ }
+
+ // Deoptimization point in case the binary operation may have side effects.
+ PrepareForBailout(expr->binary_operation(), TOS_REG);
+ } else {
+ VisitForAccumulatorValue(expr->value());
+ }
+
+ // Record source position before possible IC call.
+ SetSourcePosition(expr->position());
+
+ // Store the value.
+ switch (assign_type) {
+ case VARIABLE:
+ EmitVariableAssignment(expr->target()->AsVariableProxy()->var(),
+ expr->op());
+ PrepareForBailoutForId(expr->AssignmentId(), TOS_REG);
+ context()->Plug(r3);
+ break;
+ case NAMED_PROPERTY:
+ EmitNamedPropertyAssignment(expr);
+ break;
+ case NAMED_SUPER_PROPERTY:
+ EmitNamedSuperPropertyStore(property);
+ context()->Plug(r3);
+ break;
+ case KEYED_SUPER_PROPERTY:
+ EmitKeyedSuperPropertyStore(property);
+ context()->Plug(r3);
+ break;
+ case KEYED_PROPERTY:
+ EmitKeyedPropertyAssignment(expr);
+ break;
+ }
+}
+
+
+void FullCodeGenerator::VisitYield(Yield* expr) {
+ Comment cmnt(masm_, "[ Yield");
+ // Evaluate yielded value first; the initial iterator definition depends on
+ // this. It stays on the stack while we update the iterator.
+ VisitForStackValue(expr->expression());
+
+ switch (expr->yield_kind()) {
+ case Yield::kSuspend:
+ // Pop value from top-of-stack slot; box result into result register.
+ EmitCreateIteratorResult(false);
+ __ push(result_register());
+ // Fall through.
+ case Yield::kInitial: {
+ Label suspend, continuation, post_runtime, resume;
+
+ __ b(&suspend);
+
+ __ bind(&continuation);
+ __ b(&resume);
+
+ __ bind(&suspend);
+ VisitForAccumulatorValue(expr->generator_object());
+ DCHECK(continuation.pos() > 0 && Smi::IsValid(continuation.pos()));
+ __ LoadSmiLiteral(r4, Smi::FromInt(continuation.pos()));
+ __ StoreP(r4, FieldMemOperand(r3, JSGeneratorObject::kContinuationOffset),
+ r0);
+ __ StoreP(cp, FieldMemOperand(r3, JSGeneratorObject::kContextOffset), r0);
+ __ mr(r4, cp);
+ __ RecordWriteField(r3, JSGeneratorObject::kContextOffset, r4, r5,
+ kLRHasBeenSaved, kDontSaveFPRegs);
+ __ addi(r4, fp, Operand(StandardFrameConstants::kExpressionsOffset));
+ __ cmp(sp, r4);
+ __ beq(&post_runtime);
+ __ push(r3); // generator object
+ __ CallRuntime(Runtime::kSuspendJSGeneratorObject, 1);
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ __ bind(&post_runtime);
+ __ pop(result_register());
+ EmitReturnSequence();
+
+ __ bind(&resume);
+ context()->Plug(result_register());
+ break;
+ }
+
+ case Yield::kFinal: {
+ VisitForAccumulatorValue(expr->generator_object());
+ __ LoadSmiLiteral(r4, Smi::FromInt(JSGeneratorObject::kGeneratorClosed));
+ __ StoreP(r4, FieldMemOperand(result_register(),
+ JSGeneratorObject::kContinuationOffset),
+ r0);
+ // Pop value from top-of-stack slot, box result into result register.
+ EmitCreateIteratorResult(true);
+ EmitUnwindBeforeReturn();
+ EmitReturnSequence();
+ break;
+ }
+
+ case Yield::kDelegating: {
+ VisitForStackValue(expr->generator_object());
+
+ // Initial stack layout is as follows:
+ // [sp + 1 * kPointerSize] iter
+ // [sp + 0 * kPointerSize] g
+
+ Label l_catch, l_try, l_suspend, l_continuation, l_resume;
+ Label l_next, l_call;
+ Register load_receiver = LoadDescriptor::ReceiverRegister();
+ Register load_name = LoadDescriptor::NameRegister();
+
+ // Initial send value is undefined.
+ __ LoadRoot(r3, Heap::kUndefinedValueRootIndex);
+ __ b(&l_next);
+
+ // catch (e) { receiver = iter; f = 'throw'; arg = e; goto l_call; }
+ __ bind(&l_catch);
+ handler_table()->set(expr->index(), Smi::FromInt(l_catch.pos()));
+ __ LoadRoot(load_name, Heap::kthrow_stringRootIndex); // "throw"
+ __ LoadP(r6, MemOperand(sp, 1 * kPointerSize)); // iter
+ __ Push(load_name, r6, r3); // "throw", iter, except
+ __ b(&l_call);
+
+ // try { received = %yield result }
+ // Shuffle the received result above a try handler and yield it without
+ // re-boxing.
+ __ bind(&l_try);
+ __ pop(r3); // result
+ __ PushTryHandler(StackHandler::CATCH, expr->index());
+ const int handler_size = StackHandlerConstants::kSize;
+ __ push(r3); // result
+ __ b(&l_suspend);
+ __ bind(&l_continuation);
+ __ b(&l_resume);
+ __ bind(&l_suspend);
+ const int generator_object_depth = kPointerSize + handler_size;
+ __ LoadP(r3, MemOperand(sp, generator_object_depth));
+ __ push(r3); // g
+ DCHECK(l_continuation.pos() > 0 && Smi::IsValid(l_continuation.pos()));
+ __ LoadSmiLiteral(r4, Smi::FromInt(l_continuation.pos()));
+ __ StoreP(r4, FieldMemOperand(r3, JSGeneratorObject::kContinuationOffset),
+ r0);
+ __ StoreP(cp, FieldMemOperand(r3, JSGeneratorObject::kContextOffset), r0);
+ __ mr(r4, cp);
+ __ RecordWriteField(r3, JSGeneratorObject::kContextOffset, r4, r5,
+ kLRHasBeenSaved, kDontSaveFPRegs);
+ __ CallRuntime(Runtime::kSuspendJSGeneratorObject, 1);
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ __ pop(r3); // result
+ EmitReturnSequence();
+ __ bind(&l_resume); // received in r3
+ __ PopTryHandler();
+
+ // receiver = iter; f = 'next'; arg = received;
+ __ bind(&l_next);
+
+ __ LoadRoot(load_name, Heap::knext_stringRootIndex); // "next"
+ __ LoadP(r6, MemOperand(sp, 1 * kPointerSize)); // iter
+ __ Push(load_name, r6, r3); // "next", iter, received
+
+ // result = receiver[f](arg);
+ __ bind(&l_call);
+ __ LoadP(load_receiver, MemOperand(sp, kPointerSize));
+ __ LoadP(load_name, MemOperand(sp, 2 * kPointerSize));
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(expr->KeyedLoadFeedbackSlot())));
+ }
+ Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
+ CallIC(ic, TypeFeedbackId::None());
+ __ mr(r4, r3);
+ __ StoreP(r4, MemOperand(sp, 2 * kPointerSize));
+ CallFunctionStub stub(isolate(), 1, CALL_AS_METHOD);
+ __ CallStub(&stub);
+
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ __ Drop(1); // The function is still on the stack; drop it.
+
+ // if (!result.done) goto l_try;
+ __ Move(load_receiver, r3);
+
+ __ push(load_receiver); // save result
+ __ LoadRoot(load_name, Heap::kdone_stringRootIndex); // "done"
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(expr->DoneFeedbackSlot())));
+ }
+ CallLoadIC(NOT_CONTEXTUAL); // r0=result.done
+ Handle<Code> bool_ic = ToBooleanStub::GetUninitialized(isolate());
+ CallIC(bool_ic);
+ __ cmpi(r3, Operand::Zero());
+ __ beq(&l_try);
+
+ // result.value
+ __ pop(load_receiver); // result
+ __ LoadRoot(load_name, Heap::kvalue_stringRootIndex); // "value"
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(expr->ValueFeedbackSlot())));
+ }
+ CallLoadIC(NOT_CONTEXTUAL); // r3=result.value
+ context()->DropAndPlug(2, r3); // drop iter and g
+ break;
+ }
+ }
+}
+
+
+void FullCodeGenerator::EmitGeneratorResume(
+ Expression* generator, Expression* value,
+ JSGeneratorObject::ResumeMode resume_mode) {
+ // The value stays in r3, and is ultimately read by the resumed generator, as
+ // if CallRuntime(Runtime::kSuspendJSGeneratorObject) returned it. Or it
+ // is read to throw the value when the resumed generator is already closed.
+ // r4 will hold the generator object until the activation has been resumed.
+ VisitForStackValue(generator);
+ VisitForAccumulatorValue(value);
+ __ pop(r4);
+
+ // Check generator state.
+ Label wrong_state, closed_state, done;
+ __ LoadP(r6, FieldMemOperand(r4, JSGeneratorObject::kContinuationOffset));
+ STATIC_ASSERT(JSGeneratorObject::kGeneratorExecuting < 0);
+ STATIC_ASSERT(JSGeneratorObject::kGeneratorClosed == 0);
+ __ CmpSmiLiteral(r6, Smi::FromInt(0), r0);
+ __ beq(&closed_state);
+ __ blt(&wrong_state);
+
+ // Load suspended function and context.
+ __ LoadP(cp, FieldMemOperand(r4, JSGeneratorObject::kContextOffset));
+ __ LoadP(r7, FieldMemOperand(r4, JSGeneratorObject::kFunctionOffset));
+
+ // Load receiver and store as the first argument.
+ __ LoadP(r5, FieldMemOperand(r4, JSGeneratorObject::kReceiverOffset));
+ __ push(r5);
+
+ // Push holes for the rest of the arguments to the generator function.
+ __ LoadP(r6, FieldMemOperand(r7, JSFunction::kSharedFunctionInfoOffset));
+ __ LoadWordArith(
+ r6, FieldMemOperand(r6, SharedFunctionInfo::kFormalParameterCountOffset));
+ __ LoadRoot(r5, Heap::kTheHoleValueRootIndex);
+ Label argument_loop, push_frame;
+#if V8_TARGET_ARCH_PPC64
+ __ cmpi(r6, Operand::Zero());
+ __ beq(&push_frame);
+#else
+ __ SmiUntag(r6, SetRC);
+ __ beq(&push_frame, cr0);
+#endif
+ __ mtctr(r6);
+ __ bind(&argument_loop);
+ __ push(r5);
+ __ bdnz(&argument_loop);
+
+ // Enter a new JavaScript frame, and initialize its slots as they were when
+ // the generator was suspended.
+ Label resume_frame;
+ __ bind(&push_frame);
+ __ b(&resume_frame, SetLK);
+ __ b(&done);
+ __ bind(&resume_frame);
+ // lr = return address.
+ // fp = caller's frame pointer.
+ // cp = callee's context,
+ // r7 = callee's JS function.
+ __ PushFixedFrame(r7);
+ // Adjust FP to point to saved FP.
+ __ addi(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
+
+ // Load the operand stack size.
+ __ LoadP(r6, FieldMemOperand(r4, JSGeneratorObject::kOperandStackOffset));
+ __ LoadP(r6, FieldMemOperand(r6, FixedArray::kLengthOffset));
+ __ SmiUntag(r6, SetRC);
+
+ // If we are sending a value and there is no operand stack, we can jump back
+ // in directly.
+ Label call_resume;
+ if (resume_mode == JSGeneratorObject::NEXT) {
+ Label slow_resume;
+ __ bne(&slow_resume, cr0);
+ __ LoadP(ip, FieldMemOperand(r7, JSFunction::kCodeEntryOffset));
+#if V8_OOL_CONSTANT_POOL
+ {
+ ConstantPoolUnavailableScope constant_pool_unavailable(masm_);
+ // Load the new code object's constant pool pointer.
+ __ LoadP(kConstantPoolRegister,
+ MemOperand(ip, Code::kConstantPoolOffset - Code::kHeaderSize));
+#endif
+ __ LoadP(r5, FieldMemOperand(r4, JSGeneratorObject::kContinuationOffset));
+ __ SmiUntag(r5);
+ __ add(ip, ip, r5);
+ __ LoadSmiLiteral(r5,
+ Smi::FromInt(JSGeneratorObject::kGeneratorExecuting));
+ __ StoreP(r5, FieldMemOperand(r4, JSGeneratorObject::kContinuationOffset),
+ r0);
+ __ Jump(ip);
+ __ bind(&slow_resume);
+#if V8_OOL_CONSTANT_POOL
+ }
+#endif
+ } else {
+ __ beq(&call_resume, cr0);
+ }
+
+ // Otherwise, we push holes for the operand stack and call the runtime to fix
+ // up the stack and the handlers.
+ Label operand_loop;
+ __ mtctr(r6);
+ __ bind(&operand_loop);
+ __ push(r5);
+ __ bdnz(&operand_loop);
+
+ __ bind(&call_resume);
+ DCHECK(!result_register().is(r4));
+ __ Push(r4, result_register());
+ __ Push(Smi::FromInt(resume_mode));
+ __ CallRuntime(Runtime::kResumeJSGeneratorObject, 3);
+ // Not reached: the runtime call returns elsewhere.
+ __ stop("not-reached");
+
+ // Reach here when generator is closed.
+ __ bind(&closed_state);
+ if (resume_mode == JSGeneratorObject::NEXT) {
+ // Return completed iterator result when generator is closed.
+ __ LoadRoot(r5, Heap::kUndefinedValueRootIndex);
+ __ push(r5);
+ // Pop value from top-of-stack slot; box result into result register.
+ EmitCreateIteratorResult(true);
+ } else {
+ // Throw the provided value.
+ __ push(r3);
+ __ CallRuntime(Runtime::kThrow, 1);
+ }
+ __ b(&done);
+
+ // Throw error if we attempt to operate on a running generator.
+ __ bind(&wrong_state);
+ __ push(r4);
+ __ CallRuntime(Runtime::kThrowGeneratorStateError, 1);
+
+ __ bind(&done);
+ context()->Plug(result_register());
+}
+
+
+void FullCodeGenerator::EmitCreateIteratorResult(bool done) {
+ Label gc_required;
+ Label allocated;
+
+ const int instance_size = 5 * kPointerSize;
+ DCHECK_EQ(isolate()->native_context()->iterator_result_map()->instance_size(),
+ instance_size);
+
+ __ Allocate(instance_size, r3, r5, r6, &gc_required, TAG_OBJECT);
+ __ b(&allocated);
+
+ __ bind(&gc_required);
+ __ Push(Smi::FromInt(instance_size));
+ __ CallRuntime(Runtime::kAllocateInNewSpace, 1);
+ __ LoadP(context_register(),
+ MemOperand(fp, StandardFrameConstants::kContextOffset));
+
+ __ bind(&allocated);
+ __ LoadP(r4, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
+ __ LoadP(r4, FieldMemOperand(r4, GlobalObject::kNativeContextOffset));
+ __ LoadP(r4, ContextOperand(r4, Context::ITERATOR_RESULT_MAP_INDEX));
+ __ pop(r5);
+ __ mov(r6, Operand(isolate()->factory()->ToBoolean(done)));
+ __ mov(r7, Operand(isolate()->factory()->empty_fixed_array()));
+ __ StoreP(r4, FieldMemOperand(r3, HeapObject::kMapOffset), r0);
+ __ StoreP(r7, FieldMemOperand(r3, JSObject::kPropertiesOffset), r0);
+ __ StoreP(r7, FieldMemOperand(r3, JSObject::kElementsOffset), r0);
+ __ StoreP(r5,
+ FieldMemOperand(r3, JSGeneratorObject::kResultValuePropertyOffset),
+ r0);
+ __ StoreP(r6,
+ FieldMemOperand(r3, JSGeneratorObject::kResultDonePropertyOffset),
+ r0);
+
+ // Only the value field needs a write barrier, as the other values are in the
+ // root set.
+ __ RecordWriteField(r3, JSGeneratorObject::kResultValuePropertyOffset, r5, r6,
+ kLRHasBeenSaved, kDontSaveFPRegs);
+}
+
+
+void FullCodeGenerator::EmitNamedPropertyLoad(Property* prop) {
+ SetSourcePosition(prop->position());
+ Literal* key = prop->key()->AsLiteral();
+ DCHECK(!prop->IsSuperAccess());
+
+ __ mov(LoadDescriptor::NameRegister(), Operand(key->value()));
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(prop->PropertyFeedbackSlot())));
+ CallLoadIC(NOT_CONTEXTUAL);
+ } else {
+ CallLoadIC(NOT_CONTEXTUAL, prop->PropertyFeedbackId());
+ }
+}
+
+
+void FullCodeGenerator::EmitNamedSuperPropertyLoad(Property* prop) {
+ // Stack: receiver, home_object.
+ SetSourcePosition(prop->position());
+ Literal* key = prop->key()->AsLiteral();
+ DCHECK(!key->value()->IsSmi());
+ DCHECK(prop->IsSuperAccess());
+
+ __ Push(key->value());
+ __ CallRuntime(Runtime::kLoadFromSuper, 3);
+}
+
+
+void FullCodeGenerator::EmitKeyedPropertyLoad(Property* prop) {
+ SetSourcePosition(prop->position());
+ Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(prop->PropertyFeedbackSlot())));
+ CallIC(ic);
+ } else {
+ CallIC(ic, prop->PropertyFeedbackId());
+ }
+}
+
+
+void FullCodeGenerator::EmitKeyedSuperPropertyLoad(Property* prop) {
+ // Stack: receiver, home_object, key.
+ SetSourcePosition(prop->position());
+
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+}
+
+
+void FullCodeGenerator::EmitInlineSmiBinaryOp(BinaryOperation* expr,
+ Token::Value op,
+ OverwriteMode mode,
+ Expression* left_expr,
+ Expression* right_expr) {
+ Label done, smi_case, stub_call;
+
+ Register scratch1 = r5;
+ Register scratch2 = r6;
+
+ // Get the arguments.
+ Register left = r4;
+ Register right = r3;
+ __ pop(left);
+
+ // Perform combined smi check on both operands.
+ __ orx(scratch1, left, right);
+ STATIC_ASSERT(kSmiTag == 0);
+ JumpPatchSite patch_site(masm_);
+ patch_site.EmitJumpIfSmi(scratch1, &smi_case);
+
+ __ bind(&stub_call);
+ Handle<Code> code = CodeFactory::BinaryOpIC(isolate(), op, mode).code();
+ CallIC(code, expr->BinaryOperationFeedbackId());
+ patch_site.EmitPatchInfo();
+ __ b(&done);
+
+ __ bind(&smi_case);
+ // Smi case. This code works the same way as the smi-smi case in the type
+ // recording binary operation stub.
+ switch (op) {
+ case Token::SAR:
+ __ GetLeastBitsFromSmi(scratch1, right, 5);
+ __ ShiftRightArith(right, left, scratch1);
+ __ ClearRightImm(right, right, Operand(kSmiTagSize + kSmiShiftSize));
+ break;
+ case Token::SHL: {
+ __ GetLeastBitsFromSmi(scratch2, right, 5);
+#if V8_TARGET_ARCH_PPC64
+ __ ShiftLeft_(right, left, scratch2);
+#else
+ __ SmiUntag(scratch1, left);
+ __ ShiftLeft_(scratch1, scratch1, scratch2);
+ // Check that the *signed* result fits in a smi
+ __ JumpIfNotSmiCandidate(scratch1, scratch2, &stub_call);
+ __ SmiTag(right, scratch1);
+#endif
+ break;
+ }
+ case Token::SHR: {
+ __ SmiUntag(scratch1, left);
+ __ GetLeastBitsFromSmi(scratch2, right, 5);
+ __ srw(scratch1, scratch1, scratch2);
+ // Unsigned shift is not allowed to produce a negative number.
+ __ JumpIfNotUnsignedSmiCandidate(scratch1, r0, &stub_call);
+ __ SmiTag(right, scratch1);
+ break;
+ }
+ case Token::ADD: {
+ __ AddAndCheckForOverflow(scratch1, left, right, scratch2, r0);
+ __ bne(&stub_call, cr0);
+ __ mr(right, scratch1);
+ break;
+ }
+ case Token::SUB: {
+ __ SubAndCheckForOverflow(scratch1, left, right, scratch2, r0);
+ __ bne(&stub_call, cr0);
+ __ mr(right, scratch1);
+ break;
+ }
+ case Token::MUL: {
+ Label mul_zero;
+#if V8_TARGET_ARCH_PPC64
+ // Remove tag from both operands.
+ __ SmiUntag(ip, right);
+ __ SmiUntag(r0, left);
+ __ Mul(scratch1, r0, ip);
+ // Check for overflowing the smi range - no overflow if higher 33 bits of
+ // the result are identical.
+ __ TestIfInt32(scratch1, scratch2, ip);
+ __ bne(&stub_call);
+#else
+ __ SmiUntag(ip, right);
+ __ mullw(scratch1, left, ip);
+ __ mulhw(scratch2, left, ip);
+ // Check for overflowing the smi range - no overflow if higher 33 bits of
+ // the result are identical.
+ __ TestIfInt32(scratch2, scratch1, ip);
+ __ bne(&stub_call);
+#endif
+ // Go slow on zero result to handle -0.
+ __ cmpi(scratch1, Operand::Zero());
+ __ beq(&mul_zero);
+#if V8_TARGET_ARCH_PPC64
+ __ SmiTag(right, scratch1);
+#else
+ __ mr(right, scratch1);
+#endif
+ __ b(&done);
+ // We need -0 if we were multiplying a negative number with 0 to get 0.
+ // We know one of them was zero.
+ __ bind(&mul_zero);
+ __ add(scratch2, right, left);
+ __ cmpi(scratch2, Operand::Zero());
+ __ blt(&stub_call);
+ __ LoadSmiLiteral(right, Smi::FromInt(0));
+ break;
+ }
+ case Token::BIT_OR:
+ __ orx(right, left, right);
+ break;
+ case Token::BIT_AND:
+ __ and_(right, left, right);
+ break;
+ case Token::BIT_XOR:
+ __ xor_(right, left, right);
+ break;
+ default:
+ UNREACHABLE();
+ }
+
+ __ bind(&done);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitClassDefineProperties(ClassLiteral* lit) {
+ // Constructor is in r3.
+ DCHECK(lit != NULL);
+ __ push(r3);
+
+ // No access check is needed here since the constructor is created by the
+ // class literal.
+ Register scratch = r4;
+ __ LoadP(scratch,
+ FieldMemOperand(r3, JSFunction::kPrototypeOrInitialMapOffset));
+ __ push(scratch);
+
+ for (int i = 0; i < lit->properties()->length(); i++) {
+ ObjectLiteral::Property* property = lit->properties()->at(i);
+ Literal* key = property->key()->AsLiteral();
+ Expression* value = property->value();
+ DCHECK(key != NULL);
+
+ if (property->is_static()) {
+ __ LoadP(scratch, MemOperand(sp, kPointerSize)); // constructor
+ } else {
+ __ LoadP(scratch, MemOperand(sp, 0)); // prototype
+ }
+ __ push(scratch);
+ VisitForStackValue(key);
+ VisitForStackValue(value);
+
+ switch (property->kind()) {
+ case ObjectLiteral::Property::CONSTANT:
+ case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+ case ObjectLiteral::Property::COMPUTED:
+ case ObjectLiteral::Property::PROTOTYPE:
+ __ CallRuntime(Runtime::kDefineClassMethod, 3);
+ break;
+
+ case ObjectLiteral::Property::GETTER:
+ __ CallRuntime(Runtime::kDefineClassGetter, 3);
+ break;
+
+ case ObjectLiteral::Property::SETTER:
+ __ CallRuntime(Runtime::kDefineClassSetter, 3);
+ break;
+
+ default:
+ UNREACHABLE();
+ }
+ }
+
+ // prototype
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+
+ // constructor
+ __ CallRuntime(Runtime::kToFastProperties, 1);
+}
+
+
+void FullCodeGenerator::EmitBinaryOp(BinaryOperation* expr, Token::Value op,
+ OverwriteMode mode) {
+ __ pop(r4);
+ Handle<Code> code = CodeFactory::BinaryOpIC(isolate(), op, mode).code();
+ JumpPatchSite patch_site(masm_); // unbound, signals no inlined smi code.
+ CallIC(code, expr->BinaryOperationFeedbackId());
+ patch_site.EmitPatchInfo();
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitAssignment(Expression* expr) {
+ DCHECK(expr->IsValidReferenceExpression());
+
+ Property* prop = expr->AsProperty();
+ LhsKind assign_type = GetAssignType(prop);
+
+ switch (assign_type) {
+ case VARIABLE: {
+ Variable* var = expr->AsVariableProxy()->var();
+ EffectContext context(this);
+ EmitVariableAssignment(var, Token::ASSIGN);
+ break;
+ }
+ case NAMED_PROPERTY: {
+ __ push(r3); // Preserve value.
+ VisitForAccumulatorValue(prop->obj());
+ __ Move(StoreDescriptor::ReceiverRegister(), r3);
+ __ pop(StoreDescriptor::ValueRegister()); // Restore value.
+ __ mov(StoreDescriptor::NameRegister(),
+ Operand(prop->key()->AsLiteral()->value()));
+ CallStoreIC();
+ break;
+ }
+ case NAMED_SUPER_PROPERTY: {
+ __ Push(r3);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ // stack: value, this; r3: home_object
+ Register scratch = r5;
+ Register scratch2 = r6;
+ __ mr(scratch, result_register()); // home_object
+ __ LoadP(r3, MemOperand(sp, kPointerSize)); // value
+ __ LoadP(scratch2, MemOperand(sp, 0)); // this
+ __ StoreP(scratch2, MemOperand(sp, kPointerSize)); // this
+ __ StoreP(scratch, MemOperand(sp, 0)); // home_object
+ // stack: this, home_object; r3: value
+ EmitNamedSuperPropertyStore(prop);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ __ Push(r3);
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForAccumulatorValue(prop->key());
+ Register scratch = r5;
+ Register scratch2 = r6;
+ __ LoadP(scratch2, MemOperand(sp, 2 * kPointerSize)); // value
+ // stack: value, this, home_object; r3: key, r6: value
+ __ LoadP(scratch, MemOperand(sp, kPointerSize)); // this
+ __ StoreP(scratch, MemOperand(sp, 2 * kPointerSize));
+ __ LoadP(scratch, MemOperand(sp, 0)); // home_object
+ __ StoreP(scratch, MemOperand(sp, kPointerSize));
+ __ StoreP(r3, MemOperand(sp, 0));
+ __ Move(r3, scratch2);
+ // stack: this, home_object, key; r3: value.
+ EmitKeyedSuperPropertyStore(prop);
+ break;
+ }
+ case KEYED_PROPERTY: {
+ __ push(r3); // Preserve value.
+ VisitForStackValue(prop->obj());
+ VisitForAccumulatorValue(prop->key());
+ __ Move(StoreDescriptor::NameRegister(), r3);
+ __ Pop(StoreDescriptor::ValueRegister(),
+ StoreDescriptor::ReceiverRegister());
+ Handle<Code> ic =
+ CodeFactory::KeyedStoreIC(isolate(), strict_mode()).code();
+ CallIC(ic);
+ break;
+ }
+ }
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitStoreToStackLocalOrContextSlot(
+ Variable* var, MemOperand location) {
+ __ StoreP(result_register(), location, r0);
+ if (var->IsContextSlot()) {
+ // RecordWrite may destroy all its register arguments.
+ __ mr(r6, result_register());
+ int offset = Context::SlotOffset(var->index());
+ __ RecordWriteContextSlot(r4, offset, r6, r5, kLRHasBeenSaved,
+ kDontSaveFPRegs);
+ }
+}
+
+
+void FullCodeGenerator::EmitVariableAssignment(Variable* var, Token::Value op) {
+ if (var->IsUnallocated()) {
+ // Global var, const, or let.
+ __ mov(StoreDescriptor::NameRegister(), Operand(var->name()));
+ __ LoadP(StoreDescriptor::ReceiverRegister(), GlobalObjectOperand());
+ CallStoreIC();
+
+ } else if (op == Token::INIT_CONST_LEGACY) {
+ // Const initializers need a write barrier.
+ DCHECK(!var->IsParameter()); // No const parameters.
+ if (var->IsLookupSlot()) {
+ __ push(r3);
+ __ mov(r3, Operand(var->name()));
+ __ Push(cp, r3); // Context and name.
+ __ CallRuntime(Runtime::kInitializeLegacyConstLookupSlot, 3);
+ } else {
+ DCHECK(var->IsStackAllocated() || var->IsContextSlot());
+ Label skip;
+ MemOperand location = VarOperand(var, r4);
+ __ LoadP(r5, location);
+ __ CompareRoot(r5, Heap::kTheHoleValueRootIndex);
+ __ bne(&skip);
+ EmitStoreToStackLocalOrContextSlot(var, location);
+ __ bind(&skip);
+ }
+
+ } else if (var->mode() == LET && op != Token::INIT_LET) {
+ // Non-initializing assignment to let variable needs a write barrier.
+ DCHECK(!var->IsLookupSlot());
+ DCHECK(var->IsStackAllocated() || var->IsContextSlot());
+ Label assign;
+ MemOperand location = VarOperand(var, r4);
+ __ LoadP(r6, location);
+ __ CompareRoot(r6, Heap::kTheHoleValueRootIndex);
+ __ bne(&assign);
+ __ mov(r6, Operand(var->name()));
+ __ push(r6);
+ __ CallRuntime(Runtime::kThrowReferenceError, 1);
+ // Perform the assignment.
+ __ bind(&assign);
+ EmitStoreToStackLocalOrContextSlot(var, location);
+
+ } else if (!var->is_const_mode() || op == Token::INIT_CONST) {
+ if (var->IsLookupSlot()) {
+ // Assignment to var.
+ __ push(r3); // Value.
+ __ mov(r4, Operand(var->name()));
+ __ mov(r3, Operand(Smi::FromInt(strict_mode())));
+ __ Push(cp, r4, r3); // Context, name, strict mode.
+ __ CallRuntime(Runtime::kStoreLookupSlot, 4);
+ } else {
+ // Assignment to var or initializing assignment to let/const in harmony
+ // mode.
+ DCHECK((var->IsStackAllocated() || var->IsContextSlot()));
+ MemOperand location = VarOperand(var, r4);
+ if (generate_debug_code_ && op == Token::INIT_LET) {
+ // Check for an uninitialized let binding.
+ __ LoadP(r5, location);
+ __ CompareRoot(r5, Heap::kTheHoleValueRootIndex);
+ __ Check(eq, kLetBindingReInitialization);
+ }
+ EmitStoreToStackLocalOrContextSlot(var, location);
+ }
+ }
+ // Non-initializing assignments to consts are ignored.
+}
+
+
+void FullCodeGenerator::EmitNamedPropertyAssignment(Assignment* expr) {
+ // Assignment to a property, using a named store IC.
+ Property* prop = expr->target()->AsProperty();
+ DCHECK(prop != NULL);
+ DCHECK(prop->key()->IsLiteral());
+
+ // Record source code position before IC call.
+ SetSourcePosition(expr->position());
+ __ mov(StoreDescriptor::NameRegister(),
+ Operand(prop->key()->AsLiteral()->value()));
+ __ pop(StoreDescriptor::ReceiverRegister());
+ CallStoreIC(expr->AssignmentFeedbackId());
+
+ PrepareForBailoutForId(expr->AssignmentId(), TOS_REG);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitNamedSuperPropertyStore(Property* prop) {
+ // Assignment to named property of super.
+ // r3 : value
+ // stack : receiver ('this'), home_object
+ DCHECK(prop != NULL);
+ Literal* key = prop->key()->AsLiteral();
+ DCHECK(key != NULL);
+
+ __ Push(key->value());
+ __ Push(r3);
+ __ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreToSuper_Strict
+ : Runtime::kStoreToSuper_Sloppy),
+ 4);
+}
+
+
+void FullCodeGenerator::EmitKeyedSuperPropertyStore(Property* prop) {
+ // Assignment to named property of super.
+ // r3 : value
+ // stack : receiver ('this'), home_object, key
+ DCHECK(prop != NULL);
+
+ __ Push(r3);
+ __ CallRuntime((strict_mode() == STRICT ? Runtime::kStoreKeyedToSuper_Strict
+ : Runtime::kStoreKeyedToSuper_Sloppy),
+ 4);
+}
+
+
+void FullCodeGenerator::EmitKeyedPropertyAssignment(Assignment* expr) {
+ // Assignment to a property, using a keyed store IC.
+
+ // Record source code position before IC call.
+ SetSourcePosition(expr->position());
+ __ Pop(StoreDescriptor::ReceiverRegister(), StoreDescriptor::NameRegister());
+ DCHECK(StoreDescriptor::ValueRegister().is(r3));
+
+ Handle<Code> ic = CodeFactory::KeyedStoreIC(isolate(), strict_mode()).code();
+ CallIC(ic, expr->AssignmentFeedbackId());
+
+ PrepareForBailoutForId(expr->AssignmentId(), TOS_REG);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::VisitProperty(Property* expr) {
+ Comment cmnt(masm_, "[ Property");
+ Expression* key = expr->key();
+
+ if (key->IsPropertyName()) {
+ if (!expr->IsSuperAccess()) {
+ VisitForAccumulatorValue(expr->obj());
+ __ Move(LoadDescriptor::ReceiverRegister(), r3);
+ EmitNamedPropertyLoad(expr);
+ } else {
+ VisitForStackValue(expr->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(expr->obj()->AsSuperReference());
+ __ Push(result_register());
+ EmitNamedSuperPropertyLoad(expr);
+ }
+ PrepareForBailoutForId(expr->LoadId(), TOS_REG);
+ context()->Plug(r3);
+ } else {
+ if (!expr->IsSuperAccess()) {
+ VisitForStackValue(expr->obj());
+ VisitForAccumulatorValue(expr->key());
+ __ Move(LoadDescriptor::NameRegister(), r3);
+ __ pop(LoadDescriptor::ReceiverRegister());
+ EmitKeyedPropertyLoad(expr);
+ } else {
+ VisitForStackValue(expr->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(expr->obj()->AsSuperReference());
+ __ Push(result_register());
+ VisitForStackValue(expr->key());
+ EmitKeyedSuperPropertyLoad(expr);
+ }
+ context()->Plug(r3);
+ }
+}
+
+
+void FullCodeGenerator::CallIC(Handle<Code> code, TypeFeedbackId ast_id) {
+ ic_total_count_++;
+ __ Call(code, RelocInfo::CODE_TARGET, ast_id);
+}
+
+
+// Code common for calls using the IC.
+void FullCodeGenerator::EmitCallWithLoadIC(Call* expr) {
+ Expression* callee = expr->expression();
+
+ CallICState::CallType call_type =
+ callee->IsVariableProxy() ? CallICState::FUNCTION : CallICState::METHOD;
+
+ // Get the target function.
+ if (call_type == CallICState::FUNCTION) {
+ {
+ StackValueContext context(this);
+ EmitVariableLoad(callee->AsVariableProxy());
+ PrepareForBailout(callee, NO_REGISTERS);
+ }
+ // Push undefined as receiver. This is patched in the method prologue if it
+ // is a sloppy mode method.
+ __ Push(isolate()->factory()->undefined_value());
+ } else {
+ // Load the function from the receiver.
+ DCHECK(callee->IsProperty());
+ DCHECK(!callee->AsProperty()->IsSuperAccess());
+ __ LoadP(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
+ EmitNamedPropertyLoad(callee->AsProperty());
+ PrepareForBailoutForId(callee->AsProperty()->LoadId(), TOS_REG);
+ // Push the target function under the receiver.
+ __ LoadP(ip, MemOperand(sp, 0));
+ __ push(ip);
+ __ StoreP(r3, MemOperand(sp, kPointerSize));
+ }
+
+ EmitCall(expr, call_type);
+}
+
+
+void FullCodeGenerator::EmitSuperCallWithLoadIC(Call* expr) {
+ Expression* callee = expr->expression();
+ DCHECK(callee->IsProperty());
+ Property* prop = callee->AsProperty();
+ DCHECK(prop->IsSuperAccess());
+
+ SetSourcePosition(prop->position());
+ Literal* key = prop->key()->AsLiteral();
+ DCHECK(!key->value()->IsSmi());
+ // Load the function from the receiver.
+ const Register scratch = r4;
+ SuperReference* super_ref = prop->obj()->AsSuperReference();
+ EmitLoadHomeObject(super_ref);
+ __ mr(scratch, r3);
+ VisitForAccumulatorValue(super_ref->this_var());
+ __ Push(scratch, r3, r3, scratch);
+ __ Push(key->value());
+
+ // Stack here:
+ // - home_object
+ // - this (receiver)
+ // - this (receiver) <-- LoadFromSuper will pop here and below.
+ // - home_object
+ // - key
+ __ CallRuntime(Runtime::kLoadFromSuper, 3);
+
+ // Replace home_object with target function.
+ __ StoreP(r3, MemOperand(sp, kPointerSize));
+
+ // Stack here:
+ // - target function
+ // - this (receiver)
+ EmitCall(expr, CallICState::METHOD);
+}
+
+
+// Code common for calls using the IC.
+void FullCodeGenerator::EmitKeyedCallWithLoadIC(Call* expr, Expression* key) {
+ // Load the key.
+ VisitForAccumulatorValue(key);
+
+ Expression* callee = expr->expression();
+
+ // Load the function from the receiver.
+ DCHECK(callee->IsProperty());
+ __ LoadP(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
+ __ Move(LoadDescriptor::NameRegister(), r3);
+ EmitKeyedPropertyLoad(callee->AsProperty());
+ PrepareForBailoutForId(callee->AsProperty()->LoadId(), TOS_REG);
+
+ // Push the target function under the receiver.
+ __ LoadP(ip, MemOperand(sp, 0));
+ __ push(ip);
+ __ StoreP(r3, MemOperand(sp, kPointerSize));
+
+ EmitCall(expr, CallICState::METHOD);
+}
+
+
+void FullCodeGenerator::EmitKeyedSuperCallWithLoadIC(Call* expr) {
+ Expression* callee = expr->expression();
+ DCHECK(callee->IsProperty());
+ Property* prop = callee->AsProperty();
+ DCHECK(prop->IsSuperAccess());
+
+ SetSourcePosition(prop->position());
+ // Load the function from the receiver.
+ const Register scratch = r4;
+ SuperReference* super_ref = prop->obj()->AsSuperReference();
+ EmitLoadHomeObject(super_ref);
+ __ Push(r3);
+ VisitForAccumulatorValue(super_ref->this_var());
+ __ Push(r3);
+ __ Push(r3);
+ __ LoadP(scratch, MemOperand(sp, kPointerSize * 2));
+ __ Push(scratch);
+ VisitForStackValue(prop->key());
+
+ // Stack here:
+ // - home_object
+ // - this (receiver)
+ // - this (receiver) <-- LoadKeyedFromSuper will pop here and below.
+ // - home_object
+ // - key
+ __ CallRuntime(Runtime::kLoadKeyedFromSuper, 3);
+
+ // Replace home_object with target function.
+ __ StoreP(r3, MemOperand(sp, kPointerSize));
+
+ // Stack here:
+ // - target function
+ // - this (receiver)
+ EmitCall(expr, CallICState::METHOD);
+}
+
+
+void FullCodeGenerator::EmitCall(Call* expr, CallICState::CallType call_type) {
+ // Load the arguments.
+ ZoneList<Expression*>* args = expr->arguments();
+ int arg_count = args->length();
+ {
+ PreservePositionScope scope(masm()->positions_recorder());
+ for (int i = 0; i < arg_count; i++) {
+ VisitForStackValue(args->at(i));
+ }
+ }
+
+ // Record source position of the IC call.
+ SetSourcePosition(expr->position());
+ Handle<Code> ic = CallIC::initialize_stub(isolate(), arg_count, call_type);
+ __ LoadSmiLiteral(r6, SmiFromSlot(expr->CallFeedbackSlot()));
+ __ LoadP(r4, MemOperand(sp, (arg_count + 1) * kPointerSize), r0);
+ // Don't assign a type feedback id to the IC, since type feedback is provided
+ // by the vector above.
+ CallIC(ic);
+
+ RecordJSReturnSite(expr);
+ // Restore context register.
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ context()->DropAndPlug(1, r3);
+}
+
+
+void FullCodeGenerator::EmitResolvePossiblyDirectEval(int arg_count) {
+ // r8: copy of the first argument or undefined if it doesn't exist.
+ if (arg_count > 0) {
+ __ LoadP(r8, MemOperand(sp, arg_count * kPointerSize), r0);
+ } else {
+ __ LoadRoot(r8, Heap::kUndefinedValueRootIndex);
+ }
+
+ // r7: the receiver of the enclosing function.
+ __ LoadP(r7, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+
+ // r6: the receiver of the enclosing function.
+ int receiver_offset = 2 + info_->scope()->num_parameters();
+ __ LoadP(r6, MemOperand(fp, receiver_offset * kPointerSize), r0);
+
+ // r5: strict mode.
+ __ LoadSmiLiteral(r5, Smi::FromInt(strict_mode()));
+
+ // r4: the start position of the scope the calls resides in.
+ __ LoadSmiLiteral(r4, Smi::FromInt(scope()->start_position()));
+
+ // Do the runtime call.
+ __ Push(r8, r7, r6, r5, r4);
+ __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 6);
+}
+
+
+void FullCodeGenerator::EmitLoadSuperConstructor(SuperReference* super_ref) {
+ DCHECK(super_ref != NULL);
+ __ LoadP(r3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ __ Push(r3);
+ __ CallRuntime(Runtime::kGetPrototype, 1);
+}
+
+
+void FullCodeGenerator::VisitCall(Call* expr) {
+#ifdef DEBUG
+ // We want to verify that RecordJSReturnSite gets called on all paths
+ // through this function. Avoid early returns.
+ expr->return_is_recorded_ = false;
+#endif
+
+ Comment cmnt(masm_, "[ Call");
+ Expression* callee = expr->expression();
+ Call::CallType call_type = expr->GetCallType(isolate());
+
+ if (call_type == Call::POSSIBLY_EVAL_CALL) {
+ // In a call to eval, we first call RuntimeHidden_ResolvePossiblyDirectEval
+ // to resolve the function we need to call and the receiver of the
+ // call. Then we call the resolved function using the given
+ // arguments.
+ ZoneList<Expression*>* args = expr->arguments();
+ int arg_count = args->length();
+
+ {
+ PreservePositionScope pos_scope(masm()->positions_recorder());
+ VisitForStackValue(callee);
+ __ LoadRoot(r5, Heap::kUndefinedValueRootIndex);
+ __ push(r5); // Reserved receiver slot.
+
+ // Push the arguments.
+ for (int i = 0; i < arg_count; i++) {
+ VisitForStackValue(args->at(i));
+ }
+
+ // Push a copy of the function (found below the arguments) and
+ // resolve eval.
+ __ LoadP(r4, MemOperand(sp, (arg_count + 1) * kPointerSize), r0);
+ __ push(r4);
+ EmitResolvePossiblyDirectEval(arg_count);
+
+ // The runtime call returns a pair of values in r3 (function) and
+ // r4 (receiver). Touch up the stack with the right values.
+ __ StoreP(r3, MemOperand(sp, (arg_count + 1) * kPointerSize), r0);
+ __ StoreP(r4, MemOperand(sp, arg_count * kPointerSize), r0);
+
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
+ }
+
+ // Record source position for debugger.
+ SetSourcePosition(expr->position());
+ CallFunctionStub stub(isolate(), arg_count, NO_CALL_FUNCTION_FLAGS);
+ __ LoadP(r4, MemOperand(sp, (arg_count + 1) * kPointerSize), r0);
+ __ CallStub(&stub);
+ RecordJSReturnSite(expr);
+ // Restore context register.
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ context()->DropAndPlug(1, r3);
+ } else if (call_type == Call::GLOBAL_CALL) {
+ EmitCallWithLoadIC(expr);
+
+ } else if (call_type == Call::LOOKUP_SLOT_CALL) {
+ // Call to a lookup slot (dynamically introduced variable).
+ VariableProxy* proxy = callee->AsVariableProxy();
+ Label slow, done;
+
+ {
+ PreservePositionScope scope(masm()->positions_recorder());
+ // Generate code for loading from variables potentially shadowed
+ // by eval-introduced variables.
+ EmitDynamicLookupFastCase(proxy, NOT_INSIDE_TYPEOF, &slow, &done);
+ }
+
+ __ bind(&slow);
+ // Call the runtime to find the function to call (returned in r3)
+ // and the object holding it (returned in edx).
+ DCHECK(!context_register().is(r5));
+ __ mov(r5, Operand(proxy->name()));
+ __ Push(context_register(), r5);
+ __ CallRuntime(Runtime::kLoadLookupSlot, 2);
+ __ Push(r3, r4); // Function, receiver.
+ PrepareForBailoutForId(expr->EvalOrLookupId(), NO_REGISTERS);
+
+ // If fast case code has been generated, emit code to push the
+ // function and receiver and have the slow path jump around this
+ // code.
+ if (done.is_linked()) {
+ Label call;
+ __ b(&call);
+ __ bind(&done);
+ // Push function.
+ __ push(r3);
+ // The receiver is implicitly the global receiver. Indicate this
+ // by passing the hole to the call function stub.
+ __ LoadRoot(r4, Heap::kUndefinedValueRootIndex);
+ __ push(r4);
+ __ bind(&call);
+ }
+
+ // The receiver is either the global receiver or an object found
+ // by LoadContextSlot.
+ EmitCall(expr);
+ } else if (call_type == Call::PROPERTY_CALL) {
+ Property* property = callee->AsProperty();
+ bool is_named_call = property->key()->IsPropertyName();
+ if (property->IsSuperAccess()) {
+ if (is_named_call) {
+ EmitSuperCallWithLoadIC(expr);
+ } else {
+ EmitKeyedSuperCallWithLoadIC(expr);
+ }
+ } else {
+ {
+ PreservePositionScope scope(masm()->positions_recorder());
+ VisitForStackValue(property->obj());
+ }
+ if (is_named_call) {
+ EmitCallWithLoadIC(expr);
+ } else {
+ EmitKeyedCallWithLoadIC(expr, property->key());
+ }
+ }
+ } else if (call_type == Call::SUPER_CALL) {
+ SuperReference* super_ref = callee->AsSuperReference();
+ EmitLoadSuperConstructor(super_ref);
+ __ Push(result_register());
+ VisitForStackValue(super_ref->this_var());
+ EmitCall(expr, CallICState::METHOD);
+ } else {
+ DCHECK(call_type == Call::OTHER_CALL);
+ // Call to an arbitrary expression not handled specially above.
+ {
+ PreservePositionScope scope(masm()->positions_recorder());
+ VisitForStackValue(callee);
+ }
+ __ LoadRoot(r4, Heap::kUndefinedValueRootIndex);
+ __ push(r4);
+ // Emit function call.
+ EmitCall(expr);
+ }
+
+#ifdef DEBUG
+ // RecordJSReturnSite should have been called.
+ DCHECK(expr->return_is_recorded_);
+#endif
+}
+
+
+void FullCodeGenerator::VisitCallNew(CallNew* expr) {
+ Comment cmnt(masm_, "[ CallNew");
+ // According to ECMA-262, section 11.2.2, page 44, the function
+ // expression in new calls must be evaluated before the
+ // arguments.
+
+ // Push constructor on the stack. If it's not a function it's used as
+ // receiver for CALL_NON_FUNCTION, otherwise the value on the stack is
+ // ignored.
+ if (expr->expression()->IsSuperReference()) {
+ EmitLoadSuperConstructor(expr->expression()->AsSuperReference());
+ __ Push(result_register());
+ } else {
+ VisitForStackValue(expr->expression());
+ }
+
+ // Push the arguments ("left-to-right") on the stack.
+ ZoneList<Expression*>* args = expr->arguments();
+ int arg_count = args->length();
+ for (int i = 0; i < arg_count; i++) {
+ VisitForStackValue(args->at(i));
+ }
+
+ // Call the construct call builtin that handles allocation and
+ // constructor invocation.
+ SetSourcePosition(expr->position());
+
+ // Load function and argument count into r4 and r3.
+ __ mov(r3, Operand(arg_count));
+ __ LoadP(r4, MemOperand(sp, arg_count * kPointerSize), r0);
+
+ // Record call targets in unoptimized code.
+ if (FLAG_pretenuring_call_new) {
+ EnsureSlotContainsAllocationSite(expr->AllocationSiteFeedbackSlot());
+ DCHECK(expr->AllocationSiteFeedbackSlot().ToInt() ==
+ expr->CallNewFeedbackSlot().ToInt() + 1);
+ }
+
+ __ Move(r5, FeedbackVector());
+ __ LoadSmiLiteral(r6, SmiFromSlot(expr->CallNewFeedbackSlot()));
+
+ CallConstructStub stub(isolate(), RECORD_CONSTRUCTOR_TARGET);
+ __ Call(stub.GetCode(), RelocInfo::CONSTRUCT_CALL);
+ PrepareForBailoutForId(expr->ReturnId(), TOS_REG);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitIsSmi(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ __ TestIfSmi(r3, r0);
+ Split(eq, if_true, if_false, fall_through, cr0);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitIsNonNegativeSmi(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ __ TestIfPositiveSmi(r3, r0);
+ Split(eq, if_true, if_false, fall_through, cr0);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitIsObject(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(r3, if_false);
+ __ LoadRoot(ip, Heap::kNullValueRootIndex);
+ __ cmp(r3, ip);
+ __ beq(if_true);
+ __ LoadP(r5, FieldMemOperand(r3, HeapObject::kMapOffset));
+ // Undetectable objects behave like undefined when tested with typeof.
+ __ lbz(r4, FieldMemOperand(r5, Map::kBitFieldOffset));
+ __ andi(r0, r4, Operand(1 << Map::kIsUndetectable));
+ __ bne(if_false, cr0);
+ __ lbz(r4, FieldMemOperand(r5, Map::kInstanceTypeOffset));
+ __ cmpi(r4, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
+ __ blt(if_false);
+ __ cmpi(r4, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE));
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(le, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitIsSpecObject(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(r3, if_false);
+ __ CompareObjectType(r3, r4, r4, FIRST_SPEC_OBJECT_TYPE);
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(ge, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitIsUndetectableObject(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(r3, if_false);
+ __ LoadP(r4, FieldMemOperand(r3, HeapObject::kMapOffset));
+ __ lbz(r4, FieldMemOperand(r4, Map::kBitFieldOffset));
+ __ andi(r0, r4, Operand(1 << Map::kIsUndetectable));
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(ne, if_true, if_false, fall_through, cr0);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitIsStringWrapperSafeForDefaultValueOf(
+ CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false, skip_lookup;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ AssertNotSmi(r3);
+
+ __ LoadP(r4, FieldMemOperand(r3, HeapObject::kMapOffset));
+ __ lbz(ip, FieldMemOperand(r4, Map::kBitField2Offset));
+ __ andi(r0, ip, Operand(1 << Map::kStringWrapperSafeForDefaultValueOf));
+ __ bne(&skip_lookup, cr0);
+
+ // Check for fast case object. Generate false result for slow case object.
+ __ LoadP(r5, FieldMemOperand(r3, JSObject::kPropertiesOffset));
+ __ LoadP(r5, FieldMemOperand(r5, HeapObject::kMapOffset));
+ __ LoadRoot(ip, Heap::kHashTableMapRootIndex);
+ __ cmp(r5, ip);
+ __ beq(if_false);
+
+ // Look for valueOf name in the descriptor array, and indicate false if
+ // found. Since we omit an enumeration index check, if it is added via a
+ // transition that shares its descriptor array, this is a false positive.
+ Label entry, loop, done;
+
+ // Skip loop if no descriptors are valid.
+ __ NumberOfOwnDescriptors(r6, r4);
+ __ cmpi(r6, Operand::Zero());
+ __ beq(&done);
+
+ __ LoadInstanceDescriptors(r4, r7);
+ // r7: descriptor array.
+ // r6: valid entries in the descriptor array.
+ __ mov(ip, Operand(DescriptorArray::kDescriptorSize));
+ __ Mul(r6, r6, ip);
+ // Calculate location of the first key name.
+ __ addi(r7, r7, Operand(DescriptorArray::kFirstOffset - kHeapObjectTag));
+ // Calculate the end of the descriptor array.
+ __ mr(r5, r7);
+ __ ShiftLeftImm(ip, r6, Operand(kPointerSizeLog2));
+ __ add(r5, r5, ip);
+
+ // Loop through all the keys in the descriptor array. If one of these is the
+ // string "valueOf" the result is false.
+ // The use of ip to store the valueOf string assumes that it is not otherwise
+ // used in the loop below.
+ __ mov(ip, Operand(isolate()->factory()->value_of_string()));
+ __ b(&entry);
+ __ bind(&loop);
+ __ LoadP(r6, MemOperand(r7, 0));
+ __ cmp(r6, ip);
+ __ beq(if_false);
+ __ addi(r7, r7, Operand(DescriptorArray::kDescriptorSize * kPointerSize));
+ __ bind(&entry);
+ __ cmp(r7, r5);
+ __ bne(&loop);
+
+ __ bind(&done);
+
+ // Set the bit in the map to indicate that there is no local valueOf field.
+ __ lbz(r5, FieldMemOperand(r4, Map::kBitField2Offset));
+ __ ori(r5, r5, Operand(1 << Map::kStringWrapperSafeForDefaultValueOf));
+ __ stb(r5, FieldMemOperand(r4, Map::kBitField2Offset));
+
+ __ bind(&skip_lookup);
+
+ // If a valueOf property is not found on the object check that its
+ // prototype is the un-modified String prototype. If not result is false.
+ __ LoadP(r5, FieldMemOperand(r4, Map::kPrototypeOffset));
+ __ JumpIfSmi(r5, if_false);
+ __ LoadP(r5, FieldMemOperand(r5, HeapObject::kMapOffset));
+ __ LoadP(r6, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
+ __ LoadP(r6, FieldMemOperand(r6, GlobalObject::kNativeContextOffset));
+ __ LoadP(r6,
+ ContextOperand(r6, Context::STRING_FUNCTION_PROTOTYPE_MAP_INDEX));
+ __ cmp(r5, r6);
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(eq, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitIsFunction(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(r3, if_false);
+ __ CompareObjectType(r3, r4, r5, JS_FUNCTION_TYPE);
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(eq, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitIsMinusZero(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ CheckMap(r3, r4, Heap::kHeapNumberMapRootIndex, if_false, DO_SMI_CHECK);
+#if V8_TARGET_ARCH_PPC64
+ __ LoadP(r4, FieldMemOperand(r3, HeapNumber::kValueOffset));
+ __ li(r5, Operand(1));
+ __ rotrdi(r5, r5, 1); // r5 = 0x80000000_00000000
+ __ cmp(r4, r5);
+#else
+ __ lwz(r5, FieldMemOperand(r3, HeapNumber::kExponentOffset));
+ __ lwz(r4, FieldMemOperand(r3, HeapNumber::kMantissaOffset));
+ Label skip;
+ __ lis(r0, Operand(SIGN_EXT_IMM16(0x8000)));
+ __ cmp(r5, r0);
+ __ bne(&skip);
+ __ cmpi(r4, Operand::Zero());
+ __ bind(&skip);
+#endif
+
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(eq, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitIsArray(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(r3, if_false);
+ __ CompareObjectType(r3, r4, r4, JS_ARRAY_TYPE);
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(eq, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitIsRegExp(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(r3, if_false);
+ __ CompareObjectType(r3, r4, r4, JS_REGEXP_TYPE);
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(eq, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitIsJSProxy(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ JumpIfSmi(r3, if_false);
+ Register map = r4;
+ Register type_reg = r5;
+ __ LoadP(map, FieldMemOperand(r3, HeapObject::kMapOffset));
+ __ lbz(type_reg, FieldMemOperand(map, Map::kInstanceTypeOffset));
+ __ subi(type_reg, type_reg, Operand(FIRST_JS_PROXY_TYPE));
+ __ cmpli(type_reg, Operand(LAST_JS_PROXY_TYPE - FIRST_JS_PROXY_TYPE));
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(le, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitIsConstructCall(CallRuntime* expr) {
+ DCHECK(expr->arguments()->length() == 0);
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ // Get the frame pointer for the calling frame.
+ __ LoadP(r5, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+
+ // Skip the arguments adaptor frame if it exists.
+ Label check_frame_marker;
+ __ LoadP(r4, MemOperand(r5, StandardFrameConstants::kContextOffset));
+ __ CmpSmiLiteral(r4, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
+ __ bne(&check_frame_marker);
+ __ LoadP(r5, MemOperand(r5, StandardFrameConstants::kCallerFPOffset));
+
+ // Check the marker in the calling frame.
+ __ bind(&check_frame_marker);
+ __ LoadP(r4, MemOperand(r5, StandardFrameConstants::kMarkerOffset));
+ STATIC_ASSERT(StackFrame::CONSTRUCT < 0x4000);
+ __ CmpSmiLiteral(r4, Smi::FromInt(StackFrame::CONSTRUCT), r0);
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(eq, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitObjectEquals(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 2);
+
+ // Load the two objects into registers and perform the comparison.
+ VisitForStackValue(args->at(0));
+ VisitForAccumulatorValue(args->at(1));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ pop(r4);
+ __ cmp(r3, r4);
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(eq, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitArguments(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+
+ // ArgumentsAccessStub expects the key in edx and the formal
+ // parameter count in r3.
+ VisitForAccumulatorValue(args->at(0));
+ __ mr(r4, r3);
+ __ LoadSmiLiteral(r3, Smi::FromInt(info_->scope()->num_parameters()));
+ ArgumentsAccessStub stub(isolate(), ArgumentsAccessStub::READ_ELEMENT);
+ __ CallStub(&stub);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitArgumentsLength(CallRuntime* expr) {
+ DCHECK(expr->arguments()->length() == 0);
+ Label exit;
+ // Get the number of formal parameters.
+ __ LoadSmiLiteral(r3, Smi::FromInt(info_->scope()->num_parameters()));
+
+ // Check if the calling frame is an arguments adaptor frame.
+ __ LoadP(r5, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+ __ LoadP(r6, MemOperand(r5, StandardFrameConstants::kContextOffset));
+ __ CmpSmiLiteral(r6, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
+ __ bne(&exit);
+
+ // Arguments adaptor case: Read the arguments length from the
+ // adaptor frame.
+ __ LoadP(r3, MemOperand(r5, ArgumentsAdaptorFrameConstants::kLengthOffset));
+
+ __ bind(&exit);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitClassOf(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+ Label done, null, function, non_function_constructor;
+
+ VisitForAccumulatorValue(args->at(0));
+
+ // If the object is a smi, we return null.
+ __ JumpIfSmi(r3, &null);
+
+ // Check that the object is a JS object but take special care of JS
+ // functions to make sure they have 'Function' as their class.
+ // Assume that there are only two callable types, and one of them is at
+ // either end of the type range for JS object types. Saves extra comparisons.
+ STATIC_ASSERT(NUM_OF_CALLABLE_SPEC_OBJECT_TYPES == 2);
+ __ CompareObjectType(r3, r3, r4, FIRST_SPEC_OBJECT_TYPE);
+ // Map is now in r3.
+ __ blt(&null);
+ STATIC_ASSERT(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE ==
+ FIRST_SPEC_OBJECT_TYPE + 1);
+ __ beq(&function);
+
+ __ cmpi(r4, Operand(LAST_SPEC_OBJECT_TYPE));
+ STATIC_ASSERT(LAST_NONCALLABLE_SPEC_OBJECT_TYPE == LAST_SPEC_OBJECT_TYPE - 1);
+ __ beq(&function);
+ // Assume that there is no larger type.
+ STATIC_ASSERT(LAST_NONCALLABLE_SPEC_OBJECT_TYPE == LAST_TYPE - 1);
+
+ // Check if the constructor in the map is a JS function.
+ __ LoadP(r3, FieldMemOperand(r3, Map::kConstructorOffset));
+ __ CompareObjectType(r3, r4, r4, JS_FUNCTION_TYPE);
+ __ bne(&non_function_constructor);
+
+ // r3 now contains the constructor function. Grab the
+ // instance class name from there.
+ __ LoadP(r3, FieldMemOperand(r3, JSFunction::kSharedFunctionInfoOffset));
+ __ LoadP(r3,
+ FieldMemOperand(r3, SharedFunctionInfo::kInstanceClassNameOffset));
+ __ b(&done);
+
+ // Functions have class 'Function'.
+ __ bind(&function);
+ __ LoadRoot(r3, Heap::kFunction_stringRootIndex);
+ __ b(&done);
+
+ // Objects with a non-function constructor have class 'Object'.
+ __ bind(&non_function_constructor);
+ __ LoadRoot(r3, Heap::kObject_stringRootIndex);
+ __ b(&done);
+
+ // Non-JS objects have class null.
+ __ bind(&null);
+ __ LoadRoot(r3, Heap::kNullValueRootIndex);
+
+ // All done.
+ __ bind(&done);
+
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitSubString(CallRuntime* expr) {
+ // Load the arguments on the stack and call the stub.
+ SubStringStub stub(isolate());
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 3);
+ VisitForStackValue(args->at(0));
+ VisitForStackValue(args->at(1));
+ VisitForStackValue(args->at(2));
+ __ CallStub(&stub);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitRegExpExec(CallRuntime* expr) {
+ // Load the arguments on the stack and call the stub.
+ RegExpExecStub stub(isolate());
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 4);
+ VisitForStackValue(args->at(0));
+ VisitForStackValue(args->at(1));
+ VisitForStackValue(args->at(2));
+ VisitForStackValue(args->at(3));
+ __ CallStub(&stub);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitValueOf(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+ VisitForAccumulatorValue(args->at(0)); // Load the object.
+
+ Label done;
+ // If the object is a smi return the object.
+ __ JumpIfSmi(r3, &done);
+ // If the object is not a value type, return the object.
+ __ CompareObjectType(r3, r4, r4, JS_VALUE_TYPE);
+ __ bne(&done);
+ __ LoadP(r3, FieldMemOperand(r3, JSValue::kValueOffset));
+
+ __ bind(&done);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitDateField(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 2);
+ DCHECK_NE(NULL, args->at(1)->AsLiteral());
+ Smi* index = Smi::cast(*(args->at(1)->AsLiteral()->value()));
+
+ VisitForAccumulatorValue(args->at(0)); // Load the object.
+
+ Label runtime, done, not_date_object;
+ Register object = r3;
+ Register result = r3;
+ Register scratch0 = r11;
+ Register scratch1 = r4;
+
+ __ JumpIfSmi(object, ¬_date_object);
+ __ CompareObjectType(object, scratch1, scratch1, JS_DATE_TYPE);
+ __ bne(¬_date_object);
+
+ if (index->value() == 0) {
+ __ LoadP(result, FieldMemOperand(object, JSDate::kValueOffset));
+ __ b(&done);
+ } else {
+ if (index->value() < JSDate::kFirstUncachedField) {
+ ExternalReference stamp = ExternalReference::date_cache_stamp(isolate());
+ __ mov(scratch1, Operand(stamp));
+ __ LoadP(scratch1, MemOperand(scratch1));
+ __ LoadP(scratch0, FieldMemOperand(object, JSDate::kCacheStampOffset));
+ __ cmp(scratch1, scratch0);
+ __ bne(&runtime);
+ __ LoadP(result,
+ FieldMemOperand(object, JSDate::kValueOffset +
+ kPointerSize * index->value()),
+ scratch0);
+ __ b(&done);
+ }
+ __ bind(&runtime);
+ __ PrepareCallCFunction(2, scratch1);
+ __ LoadSmiLiteral(r4, index);
+ __ CallCFunction(ExternalReference::get_date_field_function(isolate()), 2);
+ __ b(&done);
+ }
+
+ __ bind(¬_date_object);
+ __ CallRuntime(Runtime::kThrowNotDateError, 0);
+ __ bind(&done);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitOneByteSeqStringSetChar(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK_EQ(3, args->length());
+
+ Register string = r3;
+ Register index = r4;
+ Register value = r5;
+
+ VisitForStackValue(args->at(0)); // index
+ VisitForStackValue(args->at(1)); // value
+ VisitForAccumulatorValue(args->at(2)); // string
+ __ Pop(index, value);
+
+ if (FLAG_debug_code) {
+ __ TestIfSmi(value, r0);
+ __ Check(eq, kNonSmiValue, cr0);
+ __ TestIfSmi(index, r0);
+ __ Check(eq, kNonSmiIndex, cr0);
+ __ SmiUntag(index, index);
+ static const uint32_t one_byte_seq_type = kSeqStringTag | kOneByteStringTag;
+ __ EmitSeqStringSetCharCheck(string, index, value, one_byte_seq_type);
+ __ SmiTag(index, index);
+ }
+
+ __ SmiUntag(value);
+ __ addi(ip, string, Operand(SeqOneByteString::kHeaderSize - kHeapObjectTag));
+ __ SmiToByteArrayOffset(r0, index);
+ __ stbx(value, MemOperand(ip, r0));
+ context()->Plug(string);
+}
+
+
+void FullCodeGenerator::EmitTwoByteSeqStringSetChar(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK_EQ(3, args->length());
+
+ Register string = r3;
+ Register index = r4;
+ Register value = r5;
+
+ VisitForStackValue(args->at(0)); // index
+ VisitForStackValue(args->at(1)); // value
+ VisitForAccumulatorValue(args->at(2)); // string
+ __ Pop(index, value);
+
+ if (FLAG_debug_code) {
+ __ TestIfSmi(value, r0);
+ __ Check(eq, kNonSmiValue, cr0);
+ __ TestIfSmi(index, r0);
+ __ Check(eq, kNonSmiIndex, cr0);
+ __ SmiUntag(index, index);
+ static const uint32_t two_byte_seq_type = kSeqStringTag | kTwoByteStringTag;
+ __ EmitSeqStringSetCharCheck(string, index, value, two_byte_seq_type);
+ __ SmiTag(index, index);
+ }
+
+ __ SmiUntag(value);
+ __ addi(ip, string, Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
+ __ SmiToShortArrayOffset(r0, index);
+ __ sthx(value, MemOperand(ip, r0));
+ context()->Plug(string);
+}
+
+
+void FullCodeGenerator::EmitMathPow(CallRuntime* expr) {
+ // Load the arguments on the stack and call the runtime function.
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 2);
+ VisitForStackValue(args->at(0));
+ VisitForStackValue(args->at(1));
+ MathPowStub stub(isolate(), MathPowStub::ON_STACK);
+ __ CallStub(&stub);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitSetValueOf(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 2);
+ VisitForStackValue(args->at(0)); // Load the object.
+ VisitForAccumulatorValue(args->at(1)); // Load the value.
+ __ pop(r4); // r3 = value. r4 = object.
+
+ Label done;
+ // If the object is a smi, return the value.
+ __ JumpIfSmi(r4, &done);
+
+ // If the object is not a value type, return the value.
+ __ CompareObjectType(r4, r5, r5, JS_VALUE_TYPE);
+ __ bne(&done);
+
+ // Store the value.
+ __ StoreP(r3, FieldMemOperand(r4, JSValue::kValueOffset), r0);
+ // Update the write barrier. Save the value as it will be
+ // overwritten by the write barrier code and is needed afterward.
+ __ mr(r5, r3);
+ __ RecordWriteField(r4, JSValue::kValueOffset, r5, r6, kLRHasBeenSaved,
+ kDontSaveFPRegs);
+
+ __ bind(&done);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitNumberToString(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK_EQ(args->length(), 1);
+ // Load the argument into r3 and call the stub.
+ VisitForAccumulatorValue(args->at(0));
+
+ NumberToStringStub stub(isolate());
+ __ CallStub(&stub);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitStringCharFromCode(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+ VisitForAccumulatorValue(args->at(0));
+
+ Label done;
+ StringCharFromCodeGenerator generator(r3, r4);
+ generator.GenerateFast(masm_);
+ __ b(&done);
+
+ NopRuntimeCallHelper call_helper;
+ generator.GenerateSlow(masm_, call_helper);
+
+ __ bind(&done);
+ context()->Plug(r4);
+}
+
+
+void FullCodeGenerator::EmitStringCharCodeAt(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 2);
+ VisitForStackValue(args->at(0));
+ VisitForAccumulatorValue(args->at(1));
+
+ Register object = r4;
+ Register index = r3;
+ Register result = r6;
+
+ __ pop(object);
+
+ Label need_conversion;
+ Label index_out_of_range;
+ Label done;
+ StringCharCodeAtGenerator generator(object, index, result, &need_conversion,
+ &need_conversion, &index_out_of_range,
+ STRING_INDEX_IS_NUMBER);
+ generator.GenerateFast(masm_);
+ __ b(&done);
+
+ __ bind(&index_out_of_range);
+ // When the index is out of range, the spec requires us to return
+ // NaN.
+ __ LoadRoot(result, Heap::kNanValueRootIndex);
+ __ b(&done);
+
+ __ bind(&need_conversion);
+ // Load the undefined value into the result register, which will
+ // trigger conversion.
+ __ LoadRoot(result, Heap::kUndefinedValueRootIndex);
+ __ b(&done);
+
+ NopRuntimeCallHelper call_helper;
+ generator.GenerateSlow(masm_, call_helper);
+
+ __ bind(&done);
+ context()->Plug(result);
+}
+
+
+void FullCodeGenerator::EmitStringCharAt(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 2);
+ VisitForStackValue(args->at(0));
+ VisitForAccumulatorValue(args->at(1));
+
+ Register object = r4;
+ Register index = r3;
+ Register scratch = r6;
+ Register result = r3;
+
+ __ pop(object);
+
+ Label need_conversion;
+ Label index_out_of_range;
+ Label done;
+ StringCharAtGenerator generator(object, index, scratch, result,
+ &need_conversion, &need_conversion,
+ &index_out_of_range, STRING_INDEX_IS_NUMBER);
+ generator.GenerateFast(masm_);
+ __ b(&done);
+
+ __ bind(&index_out_of_range);
+ // When the index is out of range, the spec requires us to return
+ // the empty string.
+ __ LoadRoot(result, Heap::kempty_stringRootIndex);
+ __ b(&done);
+
+ __ bind(&need_conversion);
+ // Move smi zero into the result register, which will trigger
+ // conversion.
+ __ LoadSmiLiteral(result, Smi::FromInt(0));
+ __ b(&done);
+
+ NopRuntimeCallHelper call_helper;
+ generator.GenerateSlow(masm_, call_helper);
+
+ __ bind(&done);
+ context()->Plug(result);
+}
+
+
+void FullCodeGenerator::EmitStringAdd(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK_EQ(2, args->length());
+ VisitForStackValue(args->at(0));
+ VisitForAccumulatorValue(args->at(1));
+
+ __ pop(r4);
+ StringAddStub stub(isolate(), STRING_ADD_CHECK_BOTH, NOT_TENURED);
+ __ CallStub(&stub);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitStringCompare(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK_EQ(2, args->length());
+ VisitForStackValue(args->at(0));
+ VisitForStackValue(args->at(1));
+
+ StringCompareStub stub(isolate());
+ __ CallStub(&stub);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitCallFunction(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() >= 2);
+
+ int arg_count = args->length() - 2; // 2 ~ receiver and function.
+ for (int i = 0; i < arg_count + 1; i++) {
+ VisitForStackValue(args->at(i));
+ }
+ VisitForAccumulatorValue(args->last()); // Function.
+
+ Label runtime, done;
+ // Check for non-function argument (including proxy).
+ __ JumpIfSmi(r3, &runtime);
+ __ CompareObjectType(r3, r4, r4, JS_FUNCTION_TYPE);
+ __ bne(&runtime);
+
+ // InvokeFunction requires the function in r4. Move it in there.
+ __ mr(r4, result_register());
+ ParameterCount count(arg_count);
+ __ InvokeFunction(r4, count, CALL_FUNCTION, NullCallWrapper());
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ __ b(&done);
+
+ __ bind(&runtime);
+ __ push(r3);
+ __ CallRuntime(Runtime::kCall, args->length());
+ __ bind(&done);
+
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitRegExpConstructResult(CallRuntime* expr) {
+ RegExpConstructResultStub stub(isolate());
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 3);
+ VisitForStackValue(args->at(0));
+ VisitForStackValue(args->at(1));
+ VisitForAccumulatorValue(args->at(2));
+ __ Pop(r5, r4);
+ __ CallStub(&stub);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitGetFromCache(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK_EQ(2, args->length());
+ DCHECK_NE(NULL, args->at(0)->AsLiteral());
+ int cache_id = Smi::cast(*(args->at(0)->AsLiteral()->value()))->value();
+
+ Handle<FixedArray> jsfunction_result_caches(
+ isolate()->native_context()->jsfunction_result_caches());
+ if (jsfunction_result_caches->length() <= cache_id) {
+ __ Abort(kAttemptToUseUndefinedCache);
+ __ LoadRoot(r3, Heap::kUndefinedValueRootIndex);
+ context()->Plug(r3);
+ return;
+ }
+
+ VisitForAccumulatorValue(args->at(1));
+
+ Register key = r3;
+ Register cache = r4;
+ __ LoadP(cache, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
+ __ LoadP(cache, FieldMemOperand(cache, GlobalObject::kNativeContextOffset));
+ __ LoadP(cache,
+ ContextOperand(cache, Context::JSFUNCTION_RESULT_CACHES_INDEX));
+ __ LoadP(cache,
+ FieldMemOperand(cache, FixedArray::OffsetOfElementAt(cache_id)), r0);
+
+ Label done, not_found;
+ __ LoadP(r5, FieldMemOperand(cache, JSFunctionResultCache::kFingerOffset));
+ // r5 now holds finger offset as a smi.
+ __ addi(r6, cache, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ // r6 now points to the start of fixed array elements.
+ __ SmiToPtrArrayOffset(r5, r5);
+ __ LoadPUX(r5, MemOperand(r6, r5));
+ // r6 now points to the key of the pair.
+ __ cmp(key, r5);
+ __ bne(¬_found);
+
+ __ LoadP(r3, MemOperand(r6, kPointerSize));
+ __ b(&done);
+
+ __ bind(¬_found);
+ // Call runtime to perform the lookup.
+ __ Push(cache, key);
+ __ CallRuntime(Runtime::kGetFromCache, 2);
+
+ __ bind(&done);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitHasCachedArrayIndex(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ VisitForAccumulatorValue(args->at(0));
+
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ __ lwz(r3, FieldMemOperand(r3, String::kHashFieldOffset));
+ // PPC - assume ip is free
+ __ mov(ip, Operand(String::kContainsCachedArrayIndexMask));
+ __ and_(r0, r3, ip);
+ __ cmpi(r0, Operand::Zero());
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ Split(eq, if_true, if_false, fall_through);
+
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitGetCachedArrayIndex(CallRuntime* expr) {
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 1);
+ VisitForAccumulatorValue(args->at(0));
+
+ __ AssertString(r3);
+
+ __ lwz(r3, FieldMemOperand(r3, String::kHashFieldOffset));
+ __ IndexFromHash(r3, r3);
+
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitFastOneByteArrayJoin(CallRuntime* expr) {
+ Label bailout, done, one_char_separator, long_separator, non_trivial_array,
+ not_size_one_array, loop, empty_separator_loop, one_char_separator_loop,
+ one_char_separator_loop_entry, long_separator_loop;
+ ZoneList<Expression*>* args = expr->arguments();
+ DCHECK(args->length() == 2);
+ VisitForStackValue(args->at(1));
+ VisitForAccumulatorValue(args->at(0));
+
+ // All aliases of the same register have disjoint lifetimes.
+ Register array = r3;
+ Register elements = no_reg; // Will be r3.
+ Register result = no_reg; // Will be r3.
+ Register separator = r4;
+ Register array_length = r5;
+ Register result_pos = no_reg; // Will be r5
+ Register string_length = r6;
+ Register string = r7;
+ Register element = r8;
+ Register elements_end = r9;
+ Register scratch1 = r10;
+ Register scratch2 = r11;
+
+ // Separator operand is on the stack.
+ __ pop(separator);
+
+ // Check that the array is a JSArray.
+ __ JumpIfSmi(array, &bailout);
+ __ CompareObjectType(array, scratch1, scratch2, JS_ARRAY_TYPE);
+ __ bne(&bailout);
+
+ // Check that the array has fast elements.
+ __ CheckFastElements(scratch1, scratch2, &bailout);
+
+ // If the array has length zero, return the empty string.
+ __ LoadP(array_length, FieldMemOperand(array, JSArray::kLengthOffset));
+ __ SmiUntag(array_length);
+ __ cmpi(array_length, Operand::Zero());
+ __ bne(&non_trivial_array);
+ __ LoadRoot(r3, Heap::kempty_stringRootIndex);
+ __ b(&done);
+
+ __ bind(&non_trivial_array);
+
+ // Get the FixedArray containing array's elements.
+ elements = array;
+ __ LoadP(elements, FieldMemOperand(array, JSArray::kElementsOffset));
+ array = no_reg; // End of array's live range.
+
+ // Check that all array elements are sequential one-byte strings, and
+ // accumulate the sum of their lengths, as a smi-encoded value.
+ __ li(string_length, Operand::Zero());
+ __ addi(element, elements, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ __ ShiftLeftImm(elements_end, array_length, Operand(kPointerSizeLog2));
+ __ add(elements_end, element, elements_end);
+ // Loop condition: while (element < elements_end).
+ // Live values in registers:
+ // elements: Fixed array of strings.
+ // array_length: Length of the fixed array of strings (not smi)
+ // separator: Separator string
+ // string_length: Accumulated sum of string lengths (smi).
+ // element: Current array element.
+ // elements_end: Array end.
+ if (generate_debug_code_) {
+ __ cmpi(array_length, Operand::Zero());
+ __ Assert(gt, kNoEmptyArraysHereInEmitFastOneByteArrayJoin);
+ }
+ __ bind(&loop);
+ __ LoadP(string, MemOperand(element));
+ __ addi(element, element, Operand(kPointerSize));
+ __ JumpIfSmi(string, &bailout);
+ __ LoadP(scratch1, FieldMemOperand(string, HeapObject::kMapOffset));
+ __ lbz(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset));
+ __ JumpIfInstanceTypeIsNotSequentialOneByte(scratch1, scratch2, &bailout);
+ __ LoadP(scratch1, FieldMemOperand(string, SeqOneByteString::kLengthOffset));
+
+ __ AddAndCheckForOverflow(string_length, string_length, scratch1, scratch2,
+ r0);
+ __ BranchOnOverflow(&bailout);
+
+ __ cmp(element, elements_end);
+ __ blt(&loop);
+
+ // If array_length is 1, return elements[0], a string.
+ __ cmpi(array_length, Operand(1));
+ __ bne(¬_size_one_array);
+ __ LoadP(r3, FieldMemOperand(elements, FixedArray::kHeaderSize));
+ __ b(&done);
+
+ __ bind(¬_size_one_array);
+
+ // Live values in registers:
+ // separator: Separator string
+ // array_length: Length of the array.
+ // string_length: Sum of string lengths (smi).
+ // elements: FixedArray of strings.
+
+ // Check that the separator is a flat one-byte string.
+ __ JumpIfSmi(separator, &bailout);
+ __ LoadP(scratch1, FieldMemOperand(separator, HeapObject::kMapOffset));
+ __ lbz(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset));
+ __ JumpIfInstanceTypeIsNotSequentialOneByte(scratch1, scratch2, &bailout);
+
+ // Add (separator length times array_length) - separator length to the
+ // string_length to get the length of the result string.
+ __ LoadP(scratch1,
+ FieldMemOperand(separator, SeqOneByteString::kLengthOffset));
+ __ sub(string_length, string_length, scratch1);
+#if V8_TARGET_ARCH_PPC64
+ __ SmiUntag(scratch1, scratch1);
+ __ Mul(scratch2, array_length, scratch1);
+ // Check for smi overflow. No overflow if higher 33 bits of 64-bit result are
+ // zero.
+ __ ShiftRightImm(ip, scratch2, Operand(31), SetRC);
+ __ bne(&bailout, cr0);
+ __ SmiTag(scratch2, scratch2);
+#else
+ // array_length is not smi but the other values are, so the result is a smi
+ __ mullw(scratch2, array_length, scratch1);
+ __ mulhw(ip, array_length, scratch1);
+ // Check for smi overflow. No overflow if higher 33 bits of 64-bit result are
+ // zero.
+ __ cmpi(ip, Operand::Zero());
+ __ bne(&bailout);
+ __ cmpwi(scratch2, Operand::Zero());
+ __ blt(&bailout);
+#endif
+
+ __ AddAndCheckForOverflow(string_length, string_length, scratch2, scratch1,
+ r0);
+ __ BranchOnOverflow(&bailout);
+ __ SmiUntag(string_length);
+
+ // Get first element in the array to free up the elements register to be used
+ // for the result.
+ __ addi(element, elements, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ result = elements; // End of live range for elements.
+ elements = no_reg;
+ // Live values in registers:
+ // element: First array element
+ // separator: Separator string
+ // string_length: Length of result string (not smi)
+ // array_length: Length of the array.
+ __ AllocateOneByteString(result, string_length, scratch1, scratch2,
+ elements_end, &bailout);
+ // Prepare for looping. Set up elements_end to end of the array. Set
+ // result_pos to the position of the result where to write the first
+ // character.
+ __ ShiftLeftImm(elements_end, array_length, Operand(kPointerSizeLog2));
+ __ add(elements_end, element, elements_end);
+ result_pos = array_length; // End of live range for array_length.
+ array_length = no_reg;
+ __ addi(result_pos, result,
+ Operand(SeqOneByteString::kHeaderSize - kHeapObjectTag));
+
+ // Check the length of the separator.
+ __ LoadP(scratch1,
+ FieldMemOperand(separator, SeqOneByteString::kLengthOffset));
+ __ CmpSmiLiteral(scratch1, Smi::FromInt(1), r0);
+ __ beq(&one_char_separator);
+ __ bgt(&long_separator);
+
+ // Empty separator case
+ __ bind(&empty_separator_loop);
+ // Live values in registers:
+ // result_pos: the position to which we are currently copying characters.
+ // element: Current array element.
+ // elements_end: Array end.
+
+ // Copy next array element to the result.
+ __ LoadP(string, MemOperand(element));
+ __ addi(element, element, Operand(kPointerSize));
+ __ LoadP(string_length, FieldMemOperand(string, String::kLengthOffset));
+ __ SmiUntag(string_length);
+ __ addi(string, string,
+ Operand(SeqOneByteString::kHeaderSize - kHeapObjectTag));
+ __ CopyBytes(string, result_pos, string_length, scratch1);
+ __ cmp(element, elements_end);
+ __ blt(&empty_separator_loop); // End while (element < elements_end).
+ DCHECK(result.is(r3));
+ __ b(&done);
+
+ // One-character separator case
+ __ bind(&one_char_separator);
+ // Replace separator with its one-byte character value.
+ __ lbz(separator, FieldMemOperand(separator, SeqOneByteString::kHeaderSize));
+ // Jump into the loop after the code that copies the separator, so the first
+ // element is not preceded by a separator
+ __ b(&one_char_separator_loop_entry);
+
+ __ bind(&one_char_separator_loop);
+ // Live values in registers:
+ // result_pos: the position to which we are currently copying characters.
+ // element: Current array element.
+ // elements_end: Array end.
+ // separator: Single separator one-byte char (in lower byte).
+
+ // Copy the separator character to the result.
+ __ stb(separator, MemOperand(result_pos));
+ __ addi(result_pos, result_pos, Operand(1));
+
+ // Copy next array element to the result.
+ __ bind(&one_char_separator_loop_entry);
+ __ LoadP(string, MemOperand(element));
+ __ addi(element, element, Operand(kPointerSize));
+ __ LoadP(string_length, FieldMemOperand(string, String::kLengthOffset));
+ __ SmiUntag(string_length);
+ __ addi(string, string,
+ Operand(SeqOneByteString::kHeaderSize - kHeapObjectTag));
+ __ CopyBytes(string, result_pos, string_length, scratch1);
+ __ cmpl(element, elements_end);
+ __ blt(&one_char_separator_loop); // End while (element < elements_end).
+ DCHECK(result.is(r3));
+ __ b(&done);
+
+ // Long separator case (separator is more than one character). Entry is at the
+ // label long_separator below.
+ __ bind(&long_separator_loop);
+ // Live values in registers:
+ // result_pos: the position to which we are currently copying characters.
+ // element: Current array element.
+ // elements_end: Array end.
+ // separator: Separator string.
+
+ // Copy the separator to the result.
+ __ LoadP(string_length, FieldMemOperand(separator, String::kLengthOffset));
+ __ SmiUntag(string_length);
+ __ addi(string, separator,
+ Operand(SeqOneByteString::kHeaderSize - kHeapObjectTag));
+ __ CopyBytes(string, result_pos, string_length, scratch1);
+
+ __ bind(&long_separator);
+ __ LoadP(string, MemOperand(element));
+ __ addi(element, element, Operand(kPointerSize));
+ __ LoadP(string_length, FieldMemOperand(string, String::kLengthOffset));
+ __ SmiUntag(string_length);
+ __ addi(string, string,
+ Operand(SeqOneByteString::kHeaderSize - kHeapObjectTag));
+ __ CopyBytes(string, result_pos, string_length, scratch1);
+ __ cmpl(element, elements_end);
+ __ blt(&long_separator_loop); // End while (element < elements_end).
+ DCHECK(result.is(r3));
+ __ b(&done);
+
+ __ bind(&bailout);
+ __ LoadRoot(r3, Heap::kUndefinedValueRootIndex);
+ __ bind(&done);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::EmitDebugIsActive(CallRuntime* expr) {
+ DCHECK(expr->arguments()->length() == 0);
+ ExternalReference debug_is_active =
+ ExternalReference::debug_is_active_address(isolate());
+ __ mov(ip, Operand(debug_is_active));
+ __ lbz(r3, MemOperand(ip));
+ __ SmiTag(r3);
+ context()->Plug(r3);
+}
+
+
+void FullCodeGenerator::VisitCallRuntime(CallRuntime* expr) {
+ if (expr->function() != NULL &&
+ expr->function()->intrinsic_type == Runtime::INLINE) {
+ Comment cmnt(masm_, "[ InlineRuntimeCall");
+ EmitInlineRuntimeCall(expr);
+ return;
+ }
+
+ Comment cmnt(masm_, "[ CallRuntime");
+ ZoneList<Expression*>* args = expr->arguments();
+ int arg_count = args->length();
+
+ if (expr->is_jsruntime()) {
+ // Push the builtins object as the receiver.
+ Register receiver = LoadDescriptor::ReceiverRegister();
+ __ LoadP(receiver, GlobalObjectOperand());
+ __ LoadP(receiver,
+ FieldMemOperand(receiver, GlobalObject::kBuiltinsOffset));
+ __ push(receiver);
+
+ // Load the function from the receiver.
+ __ mov(LoadDescriptor::NameRegister(), Operand(expr->name()));
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(expr->CallRuntimeFeedbackSlot())));
+ CallLoadIC(NOT_CONTEXTUAL);
+ } else {
+ CallLoadIC(NOT_CONTEXTUAL, expr->CallRuntimeFeedbackId());
+ }
+
+ // Push the target function under the receiver.
+ __ LoadP(ip, MemOperand(sp, 0));
+ __ push(ip);
+ __ StoreP(r3, MemOperand(sp, kPointerSize));
+
+ // Push the arguments ("left-to-right").
+ int arg_count = args->length();
+ for (int i = 0; i < arg_count; i++) {
+ VisitForStackValue(args->at(i));
+ }
+
+ // Record source position of the IC call.
+ SetSourcePosition(expr->position());
+ CallFunctionStub stub(isolate(), arg_count, NO_CALL_FUNCTION_FLAGS);
+ __ LoadP(r4, MemOperand(sp, (arg_count + 1) * kPointerSize), r0);
+ __ CallStub(&stub);
+
+ // Restore context register.
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+
+ context()->DropAndPlug(1, r3);
+ } else {
+ // Push the arguments ("left-to-right").
+ for (int i = 0; i < arg_count; i++) {
+ VisitForStackValue(args->at(i));
+ }
+
+ // Call the C runtime function.
+ __ CallRuntime(expr->function(), arg_count);
+ context()->Plug(r3);
+ }
+}
+
+
+void FullCodeGenerator::VisitUnaryOperation(UnaryOperation* expr) {
+ switch (expr->op()) {
+ case Token::DELETE: {
+ Comment cmnt(masm_, "[ UnaryOperation (DELETE)");
+ Property* property = expr->expression()->AsProperty();
+ VariableProxy* proxy = expr->expression()->AsVariableProxy();
+
+ if (property != NULL) {
+ VisitForStackValue(property->obj());
+ VisitForStackValue(property->key());
+ __ LoadSmiLiteral(r4, Smi::FromInt(strict_mode()));
+ __ push(r4);
+ __ InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION);
+ context()->Plug(r3);
+ } else if (proxy != NULL) {
+ Variable* var = proxy->var();
+ // Delete of an unqualified identifier is disallowed in strict mode
+ // but "delete this" is allowed.
+ DCHECK(strict_mode() == SLOPPY || var->is_this());
+ if (var->IsUnallocated()) {
+ __ LoadP(r5, GlobalObjectOperand());
+ __ mov(r4, Operand(var->name()));
+ __ LoadSmiLiteral(r3, Smi::FromInt(SLOPPY));
+ __ Push(r5, r4, r3);
+ __ InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION);
+ context()->Plug(r3);
+ } else if (var->IsStackAllocated() || var->IsContextSlot()) {
+ // Result of deleting non-global, non-dynamic variables is false.
+ // The subexpression does not have side effects.
+ context()->Plug(var->is_this());
+ } else {
+ // Non-global variable. Call the runtime to try to delete from the
+ // context where the variable was introduced.
+ DCHECK(!context_register().is(r5));
+ __ mov(r5, Operand(var->name()));
+ __ Push(context_register(), r5);
+ __ CallRuntime(Runtime::kDeleteLookupSlot, 2);
+ context()->Plug(r3);
+ }
+ } else {
+ // Result of deleting non-property, non-variable reference is true.
+ // The subexpression may have side effects.
+ VisitForEffect(expr->expression());
+ context()->Plug(true);
+ }
+ break;
+ }
+
+ case Token::VOID: {
+ Comment cmnt(masm_, "[ UnaryOperation (VOID)");
+ VisitForEffect(expr->expression());
+ context()->Plug(Heap::kUndefinedValueRootIndex);
+ break;
+ }
+
+ case Token::NOT: {
+ Comment cmnt(masm_, "[ UnaryOperation (NOT)");
+ if (context()->IsEffect()) {
+ // Unary NOT has no side effects so it's only necessary to visit the
+ // subexpression. Match the optimizing compiler by not branching.
+ VisitForEffect(expr->expression());
+ } else if (context()->IsTest()) {
+ const TestContext* test = TestContext::cast(context());
+ // The labels are swapped for the recursive call.
+ VisitForControl(expr->expression(), test->false_label(),
+ test->true_label(), test->fall_through());
+ context()->Plug(test->true_label(), test->false_label());
+ } else {
+ // We handle value contexts explicitly rather than simply visiting
+ // for control and plugging the control flow into the context,
+ // because we need to prepare a pair of extra administrative AST ids
+ // for the optimizing compiler.
+ DCHECK(context()->IsAccumulatorValue() || context()->IsStackValue());
+ Label materialize_true, materialize_false, done;
+ VisitForControl(expr->expression(), &materialize_false,
+ &materialize_true, &materialize_true);
+ __ bind(&materialize_true);
+ PrepareForBailoutForId(expr->MaterializeTrueId(), NO_REGISTERS);
+ __ LoadRoot(r3, Heap::kTrueValueRootIndex);
+ if (context()->IsStackValue()) __ push(r3);
+ __ b(&done);
+ __ bind(&materialize_false);
+ PrepareForBailoutForId(expr->MaterializeFalseId(), NO_REGISTERS);
+ __ LoadRoot(r3, Heap::kFalseValueRootIndex);
+ if (context()->IsStackValue()) __ push(r3);
+ __ bind(&done);
+ }
+ break;
+ }
+
+ case Token::TYPEOF: {
+ Comment cmnt(masm_, "[ UnaryOperation (TYPEOF)");
+ {
+ StackValueContext context(this);
+ VisitForTypeofValue(expr->expression());
+ }
+ __ CallRuntime(Runtime::kTypeof, 1);
+ context()->Plug(r3);
+ break;
+ }
+
+ default:
+ UNREACHABLE();
+ }
+}
+
+
+void FullCodeGenerator::VisitCountOperation(CountOperation* expr) {
+ DCHECK(expr->expression()->IsValidReferenceExpression());
+
+ Comment cmnt(masm_, "[ CountOperation");
+ SetSourcePosition(expr->position());
+
+ Property* prop = expr->expression()->AsProperty();
+ LhsKind assign_type = GetAssignType(prop);
+
+ // Evaluate expression and get value.
+ if (assign_type == VARIABLE) {
+ DCHECK(expr->expression()->AsVariableProxy()->var() != NULL);
+ AccumulatorValueContext context(this);
+ EmitVariableLoad(expr->expression()->AsVariableProxy());
+ } else {
+ // Reserve space for result of postfix operation.
+ if (expr->is_postfix() && !context()->IsEffect()) {
+ __ LoadSmiLiteral(ip, Smi::FromInt(0));
+ __ push(ip);
+ }
+ switch (assign_type) {
+ case NAMED_PROPERTY: {
+ // Put the object both on the stack and in the register.
+ VisitForStackValue(prop->obj());
+ __ LoadP(LoadDescriptor::ReceiverRegister(), MemOperand(sp, 0));
+ EmitNamedPropertyLoad(prop);
+ break;
+ }
+
+ case NAMED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ __ Push(result_register());
+ const Register scratch = r4;
+ __ LoadP(scratch, MemOperand(sp, kPointerSize));
+ __ Push(scratch, result_register());
+ EmitNamedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_SUPER_PROPERTY: {
+ VisitForStackValue(prop->obj()->AsSuperReference()->this_var());
+ EmitLoadHomeObject(prop->obj()->AsSuperReference());
+ const Register scratch = r4;
+ const Register scratch1 = r5;
+ __ Move(scratch, result_register());
+ VisitForAccumulatorValue(prop->key());
+ __ Push(scratch, result_register());
+ __ LoadP(scratch1, MemOperand(sp, 2 * kPointerSize));
+ __ Push(scratch1, scratch, result_register());
+ EmitKeyedSuperPropertyLoad(prop);
+ break;
+ }
+
+ case KEYED_PROPERTY: {
+ VisitForStackValue(prop->obj());
+ VisitForStackValue(prop->key());
+ __ LoadP(LoadDescriptor::ReceiverRegister(),
+ MemOperand(sp, 1 * kPointerSize));
+ __ LoadP(LoadDescriptor::NameRegister(), MemOperand(sp, 0));
+ EmitKeyedPropertyLoad(prop);
+ break;
+ }
+
+ case VARIABLE:
+ UNREACHABLE();
+ }
+ }
+
+ // We need a second deoptimization point after loading the value
+ // in case evaluating the property load my have a side effect.
+ if (assign_type == VARIABLE) {
+ PrepareForBailout(expr->expression(), TOS_REG);
+ } else {
+ PrepareForBailoutForId(prop->LoadId(), TOS_REG);
+ }
+
+ // Inline smi case if we are in a loop.
+ Label stub_call, done;
+ JumpPatchSite patch_site(masm_);
+
+ int count_value = expr->op() == Token::INC ? 1 : -1;
+ if (ShouldInlineSmiCase(expr->op())) {
+ Label slow;
+ patch_site.EmitJumpIfNotSmi(r3, &slow);
+
+ // Save result for postfix expressions.
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ // Save the result on the stack. If we have a named or keyed property
+ // we store the result under the receiver that is currently on top
+ // of the stack.
+ switch (assign_type) {
+ case VARIABLE:
+ __ push(r3);
+ break;
+ case NAMED_PROPERTY:
+ __ StoreP(r3, MemOperand(sp, kPointerSize));
+ break;
+ case NAMED_SUPER_PROPERTY:
+ __ StoreP(r3, MemOperand(sp, 2 * kPointerSize));
+ break;
+ case KEYED_PROPERTY:
+ __ StoreP(r3, MemOperand(sp, 2 * kPointerSize));
+ break;
+ case KEYED_SUPER_PROPERTY:
+ __ StoreP(r3, MemOperand(sp, 3 * kPointerSize));
+ break;
+ }
+ }
+ }
+
+ Register scratch1 = r4;
+ Register scratch2 = r5;
+ __ LoadSmiLiteral(scratch1, Smi::FromInt(count_value));
+ __ AddAndCheckForOverflow(r3, r3, scratch1, scratch2, r0);
+ __ BranchOnNoOverflow(&done);
+ // Call stub. Undo operation first.
+ __ sub(r3, r3, scratch1);
+ __ b(&stub_call);
+ __ bind(&slow);
+ }
+ ToNumberStub convert_stub(isolate());
+ __ CallStub(&convert_stub);
+
+ // Save result for postfix expressions.
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ // Save the result on the stack. If we have a named or keyed property
+ // we store the result under the receiver that is currently on top
+ // of the stack.
+ switch (assign_type) {
+ case VARIABLE:
+ __ push(r3);
+ break;
+ case NAMED_PROPERTY:
+ __ StoreP(r3, MemOperand(sp, kPointerSize));
+ break;
+ case NAMED_SUPER_PROPERTY:
+ __ StoreP(r3, MemOperand(sp, 2 * kPointerSize));
+ break;
+ case KEYED_PROPERTY:
+ __ StoreP(r3, MemOperand(sp, 2 * kPointerSize));
+ break;
+ case KEYED_SUPER_PROPERTY:
+ __ StoreP(r3, MemOperand(sp, 3 * kPointerSize));
+ break;
+ }
+ }
+ }
+
+ __ bind(&stub_call);
+ __ mr(r4, r3);
+ __ LoadSmiLiteral(r3, Smi::FromInt(count_value));
+
+ // Record position before stub call.
+ SetSourcePosition(expr->position());
+
+ Handle<Code> code =
+ CodeFactory::BinaryOpIC(isolate(), Token::ADD, NO_OVERWRITE).code();
+ CallIC(code, expr->CountBinOpFeedbackId());
+ patch_site.EmitPatchInfo();
+ __ bind(&done);
+
+ // Store the value returned in r3.
+ switch (assign_type) {
+ case VARIABLE:
+ if (expr->is_postfix()) {
+ {
+ EffectContext context(this);
+ EmitVariableAssignment(expr->expression()->AsVariableProxy()->var(),
+ Token::ASSIGN);
+ PrepareForBailoutForId(expr->AssignmentId(), TOS_REG);
+ context.Plug(r3);
+ }
+ // For all contexts except EffectConstant We have the result on
+ // top of the stack.
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ EmitVariableAssignment(expr->expression()->AsVariableProxy()->var(),
+ Token::ASSIGN);
+ PrepareForBailoutForId(expr->AssignmentId(), TOS_REG);
+ context()->Plug(r3);
+ }
+ break;
+ case NAMED_PROPERTY: {
+ __ mov(StoreDescriptor::NameRegister(),
+ Operand(prop->key()->AsLiteral()->value()));
+ __ pop(StoreDescriptor::ReceiverRegister());
+ CallStoreIC(expr->CountStoreFeedbackId());
+ PrepareForBailoutForId(expr->AssignmentId(), TOS_REG);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(r3);
+ }
+ break;
+ }
+ case NAMED_SUPER_PROPERTY: {
+ EmitNamedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(r3);
+ }
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ EmitKeyedSuperPropertyStore(prop);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(r3);
+ }
+ break;
+ }
+ case KEYED_PROPERTY: {
+ __ Pop(StoreDescriptor::ReceiverRegister(),
+ StoreDescriptor::NameRegister());
+ Handle<Code> ic =
+ CodeFactory::KeyedStoreIC(isolate(), strict_mode()).code();
+ CallIC(ic, expr->CountStoreFeedbackId());
+ PrepareForBailoutForId(expr->AssignmentId(), TOS_REG);
+ if (expr->is_postfix()) {
+ if (!context()->IsEffect()) {
+ context()->PlugTOS();
+ }
+ } else {
+ context()->Plug(r3);
+ }
+ break;
+ }
+ }
+}
+
+
+void FullCodeGenerator::VisitForTypeofValue(Expression* expr) {
+ DCHECK(!context()->IsEffect());
+ DCHECK(!context()->IsTest());
+ VariableProxy* proxy = expr->AsVariableProxy();
+ if (proxy != NULL && proxy->var()->IsUnallocated()) {
+ Comment cmnt(masm_, "[ Global variable");
+ __ LoadP(LoadDescriptor::ReceiverRegister(), GlobalObjectOperand());
+ __ mov(LoadDescriptor::NameRegister(), Operand(proxy->name()));
+ if (FLAG_vector_ics) {
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Operand(SmiFromSlot(proxy->VariableFeedbackSlot())));
+ }
+ // Use a regular load, not a contextual load, to avoid a reference
+ // error.
+ CallLoadIC(NOT_CONTEXTUAL);
+ PrepareForBailout(expr, TOS_REG);
+ context()->Plug(r3);
+ } else if (proxy != NULL && proxy->var()->IsLookupSlot()) {
+ Comment cmnt(masm_, "[ Lookup slot");
+ Label done, slow;
+
+ // Generate code for loading from variables potentially shadowed
+ // by eval-introduced variables.
+ EmitDynamicLookupFastCase(proxy, INSIDE_TYPEOF, &slow, &done);
+
+ __ bind(&slow);
+ __ mov(r3, Operand(proxy->name()));
+ __ Push(cp, r3);
+ __ CallRuntime(Runtime::kLoadLookupSlotNoReferenceError, 2);
+ PrepareForBailout(expr, TOS_REG);
+ __ bind(&done);
+
+ context()->Plug(r3);
+ } else {
+ // This expression cannot throw a reference error at the top level.
+ VisitInDuplicateContext(expr);
+ }
+}
+
+
+void FullCodeGenerator::EmitLiteralCompareTypeof(Expression* expr,
+ Expression* sub_expr,
+ Handle<String> check) {
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ {
+ AccumulatorValueContext context(this);
+ VisitForTypeofValue(sub_expr);
+ }
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+
+ Factory* factory = isolate()->factory();
+ if (String::Equals(check, factory->number_string())) {
+ __ JumpIfSmi(r3, if_true);
+ __ LoadP(r3, FieldMemOperand(r3, HeapObject::kMapOffset));
+ __ LoadRoot(ip, Heap::kHeapNumberMapRootIndex);
+ __ cmp(r3, ip);
+ Split(eq, if_true, if_false, fall_through);
+ } else if (String::Equals(check, factory->string_string())) {
+ __ JumpIfSmi(r3, if_false);
+ // Check for undetectable objects => false.
+ __ CompareObjectType(r3, r3, r4, FIRST_NONSTRING_TYPE);
+ __ bge(if_false);
+ __ lbz(r4, FieldMemOperand(r3, Map::kBitFieldOffset));
+ STATIC_ASSERT((1 << Map::kIsUndetectable) < 0x8000);
+ __ andi(r0, r4, Operand(1 << Map::kIsUndetectable));
+ Split(eq, if_true, if_false, fall_through, cr0);
+ } else if (String::Equals(check, factory->symbol_string())) {
+ __ JumpIfSmi(r3, if_false);
+ __ CompareObjectType(r3, r3, r4, SYMBOL_TYPE);
+ Split(eq, if_true, if_false, fall_through);
+ } else if (String::Equals(check, factory->boolean_string())) {
+ __ CompareRoot(r3, Heap::kTrueValueRootIndex);
+ __ beq(if_true);
+ __ CompareRoot(r3, Heap::kFalseValueRootIndex);
+ Split(eq, if_true, if_false, fall_through);
+ } else if (String::Equals(check, factory->undefined_string())) {
+ __ CompareRoot(r3, Heap::kUndefinedValueRootIndex);
+ __ beq(if_true);
+ __ JumpIfSmi(r3, if_false);
+ // Check for undetectable objects => true.
+ __ LoadP(r3, FieldMemOperand(r3, HeapObject::kMapOffset));
+ __ lbz(r4, FieldMemOperand(r3, Map::kBitFieldOffset));
+ __ andi(r0, r4, Operand(1 << Map::kIsUndetectable));
+ Split(ne, if_true, if_false, fall_through, cr0);
+
+ } else if (String::Equals(check, factory->function_string())) {
+ __ JumpIfSmi(r3, if_false);
+ STATIC_ASSERT(NUM_OF_CALLABLE_SPEC_OBJECT_TYPES == 2);
+ __ CompareObjectType(r3, r3, r4, JS_FUNCTION_TYPE);
+ __ beq(if_true);
+ __ cmpi(r4, Operand(JS_FUNCTION_PROXY_TYPE));
+ Split(eq, if_true, if_false, fall_through);
+ } else if (String::Equals(check, factory->object_string())) {
+ __ JumpIfSmi(r3, if_false);
+ __ CompareRoot(r3, Heap::kNullValueRootIndex);
+ __ beq(if_true);
+ // Check for JS objects => true.
+ __ CompareObjectType(r3, r3, r4, FIRST_NONCALLABLE_SPEC_OBJECT_TYPE);
+ __ blt(if_false);
+ __ CompareInstanceType(r3, r4, LAST_NONCALLABLE_SPEC_OBJECT_TYPE);
+ __ bgt(if_false);
+ // Check for undetectable objects => false.
+ __ lbz(r4, FieldMemOperand(r3, Map::kBitFieldOffset));
+ __ andi(r0, r4, Operand(1 << Map::kIsUndetectable));
+ Split(eq, if_true, if_false, fall_through, cr0);
+ } else {
+ if (if_false != fall_through) __ b(if_false);
+ }
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::VisitCompareOperation(CompareOperation* expr) {
+ Comment cmnt(masm_, "[ CompareOperation");
+ SetSourcePosition(expr->position());
+
+ // First we try a fast inlined version of the compare when one of
+ // the operands is a literal.
+ if (TryLiteralCompare(expr)) return;
+
+ // Always perform the comparison for its control flow. Pack the result
+ // into the expression's context after the comparison is performed.
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ Token::Value op = expr->op();
+ VisitForStackValue(expr->left());
+ switch (op) {
+ case Token::IN:
+ VisitForStackValue(expr->right());
+ __ InvokeBuiltin(Builtins::IN, CALL_FUNCTION);
+ PrepareForBailoutBeforeSplit(expr, false, NULL, NULL);
+ __ LoadRoot(ip, Heap::kTrueValueRootIndex);
+ __ cmp(r3, ip);
+ Split(eq, if_true, if_false, fall_through);
+ break;
+
+ case Token::INSTANCEOF: {
+ VisitForStackValue(expr->right());
+ InstanceofStub stub(isolate(), InstanceofStub::kNoFlags);
+ __ CallStub(&stub);
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ // The stub returns 0 for true.
+ __ cmpi(r3, Operand::Zero());
+ Split(eq, if_true, if_false, fall_through);
+ break;
+ }
+
+ default: {
+ VisitForAccumulatorValue(expr->right());
+ Condition cond = CompareIC::ComputeCondition(op);
+ __ pop(r4);
+
+ bool inline_smi_code = ShouldInlineSmiCase(op);
+ JumpPatchSite patch_site(masm_);
+ if (inline_smi_code) {
+ Label slow_case;
+ __ orx(r5, r3, r4);
+ patch_site.EmitJumpIfNotSmi(r5, &slow_case);
+ __ cmp(r4, r3);
+ Split(cond, if_true, if_false, NULL);
+ __ bind(&slow_case);
+ }
+
+ // Record position and call the compare IC.
+ SetSourcePosition(expr->position());
+ Handle<Code> ic = CodeFactory::CompareIC(isolate(), op).code();
+ CallIC(ic, expr->CompareOperationFeedbackId());
+ patch_site.EmitPatchInfo();
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ __ cmpi(r3, Operand::Zero());
+ Split(cond, if_true, if_false, fall_through);
+ }
+ }
+
+ // Convert the result of the comparison into one expected for this
+ // expression's context.
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::EmitLiteralCompareNil(CompareOperation* expr,
+ Expression* sub_expr,
+ NilValue nil) {
+ Label materialize_true, materialize_false;
+ Label* if_true = NULL;
+ Label* if_false = NULL;
+ Label* fall_through = NULL;
+ context()->PrepareTest(&materialize_true, &materialize_false, &if_true,
+ &if_false, &fall_through);
+
+ VisitForAccumulatorValue(sub_expr);
+ PrepareForBailoutBeforeSplit(expr, true, if_true, if_false);
+ if (expr->op() == Token::EQ_STRICT) {
+ Heap::RootListIndex nil_value = nil == kNullValue
+ ? Heap::kNullValueRootIndex
+ : Heap::kUndefinedValueRootIndex;
+ __ LoadRoot(r4, nil_value);
+ __ cmp(r3, r4);
+ Split(eq, if_true, if_false, fall_through);
+ } else {
+ Handle<Code> ic = CompareNilICStub::GetUninitialized(isolate(), nil);
+ CallIC(ic, expr->CompareOperationFeedbackId());
+ __ cmpi(r3, Operand::Zero());
+ Split(ne, if_true, if_false, fall_through);
+ }
+ context()->Plug(if_true, if_false);
+}
+
+
+void FullCodeGenerator::VisitThisFunction(ThisFunction* expr) {
+ __ LoadP(r3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ context()->Plug(r3);
+}
+
+
+Register FullCodeGenerator::result_register() { return r3; }
+
+
+Register FullCodeGenerator::context_register() { return cp; }
+
+
+void FullCodeGenerator::StoreToFrameField(int frame_offset, Register value) {
+ DCHECK_EQ(static_cast<int>(POINTER_SIZE_ALIGN(frame_offset)), frame_offset);
+ __ StoreP(value, MemOperand(fp, frame_offset), r0);
+}
+
+
+void FullCodeGenerator::LoadContextField(Register dst, int context_index) {
+ __ LoadP(dst, ContextOperand(cp, context_index), r0);
+}
+
+
+void FullCodeGenerator::PushFunctionArgumentForContextAllocation() {
+ Scope* declaration_scope = scope()->DeclarationScope();
+ if (declaration_scope->is_global_scope() ||
+ declaration_scope->is_module_scope()) {
+ // Contexts nested in the native context have a canonical empty function
+ // as their closure, not the anonymous closure containing the global
+ // code. Pass a smi sentinel and let the runtime look up the empty
+ // function.
+ __ LoadSmiLiteral(ip, Smi::FromInt(0));
+ } else if (declaration_scope->is_eval_scope()) {
+ // Contexts created by a call to eval have the same closure as the
+ // context calling eval, not the anonymous closure containing the eval
+ // code. Fetch it from the context.
+ __ LoadP(ip, ContextOperand(cp, Context::CLOSURE_INDEX));
+ } else {
+ DCHECK(declaration_scope->is_function_scope());
+ __ LoadP(ip, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+ }
+ __ push(ip);
+}
+
+
+// ----------------------------------------------------------------------------
+// Non-local control flow support.
+
+void FullCodeGenerator::EnterFinallyBlock() {
+ DCHECK(!result_register().is(r4));
+ // Store result register while executing finally block.
+ __ push(result_register());
+ // Cook return address in link register to stack (smi encoded Code* delta)
+ __ mflr(r4);
+ __ mov(ip, Operand(masm_->CodeObject()));
+ __ sub(r4, r4, ip);
+ __ SmiTag(r4);
+
+ // Store result register while executing finally block.
+ __ push(r4);
+
+ // Store pending message while executing finally block.
+ ExternalReference pending_message_obj =
+ ExternalReference::address_of_pending_message_obj(isolate());
+ __ mov(ip, Operand(pending_message_obj));
+ __ LoadP(r4, MemOperand(ip));
+ __ push(r4);
+
+ ExternalReference has_pending_message =
+ ExternalReference::address_of_has_pending_message(isolate());
+ __ mov(ip, Operand(has_pending_message));
+ __ lbz(r4, MemOperand(ip));
+ __ SmiTag(r4);
+ __ push(r4);
+
+ ExternalReference pending_message_script =
+ ExternalReference::address_of_pending_message_script(isolate());
+ __ mov(ip, Operand(pending_message_script));
+ __ LoadP(r4, MemOperand(ip));
+ __ push(r4);
+}
+
+
+void FullCodeGenerator::ExitFinallyBlock() {
+ DCHECK(!result_register().is(r4));
+ // Restore pending message from stack.
+ __ pop(r4);
+ ExternalReference pending_message_script =
+ ExternalReference::address_of_pending_message_script(isolate());
+ __ mov(ip, Operand(pending_message_script));
+ __ StoreP(r4, MemOperand(ip));
+
+ __ pop(r4);
+ __ SmiUntag(r4);
+ ExternalReference has_pending_message =
+ ExternalReference::address_of_has_pending_message(isolate());
+ __ mov(ip, Operand(has_pending_message));
+ __ stb(r4, MemOperand(ip));
+
+ __ pop(r4);
+ ExternalReference pending_message_obj =
+ ExternalReference::address_of_pending_message_obj(isolate());
+ __ mov(ip, Operand(pending_message_obj));
+ __ StoreP(r4, MemOperand(ip));
+
+ // Restore result register from stack.
+ __ pop(r4);
+
+ // Uncook return address and return.
+ __ pop(result_register());
+ __ SmiUntag(r4);
+ __ mov(ip, Operand(masm_->CodeObject()));
+ __ add(ip, ip, r4);
+ __ mtctr(ip);
+ __ bctr();
+}
+
+
+#undef __
+
+#define __ ACCESS_MASM(masm())
+
+FullCodeGenerator::NestedStatement* FullCodeGenerator::TryFinally::Exit(
+ int* stack_depth, int* context_length) {
+ // The macros used here must preserve the result register.
+
+ // Because the handler block contains the context of the finally
+ // code, we can restore it directly from there for the finally code
+ // rather than iteratively unwinding contexts via their previous
+ // links.
+ __ Drop(*stack_depth); // Down to the handler block.
+ if (*context_length > 0) {
+ // Restore the context to its dedicated register and the stack.
+ __ LoadP(cp, MemOperand(sp, StackHandlerConstants::kContextOffset));
+ __ StoreP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ }
+ __ PopTryHandler();
+ __ b(finally_entry_, SetLK);
+
+ *stack_depth = 0;
+ *context_length = 0;
+ return previous_;
+}
+
+#undef __
+
+
+void BackEdgeTable::PatchAt(Code* unoptimized_code, Address pc,
+ BackEdgeState target_state,
+ Code* replacement_code) {
+ Address mov_address = Assembler::target_address_from_return_address(pc);
+ Address cmp_address = mov_address - 2 * Assembler::kInstrSize;
+ CodePatcher patcher(cmp_address, 1);
+
+ switch (target_state) {
+ case INTERRUPT: {
+ // <decrement profiling counter>
+ // cmpi r6, 0
+ // bge <ok> ;; not changed
+ // mov r12, <interrupt stub address>
+ // mtlr r12
+ // blrl
+ // <reset profiling counter>
+ // ok-label
+ patcher.masm()->cmpi(r6, Operand::Zero());
+ break;
+ }
+ case ON_STACK_REPLACEMENT:
+ case OSR_AFTER_STACK_CHECK:
+ // <decrement profiling counter>
+ // crset
+ // bge <ok> ;; not changed
+ // mov r12, <on-stack replacement address>
+ // mtlr r12
+ // blrl
+ // <reset profiling counter>
+ // ok-label ----- pc_after points here
+
+ // Set the LT bit such that bge is a NOP
+ patcher.masm()->crset(Assembler::encode_crbit(cr7, CR_LT));
+ break;
+ }
+
+ // Replace the stack check address in the mov sequence with the
+ // entry address of the replacement code.
+ Assembler::set_target_address_at(mov_address, unoptimized_code,
+ replacement_code->entry());
+
+ unoptimized_code->GetHeap()->incremental_marking()->RecordCodeTargetPatch(
+ unoptimized_code, mov_address, replacement_code);
+}
+
+
+BackEdgeTable::BackEdgeState BackEdgeTable::GetBackEdgeState(
+ Isolate* isolate, Code* unoptimized_code, Address pc) {
+ Address mov_address = Assembler::target_address_from_return_address(pc);
+ Address cmp_address = mov_address - 2 * Assembler::kInstrSize;
+ Address interrupt_address =
+ Assembler::target_address_at(mov_address, unoptimized_code);
+
+ if (Assembler::IsCmpImmediate(Assembler::instr_at(cmp_address))) {
+ DCHECK(interrupt_address == isolate->builtins()->InterruptCheck()->entry());
+ return INTERRUPT;
+ }
+
+ DCHECK(Assembler::IsCrSet(Assembler::instr_at(cmp_address)));
+
+ if (interrupt_address == isolate->builtins()->OnStackReplacement()->entry()) {
+ return ON_STACK_REPLACEMENT;
+ }
+
+ DCHECK(interrupt_address ==
+ isolate->builtins()->OsrAfterStackCheck()->entry());
+ return OSR_AFTER_STACK_CHECK;
+}
+}
+} // namespace v8::internal
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/interface-descriptors.h"
+
+namespace v8 {
+namespace internal {
+
+const Register CallInterfaceDescriptor::ContextRegister() { return cp; }
+
+
+const Register LoadDescriptor::ReceiverRegister() { return r4; }
+const Register LoadDescriptor::NameRegister() { return r5; }
+
+
+const Register VectorLoadICTrampolineDescriptor::SlotRegister() { return r3; }
+
+
+const Register VectorLoadICDescriptor::VectorRegister() { return r6; }
+
+
+const Register StoreDescriptor::ReceiverRegister() { return r4; }
+const Register StoreDescriptor::NameRegister() { return r5; }
+const Register StoreDescriptor::ValueRegister() { return r3; }
+
+
+const Register StoreTransitionDescriptor::MapRegister() { return r6; }
+
+
+const Register ElementTransitionAndStoreDescriptor::MapRegister() { return r6; }
+
+
+const Register InstanceofDescriptor::left() { return r3; }
+const Register InstanceofDescriptor::right() { return r4; }
+
+
+const Register ArgumentsAccessReadDescriptor::index() { return r4; }
+const Register ArgumentsAccessReadDescriptor::parameter_count() { return r3; }
+
+
+const Register ApiGetterDescriptor::function_address() { return r5; }
+
+
+const Register MathPowTaggedDescriptor::exponent() { return r5; }
+
+
+const Register MathPowIntegerDescriptor::exponent() {
+ return MathPowTaggedDescriptor::exponent();
+}
+
+
+void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r5};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r4};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r3};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r3};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void FastCloneShallowArrayDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r6, r5, r4};
+ Representation representations[] = {
+ Representation::Tagged(), Representation::Tagged(), Representation::Smi(),
+ Representation::Tagged()};
+ data->Initialize(arraysize(registers), registers, representations);
+}
+
+
+void FastCloneShallowObjectDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r6, r5, r4, r3};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void CreateAllocationSiteDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r5, r6};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void StoreArrayLiteralElementDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r6, r3};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r4};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void CallFunctionWithFeedbackDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r4, r6};
+ Representation representations[] = {Representation::Tagged(),
+ Representation::Tagged(),
+ Representation::Smi()};
+ data->Initialize(arraysize(registers), registers, representations);
+}
+
+
+void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ // r3 : number of arguments
+ // r4 : the function to call
+ // r5 : feedback vector
+ // r6 : (only if r5 is not the megamorphic symbol) slot in feedback
+ // vector (Smi)
+ // TODO(turbofan): So far we don't gather type feedback and hence skip the
+ // slot parameter, but ArrayConstructStub needs the vector to be undefined.
+ Register registers[] = {cp, r3, r4, r5};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void RegExpConstructResultDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r5, r4, r3};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void TransitionElementsKindDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r3, r4};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void ArrayConstructorConstantArgCountDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ // register state
+ // cp -- context
+ // r3 -- number of arguments
+ // r4 -- function
+ // r5 -- allocation site with elements kind
+ Register registers[] = {cp, r4, r5};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ // stack param count needs (constructor pointer, and single argument)
+ Register registers[] = {cp, r4, r5, r3};
+ Representation representations[] = {
+ Representation::Tagged(), Representation::Tagged(),
+ Representation::Tagged(), Representation::Integer32()};
+ data->Initialize(arraysize(registers), registers, representations);
+}
+
+
+void InternalArrayConstructorConstantArgCountDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ // register state
+ // cp -- context
+ // r3 -- number of arguments
+ // r4 -- constructor function
+ Register registers[] = {cp, r4};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void InternalArrayConstructorDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ // stack param count needs (constructor pointer, and single argument)
+ Register registers[] = {cp, r4, r3};
+ Representation representations[] = {Representation::Tagged(),
+ Representation::Tagged(),
+ Representation::Integer32()};
+ data->Initialize(arraysize(registers), registers, representations);
+}
+
+
+void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r3};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r3};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r4, r3};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void BinaryOpWithAllocationSiteDescriptor::Initialize(
+ CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r5, r4, r3};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {cp, r4, r3};
+ data->Initialize(arraysize(registers), registers, NULL);
+}
+
+
+void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {
+ cp, // context
+ r5, // key
+ };
+ Representation representations[] = {
+ Representation::Tagged(), // context
+ Representation::Tagged(), // key
+ };
+ data->Initialize(arraysize(registers), registers, representations);
+}
+
+
+void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {
+ cp, // context
+ r5, // name
+ };
+ Representation representations[] = {
+ Representation::Tagged(), // context
+ Representation::Tagged(), // name
+ };
+ data->Initialize(arraysize(registers), registers, representations);
+}
+
+
+void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {
+ cp, // context
+ r3, // receiver
+ };
+ Representation representations[] = {
+ Representation::Tagged(), // context
+ Representation::Tagged(), // receiver
+ };
+ data->Initialize(arraysize(registers), registers, representations);
+}
+
+
+void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {
+ cp, // context
+ r4, // JSFunction
+ r3, // actual number of arguments
+ r5, // expected number of arguments
+ };
+ Representation representations[] = {
+ Representation::Tagged(), // context
+ Representation::Tagged(), // JSFunction
+ Representation::Integer32(), // actual number of arguments
+ Representation::Integer32(), // expected number of arguments
+ };
+ data->Initialize(arraysize(registers), registers, representations);
+}
+
+
+void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) {
+ Register registers[] = {
+ cp, // context
+ r3, // callee
+ r7, // call_data
+ r5, // holder
+ r4, // api_function_address
+ };
+ Representation representations[] = {
+ Representation::Tagged(), // context
+ Representation::Tagged(), // callee
+ Representation::Tagged(), // call_data
+ Representation::Tagged(), // holder
+ Representation::External(), // api_function_address
+ };
+ data->Initialize(arraysize(registers), registers, representations);
+}
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#include "src/base/bits.h"
+#include "src/code-factory.h"
+#include "src/code-stubs.h"
+#include "src/hydrogen-osr.h"
+#include "src/ic/ic.h"
+#include "src/ic/stub-cache.h"
+#include "src/ppc/lithium-codegen-ppc.h"
+#include "src/ppc/lithium-gap-resolver-ppc.h"
+
+namespace v8 {
+namespace internal {
+
+
+class SafepointGenerator FINAL : public CallWrapper {
+ public:
+ SafepointGenerator(LCodeGen* codegen, LPointerMap* pointers,
+ Safepoint::DeoptMode mode)
+ : codegen_(codegen), pointers_(pointers), deopt_mode_(mode) {}
+ virtual ~SafepointGenerator() {}
+
+ virtual void BeforeCall(int call_size) const OVERRIDE {}
+
+ virtual void AfterCall() const OVERRIDE {
+ codegen_->RecordSafepoint(pointers_, deopt_mode_);
+ }
+
+ private:
+ LCodeGen* codegen_;
+ LPointerMap* pointers_;
+ Safepoint::DeoptMode deopt_mode_;
+};
+
+
+#define __ masm()->
+
+bool LCodeGen::GenerateCode() {
+ LPhase phase("Z_Code generation", chunk());
+ DCHECK(is_unused());
+ status_ = GENERATING;
+
+ // Open a frame scope to indicate that there is a frame on the stack. The
+ // NONE indicates that the scope shouldn't actually generate code to set up
+ // the frame (that is done in GeneratePrologue).
+ FrameScope frame_scope(masm_, StackFrame::NONE);
+
+ return GeneratePrologue() && GenerateBody() && GenerateDeferredCode() &&
+ GenerateJumpTable() && GenerateSafepointTable();
+}
+
+
+void LCodeGen::FinishCode(Handle<Code> code) {
+ DCHECK(is_done());
+ code->set_stack_slots(GetStackSlotCount());
+ code->set_safepoint_table_offset(safepoints_.GetCodeOffset());
+ if (code->is_optimized_code()) RegisterWeakObjectsInOptimizedCode(code);
+ PopulateDeoptimizationData(code);
+}
+
+
+void LCodeGen::SaveCallerDoubles() {
+ DCHECK(info()->saves_caller_doubles());
+ DCHECK(NeedsEagerFrame());
+ Comment(";;; Save clobbered callee double registers");
+ int count = 0;
+ BitVector* doubles = chunk()->allocated_double_registers();
+ BitVector::Iterator save_iterator(doubles);
+ while (!save_iterator.Done()) {
+ __ stfd(DoubleRegister::FromAllocationIndex(save_iterator.Current()),
+ MemOperand(sp, count * kDoubleSize));
+ save_iterator.Advance();
+ count++;
+ }
+}
+
+
+void LCodeGen::RestoreCallerDoubles() {
+ DCHECK(info()->saves_caller_doubles());
+ DCHECK(NeedsEagerFrame());
+ Comment(";;; Restore clobbered callee double registers");
+ BitVector* doubles = chunk()->allocated_double_registers();
+ BitVector::Iterator save_iterator(doubles);
+ int count = 0;
+ while (!save_iterator.Done()) {
+ __ lfd(DoubleRegister::FromAllocationIndex(save_iterator.Current()),
+ MemOperand(sp, count * kDoubleSize));
+ save_iterator.Advance();
+ count++;
+ }
+}
+
+
+bool LCodeGen::GeneratePrologue() {
+ DCHECK(is_generating());
+
+ if (info()->IsOptimizing()) {
+ ProfileEntryHookStub::MaybeCallEntryHook(masm_);
+
+#ifdef DEBUG
+ if (strlen(FLAG_stop_at) > 0 &&
+ info_->function()->name()->IsUtf8EqualTo(CStrVector(FLAG_stop_at))) {
+ __ stop("stop_at");
+ }
+#endif
+
+ // r4: Callee's JS function.
+ // cp: Callee's context.
+ // pp: Callee's constant pool pointer (if FLAG_enable_ool_constant_pool)
+ // fp: Caller's frame pointer.
+ // lr: Caller's pc.
+ // ip: Our own function entry (required by the prologue)
+
+ // Sloppy mode functions and builtins need to replace the receiver with the
+ // global proxy when called as functions (without an explicit receiver
+ // object).
+ if (info_->this_has_uses() && info_->strict_mode() == SLOPPY &&
+ !info_->is_native()) {
+ Label ok;
+ int receiver_offset = info_->scope()->num_parameters() * kPointerSize;
+ __ LoadP(r5, MemOperand(sp, receiver_offset));
+ __ CompareRoot(r5, Heap::kUndefinedValueRootIndex);
+ __ bne(&ok);
+
+ __ LoadP(r5, GlobalObjectOperand());
+ __ LoadP(r5, FieldMemOperand(r5, GlobalObject::kGlobalProxyOffset));
+
+ __ StoreP(r5, MemOperand(sp, receiver_offset));
+
+ __ bind(&ok);
+ }
+ }
+
+ int prologue_offset = masm_->pc_offset();
+
+ if (prologue_offset) {
+ // Prologue logic requires it's starting address in ip and the
+ // corresponding offset from the function entry.
+ prologue_offset += Instruction::kInstrSize;
+ __ addi(ip, ip, Operand(prologue_offset));
+ }
+ info()->set_prologue_offset(prologue_offset);
+ if (NeedsEagerFrame()) {
+ if (info()->IsStub()) {
+ __ StubPrologue(prologue_offset);
+ } else {
+ __ Prologue(info()->IsCodePreAgingActive(), prologue_offset);
+ }
+ frame_is_built_ = true;
+ info_->AddNoFrameRange(0, masm_->pc_offset());
+ }
+
+ // Reserve space for the stack slots needed by the code.
+ int slots = GetStackSlotCount();
+ if (slots > 0) {
+ __ subi(sp, sp, Operand(slots * kPointerSize));
+ if (FLAG_debug_code) {
+ __ Push(r3, r4);
+ __ li(r0, Operand(slots));
+ __ mtctr(r0);
+ __ addi(r3, sp, Operand((slots + 2) * kPointerSize));
+ __ mov(r4, Operand(kSlotsZapValue));
+ Label loop;
+ __ bind(&loop);
+ __ StorePU(r4, MemOperand(r3, -kPointerSize));
+ __ bdnz(&loop);
+ __ Pop(r3, r4);
+ }
+ }
+
+ if (info()->saves_caller_doubles()) {
+ SaveCallerDoubles();
+ }
+
+ // Possibly allocate a local context.
+ int heap_slots = info()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
+ if (heap_slots > 0) {
+ Comment(";;; Allocate local context");
+ bool need_write_barrier = true;
+ // Argument to NewContext is the function, which is in r4.
+ if (heap_slots <= FastNewContextStub::kMaximumSlots) {
+ FastNewContextStub stub(isolate(), heap_slots);
+ __ CallStub(&stub);
+ // Result of FastNewContextStub is always in new space.
+ need_write_barrier = false;
+ } else {
+ __ push(r4);
+ __ CallRuntime(Runtime::kNewFunctionContext, 1);
+ }
+ RecordSafepoint(Safepoint::kNoLazyDeopt);
+ // Context is returned in both r3 and cp. It replaces the context
+ // passed to us. It's saved in the stack and kept live in cp.
+ __ mr(cp, r3);
+ __ StoreP(r3, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ // Copy any necessary parameters into the context.
+ int num_parameters = scope()->num_parameters();
+ for (int i = 0; i < num_parameters; i++) {
+ Variable* var = scope()->parameter(i);
+ if (var->IsContextSlot()) {
+ int parameter_offset = StandardFrameConstants::kCallerSPOffset +
+ (num_parameters - 1 - i) * kPointerSize;
+ // Load parameter from stack.
+ __ LoadP(r3, MemOperand(fp, parameter_offset));
+ // Store it in the context.
+ MemOperand target = ContextOperand(cp, var->index());
+ __ StoreP(r3, target, r0);
+ // Update the write barrier. This clobbers r6 and r3.
+ if (need_write_barrier) {
+ __ RecordWriteContextSlot(cp, target.offset(), r3, r6,
+ GetLinkRegisterState(), kSaveFPRegs);
+ } else if (FLAG_debug_code) {
+ Label done;
+ __ JumpIfInNewSpace(cp, r3, &done);
+ __ Abort(kExpectedNewSpaceObject);
+ __ bind(&done);
+ }
+ }
+ }
+ Comment(";;; End allocate local context");
+ }
+
+ // Trace the call.
+ if (FLAG_trace && info()->IsOptimizing()) {
+ // We have not executed any compiled code yet, so cp still holds the
+ // incoming context.
+ __ CallRuntime(Runtime::kTraceEnter, 0);
+ }
+ return !is_aborted();
+}
+
+
+void LCodeGen::GenerateOsrPrologue() {
+ // Generate the OSR entry prologue at the first unknown OSR value, or if there
+ // are none, at the OSR entrypoint instruction.
+ if (osr_pc_offset_ >= 0) return;
+
+ osr_pc_offset_ = masm()->pc_offset();
+
+ // Adjust the frame size, subsuming the unoptimized frame into the
+ // optimized frame.
+ int slots = GetStackSlotCount() - graph()->osr()->UnoptimizedFrameSlots();
+ DCHECK(slots >= 0);
+ __ subi(sp, sp, Operand(slots * kPointerSize));
+}
+
+
+void LCodeGen::GenerateBodyInstructionPre(LInstruction* instr) {
+ if (instr->IsCall()) {
+ EnsureSpaceForLazyDeopt(Deoptimizer::patch_size());
+ }
+ if (!instr->IsLazyBailout() && !instr->IsGap()) {
+ safepoints_.BumpLastLazySafepointIndex();
+ }
+}
+
+
+bool LCodeGen::GenerateDeferredCode() {
+ DCHECK(is_generating());
+ if (deferred_.length() > 0) {
+ for (int i = 0; !is_aborted() && i < deferred_.length(); i++) {
+ LDeferredCode* code = deferred_[i];
+
+ HValue* value =
+ instructions_->at(code->instruction_index())->hydrogen_value();
+ RecordAndWritePosition(
+ chunk()->graph()->SourcePositionToScriptPosition(value->position()));
+
+ Comment(
+ ";;; <@%d,#%d> "
+ "-------------------- Deferred %s --------------------",
+ code->instruction_index(), code->instr()->hydrogen_value()->id(),
+ code->instr()->Mnemonic());
+ __ bind(code->entry());
+ if (NeedsDeferredFrame()) {
+ Comment(";;; Build frame");
+ DCHECK(!frame_is_built_);
+ DCHECK(info()->IsStub());
+ frame_is_built_ = true;
+ __ LoadSmiLiteral(scratch0(), Smi::FromInt(StackFrame::STUB));
+ __ PushFixedFrame(scratch0());
+ __ addi(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
+ Comment(";;; Deferred code");
+ }
+ code->Generate();
+ if (NeedsDeferredFrame()) {
+ Comment(";;; Destroy frame");
+ DCHECK(frame_is_built_);
+ __ PopFixedFrame(ip);
+ frame_is_built_ = false;
+ }
+ __ b(code->exit());
+ }
+ }
+
+ return !is_aborted();
+}
+
+
+bool LCodeGen::GenerateJumpTable() {
+ // Check that the jump table is accessible from everywhere in the function
+ // code, i.e. that offsets to the table can be encoded in the 24bit signed
+ // immediate of a branch instruction.
+ // To simplify we consider the code size from the first instruction to the
+ // end of the jump table. We also don't consider the pc load delta.
+ // Each entry in the jump table generates one instruction and inlines one
+ // 32bit data after it.
+ if (!is_int24((masm()->pc_offset() / Assembler::kInstrSize) +
+ jump_table_.length() * 7)) {
+ Abort(kGeneratedCodeIsTooLarge);
+ }
+
+ if (jump_table_.length() > 0) {
+ Label needs_frame, call_deopt_entry;
+
+ Comment(";;; -------------------- Jump table --------------------");
+ Address base = jump_table_[0].address;
+
+ Register entry_offset = scratch0();
+
+ int length = jump_table_.length();
+ for (int i = 0; i < length; i++) {
+ Deoptimizer::JumpTableEntry* table_entry = &jump_table_[i];
+ __ bind(&table_entry->label);
+
+ DCHECK_EQ(jump_table_[0].bailout_type, table_entry->bailout_type);
+ Address entry = table_entry->address;
+ DeoptComment(table_entry->reason);
+
+ // Second-level deopt table entries are contiguous and small, so instead
+ // of loading the full, absolute address of each one, load an immediate
+ // offset which will be added to the base address later.
+ __ mov(entry_offset, Operand(entry - base));
+
+ if (table_entry->needs_frame) {
+ DCHECK(!info()->saves_caller_doubles());
+ if (needs_frame.is_bound()) {
+ __ b(&needs_frame);
+ } else {
+ __ bind(&needs_frame);
+ Comment(";;; call deopt with frame");
+ // This variant of deopt can only be used with stubs. Since we don't
+ // have a function pointer to install in the stack frame that we're
+ // building, install a special marker there instead.
+ DCHECK(info()->IsStub());
+ __ LoadSmiLiteral(ip, Smi::FromInt(StackFrame::STUB));
+ __ PushFixedFrame(ip);
+ __ addi(fp, sp,
+ Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
+ __ bind(&call_deopt_entry);
+ // Add the base address to the offset previously loaded in
+ // entry_offset.
+ __ mov(ip, Operand(ExternalReference::ForDeoptEntry(base)));
+ __ add(ip, entry_offset, ip);
+ __ Call(ip);
+ }
+ } else {
+ // The last entry can fall through into `call_deopt_entry`, avoiding a
+ // branch.
+ bool need_branch = ((i + 1) != length) || call_deopt_entry.is_bound();
+
+ if (need_branch) __ b(&call_deopt_entry);
+ }
+ }
+
+ if (!call_deopt_entry.is_bound()) {
+ Comment(";;; call deopt");
+ __ bind(&call_deopt_entry);
+
+ if (info()->saves_caller_doubles()) {
+ DCHECK(info()->IsStub());
+ RestoreCallerDoubles();
+ }
+
+ // Add the base address to the offset previously loaded in entry_offset.
+ __ mov(ip, Operand(ExternalReference::ForDeoptEntry(base)));
+ __ add(ip, entry_offset, ip);
+ __ Call(ip);
+ }
+ }
+
+ // The deoptimization jump table is the last part of the instruction
+ // sequence. Mark the generated code as done unless we bailed out.
+ if (!is_aborted()) status_ = DONE;
+ return !is_aborted();
+}
+
+
+bool LCodeGen::GenerateSafepointTable() {
+ DCHECK(is_done());
+ safepoints_.Emit(masm(), GetStackSlotCount());
+ return !is_aborted();
+}
+
+
+Register LCodeGen::ToRegister(int index) const {
+ return Register::FromAllocationIndex(index);
+}
+
+
+DoubleRegister LCodeGen::ToDoubleRegister(int index) const {
+ return DoubleRegister::FromAllocationIndex(index);
+}
+
+
+Register LCodeGen::ToRegister(LOperand* op) const {
+ DCHECK(op->IsRegister());
+ return ToRegister(op->index());
+}
+
+
+Register LCodeGen::EmitLoadRegister(LOperand* op, Register scratch) {
+ if (op->IsRegister()) {
+ return ToRegister(op->index());
+ } else if (op->IsConstantOperand()) {
+ LConstantOperand* const_op = LConstantOperand::cast(op);
+ HConstant* constant = chunk_->LookupConstant(const_op);
+ Handle<Object> literal = constant->handle(isolate());
+ Representation r = chunk_->LookupLiteralRepresentation(const_op);
+ if (r.IsInteger32()) {
+ DCHECK(literal->IsNumber());
+ __ LoadIntLiteral(scratch, static_cast<int32_t>(literal->Number()));
+ } else if (r.IsDouble()) {
+ Abort(kEmitLoadRegisterUnsupportedDoubleImmediate);
+ } else {
+ DCHECK(r.IsSmiOrTagged());
+ __ Move(scratch, literal);
+ }
+ return scratch;
+ } else if (op->IsStackSlot()) {
+ __ LoadP(scratch, ToMemOperand(op));
+ return scratch;
+ }
+ UNREACHABLE();
+ return scratch;
+}
+
+
+void LCodeGen::EmitLoadIntegerConstant(LConstantOperand* const_op,
+ Register dst) {
+ DCHECK(IsInteger32(const_op));
+ HConstant* constant = chunk_->LookupConstant(const_op);
+ int32_t value = constant->Integer32Value();
+ if (IsSmi(const_op)) {
+ __ LoadSmiLiteral(dst, Smi::FromInt(value));
+ } else {
+ __ LoadIntLiteral(dst, value);
+ }
+}
+
+
+DoubleRegister LCodeGen::ToDoubleRegister(LOperand* op) const {
+ DCHECK(op->IsDoubleRegister());
+ return ToDoubleRegister(op->index());
+}
+
+
+Handle<Object> LCodeGen::ToHandle(LConstantOperand* op) const {
+ HConstant* constant = chunk_->LookupConstant(op);
+ DCHECK(chunk_->LookupLiteralRepresentation(op).IsSmiOrTagged());
+ return constant->handle(isolate());
+}
+
+
+bool LCodeGen::IsInteger32(LConstantOperand* op) const {
+ return chunk_->LookupLiteralRepresentation(op).IsSmiOrInteger32();
+}
+
+
+bool LCodeGen::IsSmi(LConstantOperand* op) const {
+ return chunk_->LookupLiteralRepresentation(op).IsSmi();
+}
+
+
+int32_t LCodeGen::ToInteger32(LConstantOperand* op) const {
+ return ToRepresentation(op, Representation::Integer32());
+}
+
+
+intptr_t LCodeGen::ToRepresentation(LConstantOperand* op,
+ const Representation& r) const {
+ HConstant* constant = chunk_->LookupConstant(op);
+ int32_t value = constant->Integer32Value();
+ if (r.IsInteger32()) return value;
+ DCHECK(r.IsSmiOrTagged());
+ return reinterpret_cast<intptr_t>(Smi::FromInt(value));
+}
+
+
+Smi* LCodeGen::ToSmi(LConstantOperand* op) const {
+ HConstant* constant = chunk_->LookupConstant(op);
+ return Smi::FromInt(constant->Integer32Value());
+}
+
+
+double LCodeGen::ToDouble(LConstantOperand* op) const {
+ HConstant* constant = chunk_->LookupConstant(op);
+ DCHECK(constant->HasDoubleValue());
+ return constant->DoubleValue();
+}
+
+
+Operand LCodeGen::ToOperand(LOperand* op) {
+ if (op->IsConstantOperand()) {
+ LConstantOperand* const_op = LConstantOperand::cast(op);
+ HConstant* constant = chunk()->LookupConstant(const_op);
+ Representation r = chunk_->LookupLiteralRepresentation(const_op);
+ if (r.IsSmi()) {
+ DCHECK(constant->HasSmiValue());
+ return Operand(Smi::FromInt(constant->Integer32Value()));
+ } else if (r.IsInteger32()) {
+ DCHECK(constant->HasInteger32Value());
+ return Operand(constant->Integer32Value());
+ } else if (r.IsDouble()) {
+ Abort(kToOperandUnsupportedDoubleImmediate);
+ }
+ DCHECK(r.IsTagged());
+ return Operand(constant->handle(isolate()));
+ } else if (op->IsRegister()) {
+ return Operand(ToRegister(op));
+ } else if (op->IsDoubleRegister()) {
+ Abort(kToOperandIsDoubleRegisterUnimplemented);
+ return Operand::Zero();
+ }
+ // Stack slots not implemented, use ToMemOperand instead.
+ UNREACHABLE();
+ return Operand::Zero();
+}
+
+
+static int ArgumentsOffsetWithoutFrame(int index) {
+ DCHECK(index < 0);
+ return -(index + 1) * kPointerSize;
+}
+
+
+MemOperand LCodeGen::ToMemOperand(LOperand* op) const {
+ DCHECK(!op->IsRegister());
+ DCHECK(!op->IsDoubleRegister());
+ DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());
+ if (NeedsEagerFrame()) {
+ return MemOperand(fp, StackSlotOffset(op->index()));
+ } else {
+ // Retrieve parameter without eager stack-frame relative to the
+ // stack-pointer.
+ return MemOperand(sp, ArgumentsOffsetWithoutFrame(op->index()));
+ }
+}
+
+
+MemOperand LCodeGen::ToHighMemOperand(LOperand* op) const {
+ DCHECK(op->IsDoubleStackSlot());
+ if (NeedsEagerFrame()) {
+ return MemOperand(fp, StackSlotOffset(op->index()) + kPointerSize);
+ } else {
+ // Retrieve parameter without eager stack-frame relative to the
+ // stack-pointer.
+ return MemOperand(sp,
+ ArgumentsOffsetWithoutFrame(op->index()) + kPointerSize);
+ }
+}
+
+
+void LCodeGen::WriteTranslation(LEnvironment* environment,
+ Translation* translation) {
+ if (environment == NULL) return;
+
+ // The translation includes one command per value in the environment.
+ int translation_size = environment->translation_size();
+ // The output frame height does not include the parameters.
+ int height = translation_size - environment->parameter_count();
+
+ WriteTranslation(environment->outer(), translation);
+ bool has_closure_id =
+ !info()->closure().is_null() &&
+ !info()->closure().is_identical_to(environment->closure());
+ int closure_id = has_closure_id
+ ? DefineDeoptimizationLiteral(environment->closure())
+ : Translation::kSelfLiteralId;
+
+ switch (environment->frame_type()) {
+ case JS_FUNCTION:
+ translation->BeginJSFrame(environment->ast_id(), closure_id, height);
+ break;
+ case JS_CONSTRUCT:
+ translation->BeginConstructStubFrame(closure_id, translation_size);
+ break;
+ case JS_GETTER:
+ DCHECK(translation_size == 1);
+ DCHECK(height == 0);
+ translation->BeginGetterStubFrame(closure_id);
+ break;
+ case JS_SETTER:
+ DCHECK(translation_size == 2);
+ DCHECK(height == 0);
+ translation->BeginSetterStubFrame(closure_id);
+ break;
+ case STUB:
+ translation->BeginCompiledStubFrame();
+ break;
+ case ARGUMENTS_ADAPTOR:
+ translation->BeginArgumentsAdaptorFrame(closure_id, translation_size);
+ break;
+ }
+
+ int object_index = 0;
+ int dematerialized_index = 0;
+ for (int i = 0; i < translation_size; ++i) {
+ LOperand* value = environment->values()->at(i);
+ AddToTranslation(
+ environment, translation, value, environment->HasTaggedValueAt(i),
+ environment->HasUint32ValueAt(i), &object_index, &dematerialized_index);
+ }
+}
+
+
+void LCodeGen::AddToTranslation(LEnvironment* environment,
+ Translation* translation, LOperand* op,
+ bool is_tagged, bool is_uint32,
+ int* object_index_pointer,
+ int* dematerialized_index_pointer) {
+ if (op == LEnvironment::materialization_marker()) {
+ int object_index = (*object_index_pointer)++;
+ if (environment->ObjectIsDuplicateAt(object_index)) {
+ int dupe_of = environment->ObjectDuplicateOfAt(object_index);
+ translation->DuplicateObject(dupe_of);
+ return;
+ }
+ int object_length = environment->ObjectLengthAt(object_index);
+ if (environment->ObjectIsArgumentsAt(object_index)) {
+ translation->BeginArgumentsObject(object_length);
+ } else {
+ translation->BeginCapturedObject(object_length);
+ }
+ int dematerialized_index = *dematerialized_index_pointer;
+ int env_offset = environment->translation_size() + dematerialized_index;
+ *dematerialized_index_pointer += object_length;
+ for (int i = 0; i < object_length; ++i) {
+ LOperand* value = environment->values()->at(env_offset + i);
+ AddToTranslation(environment, translation, value,
+ environment->HasTaggedValueAt(env_offset + i),
+ environment->HasUint32ValueAt(env_offset + i),
+ object_index_pointer, dematerialized_index_pointer);
+ }
+ return;
+ }
+
+ if (op->IsStackSlot()) {
+ if (is_tagged) {
+ translation->StoreStackSlot(op->index());
+ } else if (is_uint32) {
+ translation->StoreUint32StackSlot(op->index());
+ } else {
+ translation->StoreInt32StackSlot(op->index());
+ }
+ } else if (op->IsDoubleStackSlot()) {
+ translation->StoreDoubleStackSlot(op->index());
+ } else if (op->IsRegister()) {
+ Register reg = ToRegister(op);
+ if (is_tagged) {
+ translation->StoreRegister(reg);
+ } else if (is_uint32) {
+ translation->StoreUint32Register(reg);
+ } else {
+ translation->StoreInt32Register(reg);
+ }
+ } else if (op->IsDoubleRegister()) {
+ DoubleRegister reg = ToDoubleRegister(op);
+ translation->StoreDoubleRegister(reg);
+ } else if (op->IsConstantOperand()) {
+ HConstant* constant = chunk()->LookupConstant(LConstantOperand::cast(op));
+ int src_index = DefineDeoptimizationLiteral(constant->handle(isolate()));
+ translation->StoreLiteral(src_index);
+ } else {
+ UNREACHABLE();
+ }
+}
+
+
+void LCodeGen::CallCode(Handle<Code> code, RelocInfo::Mode mode,
+ LInstruction* instr) {
+ CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT);
+}
+
+
+void LCodeGen::CallCodeGeneric(Handle<Code> code, RelocInfo::Mode mode,
+ LInstruction* instr,
+ SafepointMode safepoint_mode) {
+ DCHECK(instr != NULL);
+ __ Call(code, mode);
+ RecordSafepointWithLazyDeopt(instr, safepoint_mode);
+
+ // Signal that we don't inline smi code before these stubs in the
+ // optimizing code generator.
+ if (code->kind() == Code::BINARY_OP_IC || code->kind() == Code::COMPARE_IC) {
+ __ nop();
+ }
+}
+
+
+void LCodeGen::CallRuntime(const Runtime::Function* function, int num_arguments,
+ LInstruction* instr, SaveFPRegsMode save_doubles) {
+ DCHECK(instr != NULL);
+
+ __ CallRuntime(function, num_arguments, save_doubles);
+
+ RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
+}
+
+
+void LCodeGen::LoadContextFromDeferred(LOperand* context) {
+ if (context->IsRegister()) {
+ __ Move(cp, ToRegister(context));
+ } else if (context->IsStackSlot()) {
+ __ LoadP(cp, ToMemOperand(context));
+ } else if (context->IsConstantOperand()) {
+ HConstant* constant =
+ chunk_->LookupConstant(LConstantOperand::cast(context));
+ __ Move(cp, Handle<Object>::cast(constant->handle(isolate())));
+ } else {
+ UNREACHABLE();
+ }
+}
+
+
+void LCodeGen::CallRuntimeFromDeferred(Runtime::FunctionId id, int argc,
+ LInstruction* instr, LOperand* context) {
+ LoadContextFromDeferred(context);
+ __ CallRuntimeSaveDoubles(id);
+ RecordSafepointWithRegisters(instr->pointer_map(), argc,
+ Safepoint::kNoLazyDeopt);
+}
+
+
+void LCodeGen::RegisterEnvironmentForDeoptimization(LEnvironment* environment,
+ Safepoint::DeoptMode mode) {
+ environment->set_has_been_used();
+ if (!environment->HasBeenRegistered()) {
+ // Physical stack frame layout:
+ // -x ............. -4 0 ..................................... y
+ // [incoming arguments] [spill slots] [pushed outgoing arguments]
+
+ // Layout of the environment:
+ // 0 ..................................................... size-1
+ // [parameters] [locals] [expression stack including arguments]
+
+ // Layout of the translation:
+ // 0 ........................................................ size - 1 + 4
+ // [expression stack including arguments] [locals] [4 words] [parameters]
+ // |>------------ translation_size ------------<|
+
+ int frame_count = 0;
+ int jsframe_count = 0;
+ for (LEnvironment* e = environment; e != NULL; e = e->outer()) {
+ ++frame_count;
+ if (e->frame_type() == JS_FUNCTION) {
+ ++jsframe_count;
+ }
+ }
+ Translation translation(&translations_, frame_count, jsframe_count, zone());
+ WriteTranslation(environment, &translation);
+ int deoptimization_index = deoptimizations_.length();
+ int pc_offset = masm()->pc_offset();
+ environment->Register(deoptimization_index, translation.index(),
+ (mode == Safepoint::kLazyDeopt) ? pc_offset : -1);
+ deoptimizations_.Add(environment, zone());
+ }
+}
+
+
+void LCodeGen::DeoptimizeIf(Condition cond, LInstruction* instr,
+ const char* detail,
+ Deoptimizer::BailoutType bailout_type,
+ CRegister cr) {
+ LEnvironment* environment = instr->environment();
+ RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);
+ DCHECK(environment->HasBeenRegistered());
+ int id = environment->deoptimization_index();
+ DCHECK(info()->IsOptimizing() || info()->IsStub());
+ Address entry =
+ Deoptimizer::GetDeoptimizationEntry(isolate(), id, bailout_type);
+ if (entry == NULL) {
+ Abort(kBailoutWasNotPrepared);
+ return;
+ }
+
+ if (FLAG_deopt_every_n_times != 0 && !info()->IsStub()) {
+ CRegister alt_cr = cr6;
+ Register scratch = scratch0();
+ ExternalReference count = ExternalReference::stress_deopt_count(isolate());
+ Label no_deopt;
+ DCHECK(!alt_cr.is(cr));
+ __ Push(r4, scratch);
+ __ mov(scratch, Operand(count));
+ __ lwz(r4, MemOperand(scratch));
+ __ subi(r4, r4, Operand(1));
+ __ cmpi(r4, Operand::Zero(), alt_cr);
+ __ bne(&no_deopt, alt_cr);
+ __ li(r4, Operand(FLAG_deopt_every_n_times));
+ __ stw(r4, MemOperand(scratch));
+ __ Pop(r4, scratch);
+
+ __ Call(entry, RelocInfo::RUNTIME_ENTRY);
+ __ bind(&no_deopt);
+ __ stw(r4, MemOperand(scratch));
+ __ Pop(r4, scratch);
+ }
+
+ if (info()->ShouldTrapOnDeopt()) {
+ __ stop("trap_on_deopt", cond, kDefaultStopCode, cr);
+ }
+
+ Deoptimizer::Reason reason(instr->hydrogen_value()->position().raw(),
+ instr->Mnemonic(), detail);
+ DCHECK(info()->IsStub() || frame_is_built_);
+ // Go through jump table if we need to handle condition, build frame, or
+ // restore caller doubles.
+ if (cond == al && frame_is_built_ && !info()->saves_caller_doubles()) {
+ DeoptComment(reason);
+ __ Call(entry, RelocInfo::RUNTIME_ENTRY);
+ } else {
+ Deoptimizer::JumpTableEntry table_entry(entry, reason, bailout_type,
+ !frame_is_built_);
+ // We often have several deopts to the same entry, reuse the last
+ // jump entry if this is the case.
+ if (jump_table_.is_empty() ||
+ !table_entry.IsEquivalentTo(jump_table_.last())) {
+ jump_table_.Add(table_entry, zone());
+ }
+ __ b(cond, &jump_table_.last().label, cr);
+ }
+}
+
+
+void LCodeGen::DeoptimizeIf(Condition condition, LInstruction* instr,
+ const char* detail, CRegister cr) {
+ Deoptimizer::BailoutType bailout_type =
+ info()->IsStub() ? Deoptimizer::LAZY : Deoptimizer::EAGER;
+ DeoptimizeIf(condition, instr, detail, bailout_type, cr);
+}
+
+
+void LCodeGen::PopulateDeoptimizationData(Handle<Code> code) {
+ int length = deoptimizations_.length();
+ if (length == 0) return;
+ Handle<DeoptimizationInputData> data =
+ DeoptimizationInputData::New(isolate(), length, TENURED);
+
+ Handle<ByteArray> translations =
+ translations_.CreateByteArray(isolate()->factory());
+ data->SetTranslationByteArray(*translations);
+ data->SetInlinedFunctionCount(Smi::FromInt(inlined_function_count_));
+ data->SetOptimizationId(Smi::FromInt(info_->optimization_id()));
+ if (info_->IsOptimizing()) {
+ // Reference to shared function info does not change between phases.
+ AllowDeferredHandleDereference allow_handle_dereference;
+ data->SetSharedFunctionInfo(*info_->shared_info());
+ } else {
+ data->SetSharedFunctionInfo(Smi::FromInt(0));
+ }
+
+ Handle<FixedArray> literals =
+ factory()->NewFixedArray(deoptimization_literals_.length(), TENURED);
+ {
+ AllowDeferredHandleDereference copy_handles;
+ for (int i = 0; i < deoptimization_literals_.length(); i++) {
+ literals->set(i, *deoptimization_literals_[i]);
+ }
+ data->SetLiteralArray(*literals);
+ }
+
+ data->SetOsrAstId(Smi::FromInt(info_->osr_ast_id().ToInt()));
+ data->SetOsrPcOffset(Smi::FromInt(osr_pc_offset_));
+
+ // Populate the deoptimization entries.
+ for (int i = 0; i < length; i++) {
+ LEnvironment* env = deoptimizations_[i];
+ data->SetAstId(i, env->ast_id());
+ data->SetTranslationIndex(i, Smi::FromInt(env->translation_index()));
+ data->SetArgumentsStackHeight(i,
+ Smi::FromInt(env->arguments_stack_height()));
+ data->SetPc(i, Smi::FromInt(env->pc_offset()));
+ }
+ code->set_deoptimization_data(*data);
+}
+
+
+int LCodeGen::DefineDeoptimizationLiteral(Handle<Object> literal) {
+ int result = deoptimization_literals_.length();
+ for (int i = 0; i < deoptimization_literals_.length(); ++i) {
+ if (deoptimization_literals_[i].is_identical_to(literal)) return i;
+ }
+ deoptimization_literals_.Add(literal, zone());
+ return result;
+}
+
+
+void LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions() {
+ DCHECK(deoptimization_literals_.length() == 0);
+
+ const ZoneList<Handle<JSFunction> >* inlined_closures =
+ chunk()->inlined_closures();
+
+ for (int i = 0, length = inlined_closures->length(); i < length; i++) {
+ DefineDeoptimizationLiteral(inlined_closures->at(i));
+ }
+
+ inlined_function_count_ = deoptimization_literals_.length();
+}
+
+
+void LCodeGen::RecordSafepointWithLazyDeopt(LInstruction* instr,
+ SafepointMode safepoint_mode) {
+ if (safepoint_mode == RECORD_SIMPLE_SAFEPOINT) {
+ RecordSafepoint(instr->pointer_map(), Safepoint::kLazyDeopt);
+ } else {
+ DCHECK(safepoint_mode == RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
+ RecordSafepointWithRegisters(instr->pointer_map(), 0,
+ Safepoint::kLazyDeopt);
+ }
+}
+
+
+void LCodeGen::RecordSafepoint(LPointerMap* pointers, Safepoint::Kind kind,
+ int arguments, Safepoint::DeoptMode deopt_mode) {
+ DCHECK(expected_safepoint_kind_ == kind);
+
+ const ZoneList<LOperand*>* operands = pointers->GetNormalizedOperands();
+ Safepoint safepoint =
+ safepoints_.DefineSafepoint(masm(), kind, arguments, deopt_mode);
+ for (int i = 0; i < operands->length(); i++) {
+ LOperand* pointer = operands->at(i);
+ if (pointer->IsStackSlot()) {
+ safepoint.DefinePointerSlot(pointer->index(), zone());
+ } else if (pointer->IsRegister() && (kind & Safepoint::kWithRegisters)) {
+ safepoint.DefinePointerRegister(ToRegister(pointer), zone());
+ }
+ }
+#if V8_OOL_CONSTANT_POOL
+ if (kind & Safepoint::kWithRegisters) {
+ // Register always contains a pointer to the constant pool.
+ safepoint.DefinePointerRegister(kConstantPoolRegister, zone());
+ }
+#endif
+}
+
+
+void LCodeGen::RecordSafepoint(LPointerMap* pointers,
+ Safepoint::DeoptMode deopt_mode) {
+ RecordSafepoint(pointers, Safepoint::kSimple, 0, deopt_mode);
+}
+
+
+void LCodeGen::RecordSafepoint(Safepoint::DeoptMode deopt_mode) {
+ LPointerMap empty_pointers(zone());
+ RecordSafepoint(&empty_pointers, deopt_mode);
+}
+
+
+void LCodeGen::RecordSafepointWithRegisters(LPointerMap* pointers,
+ int arguments,
+ Safepoint::DeoptMode deopt_mode) {
+ RecordSafepoint(pointers, Safepoint::kWithRegisters, arguments, deopt_mode);
+}
+
+
+void LCodeGen::RecordAndWritePosition(int position) {
+ if (position == RelocInfo::kNoPosition) return;
+ masm()->positions_recorder()->RecordPosition(position);
+ masm()->positions_recorder()->WriteRecordedPositions();
+}
+
+
+static const char* LabelType(LLabel* label) {
+ if (label->is_loop_header()) return " (loop header)";
+ if (label->is_osr_entry()) return " (OSR entry)";
+ return "";
+}
+
+
+void LCodeGen::DoLabel(LLabel* label) {
+ Comment(";;; <@%d,#%d> -------------------- B%d%s --------------------",
+ current_instruction_, label->hydrogen_value()->id(),
+ label->block_id(), LabelType(label));
+ __ bind(label->label());
+ current_block_ = label->block_id();
+ DoGap(label);
+}
+
+
+void LCodeGen::DoParallelMove(LParallelMove* move) { resolver_.Resolve(move); }
+
+
+void LCodeGen::DoGap(LGap* gap) {
+ for (int i = LGap::FIRST_INNER_POSITION; i <= LGap::LAST_INNER_POSITION;
+ i++) {
+ LGap::InnerPosition inner_pos = static_cast<LGap::InnerPosition>(i);
+ LParallelMove* move = gap->GetParallelMove(inner_pos);
+ if (move != NULL) DoParallelMove(move);
+ }
+}
+
+
+void LCodeGen::DoInstructionGap(LInstructionGap* instr) { DoGap(instr); }
+
+
+void LCodeGen::DoParameter(LParameter* instr) {
+ // Nothing to do.
+}
+
+
+void LCodeGen::DoCallStub(LCallStub* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->result()).is(r3));
+ switch (instr->hydrogen()->major_key()) {
+ case CodeStub::RegExpExec: {
+ RegExpExecStub stub(isolate());
+ CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
+ break;
+ }
+ case CodeStub::SubString: {
+ SubStringStub stub(isolate());
+ CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
+ break;
+ }
+ case CodeStub::StringCompare: {
+ StringCompareStub stub(isolate());
+ CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
+ break;
+ }
+ default:
+ UNREACHABLE();
+ }
+}
+
+
+void LCodeGen::DoUnknownOSRValue(LUnknownOSRValue* instr) {
+ GenerateOsrPrologue();
+}
+
+
+void LCodeGen::DoModByPowerOf2I(LModByPowerOf2I* instr) {
+ Register dividend = ToRegister(instr->dividend());
+ int32_t divisor = instr->divisor();
+ DCHECK(dividend.is(ToRegister(instr->result())));
+
+ // Theoretically, a variation of the branch-free code for integer division by
+ // a power of 2 (calculating the remainder via an additional multiplication
+ // (which gets simplified to an 'and') and subtraction) should be faster, and
+ // this is exactly what GCC and clang emit. Nevertheless, benchmarks seem to
+ // indicate that positive dividends are heavily favored, so the branching
+ // version performs better.
+ HMod* hmod = instr->hydrogen();
+ int32_t shift = WhichPowerOf2Abs(divisor);
+ Label dividend_is_not_negative, done;
+ if (hmod->CheckFlag(HValue::kLeftCanBeNegative)) {
+ __ cmpwi(dividend, Operand::Zero());
+ __ bge(÷nd_is_not_negative);
+ if (shift) {
+ // Note that this is correct even for kMinInt operands.
+ __ neg(dividend, dividend);
+ __ ExtractBitRange(dividend, dividend, shift - 1, 0);
+ __ neg(dividend, dividend, LeaveOE, SetRC);
+ if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ DeoptimizeIf(eq, instr, "minus zero", cr0);
+ }
+ } else if (!hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ __ li(dividend, Operand::Zero());
+ } else {
+ DeoptimizeIf(al, instr, "minus zero");
+ }
+ __ b(&done);
+ }
+
+ __ bind(÷nd_is_not_negative);
+ if (shift) {
+ __ ExtractBitRange(dividend, dividend, shift - 1, 0);
+ } else {
+ __ li(dividend, Operand::Zero());
+ }
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoModByConstI(LModByConstI* instr) {
+ Register dividend = ToRegister(instr->dividend());
+ int32_t divisor = instr->divisor();
+ Register result = ToRegister(instr->result());
+ DCHECK(!dividend.is(result));
+
+ if (divisor == 0) {
+ DeoptimizeIf(al, instr, "division by zero");
+ return;
+ }
+
+ __ TruncatingDiv(result, dividend, Abs(divisor));
+ __ mov(ip, Operand(Abs(divisor)));
+ __ mullw(result, result, ip);
+ __ sub(result, dividend, result, LeaveOE, SetRC);
+
+ // Check for negative zero.
+ HMod* hmod = instr->hydrogen();
+ if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ Label remainder_not_zero;
+ __ bne(&remainder_not_zero, cr0);
+ __ cmpwi(dividend, Operand::Zero());
+ DeoptimizeIf(lt, instr, "minus zero");
+ __ bind(&remainder_not_zero);
+ }
+}
+
+
+void LCodeGen::DoModI(LModI* instr) {
+ HMod* hmod = instr->hydrogen();
+ Register left_reg = ToRegister(instr->left());
+ Register right_reg = ToRegister(instr->right());
+ Register result_reg = ToRegister(instr->result());
+ Register scratch = scratch0();
+ Label done;
+
+ if (hmod->CheckFlag(HValue::kCanOverflow)) {
+ __ li(r0, Operand::Zero()); // clear xer
+ __ mtxer(r0);
+ }
+
+ __ divw(scratch, left_reg, right_reg, SetOE, SetRC);
+
+ // Check for x % 0.
+ if (hmod->CheckFlag(HValue::kCanBeDivByZero)) {
+ __ cmpwi(right_reg, Operand::Zero());
+ DeoptimizeIf(eq, instr, "division by zero");
+ }
+
+ // Check for kMinInt % -1, divw will return undefined, which is not what we
+ // want. We have to deopt if we care about -0, because we can't return that.
+ if (hmod->CheckFlag(HValue::kCanOverflow)) {
+ Label no_overflow_possible;
+ if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ DeoptimizeIf(overflow, instr, "minus zero", cr0);
+ } else {
+ __ bnooverflow(&no_overflow_possible, cr0);
+ __ li(result_reg, Operand::Zero());
+ __ b(&done);
+ }
+ __ bind(&no_overflow_possible);
+ }
+
+ __ mullw(scratch, right_reg, scratch);
+ __ sub(result_reg, left_reg, scratch, LeaveOE, SetRC);
+
+ // If we care about -0, test if the dividend is <0 and the result is 0.
+ if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ __ bne(&done, cr0);
+ __ cmpwi(left_reg, Operand::Zero());
+ DeoptimizeIf(lt, instr, "minus zero");
+ }
+
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoDivByPowerOf2I(LDivByPowerOf2I* instr) {
+ Register dividend = ToRegister(instr->dividend());
+ int32_t divisor = instr->divisor();
+ Register result = ToRegister(instr->result());
+ DCHECK(divisor == kMinInt || base::bits::IsPowerOfTwo32(Abs(divisor)));
+ DCHECK(!result.is(dividend));
+
+ // Check for (0 / -x) that will produce negative zero.
+ HDiv* hdiv = instr->hydrogen();
+ if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) {
+ __ cmpwi(dividend, Operand::Zero());
+ DeoptimizeIf(eq, instr, "minus zero");
+ }
+ // Check for (kMinInt / -1).
+ if (hdiv->CheckFlag(HValue::kCanOverflow) && divisor == -1) {
+ __ lis(r0, Operand(SIGN_EXT_IMM16(0x8000)));
+ __ cmpw(dividend, r0);
+ DeoptimizeIf(eq, instr, "overflow");
+ }
+
+ int32_t shift = WhichPowerOf2Abs(divisor);
+
+ // Deoptimize if remainder will not be 0.
+ if (!hdiv->CheckFlag(HInstruction::kAllUsesTruncatingToInt32) && shift) {
+ __ TestBitRange(dividend, shift - 1, 0, r0);
+ DeoptimizeIf(ne, instr, "lost precision", cr0);
+ }
+
+ if (divisor == -1) { // Nice shortcut, not needed for correctness.
+ __ neg(result, dividend);
+ return;
+ }
+ if (shift == 0) {
+ __ mr(result, dividend);
+ } else {
+ if (shift == 1) {
+ __ srwi(result, dividend, Operand(31));
+ } else {
+ __ srawi(result, dividend, 31);
+ __ srwi(result, result, Operand(32 - shift));
+ }
+ __ add(result, dividend, result);
+ __ srawi(result, result, shift);
+ }
+ if (divisor < 0) __ neg(result, result);
+}
+
+
+void LCodeGen::DoDivByConstI(LDivByConstI* instr) {
+ Register dividend = ToRegister(instr->dividend());
+ int32_t divisor = instr->divisor();
+ Register result = ToRegister(instr->result());
+ DCHECK(!dividend.is(result));
+
+ if (divisor == 0) {
+ DeoptimizeIf(al, instr, "division by zero");
+ return;
+ }
+
+ // Check for (0 / -x) that will produce negative zero.
+ HDiv* hdiv = instr->hydrogen();
+ if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) {
+ __ cmpwi(dividend, Operand::Zero());
+ DeoptimizeIf(eq, instr, "minus zero");
+ }
+
+ __ TruncatingDiv(result, dividend, Abs(divisor));
+ if (divisor < 0) __ neg(result, result);
+
+ if (!hdiv->CheckFlag(HInstruction::kAllUsesTruncatingToInt32)) {
+ Register scratch = scratch0();
+ __ mov(ip, Operand(divisor));
+ __ mullw(scratch, result, ip);
+ __ cmpw(scratch, dividend);
+ DeoptimizeIf(ne, instr, "lost precision");
+ }
+}
+
+
+// TODO(svenpanne) Refactor this to avoid code duplication with DoFlooringDivI.
+void LCodeGen::DoDivI(LDivI* instr) {
+ HBinaryOperation* hdiv = instr->hydrogen();
+ const Register dividend = ToRegister(instr->dividend());
+ const Register divisor = ToRegister(instr->divisor());
+ Register result = ToRegister(instr->result());
+
+ DCHECK(!dividend.is(result));
+ DCHECK(!divisor.is(result));
+
+ if (hdiv->CheckFlag(HValue::kCanOverflow)) {
+ __ li(r0, Operand::Zero()); // clear xer
+ __ mtxer(r0);
+ }
+
+ __ divw(result, dividend, divisor, SetOE, SetRC);
+
+ // Check for x / 0.
+ if (hdiv->CheckFlag(HValue::kCanBeDivByZero)) {
+ __ cmpwi(divisor, Operand::Zero());
+ DeoptimizeIf(eq, instr, "division by zero");
+ }
+
+ // Check for (0 / -x) that will produce negative zero.
+ if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ Label dividend_not_zero;
+ __ cmpwi(dividend, Operand::Zero());
+ __ bne(÷nd_not_zero);
+ __ cmpwi(divisor, Operand::Zero());
+ DeoptimizeIf(lt, instr, "minus zero");
+ __ bind(÷nd_not_zero);
+ }
+
+ // Check for (kMinInt / -1).
+ if (hdiv->CheckFlag(HValue::kCanOverflow)) {
+ Label no_overflow_possible;
+ if (!hdiv->CheckFlag(HValue::kAllUsesTruncatingToInt32)) {
+ DeoptimizeIf(overflow, instr, "overflow", cr0);
+ } else {
+ // When truncating, we want kMinInt / -1 = kMinInt.
+ __ bnooverflow(&no_overflow_possible, cr0);
+ __ mr(result, dividend);
+ }
+ __ bind(&no_overflow_possible);
+ }
+
+ if (!hdiv->CheckFlag(HInstruction::kAllUsesTruncatingToInt32)) {
+ // Deoptimize if remainder is not 0.
+ Register scratch = scratch0();
+ __ mullw(scratch, divisor, result);
+ __ cmpw(dividend, scratch);
+ DeoptimizeIf(ne, instr, "lost precision");
+ }
+}
+
+
+void LCodeGen::DoFlooringDivByPowerOf2I(LFlooringDivByPowerOf2I* instr) {
+ HBinaryOperation* hdiv = instr->hydrogen();
+ Register dividend = ToRegister(instr->dividend());
+ Register result = ToRegister(instr->result());
+ int32_t divisor = instr->divisor();
+
+ // If the divisor is positive, things are easy: There can be no deopts and we
+ // can simply do an arithmetic right shift.
+ int32_t shift = WhichPowerOf2Abs(divisor);
+ if (divisor > 0) {
+ if (shift || !result.is(dividend)) {
+ __ srawi(result, dividend, shift);
+ }
+ return;
+ }
+
+ // If the divisor is negative, we have to negate and handle edge cases.
+ OEBit oe = LeaveOE;
+#if V8_TARGET_ARCH_PPC64
+ if (divisor == -1 && hdiv->CheckFlag(HValue::kLeftCanBeMinInt)) {
+ __ lis(r0, Operand(SIGN_EXT_IMM16(0x8000)));
+ __ cmpw(dividend, r0);
+ DeoptimizeIf(eq, instr, "overflow");
+ }
+#else
+ if (hdiv->CheckFlag(HValue::kLeftCanBeMinInt)) {
+ __ li(r0, Operand::Zero()); // clear xer
+ __ mtxer(r0);
+ oe = SetOE;
+ }
+#endif
+
+ __ neg(result, dividend, oe, SetRC);
+ if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ DeoptimizeIf(eq, instr, "minus zero", cr0);
+ }
+
+// If the negation could not overflow, simply shifting is OK.
+#if !V8_TARGET_ARCH_PPC64
+ if (!instr->hydrogen()->CheckFlag(HValue::kLeftCanBeMinInt)) {
+#endif
+ if (shift) {
+ __ ShiftRightArithImm(result, result, shift);
+ }
+ return;
+#if !V8_TARGET_ARCH_PPC64
+ }
+
+ // Dividing by -1 is basically negation, unless we overflow.
+ if (divisor == -1) {
+ DeoptimizeIf(overflow, instr, "overflow", cr0);
+ return;
+ }
+
+ Label overflow, done;
+ __ boverflow(&overflow, cr0);
+ __ srawi(result, result, shift);
+ __ b(&done);
+ __ bind(&overflow);
+ __ mov(result, Operand(kMinInt / divisor));
+ __ bind(&done);
+#endif
+}
+
+
+void LCodeGen::DoFlooringDivByConstI(LFlooringDivByConstI* instr) {
+ Register dividend = ToRegister(instr->dividend());
+ int32_t divisor = instr->divisor();
+ Register result = ToRegister(instr->result());
+ DCHECK(!dividend.is(result));
+
+ if (divisor == 0) {
+ DeoptimizeIf(al, instr, "division by zero");
+ return;
+ }
+
+ // Check for (0 / -x) that will produce negative zero.
+ HMathFloorOfDiv* hdiv = instr->hydrogen();
+ if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) {
+ __ cmpwi(dividend, Operand::Zero());
+ DeoptimizeIf(eq, instr, "minus zero");
+ }
+
+ // Easy case: We need no dynamic check for the dividend and the flooring
+ // division is the same as the truncating division.
+ if ((divisor > 0 && !hdiv->CheckFlag(HValue::kLeftCanBeNegative)) ||
+ (divisor < 0 && !hdiv->CheckFlag(HValue::kLeftCanBePositive))) {
+ __ TruncatingDiv(result, dividend, Abs(divisor));
+ if (divisor < 0) __ neg(result, result);
+ return;
+ }
+
+ // In the general case we may need to adjust before and after the truncating
+ // division to get a flooring division.
+ Register temp = ToRegister(instr->temp());
+ DCHECK(!temp.is(dividend) && !temp.is(result));
+ Label needs_adjustment, done;
+ __ cmpwi(dividend, Operand::Zero());
+ __ b(divisor > 0 ? lt : gt, &needs_adjustment);
+ __ TruncatingDiv(result, dividend, Abs(divisor));
+ if (divisor < 0) __ neg(result, result);
+ __ b(&done);
+ __ bind(&needs_adjustment);
+ __ addi(temp, dividend, Operand(divisor > 0 ? 1 : -1));
+ __ TruncatingDiv(result, temp, Abs(divisor));
+ if (divisor < 0) __ neg(result, result);
+ __ subi(result, result, Operand(1));
+ __ bind(&done);
+}
+
+
+// TODO(svenpanne) Refactor this to avoid code duplication with DoDivI.
+void LCodeGen::DoFlooringDivI(LFlooringDivI* instr) {
+ HBinaryOperation* hdiv = instr->hydrogen();
+ const Register dividend = ToRegister(instr->dividend());
+ const Register divisor = ToRegister(instr->divisor());
+ Register result = ToRegister(instr->result());
+
+ DCHECK(!dividend.is(result));
+ DCHECK(!divisor.is(result));
+
+ if (hdiv->CheckFlag(HValue::kCanOverflow)) {
+ __ li(r0, Operand::Zero()); // clear xer
+ __ mtxer(r0);
+ }
+
+ __ divw(result, dividend, divisor, SetOE, SetRC);
+
+ // Check for x / 0.
+ if (hdiv->CheckFlag(HValue::kCanBeDivByZero)) {
+ __ cmpwi(divisor, Operand::Zero());
+ DeoptimizeIf(eq, instr, "division by zero");
+ }
+
+ // Check for (0 / -x) that will produce negative zero.
+ if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ Label dividend_not_zero;
+ __ cmpwi(dividend, Operand::Zero());
+ __ bne(÷nd_not_zero);
+ __ cmpwi(divisor, Operand::Zero());
+ DeoptimizeIf(lt, instr, "minus zero");
+ __ bind(÷nd_not_zero);
+ }
+
+ // Check for (kMinInt / -1).
+ if (hdiv->CheckFlag(HValue::kCanOverflow)) {
+ Label no_overflow_possible;
+ if (!hdiv->CheckFlag(HValue::kAllUsesTruncatingToInt32)) {
+ DeoptimizeIf(overflow, instr, "overflow", cr0);
+ } else {
+ // When truncating, we want kMinInt / -1 = kMinInt.
+ __ bnooverflow(&no_overflow_possible, cr0);
+ __ mr(result, dividend);
+ }
+ __ bind(&no_overflow_possible);
+ }
+
+ Label done;
+ Register scratch = scratch0();
+// If both operands have the same sign then we are done.
+#if V8_TARGET_ARCH_PPC64
+ __ xor_(scratch, dividend, divisor);
+ __ cmpwi(scratch, Operand::Zero());
+ __ bge(&done);
+#else
+ __ xor_(scratch, dividend, divisor, SetRC);
+ __ bge(&done, cr0);
+#endif
+
+ // If there is no remainder then we are done.
+ __ mullw(scratch, divisor, result);
+ __ cmpw(dividend, scratch);
+ __ beq(&done);
+
+ // We performed a truncating division. Correct the result.
+ __ subi(result, result, Operand(1));
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoMultiplyAddD(LMultiplyAddD* instr) {
+ DoubleRegister addend = ToDoubleRegister(instr->addend());
+ DoubleRegister multiplier = ToDoubleRegister(instr->multiplier());
+ DoubleRegister multiplicand = ToDoubleRegister(instr->multiplicand());
+ DoubleRegister result = ToDoubleRegister(instr->result());
+
+ __ fmadd(result, multiplier, multiplicand, addend);
+}
+
+
+void LCodeGen::DoMultiplySubD(LMultiplySubD* instr) {
+ DoubleRegister minuend = ToDoubleRegister(instr->minuend());
+ DoubleRegister multiplier = ToDoubleRegister(instr->multiplier());
+ DoubleRegister multiplicand = ToDoubleRegister(instr->multiplicand());
+ DoubleRegister result = ToDoubleRegister(instr->result());
+
+ __ fmsub(result, multiplier, multiplicand, minuend);
+}
+
+
+void LCodeGen::DoMulI(LMulI* instr) {
+ Register scratch = scratch0();
+ Register result = ToRegister(instr->result());
+ // Note that result may alias left.
+ Register left = ToRegister(instr->left());
+ LOperand* right_op = instr->right();
+
+ bool bailout_on_minus_zero =
+ instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero);
+ bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
+
+ if (right_op->IsConstantOperand()) {
+ int32_t constant = ToInteger32(LConstantOperand::cast(right_op));
+
+ if (bailout_on_minus_zero && (constant < 0)) {
+ // The case of a null constant will be handled separately.
+ // If constant is negative and left is null, the result should be -0.
+ __ cmpi(left, Operand::Zero());
+ DeoptimizeIf(eq, instr, "minus zero");
+ }
+
+ switch (constant) {
+ case -1:
+ if (can_overflow) {
+#if V8_TARGET_ARCH_PPC64
+ if (instr->hydrogen()->representation().IsSmi()) {
+#endif
+ __ li(r0, Operand::Zero()); // clear xer
+ __ mtxer(r0);
+ __ neg(result, left, SetOE, SetRC);
+ DeoptimizeIf(overflow, instr, "overflow", cr0);
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ __ neg(result, left);
+ __ TestIfInt32(result, scratch, r0);
+ DeoptimizeIf(ne, instr, "overflow");
+ }
+#endif
+ } else {
+ __ neg(result, left);
+ }
+ break;
+ case 0:
+ if (bailout_on_minus_zero) {
+// If left is strictly negative and the constant is null, the
+// result is -0. Deoptimize if required, otherwise return 0.
+#if V8_TARGET_ARCH_PPC64
+ if (instr->hydrogen()->representation().IsSmi()) {
+#endif
+ __ cmpi(left, Operand::Zero());
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ __ cmpwi(left, Operand::Zero());
+ }
+#endif
+ DeoptimizeIf(lt, instr, "minus zero");
+ }
+ __ li(result, Operand::Zero());
+ break;
+ case 1:
+ __ Move(result, left);
+ break;
+ default:
+ // Multiplying by powers of two and powers of two plus or minus
+ // one can be done faster with shifted operands.
+ // For other constants we emit standard code.
+ int32_t mask = constant >> 31;
+ uint32_t constant_abs = (constant + mask) ^ mask;
+
+ if (base::bits::IsPowerOfTwo32(constant_abs)) {
+ int32_t shift = WhichPowerOf2(constant_abs);
+ __ ShiftLeftImm(result, left, Operand(shift));
+ // Correct the sign of the result if the constant is negative.
+ if (constant < 0) __ neg(result, result);
+ } else if (base::bits::IsPowerOfTwo32(constant_abs - 1)) {
+ int32_t shift = WhichPowerOf2(constant_abs - 1);
+ __ ShiftLeftImm(scratch, left, Operand(shift));
+ __ add(result, scratch, left);
+ // Correct the sign of the result if the constant is negative.
+ if (constant < 0) __ neg(result, result);
+ } else if (base::bits::IsPowerOfTwo32(constant_abs + 1)) {
+ int32_t shift = WhichPowerOf2(constant_abs + 1);
+ __ ShiftLeftImm(scratch, left, Operand(shift));
+ __ sub(result, scratch, left);
+ // Correct the sign of the result if the constant is negative.
+ if (constant < 0) __ neg(result, result);
+ } else {
+ // Generate standard code.
+ __ mov(ip, Operand(constant));
+ __ Mul(result, left, ip);
+ }
+ }
+
+ } else {
+ DCHECK(right_op->IsRegister());
+ Register right = ToRegister(right_op);
+
+ if (can_overflow) {
+#if V8_TARGET_ARCH_PPC64
+ // result = left * right.
+ if (instr->hydrogen()->representation().IsSmi()) {
+ __ SmiUntag(result, left);
+ __ SmiUntag(scratch, right);
+ __ Mul(result, result, scratch);
+ } else {
+ __ Mul(result, left, right);
+ }
+ __ TestIfInt32(result, scratch, r0);
+ DeoptimizeIf(ne, instr, "overflow");
+ if (instr->hydrogen()->representation().IsSmi()) {
+ __ SmiTag(result);
+ }
+#else
+ // scratch:result = left * right.
+ if (instr->hydrogen()->representation().IsSmi()) {
+ __ SmiUntag(result, left);
+ __ mulhw(scratch, result, right);
+ __ mullw(result, result, right);
+ } else {
+ __ mulhw(scratch, left, right);
+ __ mullw(result, left, right);
+ }
+ __ TestIfInt32(scratch, result, r0);
+ DeoptimizeIf(ne, instr, "overflow");
+#endif
+ } else {
+ if (instr->hydrogen()->representation().IsSmi()) {
+ __ SmiUntag(result, left);
+ __ Mul(result, result, right);
+ } else {
+ __ Mul(result, left, right);
+ }
+ }
+
+ if (bailout_on_minus_zero) {
+ Label done;
+#if V8_TARGET_ARCH_PPC64
+ if (instr->hydrogen()->representation().IsSmi()) {
+#endif
+ __ xor_(r0, left, right, SetRC);
+ __ bge(&done, cr0);
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ __ xor_(r0, left, right);
+ __ cmpwi(r0, Operand::Zero());
+ __ bge(&done);
+ }
+#endif
+ // Bail out if the result is minus zero.
+ __ cmpi(result, Operand::Zero());
+ DeoptimizeIf(eq, instr, "minus zero");
+ __ bind(&done);
+ }
+ }
+}
+
+
+void LCodeGen::DoBitI(LBitI* instr) {
+ LOperand* left_op = instr->left();
+ LOperand* right_op = instr->right();
+ DCHECK(left_op->IsRegister());
+ Register left = ToRegister(left_op);
+ Register result = ToRegister(instr->result());
+ Operand right(no_reg);
+
+ if (right_op->IsStackSlot()) {
+ right = Operand(EmitLoadRegister(right_op, ip));
+ } else {
+ DCHECK(right_op->IsRegister() || right_op->IsConstantOperand());
+ right = ToOperand(right_op);
+
+ if (right_op->IsConstantOperand() && is_uint16(right.immediate())) {
+ switch (instr->op()) {
+ case Token::BIT_AND:
+ __ andi(result, left, right);
+ break;
+ case Token::BIT_OR:
+ __ ori(result, left, right);
+ break;
+ case Token::BIT_XOR:
+ __ xori(result, left, right);
+ break;
+ default:
+ UNREACHABLE();
+ break;
+ }
+ return;
+ }
+ }
+
+ switch (instr->op()) {
+ case Token::BIT_AND:
+ __ And(result, left, right);
+ break;
+ case Token::BIT_OR:
+ __ Or(result, left, right);
+ break;
+ case Token::BIT_XOR:
+ if (right_op->IsConstantOperand() && right.immediate() == int32_t(~0)) {
+ __ notx(result, left);
+ } else {
+ __ Xor(result, left, right);
+ }
+ break;
+ default:
+ UNREACHABLE();
+ break;
+ }
+}
+
+
+void LCodeGen::DoShiftI(LShiftI* instr) {
+ // Both 'left' and 'right' are "used at start" (see LCodeGen::DoShift), so
+ // result may alias either of them.
+ LOperand* right_op = instr->right();
+ Register left = ToRegister(instr->left());
+ Register result = ToRegister(instr->result());
+ Register scratch = scratch0();
+ if (right_op->IsRegister()) {
+ // Mask the right_op operand.
+ __ andi(scratch, ToRegister(right_op), Operand(0x1F));
+ switch (instr->op()) {
+ case Token::ROR:
+ // rotate_right(a, b) == rotate_left(a, 32 - b)
+ __ subfic(scratch, scratch, Operand(32));
+ __ rotlw(result, left, scratch);
+ break;
+ case Token::SAR:
+ __ sraw(result, left, scratch);
+ break;
+ case Token::SHR:
+ if (instr->can_deopt()) {
+ __ srw(result, left, scratch, SetRC);
+#if V8_TARGET_ARCH_PPC64
+ __ extsw(result, result, SetRC);
+#endif
+ DeoptimizeIf(lt, instr, "negative value", cr0);
+ } else {
+ __ srw(result, left, scratch);
+ }
+ break;
+ case Token::SHL:
+ __ slw(result, left, scratch);
+#if V8_TARGET_ARCH_PPC64
+ __ extsw(result, result);
+#endif
+ break;
+ default:
+ UNREACHABLE();
+ break;
+ }
+ } else {
+ // Mask the right_op operand.
+ int value = ToInteger32(LConstantOperand::cast(right_op));
+ uint8_t shift_count = static_cast<uint8_t>(value & 0x1F);
+ switch (instr->op()) {
+ case Token::ROR:
+ if (shift_count != 0) {
+ __ rotrwi(result, left, shift_count);
+ } else {
+ __ Move(result, left);
+ }
+ break;
+ case Token::SAR:
+ if (shift_count != 0) {
+ __ srawi(result, left, shift_count);
+ } else {
+ __ Move(result, left);
+ }
+ break;
+ case Token::SHR:
+ if (shift_count != 0) {
+ __ srwi(result, left, Operand(shift_count));
+ } else {
+ if (instr->can_deopt()) {
+ __ cmpwi(left, Operand::Zero());
+ DeoptimizeIf(lt, instr, "negative value");
+ }
+ __ Move(result, left);
+ }
+ break;
+ case Token::SHL:
+ if (shift_count != 0) {
+#if V8_TARGET_ARCH_PPC64
+ if (instr->hydrogen_value()->representation().IsSmi()) {
+ __ sldi(result, left, Operand(shift_count));
+#else
+ if (instr->hydrogen_value()->representation().IsSmi() &&
+ instr->can_deopt()) {
+ if (shift_count != 1) {
+ __ slwi(result, left, Operand(shift_count - 1));
+ __ SmiTagCheckOverflow(result, result, scratch);
+ } else {
+ __ SmiTagCheckOverflow(result, left, scratch);
+ }
+ DeoptimizeIf(lt, instr, "overflow", cr0);
+#endif
+ } else {
+ __ slwi(result, left, Operand(shift_count));
+#if V8_TARGET_ARCH_PPC64
+ __ extsw(result, result);
+#endif
+ }
+ } else {
+ __ Move(result, left);
+ }
+ break;
+ default:
+ UNREACHABLE();
+ break;
+ }
+ }
+}
+
+
+void LCodeGen::DoSubI(LSubI* instr) {
+ LOperand* right = instr->right();
+ Register left = ToRegister(instr->left());
+ Register result = ToRegister(instr->result());
+ bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
+ if (!can_overflow) {
+ if (right->IsConstantOperand()) {
+ __ Add(result, left, -(ToOperand(right).immediate()), r0);
+ } else {
+ __ sub(result, left, EmitLoadRegister(right, ip));
+ }
+ } else {
+ if (right->IsConstantOperand()) {
+ __ AddAndCheckForOverflow(result, left, -(ToOperand(right).immediate()),
+ scratch0(), r0);
+ } else {
+ __ SubAndCheckForOverflow(result, left, EmitLoadRegister(right, ip),
+ scratch0(), r0);
+ }
+// Doptimize on overflow
+#if V8_TARGET_ARCH_PPC64
+ if (!instr->hydrogen()->representation().IsSmi()) {
+ __ extsw(scratch0(), scratch0(), SetRC);
+ }
+#endif
+ DeoptimizeIf(lt, instr, "overflow", cr0);
+ }
+
+#if V8_TARGET_ARCH_PPC64
+ if (!instr->hydrogen()->representation().IsSmi()) {
+ __ extsw(result, result);
+ }
+#endif
+}
+
+
+void LCodeGen::DoRSubI(LRSubI* instr) {
+ LOperand* left = instr->left();
+ LOperand* right = instr->right();
+ LOperand* result = instr->result();
+
+ DCHECK(!instr->hydrogen()->CheckFlag(HValue::kCanOverflow) &&
+ right->IsConstantOperand());
+
+ Operand right_operand = ToOperand(right);
+ if (is_int16(right_operand.immediate())) {
+ __ subfic(ToRegister(result), ToRegister(left), right_operand);
+ } else {
+ __ mov(r0, right_operand);
+ __ sub(ToRegister(result), r0, ToRegister(left));
+ }
+}
+
+
+void LCodeGen::DoConstantI(LConstantI* instr) {
+ __ mov(ToRegister(instr->result()), Operand(instr->value()));
+}
+
+
+void LCodeGen::DoConstantS(LConstantS* instr) {
+ __ LoadSmiLiteral(ToRegister(instr->result()), instr->value());
+}
+
+
+// TODO(penguin): put const to constant pool instead
+// of storing double to stack
+void LCodeGen::DoConstantD(LConstantD* instr) {
+ DCHECK(instr->result()->IsDoubleRegister());
+ DoubleRegister result = ToDoubleRegister(instr->result());
+ double v = instr->value();
+ __ LoadDoubleLiteral(result, v, scratch0());
+}
+
+
+void LCodeGen::DoConstantE(LConstantE* instr) {
+ __ mov(ToRegister(instr->result()), Operand(instr->value()));
+}
+
+
+void LCodeGen::DoConstantT(LConstantT* instr) {
+ Handle<Object> object = instr->value(isolate());
+ AllowDeferredHandleDereference smi_check;
+ __ Move(ToRegister(instr->result()), object);
+}
+
+
+void LCodeGen::DoMapEnumLength(LMapEnumLength* instr) {
+ Register result = ToRegister(instr->result());
+ Register map = ToRegister(instr->value());
+ __ EnumLength(result, map);
+}
+
+
+void LCodeGen::DoDateField(LDateField* instr) {
+ Register object = ToRegister(instr->date());
+ Register result = ToRegister(instr->result());
+ Register scratch = ToRegister(instr->temp());
+ Smi* index = instr->index();
+ Label runtime, done;
+ DCHECK(object.is(result));
+ DCHECK(object.is(r3));
+ DCHECK(!scratch.is(scratch0()));
+ DCHECK(!scratch.is(object));
+
+ __ TestIfSmi(object, r0);
+ DeoptimizeIf(eq, instr, "Smi", cr0);
+ __ CompareObjectType(object, scratch, scratch, JS_DATE_TYPE);
+ DeoptimizeIf(ne, instr, "not a date object");
+
+ if (index->value() == 0) {
+ __ LoadP(result, FieldMemOperand(object, JSDate::kValueOffset));
+ } else {
+ if (index->value() < JSDate::kFirstUncachedField) {
+ ExternalReference stamp = ExternalReference::date_cache_stamp(isolate());
+ __ mov(scratch, Operand(stamp));
+ __ LoadP(scratch, MemOperand(scratch));
+ __ LoadP(scratch0(), FieldMemOperand(object, JSDate::kCacheStampOffset));
+ __ cmp(scratch, scratch0());
+ __ bne(&runtime);
+ __ LoadP(result,
+ FieldMemOperand(object, JSDate::kValueOffset +
+ kPointerSize * index->value()));
+ __ b(&done);
+ }
+ __ bind(&runtime);
+ __ PrepareCallCFunction(2, scratch);
+ __ LoadSmiLiteral(r4, index);
+ __ CallCFunction(ExternalReference::get_date_field_function(isolate()), 2);
+ __ bind(&done);
+ }
+}
+
+
+MemOperand LCodeGen::BuildSeqStringOperand(Register string, LOperand* index,
+ String::Encoding encoding) {
+ if (index->IsConstantOperand()) {
+ int offset = ToInteger32(LConstantOperand::cast(index));
+ if (encoding == String::TWO_BYTE_ENCODING) {
+ offset *= kUC16Size;
+ }
+ STATIC_ASSERT(kCharSize == 1);
+ return FieldMemOperand(string, SeqString::kHeaderSize + offset);
+ }
+ Register scratch = scratch0();
+ DCHECK(!scratch.is(string));
+ DCHECK(!scratch.is(ToRegister(index)));
+ if (encoding == String::ONE_BYTE_ENCODING) {
+ __ add(scratch, string, ToRegister(index));
+ } else {
+ STATIC_ASSERT(kUC16Size == 2);
+ __ ShiftLeftImm(scratch, ToRegister(index), Operand(1));
+ __ add(scratch, string, scratch);
+ }
+ return FieldMemOperand(scratch, SeqString::kHeaderSize);
+}
+
+
+void LCodeGen::DoSeqStringGetChar(LSeqStringGetChar* instr) {
+ String::Encoding encoding = instr->hydrogen()->encoding();
+ Register string = ToRegister(instr->string());
+ Register result = ToRegister(instr->result());
+
+ if (FLAG_debug_code) {
+ Register scratch = scratch0();
+ __ LoadP(scratch, FieldMemOperand(string, HeapObject::kMapOffset));
+ __ lbz(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
+
+ __ andi(scratch, scratch,
+ Operand(kStringRepresentationMask | kStringEncodingMask));
+ static const uint32_t one_byte_seq_type = kSeqStringTag | kOneByteStringTag;
+ static const uint32_t two_byte_seq_type = kSeqStringTag | kTwoByteStringTag;
+ __ cmpi(scratch,
+ Operand(encoding == String::ONE_BYTE_ENCODING ? one_byte_seq_type
+ : two_byte_seq_type));
+ __ Check(eq, kUnexpectedStringType);
+ }
+
+ MemOperand operand = BuildSeqStringOperand(string, instr->index(), encoding);
+ if (encoding == String::ONE_BYTE_ENCODING) {
+ __ lbz(result, operand);
+ } else {
+ __ lhz(result, operand);
+ }
+}
+
+
+void LCodeGen::DoSeqStringSetChar(LSeqStringSetChar* instr) {
+ String::Encoding encoding = instr->hydrogen()->encoding();
+ Register string = ToRegister(instr->string());
+ Register value = ToRegister(instr->value());
+
+ if (FLAG_debug_code) {
+ Register index = ToRegister(instr->index());
+ static const uint32_t one_byte_seq_type = kSeqStringTag | kOneByteStringTag;
+ static const uint32_t two_byte_seq_type = kSeqStringTag | kTwoByteStringTag;
+ int encoding_mask =
+ instr->hydrogen()->encoding() == String::ONE_BYTE_ENCODING
+ ? one_byte_seq_type
+ : two_byte_seq_type;
+ __ EmitSeqStringSetCharCheck(string, index, value, encoding_mask);
+ }
+
+ MemOperand operand = BuildSeqStringOperand(string, instr->index(), encoding);
+ if (encoding == String::ONE_BYTE_ENCODING) {
+ __ stb(value, operand);
+ } else {
+ __ sth(value, operand);
+ }
+}
+
+
+void LCodeGen::DoAddI(LAddI* instr) {
+ LOperand* right = instr->right();
+ Register left = ToRegister(instr->left());
+ Register result = ToRegister(instr->result());
+ bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
+#if V8_TARGET_ARCH_PPC64
+ bool isInteger = !(instr->hydrogen()->representation().IsSmi() ||
+ instr->hydrogen()->representation().IsExternal());
+#endif
+
+ if (!can_overflow) {
+ if (right->IsConstantOperand()) {
+ __ Add(result, left, ToOperand(right).immediate(), r0);
+ } else {
+ __ add(result, left, EmitLoadRegister(right, ip));
+ }
+ } else {
+ if (right->IsConstantOperand()) {
+ __ AddAndCheckForOverflow(result, left, ToOperand(right).immediate(),
+ scratch0(), r0);
+ } else {
+ __ AddAndCheckForOverflow(result, left, EmitLoadRegister(right, ip),
+ scratch0(), r0);
+ }
+// Doptimize on overflow
+#if V8_TARGET_ARCH_PPC64
+ if (isInteger) {
+ __ extsw(scratch0(), scratch0(), SetRC);
+ }
+#endif
+ DeoptimizeIf(lt, instr, "overflow", cr0);
+ }
+
+#if V8_TARGET_ARCH_PPC64
+ if (isInteger) {
+ __ extsw(result, result);
+ }
+#endif
+}
+
+
+void LCodeGen::DoMathMinMax(LMathMinMax* instr) {
+ LOperand* left = instr->left();
+ LOperand* right = instr->right();
+ HMathMinMax::Operation operation = instr->hydrogen()->operation();
+ Condition cond = (operation == HMathMinMax::kMathMin) ? le : ge;
+ if (instr->hydrogen()->representation().IsSmiOrInteger32()) {
+ Register left_reg = ToRegister(left);
+ Register right_reg = EmitLoadRegister(right, ip);
+ Register result_reg = ToRegister(instr->result());
+ Label return_left, done;
+#if V8_TARGET_ARCH_PPC64
+ if (instr->hydrogen_value()->representation().IsSmi()) {
+#endif
+ __ cmp(left_reg, right_reg);
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ __ cmpw(left_reg, right_reg);
+ }
+#endif
+ __ b(cond, &return_left);
+ __ Move(result_reg, right_reg);
+ __ b(&done);
+ __ bind(&return_left);
+ __ Move(result_reg, left_reg);
+ __ bind(&done);
+ } else {
+ DCHECK(instr->hydrogen()->representation().IsDouble());
+ DoubleRegister left_reg = ToDoubleRegister(left);
+ DoubleRegister right_reg = ToDoubleRegister(right);
+ DoubleRegister result_reg = ToDoubleRegister(instr->result());
+ Label check_nan_left, check_zero, return_left, return_right, done;
+ __ fcmpu(left_reg, right_reg);
+ __ bunordered(&check_nan_left);
+ __ beq(&check_zero);
+ __ b(cond, &return_left);
+ __ b(&return_right);
+
+ __ bind(&check_zero);
+ __ fcmpu(left_reg, kDoubleRegZero);
+ __ bne(&return_left); // left == right != 0.
+
+ // At this point, both left and right are either 0 or -0.
+ // N.B. The following works because +0 + -0 == +0
+ if (operation == HMathMinMax::kMathMin) {
+ // For min we want logical-or of sign bit: -(-L + -R)
+ __ fneg(left_reg, left_reg);
+ __ fsub(result_reg, left_reg, right_reg);
+ __ fneg(result_reg, result_reg);
+ } else {
+ // For max we want logical-and of sign bit: (L + R)
+ __ fadd(result_reg, left_reg, right_reg);
+ }
+ __ b(&done);
+
+ __ bind(&check_nan_left);
+ __ fcmpu(left_reg, left_reg);
+ __ bunordered(&return_left); // left == NaN.
+
+ __ bind(&return_right);
+ if (!right_reg.is(result_reg)) {
+ __ fmr(result_reg, right_reg);
+ }
+ __ b(&done);
+
+ __ bind(&return_left);
+ if (!left_reg.is(result_reg)) {
+ __ fmr(result_reg, left_reg);
+ }
+ __ bind(&done);
+ }
+}
+
+
+void LCodeGen::DoArithmeticD(LArithmeticD* instr) {
+ DoubleRegister left = ToDoubleRegister(instr->left());
+ DoubleRegister right = ToDoubleRegister(instr->right());
+ DoubleRegister result = ToDoubleRegister(instr->result());
+ switch (instr->op()) {
+ case Token::ADD:
+ __ fadd(result, left, right);
+ break;
+ case Token::SUB:
+ __ fsub(result, left, right);
+ break;
+ case Token::MUL:
+ __ fmul(result, left, right);
+ break;
+ case Token::DIV:
+ __ fdiv(result, left, right);
+ break;
+ case Token::MOD: {
+ __ PrepareCallCFunction(0, 2, scratch0());
+ __ MovToFloatParameters(left, right);
+ __ CallCFunction(ExternalReference::mod_two_doubles_operation(isolate()),
+ 0, 2);
+ // Move the result in the double result register.
+ __ MovFromFloatResult(result);
+ break;
+ }
+ default:
+ UNREACHABLE();
+ break;
+ }
+}
+
+
+void LCodeGen::DoArithmeticT(LArithmeticT* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->left()).is(r4));
+ DCHECK(ToRegister(instr->right()).is(r3));
+ DCHECK(ToRegister(instr->result()).is(r3));
+
+ Handle<Code> code =
+ CodeFactory::BinaryOpIC(isolate(), instr->op(), NO_OVERWRITE).code();
+ CallCode(code, RelocInfo::CODE_TARGET, instr);
+}
+
+
+template <class InstrType>
+void LCodeGen::EmitBranch(InstrType instr, Condition cond, CRegister cr) {
+ int left_block = instr->TrueDestination(chunk_);
+ int right_block = instr->FalseDestination(chunk_);
+
+ int next_block = GetNextEmittedBlock();
+
+ if (right_block == left_block || cond == al) {
+ EmitGoto(left_block);
+ } else if (left_block == next_block) {
+ __ b(NegateCondition(cond), chunk_->GetAssemblyLabel(right_block), cr);
+ } else if (right_block == next_block) {
+ __ b(cond, chunk_->GetAssemblyLabel(left_block), cr);
+ } else {
+ __ b(cond, chunk_->GetAssemblyLabel(left_block), cr);
+ __ b(chunk_->GetAssemblyLabel(right_block));
+ }
+}
+
+
+template <class InstrType>
+void LCodeGen::EmitFalseBranch(InstrType instr, Condition cond, CRegister cr) {
+ int false_block = instr->FalseDestination(chunk_);
+ __ b(cond, chunk_->GetAssemblyLabel(false_block), cr);
+}
+
+
+void LCodeGen::DoDebugBreak(LDebugBreak* instr) { __ stop("LBreak"); }
+
+
+void LCodeGen::DoBranch(LBranch* instr) {
+ Representation r = instr->hydrogen()->value()->representation();
+ DoubleRegister dbl_scratch = double_scratch0();
+ const uint crZOrNaNBits = (1 << (31 - Assembler::encode_crbit(cr7, CR_EQ)) |
+ 1 << (31 - Assembler::encode_crbit(cr7, CR_FU)));
+
+ if (r.IsInteger32()) {
+ DCHECK(!info()->IsStub());
+ Register reg = ToRegister(instr->value());
+ __ cmpwi(reg, Operand::Zero());
+ EmitBranch(instr, ne);
+ } else if (r.IsSmi()) {
+ DCHECK(!info()->IsStub());
+ Register reg = ToRegister(instr->value());
+ __ cmpi(reg, Operand::Zero());
+ EmitBranch(instr, ne);
+ } else if (r.IsDouble()) {
+ DCHECK(!info()->IsStub());
+ DoubleRegister reg = ToDoubleRegister(instr->value());
+ // Test the double value. Zero and NaN are false.
+ __ fcmpu(reg, kDoubleRegZero, cr7);
+ __ mfcr(r0);
+ __ andi(r0, r0, Operand(crZOrNaNBits));
+ EmitBranch(instr, eq, cr0);
+ } else {
+ DCHECK(r.IsTagged());
+ Register reg = ToRegister(instr->value());
+ HType type = instr->hydrogen()->value()->type();
+ if (type.IsBoolean()) {
+ DCHECK(!info()->IsStub());
+ __ CompareRoot(reg, Heap::kTrueValueRootIndex);
+ EmitBranch(instr, eq);
+ } else if (type.IsSmi()) {
+ DCHECK(!info()->IsStub());
+ __ cmpi(reg, Operand::Zero());
+ EmitBranch(instr, ne);
+ } else if (type.IsJSArray()) {
+ DCHECK(!info()->IsStub());
+ EmitBranch(instr, al);
+ } else if (type.IsHeapNumber()) {
+ DCHECK(!info()->IsStub());
+ __ lfd(dbl_scratch, FieldMemOperand(reg, HeapNumber::kValueOffset));
+ // Test the double value. Zero and NaN are false.
+ __ fcmpu(dbl_scratch, kDoubleRegZero, cr7);
+ __ mfcr(r0);
+ __ andi(r0, r0, Operand(crZOrNaNBits));
+ EmitBranch(instr, eq, cr0);
+ } else if (type.IsString()) {
+ DCHECK(!info()->IsStub());
+ __ LoadP(ip, FieldMemOperand(reg, String::kLengthOffset));
+ __ cmpi(ip, Operand::Zero());
+ EmitBranch(instr, ne);
+ } else {
+ ToBooleanStub::Types expected = instr->hydrogen()->expected_input_types();
+ // Avoid deopts in the case where we've never executed this path before.
+ if (expected.IsEmpty()) expected = ToBooleanStub::Types::Generic();
+
+ if (expected.Contains(ToBooleanStub::UNDEFINED)) {
+ // undefined -> false.
+ __ CompareRoot(reg, Heap::kUndefinedValueRootIndex);
+ __ beq(instr->FalseLabel(chunk_));
+ }
+ if (expected.Contains(ToBooleanStub::BOOLEAN)) {
+ // Boolean -> its value.
+ __ CompareRoot(reg, Heap::kTrueValueRootIndex);
+ __ beq(instr->TrueLabel(chunk_));
+ __ CompareRoot(reg, Heap::kFalseValueRootIndex);
+ __ beq(instr->FalseLabel(chunk_));
+ }
+ if (expected.Contains(ToBooleanStub::NULL_TYPE)) {
+ // 'null' -> false.
+ __ CompareRoot(reg, Heap::kNullValueRootIndex);
+ __ beq(instr->FalseLabel(chunk_));
+ }
+
+ if (expected.Contains(ToBooleanStub::SMI)) {
+ // Smis: 0 -> false, all other -> true.
+ __ cmpi(reg, Operand::Zero());
+ __ beq(instr->FalseLabel(chunk_));
+ __ JumpIfSmi(reg, instr->TrueLabel(chunk_));
+ } else if (expected.NeedsMap()) {
+ // If we need a map later and have a Smi -> deopt.
+ __ TestIfSmi(reg, r0);
+ DeoptimizeIf(eq, instr, "Smi", cr0);
+ }
+
+ const Register map = scratch0();
+ if (expected.NeedsMap()) {
+ __ LoadP(map, FieldMemOperand(reg, HeapObject::kMapOffset));
+
+ if (expected.CanBeUndetectable()) {
+ // Undetectable -> false.
+ __ lbz(ip, FieldMemOperand(map, Map::kBitFieldOffset));
+ __ TestBit(ip, Map::kIsUndetectable, r0);
+ __ bne(instr->FalseLabel(chunk_), cr0);
+ }
+ }
+
+ if (expected.Contains(ToBooleanStub::SPEC_OBJECT)) {
+ // spec object -> true.
+ __ CompareInstanceType(map, ip, FIRST_SPEC_OBJECT_TYPE);
+ __ bge(instr->TrueLabel(chunk_));
+ }
+
+ if (expected.Contains(ToBooleanStub::STRING)) {
+ // String value -> false iff empty.
+ Label not_string;
+ __ CompareInstanceType(map, ip, FIRST_NONSTRING_TYPE);
+ __ bge(¬_string);
+ __ LoadP(ip, FieldMemOperand(reg, String::kLengthOffset));
+ __ cmpi(ip, Operand::Zero());
+ __ bne(instr->TrueLabel(chunk_));
+ __ b(instr->FalseLabel(chunk_));
+ __ bind(¬_string);
+ }
+
+ if (expected.Contains(ToBooleanStub::SYMBOL)) {
+ // Symbol value -> true.
+ __ CompareInstanceType(map, ip, SYMBOL_TYPE);
+ __ beq(instr->TrueLabel(chunk_));
+ }
+
+ if (expected.Contains(ToBooleanStub::HEAP_NUMBER)) {
+ // heap number -> false iff +0, -0, or NaN.
+ Label not_heap_number;
+ __ CompareRoot(map, Heap::kHeapNumberMapRootIndex);
+ __ bne(¬_heap_number);
+ __ lfd(dbl_scratch, FieldMemOperand(reg, HeapNumber::kValueOffset));
+ // Test the double value. Zero and NaN are false.
+ __ fcmpu(dbl_scratch, kDoubleRegZero, cr7);
+ __ mfcr(r0);
+ __ andi(r0, r0, Operand(crZOrNaNBits));
+ __ bne(instr->FalseLabel(chunk_), cr0);
+ __ b(instr->TrueLabel(chunk_));
+ __ bind(¬_heap_number);
+ }
+
+ if (!expected.IsGeneric()) {
+ // We've seen something for the first time -> deopt.
+ // This can only happen if we are not generic already.
+ DeoptimizeIf(al, instr, "unexpected object");
+ }
+ }
+ }
+}
+
+
+void LCodeGen::EmitGoto(int block) {
+ if (!IsNextEmittedBlock(block)) {
+ __ b(chunk_->GetAssemblyLabel(LookupDestination(block)));
+ }
+}
+
+
+void LCodeGen::DoGoto(LGoto* instr) { EmitGoto(instr->block_id()); }
+
+
+Condition LCodeGen::TokenToCondition(Token::Value op) {
+ Condition cond = kNoCondition;
+ switch (op) {
+ case Token::EQ:
+ case Token::EQ_STRICT:
+ cond = eq;
+ break;
+ case Token::NE:
+ case Token::NE_STRICT:
+ cond = ne;
+ break;
+ case Token::LT:
+ cond = lt;
+ break;
+ case Token::GT:
+ cond = gt;
+ break;
+ case Token::LTE:
+ cond = le;
+ break;
+ case Token::GTE:
+ cond = ge;
+ break;
+ case Token::IN:
+ case Token::INSTANCEOF:
+ default:
+ UNREACHABLE();
+ }
+ return cond;
+}
+
+
+void LCodeGen::DoCompareNumericAndBranch(LCompareNumericAndBranch* instr) {
+ LOperand* left = instr->left();
+ LOperand* right = instr->right();
+ bool is_unsigned =
+ instr->hydrogen()->left()->CheckFlag(HInstruction::kUint32) ||
+ instr->hydrogen()->right()->CheckFlag(HInstruction::kUint32);
+ Condition cond = TokenToCondition(instr->op());
+
+ if (left->IsConstantOperand() && right->IsConstantOperand()) {
+ // We can statically evaluate the comparison.
+ double left_val = ToDouble(LConstantOperand::cast(left));
+ double right_val = ToDouble(LConstantOperand::cast(right));
+ int next_block = EvalComparison(instr->op(), left_val, right_val)
+ ? instr->TrueDestination(chunk_)
+ : instr->FalseDestination(chunk_);
+ EmitGoto(next_block);
+ } else {
+ if (instr->is_double()) {
+ // Compare left and right operands as doubles and load the
+ // resulting flags into the normal status register.
+ __ fcmpu(ToDoubleRegister(left), ToDoubleRegister(right));
+ // If a NaN is involved, i.e. the result is unordered,
+ // jump to false block label.
+ __ bunordered(instr->FalseLabel(chunk_));
+ } else {
+ if (right->IsConstantOperand()) {
+ int32_t value = ToInteger32(LConstantOperand::cast(right));
+ if (instr->hydrogen_value()->representation().IsSmi()) {
+ if (is_unsigned) {
+ __ CmplSmiLiteral(ToRegister(left), Smi::FromInt(value), r0);
+ } else {
+ __ CmpSmiLiteral(ToRegister(left), Smi::FromInt(value), r0);
+ }
+ } else {
+ if (is_unsigned) {
+ __ Cmplwi(ToRegister(left), Operand(value), r0);
+ } else {
+ __ Cmpwi(ToRegister(left), Operand(value), r0);
+ }
+ }
+ } else if (left->IsConstantOperand()) {
+ int32_t value = ToInteger32(LConstantOperand::cast(left));
+ if (instr->hydrogen_value()->representation().IsSmi()) {
+ if (is_unsigned) {
+ __ CmplSmiLiteral(ToRegister(right), Smi::FromInt(value), r0);
+ } else {
+ __ CmpSmiLiteral(ToRegister(right), Smi::FromInt(value), r0);
+ }
+ } else {
+ if (is_unsigned) {
+ __ Cmplwi(ToRegister(right), Operand(value), r0);
+ } else {
+ __ Cmpwi(ToRegister(right), Operand(value), r0);
+ }
+ }
+ // We commuted the operands, so commute the condition.
+ cond = CommuteCondition(cond);
+ } else if (instr->hydrogen_value()->representation().IsSmi()) {
+ if (is_unsigned) {
+ __ cmpl(ToRegister(left), ToRegister(right));
+ } else {
+ __ cmp(ToRegister(left), ToRegister(right));
+ }
+ } else {
+ if (is_unsigned) {
+ __ cmplw(ToRegister(left), ToRegister(right));
+ } else {
+ __ cmpw(ToRegister(left), ToRegister(right));
+ }
+ }
+ }
+ EmitBranch(instr, cond);
+ }
+}
+
+
+void LCodeGen::DoCmpObjectEqAndBranch(LCmpObjectEqAndBranch* instr) {
+ Register left = ToRegister(instr->left());
+ Register right = ToRegister(instr->right());
+
+ __ cmp(left, right);
+ EmitBranch(instr, eq);
+}
+
+
+void LCodeGen::DoCmpHoleAndBranch(LCmpHoleAndBranch* instr) {
+ if (instr->hydrogen()->representation().IsTagged()) {
+ Register input_reg = ToRegister(instr->object());
+ __ mov(ip, Operand(factory()->the_hole_value()));
+ __ cmp(input_reg, ip);
+ EmitBranch(instr, eq);
+ return;
+ }
+
+ DoubleRegister input_reg = ToDoubleRegister(instr->object());
+ __ fcmpu(input_reg, input_reg);
+ EmitFalseBranch(instr, ordered);
+
+ Register scratch = scratch0();
+ __ MovDoubleHighToInt(scratch, input_reg);
+ __ Cmpi(scratch, Operand(kHoleNanUpper32), r0);
+ EmitBranch(instr, eq);
+}
+
+
+void LCodeGen::DoCompareMinusZeroAndBranch(LCompareMinusZeroAndBranch* instr) {
+ Representation rep = instr->hydrogen()->value()->representation();
+ DCHECK(!rep.IsInteger32());
+ Register scratch = ToRegister(instr->temp());
+
+ if (rep.IsDouble()) {
+ DoubleRegister value = ToDoubleRegister(instr->value());
+ __ fcmpu(value, kDoubleRegZero);
+ EmitFalseBranch(instr, ne);
+#if V8_TARGET_ARCH_PPC64
+ __ MovDoubleToInt64(scratch, value);
+#else
+ __ MovDoubleHighToInt(scratch, value);
+#endif
+ __ cmpi(scratch, Operand::Zero());
+ EmitBranch(instr, lt);
+ } else {
+ Register value = ToRegister(instr->value());
+ __ CheckMap(value, scratch, Heap::kHeapNumberMapRootIndex,
+ instr->FalseLabel(chunk()), DO_SMI_CHECK);
+#if V8_TARGET_ARCH_PPC64
+ __ LoadP(scratch, FieldMemOperand(value, HeapNumber::kValueOffset));
+ __ li(ip, Operand(1));
+ __ rotrdi(ip, ip, 1); // ip = 0x80000000_00000000
+ __ cmp(scratch, ip);
+#else
+ __ lwz(scratch, FieldMemOperand(value, HeapNumber::kExponentOffset));
+ __ lwz(ip, FieldMemOperand(value, HeapNumber::kMantissaOffset));
+ Label skip;
+ __ lis(r0, Operand(SIGN_EXT_IMM16(0x8000)));
+ __ cmp(scratch, r0);
+ __ bne(&skip);
+ __ cmpi(ip, Operand::Zero());
+ __ bind(&skip);
+#endif
+ EmitBranch(instr, eq);
+ }
+}
+
+
+Condition LCodeGen::EmitIsObject(Register input, Register temp1,
+ Label* is_not_object, Label* is_object) {
+ Register temp2 = scratch0();
+ __ JumpIfSmi(input, is_not_object);
+
+ __ LoadRoot(temp2, Heap::kNullValueRootIndex);
+ __ cmp(input, temp2);
+ __ beq(is_object);
+
+ // Load map.
+ __ LoadP(temp1, FieldMemOperand(input, HeapObject::kMapOffset));
+ // Undetectable objects behave like undefined.
+ __ lbz(temp2, FieldMemOperand(temp1, Map::kBitFieldOffset));
+ __ TestBit(temp2, Map::kIsUndetectable, r0);
+ __ bne(is_not_object, cr0);
+
+ // Load instance type and check that it is in object type range.
+ __ lbz(temp2, FieldMemOperand(temp1, Map::kInstanceTypeOffset));
+ __ cmpi(temp2, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
+ __ blt(is_not_object);
+ __ cmpi(temp2, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE));
+ return le;
+}
+
+
+void LCodeGen::DoIsObjectAndBranch(LIsObjectAndBranch* instr) {
+ Register reg = ToRegister(instr->value());
+ Register temp1 = ToRegister(instr->temp());
+
+ Condition true_cond = EmitIsObject(reg, temp1, instr->FalseLabel(chunk_),
+ instr->TrueLabel(chunk_));
+
+ EmitBranch(instr, true_cond);
+}
+
+
+Condition LCodeGen::EmitIsString(Register input, Register temp1,
+ Label* is_not_string,
+ SmiCheck check_needed = INLINE_SMI_CHECK) {
+ if (check_needed == INLINE_SMI_CHECK) {
+ __ JumpIfSmi(input, is_not_string);
+ }
+ __ CompareObjectType(input, temp1, temp1, FIRST_NONSTRING_TYPE);
+
+ return lt;
+}
+
+
+void LCodeGen::DoIsStringAndBranch(LIsStringAndBranch* instr) {
+ Register reg = ToRegister(instr->value());
+ Register temp1 = ToRegister(instr->temp());
+
+ SmiCheck check_needed = instr->hydrogen()->value()->type().IsHeapObject()
+ ? OMIT_SMI_CHECK
+ : INLINE_SMI_CHECK;
+ Condition true_cond =
+ EmitIsString(reg, temp1, instr->FalseLabel(chunk_), check_needed);
+
+ EmitBranch(instr, true_cond);
+}
+
+
+void LCodeGen::DoIsSmiAndBranch(LIsSmiAndBranch* instr) {
+ Register input_reg = EmitLoadRegister(instr->value(), ip);
+ __ TestIfSmi(input_reg, r0);
+ EmitBranch(instr, eq, cr0);
+}
+
+
+void LCodeGen::DoIsUndetectableAndBranch(LIsUndetectableAndBranch* instr) {
+ Register input = ToRegister(instr->value());
+ Register temp = ToRegister(instr->temp());
+
+ if (!instr->hydrogen()->value()->type().IsHeapObject()) {
+ __ JumpIfSmi(input, instr->FalseLabel(chunk_));
+ }
+ __ LoadP(temp, FieldMemOperand(input, HeapObject::kMapOffset));
+ __ lbz(temp, FieldMemOperand(temp, Map::kBitFieldOffset));
+ __ TestBit(temp, Map::kIsUndetectable, r0);
+ EmitBranch(instr, ne, cr0);
+}
+
+
+static Condition ComputeCompareCondition(Token::Value op) {
+ switch (op) {
+ case Token::EQ_STRICT:
+ case Token::EQ:
+ return eq;
+ case Token::LT:
+ return lt;
+ case Token::GT:
+ return gt;
+ case Token::LTE:
+ return le;
+ case Token::GTE:
+ return ge;
+ default:
+ UNREACHABLE();
+ return kNoCondition;
+ }
+}
+
+
+void LCodeGen::DoStringCompareAndBranch(LStringCompareAndBranch* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ Token::Value op = instr->op();
+
+ Handle<Code> ic = CodeFactory::CompareIC(isolate(), op).code();
+ CallCode(ic, RelocInfo::CODE_TARGET, instr);
+ // This instruction also signals no smi code inlined
+ __ cmpi(r3, Operand::Zero());
+
+ Condition condition = ComputeCompareCondition(op);
+
+ EmitBranch(instr, condition);
+}
+
+
+static InstanceType TestType(HHasInstanceTypeAndBranch* instr) {
+ InstanceType from = instr->from();
+ InstanceType to = instr->to();
+ if (from == FIRST_TYPE) return to;
+ DCHECK(from == to || to == LAST_TYPE);
+ return from;
+}
+
+
+static Condition BranchCondition(HHasInstanceTypeAndBranch* instr) {
+ InstanceType from = instr->from();
+ InstanceType to = instr->to();
+ if (from == to) return eq;
+ if (to == LAST_TYPE) return ge;
+ if (from == FIRST_TYPE) return le;
+ UNREACHABLE();
+ return eq;
+}
+
+
+void LCodeGen::DoHasInstanceTypeAndBranch(LHasInstanceTypeAndBranch* instr) {
+ Register scratch = scratch0();
+ Register input = ToRegister(instr->value());
+
+ if (!instr->hydrogen()->value()->type().IsHeapObject()) {
+ __ JumpIfSmi(input, instr->FalseLabel(chunk_));
+ }
+
+ __ CompareObjectType(input, scratch, scratch, TestType(instr->hydrogen()));
+ EmitBranch(instr, BranchCondition(instr->hydrogen()));
+}
+
+
+void LCodeGen::DoGetCachedArrayIndex(LGetCachedArrayIndex* instr) {
+ Register input = ToRegister(instr->value());
+ Register result = ToRegister(instr->result());
+
+ __ AssertString(input);
+
+ __ lwz(result, FieldMemOperand(input, String::kHashFieldOffset));
+ __ IndexFromHash(result, result);
+}
+
+
+void LCodeGen::DoHasCachedArrayIndexAndBranch(
+ LHasCachedArrayIndexAndBranch* instr) {
+ Register input = ToRegister(instr->value());
+ Register scratch = scratch0();
+
+ __ lwz(scratch, FieldMemOperand(input, String::kHashFieldOffset));
+ __ mov(r0, Operand(String::kContainsCachedArrayIndexMask));
+ __ and_(r0, scratch, r0, SetRC);
+ EmitBranch(instr, eq, cr0);
+}
+
+
+// Branches to a label or falls through with the answer in flags. Trashes
+// the temp registers, but not the input.
+void LCodeGen::EmitClassOfTest(Label* is_true, Label* is_false,
+ Handle<String> class_name, Register input,
+ Register temp, Register temp2) {
+ DCHECK(!input.is(temp));
+ DCHECK(!input.is(temp2));
+ DCHECK(!temp.is(temp2));
+
+ __ JumpIfSmi(input, is_false);
+
+ if (String::Equals(isolate()->factory()->Function_string(), class_name)) {
+ // Assuming the following assertions, we can use the same compares to test
+ // for both being a function type and being in the object type range.
+ STATIC_ASSERT(NUM_OF_CALLABLE_SPEC_OBJECT_TYPES == 2);
+ STATIC_ASSERT(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE ==
+ FIRST_SPEC_OBJECT_TYPE + 1);
+ STATIC_ASSERT(LAST_NONCALLABLE_SPEC_OBJECT_TYPE ==
+ LAST_SPEC_OBJECT_TYPE - 1);
+ STATIC_ASSERT(LAST_SPEC_OBJECT_TYPE == LAST_TYPE);
+ __ CompareObjectType(input, temp, temp2, FIRST_SPEC_OBJECT_TYPE);
+ __ blt(is_false);
+ __ beq(is_true);
+ __ cmpi(temp2, Operand(LAST_SPEC_OBJECT_TYPE));
+ __ beq(is_true);
+ } else {
+ // Faster code path to avoid two compares: subtract lower bound from the
+ // actual type and do a signed compare with the width of the type range.
+ __ LoadP(temp, FieldMemOperand(input, HeapObject::kMapOffset));
+ __ lbz(temp2, FieldMemOperand(temp, Map::kInstanceTypeOffset));
+ __ subi(temp2, temp2, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
+ __ cmpi(temp2, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE -
+ FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
+ __ bgt(is_false);
+ }
+
+ // Now we are in the FIRST-LAST_NONCALLABLE_SPEC_OBJECT_TYPE range.
+ // Check if the constructor in the map is a function.
+ __ LoadP(temp, FieldMemOperand(temp, Map::kConstructorOffset));
+
+ // Objects with a non-function constructor have class 'Object'.
+ __ CompareObjectType(temp, temp2, temp2, JS_FUNCTION_TYPE);
+ if (class_name->IsOneByteEqualTo(STATIC_CHAR_VECTOR("Object"))) {
+ __ bne(is_true);
+ } else {
+ __ bne(is_false);
+ }
+
+ // temp now contains the constructor function. Grab the
+ // instance class name from there.
+ __ LoadP(temp, FieldMemOperand(temp, JSFunction::kSharedFunctionInfoOffset));
+ __ LoadP(temp,
+ FieldMemOperand(temp, SharedFunctionInfo::kInstanceClassNameOffset));
+ // The class name we are testing against is internalized since it's a literal.
+ // The name in the constructor is internalized because of the way the context
+ // is booted. This routine isn't expected to work for random API-created
+ // classes and it doesn't have to because you can't access it with natives
+ // syntax. Since both sides are internalized it is sufficient to use an
+ // identity comparison.
+ __ Cmpi(temp, Operand(class_name), r0);
+ // End with the answer in flags.
+}
+
+
+void LCodeGen::DoClassOfTestAndBranch(LClassOfTestAndBranch* instr) {
+ Register input = ToRegister(instr->value());
+ Register temp = scratch0();
+ Register temp2 = ToRegister(instr->temp());
+ Handle<String> class_name = instr->hydrogen()->class_name();
+
+ EmitClassOfTest(instr->TrueLabel(chunk_), instr->FalseLabel(chunk_),
+ class_name, input, temp, temp2);
+
+ EmitBranch(instr, eq);
+}
+
+
+void LCodeGen::DoCmpMapAndBranch(LCmpMapAndBranch* instr) {
+ Register reg = ToRegister(instr->value());
+ Register temp = ToRegister(instr->temp());
+
+ __ LoadP(temp, FieldMemOperand(reg, HeapObject::kMapOffset));
+ __ Cmpi(temp, Operand(instr->map()), r0);
+ EmitBranch(instr, eq);
+}
+
+
+void LCodeGen::DoInstanceOf(LInstanceOf* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->left()).is(r3)); // Object is in r3.
+ DCHECK(ToRegister(instr->right()).is(r4)); // Function is in r4.
+
+ InstanceofStub stub(isolate(), InstanceofStub::kArgsInRegisters);
+ CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
+
+ Label equal, done;
+ __ cmpi(r3, Operand::Zero());
+ __ beq(&equal);
+ __ mov(r3, Operand(factory()->false_value()));
+ __ b(&done);
+
+ __ bind(&equal);
+ __ mov(r3, Operand(factory()->true_value()));
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
+ class DeferredInstanceOfKnownGlobal FINAL : public LDeferredCode {
+ public:
+ DeferredInstanceOfKnownGlobal(LCodeGen* codegen,
+ LInstanceOfKnownGlobal* instr)
+ : LDeferredCode(codegen), instr_(instr) {}
+ virtual void Generate() OVERRIDE {
+ codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_);
+ }
+ virtual LInstruction* instr() OVERRIDE { return instr_; }
+ Label* map_check() { return &map_check_; }
+
+ private:
+ LInstanceOfKnownGlobal* instr_;
+ Label map_check_;
+ };
+
+ DeferredInstanceOfKnownGlobal* deferred;
+ deferred = new (zone()) DeferredInstanceOfKnownGlobal(this, instr);
+
+ Label done, false_result;
+ Register object = ToRegister(instr->value());
+ Register temp = ToRegister(instr->temp());
+ Register result = ToRegister(instr->result());
+
+ // A Smi is not instance of anything.
+ __ JumpIfSmi(object, &false_result);
+
+ // This is the inlined call site instanceof cache. The two occurences of the
+ // hole value will be patched to the last map/result pair generated by the
+ // instanceof stub.
+ Label cache_miss;
+ Register map = temp;
+ __ LoadP(map, FieldMemOperand(object, HeapObject::kMapOffset));
+ {
+ // Block constant pool emission to ensure the positions of instructions are
+ // as expected by the patcher. See InstanceofStub::Generate().
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);
+ __ bind(deferred->map_check()); // Label for calculating code patching.
+ // We use Factory::the_hole_value() on purpose instead of loading from the
+ // root array to force relocation to be able to later patch with
+ // the cached map.
+ Handle<Cell> cell = factory()->NewCell(factory()->the_hole_value());
+ __ mov(ip, Operand(Handle<Object>(cell)));
+ __ LoadP(ip, FieldMemOperand(ip, PropertyCell::kValueOffset));
+ __ cmp(map, ip);
+ __ bne(&cache_miss);
+ // We use Factory::the_hole_value() on purpose instead of loading from the
+ // root array to force relocation to be able to later patch
+ // with true or false.
+ __ mov(result, Operand(factory()->the_hole_value()));
+ }
+ __ b(&done);
+
+ // The inlined call site cache did not match. Check null and string before
+ // calling the deferred code.
+ __ bind(&cache_miss);
+ // Null is not instance of anything.
+ __ LoadRoot(ip, Heap::kNullValueRootIndex);
+ __ cmp(object, ip);
+ __ beq(&false_result);
+
+ // String values is not instance of anything.
+ Condition is_string = masm_->IsObjectStringType(object, temp);
+ __ b(is_string, &false_result, cr0);
+
+ // Go to the deferred code.
+ __ b(deferred->entry());
+
+ __ bind(&false_result);
+ __ LoadRoot(result, Heap::kFalseValueRootIndex);
+
+ // Here result has either true or false. Deferred code also produces true or
+ // false object.
+ __ bind(deferred->exit());
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoDeferredInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr,
+ Label* map_check) {
+ InstanceofStub::Flags flags = InstanceofStub::kNoFlags;
+ flags = static_cast<InstanceofStub::Flags>(flags |
+ InstanceofStub::kArgsInRegisters);
+ flags = static_cast<InstanceofStub::Flags>(
+ flags | InstanceofStub::kCallSiteInlineCheck);
+ flags = static_cast<InstanceofStub::Flags>(
+ flags | InstanceofStub::kReturnTrueFalseObject);
+ InstanceofStub stub(isolate(), flags);
+
+ PushSafepointRegistersScope scope(this);
+ LoadContextFromDeferred(instr->context());
+
+ __ Move(InstanceofStub::right(), instr->function());
+ // Include instructions below in delta: mov + call = mov + (mov + 2)
+ static const int kAdditionalDelta = (2 * Assembler::kMovInstructions) + 2;
+ int delta = masm_->InstructionsGeneratedSince(map_check) + kAdditionalDelta;
+ {
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);
+ // r8 is used to communicate the offset to the location of the map check.
+ __ mov(r8, Operand(delta * Instruction::kInstrSize));
+ }
+ CallCodeGeneric(stub.GetCode(), RelocInfo::CODE_TARGET, instr,
+ RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
+ DCHECK(delta == masm_->InstructionsGeneratedSince(map_check));
+ LEnvironment* env = instr->GetDeferredLazyDeoptimizationEnvironment();
+ safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
+ // Put the result value (r3) into the result register slot and
+ // restore all registers.
+ __ StoreToSafepointRegisterSlot(r3, ToRegister(instr->result()));
+}
+
+
+void LCodeGen::DoCmpT(LCmpT* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ Token::Value op = instr->op();
+
+ Handle<Code> ic = CodeFactory::CompareIC(isolate(), op).code();
+ CallCode(ic, RelocInfo::CODE_TARGET, instr);
+ // This instruction also signals no smi code inlined
+ __ cmpi(r3, Operand::Zero());
+
+ Condition condition = ComputeCompareCondition(op);
+ Label true_value, done;
+
+ __ b(condition, &true_value);
+
+ __ LoadRoot(ToRegister(instr->result()), Heap::kFalseValueRootIndex);
+ __ b(&done);
+
+ __ bind(&true_value);
+ __ LoadRoot(ToRegister(instr->result()), Heap::kTrueValueRootIndex);
+
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoReturn(LReturn* instr) {
+ if (FLAG_trace && info()->IsOptimizing()) {
+ // Push the return value on the stack as the parameter.
+ // Runtime::TraceExit returns its parameter in r3. We're leaving the code
+ // managed by the register allocator and tearing down the frame, it's
+ // safe to write to the context register.
+ __ push(r3);
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ __ CallRuntime(Runtime::kTraceExit, 1);
+ }
+ if (info()->saves_caller_doubles()) {
+ RestoreCallerDoubles();
+ }
+ int no_frame_start = -1;
+ if (instr->has_constant_parameter_count()) {
+ int parameter_count = ToInteger32(instr->constant_parameter_count());
+ int32_t sp_delta = (parameter_count + 1) * kPointerSize;
+ if (NeedsEagerFrame()) {
+ no_frame_start = masm_->LeaveFrame(StackFrame::JAVA_SCRIPT, sp_delta);
+ } else if (sp_delta != 0) {
+ __ addi(sp, sp, Operand(sp_delta));
+ }
+ } else {
+ Register reg = ToRegister(instr->parameter_count());
+ // The argument count parameter is a smi
+ if (NeedsEagerFrame()) {
+ no_frame_start = masm_->LeaveFrame(StackFrame::JAVA_SCRIPT);
+ }
+ __ SmiToPtrArrayOffset(r0, reg);
+ __ add(sp, sp, r0);
+ }
+
+ __ blr();
+
+ if (no_frame_start != -1) {
+ info_->AddNoFrameRange(no_frame_start, masm_->pc_offset());
+ }
+}
+
+
+void LCodeGen::DoLoadGlobalCell(LLoadGlobalCell* instr) {
+ Register result = ToRegister(instr->result());
+ __ mov(ip, Operand(Handle<Object>(instr->hydrogen()->cell().handle())));
+ __ LoadP(result, FieldMemOperand(ip, Cell::kValueOffset));
+ if (instr->hydrogen()->RequiresHoleCheck()) {
+ __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
+ __ cmp(result, ip);
+ DeoptimizeIf(eq, instr, "hole");
+ }
+}
+
+
+template <class T>
+void LCodeGen::EmitVectorLoadICRegisters(T* instr) {
+ DCHECK(FLAG_vector_ics);
+ Register vector = ToRegister(instr->temp_vector());
+ DCHECK(vector.is(VectorLoadICDescriptor::VectorRegister()));
+ __ Move(vector, instr->hydrogen()->feedback_vector());
+ // No need to allocate this register.
+ DCHECK(VectorLoadICDescriptor::SlotRegister().is(r3));
+ __ mov(VectorLoadICDescriptor::SlotRegister(),
+ Operand(Smi::FromInt(instr->hydrogen()->slot())));
+}
+
+
+void LCodeGen::DoLoadGlobalGeneric(LLoadGlobalGeneric* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->global_object())
+ .is(LoadDescriptor::ReceiverRegister()));
+ DCHECK(ToRegister(instr->result()).is(r3));
+
+ __ mov(LoadDescriptor::NameRegister(), Operand(instr->name()));
+ if (FLAG_vector_ics) {
+ EmitVectorLoadICRegisters<LLoadGlobalGeneric>(instr);
+ }
+ ContextualMode mode = instr->for_typeof() ? NOT_CONTEXTUAL : CONTEXTUAL;
+ Handle<Code> ic = CodeFactory::LoadIC(isolate(), mode).code();
+ CallCode(ic, RelocInfo::CODE_TARGET, instr);
+}
+
+
+void LCodeGen::DoStoreGlobalCell(LStoreGlobalCell* instr) {
+ Register value = ToRegister(instr->value());
+ Register cell = scratch0();
+
+ // Load the cell.
+ __ mov(cell, Operand(instr->hydrogen()->cell().handle()));
+
+ // If the cell we are storing to contains the hole it could have
+ // been deleted from the property dictionary. In that case, we need
+ // to update the property details in the property dictionary to mark
+ // it as no longer deleted.
+ if (instr->hydrogen()->RequiresHoleCheck()) {
+ // We use a temp to check the payload (CompareRoot might clobber ip).
+ Register payload = ToRegister(instr->temp());
+ __ LoadP(payload, FieldMemOperand(cell, Cell::kValueOffset));
+ __ CompareRoot(payload, Heap::kTheHoleValueRootIndex);
+ DeoptimizeIf(eq, instr, "hole");
+ }
+
+ // Store the value.
+ __ StoreP(value, FieldMemOperand(cell, Cell::kValueOffset), r0);
+ // Cells are always rescanned, so no write barrier here.
+}
+
+
+void LCodeGen::DoLoadContextSlot(LLoadContextSlot* instr) {
+ Register context = ToRegister(instr->context());
+ Register result = ToRegister(instr->result());
+ __ LoadP(result, ContextOperand(context, instr->slot_index()));
+ if (instr->hydrogen()->RequiresHoleCheck()) {
+ __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
+ __ cmp(result, ip);
+ if (instr->hydrogen()->DeoptimizesOnHole()) {
+ DeoptimizeIf(eq, instr, "hole");
+ } else {
+ Label skip;
+ __ bne(&skip);
+ __ mov(result, Operand(factory()->undefined_value()));
+ __ bind(&skip);
+ }
+ }
+}
+
+
+void LCodeGen::DoStoreContextSlot(LStoreContextSlot* instr) {
+ Register context = ToRegister(instr->context());
+ Register value = ToRegister(instr->value());
+ Register scratch = scratch0();
+ MemOperand target = ContextOperand(context, instr->slot_index());
+
+ Label skip_assignment;
+
+ if (instr->hydrogen()->RequiresHoleCheck()) {
+ __ LoadP(scratch, target);
+ __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
+ __ cmp(scratch, ip);
+ if (instr->hydrogen()->DeoptimizesOnHole()) {
+ DeoptimizeIf(eq, instr, "hole");
+ } else {
+ __ bne(&skip_assignment);
+ }
+ }
+
+ __ StoreP(value, target, r0);
+ if (instr->hydrogen()->NeedsWriteBarrier()) {
+ SmiCheck check_needed = instr->hydrogen()->value()->type().IsHeapObject()
+ ? OMIT_SMI_CHECK
+ : INLINE_SMI_CHECK;
+ __ RecordWriteContextSlot(context, target.offset(), value, scratch,
+ GetLinkRegisterState(), kSaveFPRegs,
+ EMIT_REMEMBERED_SET, check_needed);
+ }
+
+ __ bind(&skip_assignment);
+}
+
+
+void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
+ HObjectAccess access = instr->hydrogen()->access();
+ int offset = access.offset();
+ Register object = ToRegister(instr->object());
+
+ if (access.IsExternalMemory()) {
+ Register result = ToRegister(instr->result());
+ MemOperand operand = MemOperand(object, offset);
+ __ LoadRepresentation(result, operand, access.representation(), r0);
+ return;
+ }
+
+ if (instr->hydrogen()->representation().IsDouble()) {
+ DoubleRegister result = ToDoubleRegister(instr->result());
+ __ lfd(result, FieldMemOperand(object, offset));
+ return;
+ }
+
+ Register result = ToRegister(instr->result());
+ if (!access.IsInobject()) {
+ __ LoadP(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
+ object = result;
+ }
+
+ Representation representation = access.representation();
+
+#if V8_TARGET_ARCH_PPC64
+ // 64-bit Smi optimization
+ if (representation.IsSmi() &&
+ instr->hydrogen()->representation().IsInteger32()) {
+ // Read int value directly from upper half of the smi.
+ STATIC_ASSERT(kSmiTag == 0);
+ STATIC_ASSERT(kSmiTagSize + kSmiShiftSize == 32);
+#if V8_TARGET_LITTLE_ENDIAN
+ offset += kPointerSize / 2;
+#endif
+ representation = Representation::Integer32();
+ }
+#endif
+
+ __ LoadRepresentation(result, FieldMemOperand(object, offset), representation,
+ r0);
+}
+
+
+void LCodeGen::DoLoadNamedGeneric(LLoadNamedGeneric* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->object()).is(LoadDescriptor::ReceiverRegister()));
+ DCHECK(ToRegister(instr->result()).is(r3));
+
+ // Name is always in r5.
+ __ mov(LoadDescriptor::NameRegister(), Operand(instr->name()));
+ if (FLAG_vector_ics) {
+ EmitVectorLoadICRegisters<LLoadNamedGeneric>(instr);
+ }
+ Handle<Code> ic = CodeFactory::LoadIC(isolate(), NOT_CONTEXTUAL).code();
+ CallCode(ic, RelocInfo::CODE_TARGET, instr);
+}
+
+
+void LCodeGen::DoLoadFunctionPrototype(LLoadFunctionPrototype* instr) {
+ Register scratch = scratch0();
+ Register function = ToRegister(instr->function());
+ Register result = ToRegister(instr->result());
+
+ // Get the prototype or initial map from the function.
+ __ LoadP(result,
+ FieldMemOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
+
+ // Check that the function has a prototype or an initial map.
+ __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
+ __ cmp(result, ip);
+ DeoptimizeIf(eq, instr, "hole");
+
+ // If the function does not have an initial map, we're done.
+ Label done;
+ __ CompareObjectType(result, scratch, scratch, MAP_TYPE);
+ __ bne(&done);
+
+ // Get the prototype from the initial map.
+ __ LoadP(result, FieldMemOperand(result, Map::kPrototypeOffset));
+
+ // All done.
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoLoadRoot(LLoadRoot* instr) {
+ Register result = ToRegister(instr->result());
+ __ LoadRoot(result, instr->index());
+}
+
+
+void LCodeGen::DoAccessArgumentsAt(LAccessArgumentsAt* instr) {
+ Register arguments = ToRegister(instr->arguments());
+ Register result = ToRegister(instr->result());
+ // There are two words between the frame pointer and the last argument.
+ // Subtracting from length accounts for one of them add one more.
+ if (instr->length()->IsConstantOperand()) {
+ int const_length = ToInteger32(LConstantOperand::cast(instr->length()));
+ if (instr->index()->IsConstantOperand()) {
+ int const_index = ToInteger32(LConstantOperand::cast(instr->index()));
+ int index = (const_length - const_index) + 1;
+ __ LoadP(result, MemOperand(arguments, index * kPointerSize), r0);
+ } else {
+ Register index = ToRegister(instr->index());
+ __ subfic(result, index, Operand(const_length + 1));
+ __ ShiftLeftImm(result, result, Operand(kPointerSizeLog2));
+ __ LoadPX(result, MemOperand(arguments, result));
+ }
+ } else if (instr->index()->IsConstantOperand()) {
+ Register length = ToRegister(instr->length());
+ int const_index = ToInteger32(LConstantOperand::cast(instr->index()));
+ int loc = const_index - 1;
+ if (loc != 0) {
+ __ subi(result, length, Operand(loc));
+ __ ShiftLeftImm(result, result, Operand(kPointerSizeLog2));
+ __ LoadPX(result, MemOperand(arguments, result));
+ } else {
+ __ ShiftLeftImm(result, length, Operand(kPointerSizeLog2));
+ __ LoadPX(result, MemOperand(arguments, result));
+ }
+ } else {
+ Register length = ToRegister(instr->length());
+ Register index = ToRegister(instr->index());
+ __ sub(result, length, index);
+ __ addi(result, result, Operand(1));
+ __ ShiftLeftImm(result, result, Operand(kPointerSizeLog2));
+ __ LoadPX(result, MemOperand(arguments, result));
+ }
+}
+
+
+void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
+ Register external_pointer = ToRegister(instr->elements());
+ Register key = no_reg;
+ ElementsKind elements_kind = instr->elements_kind();
+ bool key_is_constant = instr->key()->IsConstantOperand();
+ int constant_key = 0;
+ if (key_is_constant) {
+ constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
+ if (constant_key & 0xF0000000) {
+ Abort(kArrayIndexConstantValueTooBig);
+ }
+ } else {
+ key = ToRegister(instr->key());
+ }
+ int element_size_shift = ElementsKindToShiftSize(elements_kind);
+ bool key_is_smi = instr->hydrogen()->key()->representation().IsSmi();
+ int base_offset = instr->base_offset();
+
+ if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
+ elements_kind == FLOAT32_ELEMENTS ||
+ elements_kind == EXTERNAL_FLOAT64_ELEMENTS ||
+ elements_kind == FLOAT64_ELEMENTS) {
+ DoubleRegister result = ToDoubleRegister(instr->result());
+ if (key_is_constant) {
+ __ Add(scratch0(), external_pointer, constant_key << element_size_shift,
+ r0);
+ } else {
+ __ IndexToArrayOffset(r0, key, element_size_shift, key_is_smi);
+ __ add(scratch0(), external_pointer, r0);
+ }
+ if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
+ elements_kind == FLOAT32_ELEMENTS) {
+ __ lfs(result, MemOperand(scratch0(), base_offset));
+ } else { // i.e. elements_kind == EXTERNAL_DOUBLE_ELEMENTS
+ __ lfd(result, MemOperand(scratch0(), base_offset));
+ }
+ } else {
+ Register result = ToRegister(instr->result());
+ MemOperand mem_operand =
+ PrepareKeyedOperand(key, external_pointer, key_is_constant, key_is_smi,
+ constant_key, element_size_shift, base_offset);
+ switch (elements_kind) {
+ case EXTERNAL_INT8_ELEMENTS:
+ case INT8_ELEMENTS:
+ if (key_is_constant) {
+ __ LoadByte(result, mem_operand, r0);
+ } else {
+ __ lbzx(result, mem_operand);
+ }
+ __ extsb(result, result);
+ break;
+ case EXTERNAL_UINT8_CLAMPED_ELEMENTS:
+ case EXTERNAL_UINT8_ELEMENTS:
+ case UINT8_ELEMENTS:
+ case UINT8_CLAMPED_ELEMENTS:
+ if (key_is_constant) {
+ __ LoadByte(result, mem_operand, r0);
+ } else {
+ __ lbzx(result, mem_operand);
+ }
+ break;
+ case EXTERNAL_INT16_ELEMENTS:
+ case INT16_ELEMENTS:
+ if (key_is_constant) {
+ __ LoadHalfWord(result, mem_operand, r0);
+ } else {
+ __ lhzx(result, mem_operand);
+ }
+ __ extsh(result, result);
+ break;
+ case EXTERNAL_UINT16_ELEMENTS:
+ case UINT16_ELEMENTS:
+ if (key_is_constant) {
+ __ LoadHalfWord(result, mem_operand, r0);
+ } else {
+ __ lhzx(result, mem_operand);
+ }
+ break;
+ case EXTERNAL_INT32_ELEMENTS:
+ case INT32_ELEMENTS:
+ if (key_is_constant) {
+ __ LoadWord(result, mem_operand, r0);
+ } else {
+ __ lwzx(result, mem_operand);
+ }
+#if V8_TARGET_ARCH_PPC64
+ __ extsw(result, result);
+#endif
+ break;
+ case EXTERNAL_UINT32_ELEMENTS:
+ case UINT32_ELEMENTS:
+ if (key_is_constant) {
+ __ LoadWord(result, mem_operand, r0);
+ } else {
+ __ lwzx(result, mem_operand);
+ }
+ if (!instr->hydrogen()->CheckFlag(HInstruction::kUint32)) {
+ __ lis(r0, Operand(SIGN_EXT_IMM16(0x8000)));
+ __ cmplw(result, r0);
+ DeoptimizeIf(ge, instr, "negative value");
+ }
+ break;
+ case FLOAT32_ELEMENTS:
+ case FLOAT64_ELEMENTS:
+ case EXTERNAL_FLOAT32_ELEMENTS:
+ case EXTERNAL_FLOAT64_ELEMENTS:
+ case FAST_HOLEY_DOUBLE_ELEMENTS:
+ case FAST_HOLEY_ELEMENTS:
+ case FAST_HOLEY_SMI_ELEMENTS:
+ case FAST_DOUBLE_ELEMENTS:
+ case FAST_ELEMENTS:
+ case FAST_SMI_ELEMENTS:
+ case DICTIONARY_ELEMENTS:
+ case SLOPPY_ARGUMENTS_ELEMENTS:
+ UNREACHABLE();
+ break;
+ }
+ }
+}
+
+
+void LCodeGen::DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr) {
+ Register elements = ToRegister(instr->elements());
+ bool key_is_constant = instr->key()->IsConstantOperand();
+ Register key = no_reg;
+ DoubleRegister result = ToDoubleRegister(instr->result());
+ Register scratch = scratch0();
+
+ int element_size_shift = ElementsKindToShiftSize(FAST_DOUBLE_ELEMENTS);
+ bool key_is_smi = instr->hydrogen()->key()->representation().IsSmi();
+ int constant_key = 0;
+ if (key_is_constant) {
+ constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
+ if (constant_key & 0xF0000000) {
+ Abort(kArrayIndexConstantValueTooBig);
+ }
+ } else {
+ key = ToRegister(instr->key());
+ }
+
+ int base_offset = instr->base_offset() + constant_key * kDoubleSize;
+ if (!key_is_constant) {
+ __ IndexToArrayOffset(r0, key, element_size_shift, key_is_smi);
+ __ add(scratch, elements, r0);
+ elements = scratch;
+ }
+ if (!is_int16(base_offset)) {
+ __ Add(scratch, elements, base_offset, r0);
+ base_offset = 0;
+ elements = scratch;
+ }
+ __ lfd(result, MemOperand(elements, base_offset));
+
+ if (instr->hydrogen()->RequiresHoleCheck()) {
+ if (is_int16(base_offset + Register::kExponentOffset)) {
+ __ lwz(scratch,
+ MemOperand(elements, base_offset + Register::kExponentOffset));
+ } else {
+ __ addi(scratch, elements, Operand(base_offset));
+ __ lwz(scratch, MemOperand(scratch, Register::kExponentOffset));
+ }
+ __ Cmpi(scratch, Operand(kHoleNanUpper32), r0);
+ DeoptimizeIf(eq, instr, "hole");
+ }
+}
+
+
+void LCodeGen::DoLoadKeyedFixedArray(LLoadKeyed* instr) {
+ HLoadKeyed* hinstr = instr->hydrogen();
+ Register elements = ToRegister(instr->elements());
+ Register result = ToRegister(instr->result());
+ Register scratch = scratch0();
+ Register store_base = scratch;
+ int offset = instr->base_offset();
+
+ if (instr->key()->IsConstantOperand()) {
+ LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
+ offset += ToInteger32(const_operand) * kPointerSize;
+ store_base = elements;
+ } else {
+ Register key = ToRegister(instr->key());
+ // Even though the HLoadKeyed instruction forces the input
+ // representation for the key to be an integer, the input gets replaced
+ // during bound check elimination with the index argument to the bounds
+ // check, which can be tagged, so that case must be handled here, too.
+ if (hinstr->key()->representation().IsSmi()) {
+ __ SmiToPtrArrayOffset(r0, key);
+ } else {
+ __ ShiftLeftImm(r0, key, Operand(kPointerSizeLog2));
+ }
+ __ add(scratch, elements, r0);
+ }
+
+ bool requires_hole_check = hinstr->RequiresHoleCheck();
+ Representation representation = hinstr->representation();
+
+#if V8_TARGET_ARCH_PPC64
+ // 64-bit Smi optimization
+ if (representation.IsInteger32() &&
+ hinstr->elements_kind() == FAST_SMI_ELEMENTS) {
+ DCHECK(!requires_hole_check);
+ // Read int value directly from upper half of the smi.
+ STATIC_ASSERT(kSmiTag == 0);
+ STATIC_ASSERT(kSmiTagSize + kSmiShiftSize == 32);
+#if V8_TARGET_LITTLE_ENDIAN
+ offset += kPointerSize / 2;
+#endif
+ }
+#endif
+
+ __ LoadRepresentation(result, MemOperand(store_base, offset), representation,
+ r0);
+
+ // Check for the hole value.
+ if (requires_hole_check) {
+ if (IsFastSmiElementsKind(hinstr->elements_kind())) {
+ __ TestIfSmi(result, r0);
+ DeoptimizeIf(ne, instr, "not a Smi", cr0);
+ } else {
+ __ LoadRoot(scratch, Heap::kTheHoleValueRootIndex);
+ __ cmp(result, scratch);
+ DeoptimizeIf(eq, instr, "hole");
+ }
+ }
+}
+
+
+void LCodeGen::DoLoadKeyed(LLoadKeyed* instr) {
+ if (instr->is_typed_elements()) {
+ DoLoadKeyedExternalArray(instr);
+ } else if (instr->hydrogen()->representation().IsDouble()) {
+ DoLoadKeyedFixedDoubleArray(instr);
+ } else {
+ DoLoadKeyedFixedArray(instr);
+ }
+}
+
+
+MemOperand LCodeGen::PrepareKeyedOperand(Register key, Register base,
+ bool key_is_constant, bool key_is_smi,
+ int constant_key,
+ int element_size_shift,
+ int base_offset) {
+ Register scratch = scratch0();
+
+ if (key_is_constant) {
+ return MemOperand(base, (constant_key << element_size_shift) + base_offset);
+ }
+
+ bool needs_shift =
+ (element_size_shift != (key_is_smi ? kSmiTagSize + kSmiShiftSize : 0));
+
+ if (!(base_offset || needs_shift)) {
+ return MemOperand(base, key);
+ }
+
+ if (needs_shift) {
+ __ IndexToArrayOffset(scratch, key, element_size_shift, key_is_smi);
+ key = scratch;
+ }
+
+ if (base_offset) {
+ __ Add(scratch, key, base_offset, r0);
+ }
+
+ return MemOperand(base, scratch);
+}
+
+
+void LCodeGen::DoLoadKeyedGeneric(LLoadKeyedGeneric* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->object()).is(LoadDescriptor::ReceiverRegister()));
+ DCHECK(ToRegister(instr->key()).is(LoadDescriptor::NameRegister()));
+
+ if (FLAG_vector_ics) {
+ EmitVectorLoadICRegisters<LLoadKeyedGeneric>(instr);
+ }
+
+ Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
+ CallCode(ic, RelocInfo::CODE_TARGET, instr);
+}
+
+
+void LCodeGen::DoArgumentsElements(LArgumentsElements* instr) {
+ Register scratch = scratch0();
+ Register result = ToRegister(instr->result());
+
+ if (instr->hydrogen()->from_inlined()) {
+ __ subi(result, sp, Operand(2 * kPointerSize));
+ } else {
+ // Check if the calling frame is an arguments adaptor frame.
+ Label done, adapted;
+ __ LoadP(scratch, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+ __ LoadP(result,
+ MemOperand(scratch, StandardFrameConstants::kContextOffset));
+ __ CmpSmiLiteral(result, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
+
+ // Result is the frame pointer for the frame if not adapted and for the real
+ // frame below the adaptor frame if adapted.
+ __ beq(&adapted);
+ __ mr(result, fp);
+ __ b(&done);
+
+ __ bind(&adapted);
+ __ mr(result, scratch);
+ __ bind(&done);
+ }
+}
+
+
+void LCodeGen::DoArgumentsLength(LArgumentsLength* instr) {
+ Register elem = ToRegister(instr->elements());
+ Register result = ToRegister(instr->result());
+
+ Label done;
+
+ // If no arguments adaptor frame the number of arguments is fixed.
+ __ cmp(fp, elem);
+ __ mov(result, Operand(scope()->num_parameters()));
+ __ beq(&done);
+
+ // Arguments adaptor frame present. Get argument length from there.
+ __ LoadP(result, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+ __ LoadP(result,
+ MemOperand(result, ArgumentsAdaptorFrameConstants::kLengthOffset));
+ __ SmiUntag(result);
+
+ // Argument length is in result register.
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoWrapReceiver(LWrapReceiver* instr) {
+ Register receiver = ToRegister(instr->receiver());
+ Register function = ToRegister(instr->function());
+ Register result = ToRegister(instr->result());
+ Register scratch = scratch0();
+
+ // If the receiver is null or undefined, we have to pass the global
+ // object as a receiver to normal functions. Values have to be
+ // passed unchanged to builtins and strict-mode functions.
+ Label global_object, result_in_receiver;
+
+ if (!instr->hydrogen()->known_function()) {
+ // Do not transform the receiver to object for strict mode
+ // functions.
+ __ LoadP(scratch,
+ FieldMemOperand(function, JSFunction::kSharedFunctionInfoOffset));
+ __ lwz(scratch,
+ FieldMemOperand(scratch, SharedFunctionInfo::kCompilerHintsOffset));
+ __ TestBit(scratch,
+#if V8_TARGET_ARCH_PPC64
+ SharedFunctionInfo::kStrictModeFunction,
+#else
+ SharedFunctionInfo::kStrictModeFunction + kSmiTagSize,
+#endif
+ r0);
+ __ bne(&result_in_receiver, cr0);
+
+ // Do not transform the receiver to object for builtins.
+ __ TestBit(scratch,
+#if V8_TARGET_ARCH_PPC64
+ SharedFunctionInfo::kNative,
+#else
+ SharedFunctionInfo::kNative + kSmiTagSize,
+#endif
+ r0);
+ __ bne(&result_in_receiver, cr0);
+ }
+
+ // Normal function. Replace undefined or null with global receiver.
+ __ LoadRoot(scratch, Heap::kNullValueRootIndex);
+ __ cmp(receiver, scratch);
+ __ beq(&global_object);
+ __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
+ __ cmp(receiver, scratch);
+ __ beq(&global_object);
+
+ // Deoptimize if the receiver is not a JS object.
+ __ TestIfSmi(receiver, r0);
+ DeoptimizeIf(eq, instr, "Smi");
+ __ CompareObjectType(receiver, scratch, scratch, FIRST_SPEC_OBJECT_TYPE);
+ DeoptimizeIf(lt, instr, "not a JavaScript object");
+
+ __ b(&result_in_receiver);
+ __ bind(&global_object);
+ __ LoadP(result, FieldMemOperand(function, JSFunction::kContextOffset));
+ __ LoadP(result, ContextOperand(result, Context::GLOBAL_OBJECT_INDEX));
+ __ LoadP(result, FieldMemOperand(result, GlobalObject::kGlobalProxyOffset));
+ if (result.is(receiver)) {
+ __ bind(&result_in_receiver);
+ } else {
+ Label result_ok;
+ __ b(&result_ok);
+ __ bind(&result_in_receiver);
+ __ mr(result, receiver);
+ __ bind(&result_ok);
+ }
+}
+
+
+void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
+ Register receiver = ToRegister(instr->receiver());
+ Register function = ToRegister(instr->function());
+ Register length = ToRegister(instr->length());
+ Register elements = ToRegister(instr->elements());
+ Register scratch = scratch0();
+ DCHECK(receiver.is(r3)); // Used for parameter count.
+ DCHECK(function.is(r4)); // Required by InvokeFunction.
+ DCHECK(ToRegister(instr->result()).is(r3));
+
+ // Copy the arguments to this function possibly from the
+ // adaptor frame below it.
+ const uint32_t kArgumentsLimit = 1 * KB;
+ __ cmpli(length, Operand(kArgumentsLimit));
+ DeoptimizeIf(gt, instr, "too many arguments");
+
+ // Push the receiver and use the register to keep the original
+ // number of arguments.
+ __ push(receiver);
+ __ mr(receiver, length);
+ // The arguments are at a one pointer size offset from elements.
+ __ addi(elements, elements, Operand(1 * kPointerSize));
+
+ // Loop through the arguments pushing them onto the execution
+ // stack.
+ Label invoke, loop;
+ // length is a small non-negative integer, due to the test above.
+ __ cmpi(length, Operand::Zero());
+ __ beq(&invoke);
+ __ mtctr(length);
+ __ bind(&loop);
+ __ ShiftLeftImm(r0, length, Operand(kPointerSizeLog2));
+ __ LoadPX(scratch, MemOperand(elements, r0));
+ __ push(scratch);
+ __ addi(length, length, Operand(-1));
+ __ bdnz(&loop);
+
+ __ bind(&invoke);
+ DCHECK(instr->HasPointerMap());
+ LPointerMap* pointers = instr->pointer_map();
+ SafepointGenerator safepoint_generator(this, pointers, Safepoint::kLazyDeopt);
+ // The number of arguments is stored in receiver which is r3, as expected
+ // by InvokeFunction.
+ ParameterCount actual(receiver);
+ __ InvokeFunction(function, actual, CALL_FUNCTION, safepoint_generator);
+}
+
+
+void LCodeGen::DoPushArgument(LPushArgument* instr) {
+ LOperand* argument = instr->value();
+ if (argument->IsDoubleRegister() || argument->IsDoubleStackSlot()) {
+ Abort(kDoPushArgumentNotImplementedForDoubleType);
+ } else {
+ Register argument_reg = EmitLoadRegister(argument, ip);
+ __ push(argument_reg);
+ }
+}
+
+
+void LCodeGen::DoDrop(LDrop* instr) { __ Drop(instr->count()); }
+
+
+void LCodeGen::DoThisFunction(LThisFunction* instr) {
+ Register result = ToRegister(instr->result());
+ __ LoadP(result, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
+}
+
+
+void LCodeGen::DoContext(LContext* instr) {
+ // If there is a non-return use, the context must be moved to a register.
+ Register result = ToRegister(instr->result());
+ if (info()->IsOptimizing()) {
+ __ LoadP(result, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ } else {
+ // If there is no frame, the context must be in cp.
+ DCHECK(result.is(cp));
+ }
+}
+
+
+void LCodeGen::DoDeclareGlobals(LDeclareGlobals* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ __ push(cp); // The context is the first argument.
+ __ Move(scratch0(), instr->hydrogen()->pairs());
+ __ push(scratch0());
+ __ LoadSmiLiteral(scratch0(), Smi::FromInt(instr->hydrogen()->flags()));
+ __ push(scratch0());
+ CallRuntime(Runtime::kDeclareGlobals, 3, instr);
+}
+
+
+void LCodeGen::CallKnownFunction(Handle<JSFunction> function,
+ int formal_parameter_count, int arity,
+ LInstruction* instr, R4State r4_state) {
+ bool dont_adapt_arguments =
+ formal_parameter_count == SharedFunctionInfo::kDontAdaptArgumentsSentinel;
+ bool can_invoke_directly =
+ dont_adapt_arguments || formal_parameter_count == arity;
+
+ LPointerMap* pointers = instr->pointer_map();
+
+ if (can_invoke_directly) {
+ if (r4_state == R4_UNINITIALIZED) {
+ __ Move(r4, function);
+ }
+
+ // Change context.
+ __ LoadP(cp, FieldMemOperand(r4, JSFunction::kContextOffset));
+
+ // Set r3 to arguments count if adaption is not needed. Assumes that r3
+ // is available to write to at this point.
+ if (dont_adapt_arguments) {
+ __ mov(r3, Operand(arity));
+ }
+
+ bool is_self_call = function.is_identical_to(info()->closure());
+
+ // Invoke function.
+ if (is_self_call) {
+ __ CallSelf();
+ } else {
+ __ LoadP(ip, FieldMemOperand(r4, JSFunction::kCodeEntryOffset));
+ __ CallJSEntry(ip);
+ }
+
+ // Set up deoptimization.
+ RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
+ } else {
+ SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
+ ParameterCount count(arity);
+ ParameterCount expected(formal_parameter_count);
+ __ InvokeFunction(function, expected, count, CALL_FUNCTION, generator);
+ }
+}
+
+
+void LCodeGen::DoDeferredMathAbsTaggedHeapNumber(LMathAbs* instr) {
+ DCHECK(instr->context() != NULL);
+ DCHECK(ToRegister(instr->context()).is(cp));
+ Register input = ToRegister(instr->value());
+ Register result = ToRegister(instr->result());
+ Register scratch = scratch0();
+
+ // Deoptimize if not a heap number.
+ __ LoadP(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
+ __ LoadRoot(ip, Heap::kHeapNumberMapRootIndex);
+ __ cmp(scratch, ip);
+ DeoptimizeIf(ne, instr, "not a heap number");
+
+ Label done;
+ Register exponent = scratch0();
+ scratch = no_reg;
+ __ lwz(exponent, FieldMemOperand(input, HeapNumber::kExponentOffset));
+ // Check the sign of the argument. If the argument is positive, just
+ // return it.
+ __ cmpwi(exponent, Operand::Zero());
+ // Move the input to the result if necessary.
+ __ Move(result, input);
+ __ bge(&done);
+
+ // Input is negative. Reverse its sign.
+ // Preserve the value of all registers.
+ {
+ PushSafepointRegistersScope scope(this);
+
+ // Registers were saved at the safepoint, so we can use
+ // many scratch registers.
+ Register tmp1 = input.is(r4) ? r3 : r4;
+ Register tmp2 = input.is(r5) ? r3 : r5;
+ Register tmp3 = input.is(r6) ? r3 : r6;
+ Register tmp4 = input.is(r7) ? r3 : r7;
+
+ // exponent: floating point exponent value.
+
+ Label allocated, slow;
+ __ LoadRoot(tmp4, Heap::kHeapNumberMapRootIndex);
+ __ AllocateHeapNumber(tmp1, tmp2, tmp3, tmp4, &slow);
+ __ b(&allocated);
+
+ // Slow case: Call the runtime system to do the number allocation.
+ __ bind(&slow);
+
+ CallRuntimeFromDeferred(Runtime::kAllocateHeapNumber, 0, instr,
+ instr->context());
+ // Set the pointer to the new heap number in tmp.
+ if (!tmp1.is(r3)) __ mr(tmp1, r3);
+ // Restore input_reg after call to runtime.
+ __ LoadFromSafepointRegisterSlot(input, input);
+ __ lwz(exponent, FieldMemOperand(input, HeapNumber::kExponentOffset));
+
+ __ bind(&allocated);
+ // exponent: floating point exponent value.
+ // tmp1: allocated heap number.
+ STATIC_ASSERT(HeapNumber::kSignMask == 0x80000000u);
+ __ clrlwi(exponent, exponent, Operand(1)); // clear sign bit
+ __ stw(exponent, FieldMemOperand(tmp1, HeapNumber::kExponentOffset));
+ __ lwz(tmp2, FieldMemOperand(input, HeapNumber::kMantissaOffset));
+ __ stw(tmp2, FieldMemOperand(tmp1, HeapNumber::kMantissaOffset));
+
+ __ StoreToSafepointRegisterSlot(tmp1, result);
+ }
+
+ __ bind(&done);
+}
+
+
+void LCodeGen::EmitMathAbs(LMathAbs* instr) {
+ Register input = ToRegister(instr->value());
+ Register result = ToRegister(instr->result());
+ Label done;
+ __ cmpi(input, Operand::Zero());
+ __ Move(result, input);
+ __ bge(&done);
+ __ li(r0, Operand::Zero()); // clear xer
+ __ mtxer(r0);
+ __ neg(result, result, SetOE, SetRC);
+ // Deoptimize on overflow.
+ DeoptimizeIf(overflow, instr, "overflow", cr0);
+ __ bind(&done);
+}
+
+
+#if V8_TARGET_ARCH_PPC64
+void LCodeGen::EmitInteger32MathAbs(LMathAbs* instr) {
+ Register input = ToRegister(instr->value());
+ Register result = ToRegister(instr->result());
+ Label done;
+ __ cmpwi(input, Operand::Zero());
+ __ Move(result, input);
+ __ bge(&done);
+
+ // Deoptimize on overflow.
+ __ lis(r0, Operand(SIGN_EXT_IMM16(0x8000)));
+ __ cmpw(input, r0);
+ DeoptimizeIf(eq, instr, "overflow");
+
+ __ neg(result, result);
+ __ bind(&done);
+}
+#endif
+
+
+void LCodeGen::DoMathAbs(LMathAbs* instr) {
+ // Class for deferred case.
+ class DeferredMathAbsTaggedHeapNumber FINAL : public LDeferredCode {
+ public:
+ DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen, LMathAbs* instr)
+ : LDeferredCode(codegen), instr_(instr) {}
+ virtual void Generate() OVERRIDE {
+ codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_);
+ }
+ virtual LInstruction* instr() OVERRIDE { return instr_; }
+
+ private:
+ LMathAbs* instr_;
+ };
+
+ Representation r = instr->hydrogen()->value()->representation();
+ if (r.IsDouble()) {
+ DoubleRegister input = ToDoubleRegister(instr->value());
+ DoubleRegister result = ToDoubleRegister(instr->result());
+ __ fabs(result, input);
+#if V8_TARGET_ARCH_PPC64
+ } else if (r.IsInteger32()) {
+ EmitInteger32MathAbs(instr);
+ } else if (r.IsSmi()) {
+#else
+ } else if (r.IsSmiOrInteger32()) {
+#endif
+ EmitMathAbs(instr);
+ } else {
+ // Representation is tagged.
+ DeferredMathAbsTaggedHeapNumber* deferred =
+ new (zone()) DeferredMathAbsTaggedHeapNumber(this, instr);
+ Register input = ToRegister(instr->value());
+ // Smi check.
+ __ JumpIfNotSmi(input, deferred->entry());
+ // If smi, handle it directly.
+ EmitMathAbs(instr);
+ __ bind(deferred->exit());
+ }
+}
+
+
+void LCodeGen::DoMathFloor(LMathFloor* instr) {
+ DoubleRegister input = ToDoubleRegister(instr->value());
+ Register result = ToRegister(instr->result());
+ Register input_high = scratch0();
+ Register scratch = ip;
+ Label done, exact;
+
+ __ TryInt32Floor(result, input, input_high, scratch, double_scratch0(), &done,
+ &exact);
+ DeoptimizeIf(al, instr, "lost precision or NaN");
+
+ __ bind(&exact);
+ if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ // Test for -0.
+ __ cmpi(result, Operand::Zero());
+ __ bne(&done);
+ __ cmpwi(input_high, Operand::Zero());
+ DeoptimizeIf(lt, instr, "minus zero");
+ }
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoMathRound(LMathRound* instr) {
+ DoubleRegister input = ToDoubleRegister(instr->value());
+ Register result = ToRegister(instr->result());
+ DoubleRegister double_scratch1 = ToDoubleRegister(instr->temp());
+ DoubleRegister input_plus_dot_five = double_scratch1;
+ Register scratch1 = scratch0();
+ Register scratch2 = ip;
+ DoubleRegister dot_five = double_scratch0();
+ Label convert, done;
+
+ __ LoadDoubleLiteral(dot_five, 0.5, r0);
+ __ fabs(double_scratch1, input);
+ __ fcmpu(double_scratch1, dot_five);
+ DeoptimizeIf(unordered, instr, "lost precision or NaN");
+ // If input is in [-0.5, -0], the result is -0.
+ // If input is in [+0, +0.5[, the result is +0.
+ // If the input is +0.5, the result is 1.
+ __ bgt(&convert); // Out of [-0.5, +0.5].
+ if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
+#if V8_TARGET_ARCH_PPC64
+ __ MovDoubleToInt64(scratch1, input);
+#else
+ __ MovDoubleHighToInt(scratch1, input);
+#endif
+ __ cmpi(scratch1, Operand::Zero());
+ // [-0.5, -0].
+ DeoptimizeIf(lt, instr, "minus zero");
+ }
+ Label return_zero;
+ __ fcmpu(input, dot_five);
+ __ bne(&return_zero);
+ __ li(result, Operand(1)); // +0.5.
+ __ b(&done);
+ // Remaining cases: [+0, +0.5[ or [-0.5, +0.5[, depending on
+ // flag kBailoutOnMinusZero.
+ __ bind(&return_zero);
+ __ li(result, Operand::Zero());
+ __ b(&done);
+
+ __ bind(&convert);
+ __ fadd(input_plus_dot_five, input, dot_five);
+ // Reuse dot_five (double_scratch0) as we no longer need this value.
+ __ TryInt32Floor(result, input_plus_dot_five, scratch1, scratch2,
+ double_scratch0(), &done, &done);
+ DeoptimizeIf(al, instr, "lost precision or NaN");
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoMathFround(LMathFround* instr) {
+ DoubleRegister input_reg = ToDoubleRegister(instr->value());
+ DoubleRegister output_reg = ToDoubleRegister(instr->result());
+ __ frsp(output_reg, input_reg);
+}
+
+
+void LCodeGen::DoMathSqrt(LMathSqrt* instr) {
+ DoubleRegister input = ToDoubleRegister(instr->value());
+ DoubleRegister result = ToDoubleRegister(instr->result());
+ __ fsqrt(result, input);
+}
+
+
+void LCodeGen::DoMathPowHalf(LMathPowHalf* instr) {
+ DoubleRegister input = ToDoubleRegister(instr->value());
+ DoubleRegister result = ToDoubleRegister(instr->result());
+ DoubleRegister temp = double_scratch0();
+
+ // Note that according to ECMA-262 15.8.2.13:
+ // Math.pow(-Infinity, 0.5) == Infinity
+ // Math.sqrt(-Infinity) == NaN
+ Label skip, done;
+
+ __ LoadDoubleLiteral(temp, -V8_INFINITY, scratch0());
+ __ fcmpu(input, temp);
+ __ bne(&skip);
+ __ fneg(result, temp);
+ __ b(&done);
+
+ // Add +0 to convert -0 to +0.
+ __ bind(&skip);
+ __ fadd(result, input, kDoubleRegZero);
+ __ fsqrt(result, result);
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoPower(LPower* instr) {
+ Representation exponent_type = instr->hydrogen()->right()->representation();
+// Having marked this as a call, we can use any registers.
+// Just make sure that the input/output registers are the expected ones.
+#ifdef DEBUG
+ Register tagged_exponent = MathPowTaggedDescriptor::exponent();
+#endif
+ DCHECK(!instr->right()->IsDoubleRegister() ||
+ ToDoubleRegister(instr->right()).is(d2));
+ DCHECK(!instr->right()->IsRegister() ||
+ ToRegister(instr->right()).is(tagged_exponent));
+ DCHECK(ToDoubleRegister(instr->left()).is(d1));
+ DCHECK(ToDoubleRegister(instr->result()).is(d3));
+
+ if (exponent_type.IsSmi()) {
+ MathPowStub stub(isolate(), MathPowStub::TAGGED);
+ __ CallStub(&stub);
+ } else if (exponent_type.IsTagged()) {
+ Label no_deopt;
+ __ JumpIfSmi(r5, &no_deopt);
+ __ LoadP(r10, FieldMemOperand(r5, HeapObject::kMapOffset));
+ __ LoadRoot(ip, Heap::kHeapNumberMapRootIndex);
+ __ cmp(r10, ip);
+ DeoptimizeIf(ne, instr, "not a heap number");
+ __ bind(&no_deopt);
+ MathPowStub stub(isolate(), MathPowStub::TAGGED);
+ __ CallStub(&stub);
+ } else if (exponent_type.IsInteger32()) {
+ MathPowStub stub(isolate(), MathPowStub::INTEGER);
+ __ CallStub(&stub);
+ } else {
+ DCHECK(exponent_type.IsDouble());
+ MathPowStub stub(isolate(), MathPowStub::DOUBLE);
+ __ CallStub(&stub);
+ }
+}
+
+
+void LCodeGen::DoMathExp(LMathExp* instr) {
+ DoubleRegister input = ToDoubleRegister(instr->value());
+ DoubleRegister result = ToDoubleRegister(instr->result());
+ DoubleRegister double_scratch1 = ToDoubleRegister(instr->double_temp());
+ DoubleRegister double_scratch2 = double_scratch0();
+ Register temp1 = ToRegister(instr->temp1());
+ Register temp2 = ToRegister(instr->temp2());
+
+ MathExpGenerator::EmitMathExp(masm(), input, result, double_scratch1,
+ double_scratch2, temp1, temp2, scratch0());
+}
+
+
+void LCodeGen::DoMathLog(LMathLog* instr) {
+ __ PrepareCallCFunction(0, 1, scratch0());
+ __ MovToFloatParameter(ToDoubleRegister(instr->value()));
+ __ CallCFunction(ExternalReference::math_log_double_function(isolate()), 0,
+ 1);
+ __ MovFromFloatResult(ToDoubleRegister(instr->result()));
+}
+
+
+void LCodeGen::DoMathClz32(LMathClz32* instr) {
+ Register input = ToRegister(instr->value());
+ Register result = ToRegister(instr->result());
+ __ cntlzw_(result, input);
+}
+
+
+void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->function()).is(r4));
+ DCHECK(instr->HasPointerMap());
+
+ Handle<JSFunction> known_function = instr->hydrogen()->known_function();
+ if (known_function.is_null()) {
+ LPointerMap* pointers = instr->pointer_map();
+ SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
+ ParameterCount count(instr->arity());
+ __ InvokeFunction(r4, count, CALL_FUNCTION, generator);
+ } else {
+ CallKnownFunction(known_function,
+ instr->hydrogen()->formal_parameter_count(),
+ instr->arity(), instr, R4_CONTAINS_TARGET);
+ }
+}
+
+
+void LCodeGen::DoTailCallThroughMegamorphicCache(
+ LTailCallThroughMegamorphicCache* instr) {
+ Register receiver = ToRegister(instr->receiver());
+ Register name = ToRegister(instr->name());
+ DCHECK(receiver.is(LoadDescriptor::ReceiverRegister()));
+ DCHECK(name.is(LoadDescriptor::NameRegister()));
+ DCHECK(receiver.is(r4));
+ DCHECK(name.is(r5));
+
+ Register scratch = r6;
+ Register extra = r7;
+ Register extra2 = r8;
+ Register extra3 = r9;
+
+ // Important for the tail-call.
+ bool must_teardown_frame = NeedsEagerFrame();
+
+ // The probe will tail call to a handler if found.
+ isolate()->stub_cache()->GenerateProbe(masm(), instr->hydrogen()->flags(),
+ must_teardown_frame, receiver, name,
+ scratch, extra, extra2, extra3);
+
+ // Tail call to miss if we ended up here.
+ if (must_teardown_frame) __ LeaveFrame(StackFrame::INTERNAL);
+ LoadIC::GenerateMiss(masm());
+}
+
+
+void LCodeGen::DoCallWithDescriptor(LCallWithDescriptor* instr) {
+ DCHECK(ToRegister(instr->result()).is(r3));
+
+ LPointerMap* pointers = instr->pointer_map();
+ SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
+
+ if (instr->target()->IsConstantOperand()) {
+ LConstantOperand* target = LConstantOperand::cast(instr->target());
+ Handle<Code> code = Handle<Code>::cast(ToHandle(target));
+ generator.BeforeCall(__ CallSize(code, RelocInfo::CODE_TARGET));
+ __ Call(code, RelocInfo::CODE_TARGET);
+ } else {
+ DCHECK(instr->target()->IsRegister());
+ Register target = ToRegister(instr->target());
+ generator.BeforeCall(__ CallSize(target));
+ __ addi(ip, target, Operand(Code::kHeaderSize - kHeapObjectTag));
+ __ CallJSEntry(ip);
+ }
+ generator.AfterCall();
+}
+
+
+void LCodeGen::DoCallJSFunction(LCallJSFunction* instr) {
+ DCHECK(ToRegister(instr->function()).is(r4));
+ DCHECK(ToRegister(instr->result()).is(r3));
+
+ if (instr->hydrogen()->pass_argument_count()) {
+ __ mov(r3, Operand(instr->arity()));
+ }
+
+ // Change context.
+ __ LoadP(cp, FieldMemOperand(r4, JSFunction::kContextOffset));
+
+ bool is_self_call = false;
+ if (instr->hydrogen()->function()->IsConstant()) {
+ HConstant* fun_const = HConstant::cast(instr->hydrogen()->function());
+ Handle<JSFunction> jsfun =
+ Handle<JSFunction>::cast(fun_const->handle(isolate()));
+ is_self_call = jsfun.is_identical_to(info()->closure());
+ }
+
+ if (is_self_call) {
+ __ CallSelf();
+ } else {
+ __ LoadP(ip, FieldMemOperand(r4, JSFunction::kCodeEntryOffset));
+ __ CallJSEntry(ip);
+ }
+
+ RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
+}
+
+
+void LCodeGen::DoCallFunction(LCallFunction* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->function()).is(r4));
+ DCHECK(ToRegister(instr->result()).is(r3));
+
+ int arity = instr->arity();
+ CallFunctionStub stub(isolate(), arity, instr->hydrogen()->function_flags());
+ CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
+}
+
+
+void LCodeGen::DoCallNew(LCallNew* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->constructor()).is(r4));
+ DCHECK(ToRegister(instr->result()).is(r3));
+
+ __ mov(r3, Operand(instr->arity()));
+ // No cell in r5 for construct type feedback in optimized code
+ __ LoadRoot(r5, Heap::kUndefinedValueRootIndex);
+ CallConstructStub stub(isolate(), NO_CALL_CONSTRUCTOR_FLAGS);
+ CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
+}
+
+
+void LCodeGen::DoCallNewArray(LCallNewArray* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->constructor()).is(r4));
+ DCHECK(ToRegister(instr->result()).is(r3));
+
+ __ mov(r3, Operand(instr->arity()));
+ __ LoadRoot(r5, Heap::kUndefinedValueRootIndex);
+ ElementsKind kind = instr->hydrogen()->elements_kind();
+ AllocationSiteOverrideMode override_mode =
+ (AllocationSite::GetMode(kind) == TRACK_ALLOCATION_SITE)
+ ? DISABLE_ALLOCATION_SITES
+ : DONT_OVERRIDE;
+
+ if (instr->arity() == 0) {
+ ArrayNoArgumentConstructorStub stub(isolate(), kind, override_mode);
+ CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
+ } else if (instr->arity() == 1) {
+ Label done;
+ if (IsFastPackedElementsKind(kind)) {
+ Label packed_case;
+ // We might need a change here
+ // look at the first argument
+ __ LoadP(r8, MemOperand(sp, 0));
+ __ cmpi(r8, Operand::Zero());
+ __ beq(&packed_case);
+
+ ElementsKind holey_kind = GetHoleyElementsKind(kind);
+ ArraySingleArgumentConstructorStub stub(isolate(), holey_kind,
+ override_mode);
+ CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
+ __ b(&done);
+ __ bind(&packed_case);
+ }
+
+ ArraySingleArgumentConstructorStub stub(isolate(), kind, override_mode);
+ CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
+ __ bind(&done);
+ } else {
+ ArrayNArgumentsConstructorStub stub(isolate(), kind, override_mode);
+ CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
+ }
+}
+
+
+void LCodeGen::DoCallRuntime(LCallRuntime* instr) {
+ CallRuntime(instr->function(), instr->arity(), instr);
+}
+
+
+void LCodeGen::DoStoreCodeEntry(LStoreCodeEntry* instr) {
+ Register function = ToRegister(instr->function());
+ Register code_object = ToRegister(instr->code_object());
+ __ addi(code_object, code_object,
+ Operand(Code::kHeaderSize - kHeapObjectTag));
+ __ StoreP(code_object,
+ FieldMemOperand(function, JSFunction::kCodeEntryOffset), r0);
+}
+
+
+void LCodeGen::DoInnerAllocatedObject(LInnerAllocatedObject* instr) {
+ Register result = ToRegister(instr->result());
+ Register base = ToRegister(instr->base_object());
+ if (instr->offset()->IsConstantOperand()) {
+ LConstantOperand* offset = LConstantOperand::cast(instr->offset());
+ __ Add(result, base, ToInteger32(offset), r0);
+ } else {
+ Register offset = ToRegister(instr->offset());
+ __ add(result, base, offset);
+ }
+}
+
+
+void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
+ HStoreNamedField* hinstr = instr->hydrogen();
+ Representation representation = instr->representation();
+
+ Register object = ToRegister(instr->object());
+ Register scratch = scratch0();
+ HObjectAccess access = hinstr->access();
+ int offset = access.offset();
+
+ if (access.IsExternalMemory()) {
+ Register value = ToRegister(instr->value());
+ MemOperand operand = MemOperand(object, offset);
+ __ StoreRepresentation(value, operand, representation, r0);
+ return;
+ }
+
+ __ AssertNotSmi(object);
+
+#if V8_TARGET_ARCH_PPC64
+ DCHECK(!representation.IsSmi() || !instr->value()->IsConstantOperand() ||
+ IsInteger32(LConstantOperand::cast(instr->value())));
+#else
+ DCHECK(!representation.IsSmi() || !instr->value()->IsConstantOperand() ||
+ IsSmi(LConstantOperand::cast(instr->value())));
+#endif
+ if (representation.IsDouble()) {
+ DCHECK(access.IsInobject());
+ DCHECK(!hinstr->has_transition());
+ DCHECK(!hinstr->NeedsWriteBarrier());
+ DoubleRegister value = ToDoubleRegister(instr->value());
+ __ stfd(value, FieldMemOperand(object, offset));
+ return;
+ }
+
+ if (hinstr->has_transition()) {
+ Handle<Map> transition = hinstr->transition_map();
+ AddDeprecationDependency(transition);
+ __ mov(scratch, Operand(transition));
+ __ StoreP(scratch, FieldMemOperand(object, HeapObject::kMapOffset), r0);
+ if (hinstr->NeedsWriteBarrierForMap()) {
+ Register temp = ToRegister(instr->temp());
+ // Update the write barrier for the map field.
+ __ RecordWriteForMap(object, scratch, temp, GetLinkRegisterState(),
+ kSaveFPRegs);
+ }
+ }
+
+ // Do the store.
+ Register value = ToRegister(instr->value());
+
+#if V8_TARGET_ARCH_PPC64
+ // 64-bit Smi optimization
+ if (representation.IsSmi() &&
+ hinstr->value()->representation().IsInteger32()) {
+ DCHECK(hinstr->store_mode() == STORE_TO_INITIALIZED_ENTRY);
+ // Store int value directly to upper half of the smi.
+ STATIC_ASSERT(kSmiTag == 0);
+ STATIC_ASSERT(kSmiTagSize + kSmiShiftSize == 32);
+#if V8_TARGET_LITTLE_ENDIAN
+ offset += kPointerSize / 2;
+#endif
+ representation = Representation::Integer32();
+ }
+#endif
+
+ if (access.IsInobject()) {
+ MemOperand operand = FieldMemOperand(object, offset);
+ __ StoreRepresentation(value, operand, representation, r0);
+ if (hinstr->NeedsWriteBarrier()) {
+ // Update the write barrier for the object for in-object properties.
+ __ RecordWriteField(
+ object, offset, value, scratch, GetLinkRegisterState(), kSaveFPRegs,
+ EMIT_REMEMBERED_SET, hinstr->SmiCheckForWriteBarrier(),
+ hinstr->PointersToHereCheckForValue());
+ }
+ } else {
+ __ LoadP(scratch, FieldMemOperand(object, JSObject::kPropertiesOffset));
+ MemOperand operand = FieldMemOperand(scratch, offset);
+ __ StoreRepresentation(value, operand, representation, r0);
+ if (hinstr->NeedsWriteBarrier()) {
+ // Update the write barrier for the properties array.
+ // object is used as a scratch register.
+ __ RecordWriteField(
+ scratch, offset, value, object, GetLinkRegisterState(), kSaveFPRegs,
+ EMIT_REMEMBERED_SET, hinstr->SmiCheckForWriteBarrier(),
+ hinstr->PointersToHereCheckForValue());
+ }
+ }
+}
+
+
+void LCodeGen::DoStoreNamedGeneric(LStoreNamedGeneric* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->object()).is(StoreDescriptor::ReceiverRegister()));
+ DCHECK(ToRegister(instr->value()).is(StoreDescriptor::ValueRegister()));
+
+ __ mov(StoreDescriptor::NameRegister(), Operand(instr->name()));
+ Handle<Code> ic = StoreIC::initialize_stub(isolate(), instr->strict_mode());
+ CallCode(ic, RelocInfo::CODE_TARGET, instr);
+}
+
+
+void LCodeGen::DoBoundsCheck(LBoundsCheck* instr) {
+ Representation representation = instr->hydrogen()->length()->representation();
+ DCHECK(representation.Equals(instr->hydrogen()->index()->representation()));
+ DCHECK(representation.IsSmiOrInteger32());
+
+ Condition cc = instr->hydrogen()->allow_equality() ? lt : le;
+ if (instr->length()->IsConstantOperand()) {
+ int32_t length = ToInteger32(LConstantOperand::cast(instr->length()));
+ Register index = ToRegister(instr->index());
+ if (representation.IsSmi()) {
+ __ Cmpli(index, Operand(Smi::FromInt(length)), r0);
+ } else {
+ __ Cmplwi(index, Operand(length), r0);
+ }
+ cc = CommuteCondition(cc);
+ } else if (instr->index()->IsConstantOperand()) {
+ int32_t index = ToInteger32(LConstantOperand::cast(instr->index()));
+ Register length = ToRegister(instr->length());
+ if (representation.IsSmi()) {
+ __ Cmpli(length, Operand(Smi::FromInt(index)), r0);
+ } else {
+ __ Cmplwi(length, Operand(index), r0);
+ }
+ } else {
+ Register index = ToRegister(instr->index());
+ Register length = ToRegister(instr->length());
+ if (representation.IsSmi()) {
+ __ cmpl(length, index);
+ } else {
+ __ cmplw(length, index);
+ }
+ }
+ if (FLAG_debug_code && instr->hydrogen()->skip_check()) {
+ Label done;
+ __ b(NegateCondition(cc), &done);
+ __ stop("eliminated bounds check failed");
+ __ bind(&done);
+ } else {
+ DeoptimizeIf(cc, instr, "out of bounds");
+ }
+}
+
+
+void LCodeGen::DoStoreKeyedExternalArray(LStoreKeyed* instr) {
+ Register external_pointer = ToRegister(instr->elements());
+ Register key = no_reg;
+ ElementsKind elements_kind = instr->elements_kind();
+ bool key_is_constant = instr->key()->IsConstantOperand();
+ int constant_key = 0;
+ if (key_is_constant) {
+ constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
+ if (constant_key & 0xF0000000) {
+ Abort(kArrayIndexConstantValueTooBig);
+ }
+ } else {
+ key = ToRegister(instr->key());
+ }
+ int element_size_shift = ElementsKindToShiftSize(elements_kind);
+ bool key_is_smi = instr->hydrogen()->key()->representation().IsSmi();
+ int base_offset = instr->base_offset();
+
+ if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
+ elements_kind == FLOAT32_ELEMENTS ||
+ elements_kind == EXTERNAL_FLOAT64_ELEMENTS ||
+ elements_kind == FLOAT64_ELEMENTS) {
+ Register address = scratch0();
+ DoubleRegister value(ToDoubleRegister(instr->value()));
+ if (key_is_constant) {
+ if (constant_key != 0) {
+ __ Add(address, external_pointer, constant_key << element_size_shift,
+ r0);
+ } else {
+ address = external_pointer;
+ }
+ } else {
+ __ IndexToArrayOffset(r0, key, element_size_shift, key_is_smi);
+ __ add(address, external_pointer, r0);
+ }
+ if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
+ elements_kind == FLOAT32_ELEMENTS) {
+ __ frsp(double_scratch0(), value);
+ __ stfs(double_scratch0(), MemOperand(address, base_offset));
+ } else { // Storing doubles, not floats.
+ __ stfd(value, MemOperand(address, base_offset));
+ }
+ } else {
+ Register value(ToRegister(instr->value()));
+ MemOperand mem_operand =
+ PrepareKeyedOperand(key, external_pointer, key_is_constant, key_is_smi,
+ constant_key, element_size_shift, base_offset);
+ switch (elements_kind) {
+ case EXTERNAL_UINT8_CLAMPED_ELEMENTS:
+ case EXTERNAL_INT8_ELEMENTS:
+ case EXTERNAL_UINT8_ELEMENTS:
+ case UINT8_ELEMENTS:
+ case UINT8_CLAMPED_ELEMENTS:
+ case INT8_ELEMENTS:
+ if (key_is_constant) {
+ __ StoreByte(value, mem_operand, r0);
+ } else {
+ __ stbx(value, mem_operand);
+ }
+ break;
+ case EXTERNAL_INT16_ELEMENTS:
+ case EXTERNAL_UINT16_ELEMENTS:
+ case INT16_ELEMENTS:
+ case UINT16_ELEMENTS:
+ if (key_is_constant) {
+ __ StoreHalfWord(value, mem_operand, r0);
+ } else {
+ __ sthx(value, mem_operand);
+ }
+ break;
+ case EXTERNAL_INT32_ELEMENTS:
+ case EXTERNAL_UINT32_ELEMENTS:
+ case INT32_ELEMENTS:
+ case UINT32_ELEMENTS:
+ if (key_is_constant) {
+ __ StoreWord(value, mem_operand, r0);
+ } else {
+ __ stwx(value, mem_operand);
+ }
+ break;
+ case FLOAT32_ELEMENTS:
+ case FLOAT64_ELEMENTS:
+ case EXTERNAL_FLOAT32_ELEMENTS:
+ case EXTERNAL_FLOAT64_ELEMENTS:
+ case FAST_DOUBLE_ELEMENTS:
+ case FAST_ELEMENTS:
+ case FAST_SMI_ELEMENTS:
+ case FAST_HOLEY_DOUBLE_ELEMENTS:
+ case FAST_HOLEY_ELEMENTS:
+ case FAST_HOLEY_SMI_ELEMENTS:
+ case DICTIONARY_ELEMENTS:
+ case SLOPPY_ARGUMENTS_ELEMENTS:
+ UNREACHABLE();
+ break;
+ }
+ }
+}
+
+
+void LCodeGen::DoStoreKeyedFixedDoubleArray(LStoreKeyed* instr) {
+ DoubleRegister value = ToDoubleRegister(instr->value());
+ Register elements = ToRegister(instr->elements());
+ Register key = no_reg;
+ Register scratch = scratch0();
+ DoubleRegister double_scratch = double_scratch0();
+ bool key_is_constant = instr->key()->IsConstantOperand();
+ int constant_key = 0;
+
+ // Calculate the effective address of the slot in the array to store the
+ // double value.
+ if (key_is_constant) {
+ constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
+ if (constant_key & 0xF0000000) {
+ Abort(kArrayIndexConstantValueTooBig);
+ }
+ } else {
+ key = ToRegister(instr->key());
+ }
+ int element_size_shift = ElementsKindToShiftSize(FAST_DOUBLE_ELEMENTS);
+ bool key_is_smi = instr->hydrogen()->key()->representation().IsSmi();
+ int base_offset = instr->base_offset() + constant_key * kDoubleSize;
+ if (!key_is_constant) {
+ __ IndexToArrayOffset(scratch, key, element_size_shift, key_is_smi);
+ __ add(scratch, elements, scratch);
+ elements = scratch;
+ }
+ if (!is_int16(base_offset)) {
+ __ Add(scratch, elements, base_offset, r0);
+ base_offset = 0;
+ elements = scratch;
+ }
+
+ if (instr->NeedsCanonicalization()) {
+ // Force a canonical NaN.
+ __ CanonicalizeNaN(double_scratch, value);
+ __ stfd(double_scratch, MemOperand(elements, base_offset));
+ } else {
+ __ stfd(value, MemOperand(elements, base_offset));
+ }
+}
+
+
+void LCodeGen::DoStoreKeyedFixedArray(LStoreKeyed* instr) {
+ HStoreKeyed* hinstr = instr->hydrogen();
+ Register value = ToRegister(instr->value());
+ Register elements = ToRegister(instr->elements());
+ Register key = instr->key()->IsRegister() ? ToRegister(instr->key()) : no_reg;
+ Register scratch = scratch0();
+ Register store_base = scratch;
+ int offset = instr->base_offset();
+
+ // Do the store.
+ if (instr->key()->IsConstantOperand()) {
+ DCHECK(!hinstr->NeedsWriteBarrier());
+ LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
+ offset += ToInteger32(const_operand) * kPointerSize;
+ store_base = elements;
+ } else {
+ // Even though the HLoadKeyed instruction forces the input
+ // representation for the key to be an integer, the input gets replaced
+ // during bound check elimination with the index argument to the bounds
+ // check, which can be tagged, so that case must be handled here, too.
+ if (hinstr->key()->representation().IsSmi()) {
+ __ SmiToPtrArrayOffset(scratch, key);
+ } else {
+ __ ShiftLeftImm(scratch, key, Operand(kPointerSizeLog2));
+ }
+ __ add(scratch, elements, scratch);
+ }
+
+ Representation representation = hinstr->value()->representation();
+
+#if V8_TARGET_ARCH_PPC64
+ // 64-bit Smi optimization
+ if (representation.IsInteger32()) {
+ DCHECK(hinstr->store_mode() == STORE_TO_INITIALIZED_ENTRY);
+ DCHECK(hinstr->elements_kind() == FAST_SMI_ELEMENTS);
+ // Store int value directly to upper half of the smi.
+ STATIC_ASSERT(kSmiTag == 0);
+ STATIC_ASSERT(kSmiTagSize + kSmiShiftSize == 32);
+#if V8_TARGET_LITTLE_ENDIAN
+ offset += kPointerSize / 2;
+#endif
+ }
+#endif
+
+ __ StoreRepresentation(value, MemOperand(store_base, offset), representation,
+ r0);
+
+ if (hinstr->NeedsWriteBarrier()) {
+ SmiCheck check_needed = hinstr->value()->type().IsHeapObject()
+ ? OMIT_SMI_CHECK
+ : INLINE_SMI_CHECK;
+ // Compute address of modified element and store it into key register.
+ __ Add(key, store_base, offset, r0);
+ __ RecordWrite(elements, key, value, GetLinkRegisterState(), kSaveFPRegs,
+ EMIT_REMEMBERED_SET, check_needed,
+ hinstr->PointersToHereCheckForValue());
+ }
+}
+
+
+void LCodeGen::DoStoreKeyed(LStoreKeyed* instr) {
+ // By cases: external, fast double
+ if (instr->is_typed_elements()) {
+ DoStoreKeyedExternalArray(instr);
+ } else if (instr->hydrogen()->value()->representation().IsDouble()) {
+ DoStoreKeyedFixedDoubleArray(instr);
+ } else {
+ DoStoreKeyedFixedArray(instr);
+ }
+}
+
+
+void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->object()).is(StoreDescriptor::ReceiverRegister()));
+ DCHECK(ToRegister(instr->key()).is(StoreDescriptor::NameRegister()));
+ DCHECK(ToRegister(instr->value()).is(StoreDescriptor::ValueRegister()));
+
+ Handle<Code> ic =
+ CodeFactory::KeyedStoreIC(isolate(), instr->strict_mode()).code();
+ CallCode(ic, RelocInfo::CODE_TARGET, instr);
+}
+
+
+void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {
+ Register object_reg = ToRegister(instr->object());
+ Register scratch = scratch0();
+
+ Handle<Map> from_map = instr->original_map();
+ Handle<Map> to_map = instr->transitioned_map();
+ ElementsKind from_kind = instr->from_kind();
+ ElementsKind to_kind = instr->to_kind();
+
+ Label not_applicable;
+ __ LoadP(scratch, FieldMemOperand(object_reg, HeapObject::kMapOffset));
+ __ Cmpi(scratch, Operand(from_map), r0);
+ __ bne(¬_applicable);
+
+ if (IsSimpleMapChangeTransition(from_kind, to_kind)) {
+ Register new_map_reg = ToRegister(instr->new_map_temp());
+ __ mov(new_map_reg, Operand(to_map));
+ __ StoreP(new_map_reg, FieldMemOperand(object_reg, HeapObject::kMapOffset),
+ r0);
+ // Write barrier.
+ __ RecordWriteForMap(object_reg, new_map_reg, scratch,
+ GetLinkRegisterState(), kDontSaveFPRegs);
+ } else {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(object_reg.is(r3));
+ PushSafepointRegistersScope scope(this);
+ __ Move(r4, to_map);
+ bool is_js_array = from_map->instance_type() == JS_ARRAY_TYPE;
+ TransitionElementsKindStub stub(isolate(), from_kind, to_kind, is_js_array);
+ __ CallStub(&stub);
+ RecordSafepointWithRegisters(instr->pointer_map(), 0,
+ Safepoint::kLazyDeopt);
+ }
+ __ bind(¬_applicable);
+}
+
+
+void LCodeGen::DoTrapAllocationMemento(LTrapAllocationMemento* instr) {
+ Register object = ToRegister(instr->object());
+ Register temp = ToRegister(instr->temp());
+ Label no_memento_found;
+ __ TestJSArrayForAllocationMemento(object, temp, &no_memento_found);
+ DeoptimizeIf(eq, instr, "memento found");
+ __ bind(&no_memento_found);
+}
+
+
+void LCodeGen::DoStringAdd(LStringAdd* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ DCHECK(ToRegister(instr->left()).is(r4));
+ DCHECK(ToRegister(instr->right()).is(r3));
+ StringAddStub stub(isolate(), instr->hydrogen()->flags(),
+ instr->hydrogen()->pretenure_flag());
+ CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
+}
+
+
+void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
+ class DeferredStringCharCodeAt FINAL : public LDeferredCode {
+ public:
+ DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr)
+ : LDeferredCode(codegen), instr_(instr) {}
+ virtual void Generate() OVERRIDE {
+ codegen()->DoDeferredStringCharCodeAt(instr_);
+ }
+ virtual LInstruction* instr() OVERRIDE { return instr_; }
+
+ private:
+ LStringCharCodeAt* instr_;
+ };
+
+ DeferredStringCharCodeAt* deferred =
+ new (zone()) DeferredStringCharCodeAt(this, instr);
+
+ StringCharLoadGenerator::Generate(
+ masm(), ToRegister(instr->string()), ToRegister(instr->index()),
+ ToRegister(instr->result()), deferred->entry());
+ __ bind(deferred->exit());
+}
+
+
+void LCodeGen::DoDeferredStringCharCodeAt(LStringCharCodeAt* instr) {
+ Register string = ToRegister(instr->string());
+ Register result = ToRegister(instr->result());
+ Register scratch = scratch0();
+
+ // TODO(3095996): Get rid of this. For now, we need to make the
+ // result register contain a valid pointer because it is already
+ // contained in the register pointer map.
+ __ li(result, Operand::Zero());
+
+ PushSafepointRegistersScope scope(this);
+ __ push(string);
+ // Push the index as a smi. This is safe because of the checks in
+ // DoStringCharCodeAt above.
+ if (instr->index()->IsConstantOperand()) {
+ int const_index = ToInteger32(LConstantOperand::cast(instr->index()));
+ __ LoadSmiLiteral(scratch, Smi::FromInt(const_index));
+ __ push(scratch);
+ } else {
+ Register index = ToRegister(instr->index());
+ __ SmiTag(index);
+ __ push(index);
+ }
+ CallRuntimeFromDeferred(Runtime::kStringCharCodeAtRT, 2, instr,
+ instr->context());
+ __ AssertSmi(r3);
+ __ SmiUntag(r3);
+ __ StoreToSafepointRegisterSlot(r3, result);
+}
+
+
+void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
+ class DeferredStringCharFromCode FINAL : public LDeferredCode {
+ public:
+ DeferredStringCharFromCode(LCodeGen* codegen, LStringCharFromCode* instr)
+ : LDeferredCode(codegen), instr_(instr) {}
+ virtual void Generate() OVERRIDE {
+ codegen()->DoDeferredStringCharFromCode(instr_);
+ }
+ virtual LInstruction* instr() OVERRIDE { return instr_; }
+
+ private:
+ LStringCharFromCode* instr_;
+ };
+
+ DeferredStringCharFromCode* deferred =
+ new (zone()) DeferredStringCharFromCode(this, instr);
+
+ DCHECK(instr->hydrogen()->value()->representation().IsInteger32());
+ Register char_code = ToRegister(instr->char_code());
+ Register result = ToRegister(instr->result());
+ DCHECK(!char_code.is(result));
+
+ __ cmpli(char_code, Operand(String::kMaxOneByteCharCode));
+ __ bgt(deferred->entry());
+ __ LoadRoot(result, Heap::kSingleCharacterStringCacheRootIndex);
+ __ ShiftLeftImm(r0, char_code, Operand(kPointerSizeLog2));
+ __ add(result, result, r0);
+ __ LoadP(result, FieldMemOperand(result, FixedArray::kHeaderSize));
+ __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
+ __ cmp(result, ip);
+ __ beq(deferred->entry());
+ __ bind(deferred->exit());
+}
+
+
+void LCodeGen::DoDeferredStringCharFromCode(LStringCharFromCode* instr) {
+ Register char_code = ToRegister(instr->char_code());
+ Register result = ToRegister(instr->result());
+
+ // TODO(3095996): Get rid of this. For now, we need to make the
+ // result register contain a valid pointer because it is already
+ // contained in the register pointer map.
+ __ li(result, Operand::Zero());
+
+ PushSafepointRegistersScope scope(this);
+ __ SmiTag(char_code);
+ __ push(char_code);
+ CallRuntimeFromDeferred(Runtime::kCharFromCode, 1, instr, instr->context());
+ __ StoreToSafepointRegisterSlot(r3, result);
+}
+
+
+void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) {
+ LOperand* input = instr->value();
+ DCHECK(input->IsRegister() || input->IsStackSlot());
+ LOperand* output = instr->result();
+ DCHECK(output->IsDoubleRegister());
+ if (input->IsStackSlot()) {
+ Register scratch = scratch0();
+ __ LoadP(scratch, ToMemOperand(input));
+ __ ConvertIntToDouble(scratch, ToDoubleRegister(output));
+ } else {
+ __ ConvertIntToDouble(ToRegister(input), ToDoubleRegister(output));
+ }
+}
+
+
+void LCodeGen::DoUint32ToDouble(LUint32ToDouble* instr) {
+ LOperand* input = instr->value();
+ LOperand* output = instr->result();
+ __ ConvertUnsignedIntToDouble(ToRegister(input), ToDoubleRegister(output));
+}
+
+
+void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
+ class DeferredNumberTagI FINAL : public LDeferredCode {
+ public:
+ DeferredNumberTagI(LCodeGen* codegen, LNumberTagI* instr)
+ : LDeferredCode(codegen), instr_(instr) {}
+ virtual void Generate() OVERRIDE {
+ codegen()->DoDeferredNumberTagIU(instr_, instr_->value(), instr_->temp1(),
+ instr_->temp2(), SIGNED_INT32);
+ }
+ virtual LInstruction* instr() OVERRIDE { return instr_; }
+
+ private:
+ LNumberTagI* instr_;
+ };
+
+ Register src = ToRegister(instr->value());
+ Register dst = ToRegister(instr->result());
+
+ DeferredNumberTagI* deferred = new (zone()) DeferredNumberTagI(this, instr);
+#if V8_TARGET_ARCH_PPC64
+ __ SmiTag(dst, src);
+#else
+ __ SmiTagCheckOverflow(dst, src, r0);
+ __ BranchOnOverflow(deferred->entry());
+#endif
+ __ bind(deferred->exit());
+}
+
+
+void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
+ class DeferredNumberTagU FINAL : public LDeferredCode {
+ public:
+ DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr)
+ : LDeferredCode(codegen), instr_(instr) {}
+ virtual void Generate() OVERRIDE {
+ codegen()->DoDeferredNumberTagIU(instr_, instr_->value(), instr_->temp1(),
+ instr_->temp2(), UNSIGNED_INT32);
+ }
+ virtual LInstruction* instr() OVERRIDE { return instr_; }
+
+ private:
+ LNumberTagU* instr_;
+ };
+
+ Register input = ToRegister(instr->value());
+ Register result = ToRegister(instr->result());
+
+ DeferredNumberTagU* deferred = new (zone()) DeferredNumberTagU(this, instr);
+ __ Cmpli(input, Operand(Smi::kMaxValue), r0);
+ __ bgt(deferred->entry());
+ __ SmiTag(result, input);
+ __ bind(deferred->exit());
+}
+
+
+void LCodeGen::DoDeferredNumberTagIU(LInstruction* instr, LOperand* value,
+ LOperand* temp1, LOperand* temp2,
+ IntegerSignedness signedness) {
+ Label done, slow;
+ Register src = ToRegister(value);
+ Register dst = ToRegister(instr->result());
+ Register tmp1 = scratch0();
+ Register tmp2 = ToRegister(temp1);
+ Register tmp3 = ToRegister(temp2);
+ DoubleRegister dbl_scratch = double_scratch0();
+
+ if (signedness == SIGNED_INT32) {
+ // There was overflow, so bits 30 and 31 of the original integer
+ // disagree. Try to allocate a heap number in new space and store
+ // the value in there. If that fails, call the runtime system.
+ if (dst.is(src)) {
+ __ SmiUntag(src, dst);
+ __ xoris(src, src, Operand(HeapNumber::kSignMask >> 16));
+ }
+ __ ConvertIntToDouble(src, dbl_scratch);
+ } else {
+ __ ConvertUnsignedIntToDouble(src, dbl_scratch);
+ }
+
+ if (FLAG_inline_new) {
+ __ LoadRoot(tmp3, Heap::kHeapNumberMapRootIndex);
+ __ AllocateHeapNumber(dst, tmp1, tmp2, tmp3, &slow);
+ __ b(&done);
+ }
+
+ // Slow case: Call the runtime system to do the number allocation.
+ __ bind(&slow);
+ {
+ // TODO(3095996): Put a valid pointer value in the stack slot where the
+ // result register is stored, as this register is in the pointer map, but
+ // contains an integer value.
+ __ li(dst, Operand::Zero());
+
+ // Preserve the value of all registers.
+ PushSafepointRegistersScope scope(this);
+
+ // NumberTagI and NumberTagD use the context from the frame, rather than
+ // the environment's HContext or HInlinedContext value.
+ // They only call Runtime::kAllocateHeapNumber.
+ // The corresponding HChange instructions are added in a phase that does
+ // not have easy access to the local context.
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ __ CallRuntimeSaveDoubles(Runtime::kAllocateHeapNumber);
+ RecordSafepointWithRegisters(instr->pointer_map(), 0,
+ Safepoint::kNoLazyDeopt);
+ __ StoreToSafepointRegisterSlot(r3, dst);
+ }
+
+ // Done. Put the value in dbl_scratch into the value of the allocated heap
+ // number.
+ __ bind(&done);
+ __ stfd(dbl_scratch, FieldMemOperand(dst, HeapNumber::kValueOffset));
+}
+
+
+void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
+ class DeferredNumberTagD FINAL : public LDeferredCode {
+ public:
+ DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr)
+ : LDeferredCode(codegen), instr_(instr) {}
+ virtual void Generate() OVERRIDE {
+ codegen()->DoDeferredNumberTagD(instr_);
+ }
+ virtual LInstruction* instr() OVERRIDE { return instr_; }
+
+ private:
+ LNumberTagD* instr_;
+ };
+
+ DoubleRegister input_reg = ToDoubleRegister(instr->value());
+ Register scratch = scratch0();
+ Register reg = ToRegister(instr->result());
+ Register temp1 = ToRegister(instr->temp());
+ Register temp2 = ToRegister(instr->temp2());
+
+ DeferredNumberTagD* deferred = new (zone()) DeferredNumberTagD(this, instr);
+ if (FLAG_inline_new) {
+ __ LoadRoot(scratch, Heap::kHeapNumberMapRootIndex);
+ __ AllocateHeapNumber(reg, temp1, temp2, scratch, deferred->entry());
+ } else {
+ __ b(deferred->entry());
+ }
+ __ bind(deferred->exit());
+ __ stfd(input_reg, FieldMemOperand(reg, HeapNumber::kValueOffset));
+}
+
+
+void LCodeGen::DoDeferredNumberTagD(LNumberTagD* instr) {
+ // TODO(3095996): Get rid of this. For now, we need to make the
+ // result register contain a valid pointer because it is already
+ // contained in the register pointer map.
+ Register reg = ToRegister(instr->result());
+ __ li(reg, Operand::Zero());
+
+ PushSafepointRegistersScope scope(this);
+ // NumberTagI and NumberTagD use the context from the frame, rather than
+ // the environment's HContext or HInlinedContext value.
+ // They only call Runtime::kAllocateHeapNumber.
+ // The corresponding HChange instructions are added in a phase that does
+ // not have easy access to the local context.
+ __ LoadP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ __ CallRuntimeSaveDoubles(Runtime::kAllocateHeapNumber);
+ RecordSafepointWithRegisters(instr->pointer_map(), 0,
+ Safepoint::kNoLazyDeopt);
+ __ StoreToSafepointRegisterSlot(r3, reg);
+}
+
+
+void LCodeGen::DoSmiTag(LSmiTag* instr) {
+ HChange* hchange = instr->hydrogen();
+ Register input = ToRegister(instr->value());
+ Register output = ToRegister(instr->result());
+ if (hchange->CheckFlag(HValue::kCanOverflow) &&
+ hchange->value()->CheckFlag(HValue::kUint32)) {
+ __ TestUnsignedSmiCandidate(input, r0);
+ DeoptimizeIf(ne, instr, "overflow", cr0);
+ }
+#if !V8_TARGET_ARCH_PPC64
+ if (hchange->CheckFlag(HValue::kCanOverflow) &&
+ !hchange->value()->CheckFlag(HValue::kUint32)) {
+ __ SmiTagCheckOverflow(output, input, r0);
+ DeoptimizeIf(lt, instr, "overflow", cr0);
+ } else {
+#endif
+ __ SmiTag(output, input);
+#if !V8_TARGET_ARCH_PPC64
+ }
+#endif
+}
+
+
+void LCodeGen::DoSmiUntag(LSmiUntag* instr) {
+ Register scratch = scratch0();
+ Register input = ToRegister(instr->value());
+ Register result = ToRegister(instr->result());
+ if (instr->needs_check()) {
+ STATIC_ASSERT(kHeapObjectTag == 1);
+ // If the input is a HeapObject, value of scratch won't be zero.
+ __ andi(scratch, input, Operand(kHeapObjectTag));
+ __ SmiUntag(result, input);
+ DeoptimizeIf(ne, instr, "not a Smi", cr0);
+ } else {
+ __ SmiUntag(result, input);
+ }
+}
+
+
+void LCodeGen::EmitNumberUntagD(LNumberUntagD* instr, Register input_reg,
+ DoubleRegister result_reg,
+ NumberUntagDMode mode) {
+ bool can_convert_undefined_to_nan =
+ instr->hydrogen()->can_convert_undefined_to_nan();
+ bool deoptimize_on_minus_zero = instr->hydrogen()->deoptimize_on_minus_zero();
+
+ Register scratch = scratch0();
+ DCHECK(!result_reg.is(double_scratch0()));
+
+ Label convert, load_smi, done;
+
+ if (mode == NUMBER_CANDIDATE_IS_ANY_TAGGED) {
+ // Smi check.
+ __ UntagAndJumpIfSmi(scratch, input_reg, &load_smi);
+
+ // Heap number map check.
+ __ LoadP(scratch, FieldMemOperand(input_reg, HeapObject::kMapOffset));
+ __ LoadRoot(ip, Heap::kHeapNumberMapRootIndex);
+ __ cmp(scratch, ip);
+ if (can_convert_undefined_to_nan) {
+ __ bne(&convert);
+ } else {
+ DeoptimizeIf(ne, instr, "not a heap number");
+ }
+ // load heap number
+ __ lfd(result_reg, FieldMemOperand(input_reg, HeapNumber::kValueOffset));
+ if (deoptimize_on_minus_zero) {
+#if V8_TARGET_ARCH_PPC64
+ __ MovDoubleToInt64(scratch, result_reg);
+ // rotate left by one for simple compare.
+ __ rldicl(scratch, scratch, 1, 0);
+ __ cmpi(scratch, Operand(1));
+#else
+ __ MovDoubleToInt64(scratch, ip, result_reg);
+ __ cmpi(ip, Operand::Zero());
+ __ bne(&done);
+ __ Cmpi(scratch, Operand(HeapNumber::kSignMask), r0);
+#endif
+ DeoptimizeIf(eq, instr, "minus zero");
+ }
+ __ b(&done);
+ if (can_convert_undefined_to_nan) {
+ __ bind(&convert);
+ // Convert undefined (and hole) to NaN.
+ __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
+ __ cmp(input_reg, ip);
+ DeoptimizeIf(ne, instr, "not a heap number/undefined");
+ __ LoadRoot(scratch, Heap::kNanValueRootIndex);
+ __ lfd(result_reg, FieldMemOperand(scratch, HeapNumber::kValueOffset));
+ __ b(&done);
+ }
+ } else {
+ __ SmiUntag(scratch, input_reg);
+ DCHECK(mode == NUMBER_CANDIDATE_IS_SMI);
+ }
+ // Smi to double register conversion
+ __ bind(&load_smi);
+ // scratch: untagged value of input_reg
+ __ ConvertIntToDouble(scratch, result_reg);
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr) {
+ Register input_reg = ToRegister(instr->value());
+ Register scratch1 = scratch0();
+ Register scratch2 = ToRegister(instr->temp());
+ DoubleRegister double_scratch = double_scratch0();
+ DoubleRegister double_scratch2 = ToDoubleRegister(instr->temp2());
+
+ DCHECK(!scratch1.is(input_reg) && !scratch1.is(scratch2));
+ DCHECK(!scratch2.is(input_reg) && !scratch2.is(scratch1));
+
+ Label done;
+
+ // Heap number map check.
+ __ LoadP(scratch1, FieldMemOperand(input_reg, HeapObject::kMapOffset));
+ __ LoadRoot(ip, Heap::kHeapNumberMapRootIndex);
+ __ cmp(scratch1, ip);
+
+ if (instr->truncating()) {
+ // Performs a truncating conversion of a floating point number as used by
+ // the JS bitwise operations.
+ Label no_heap_number, check_bools, check_false;
+ __ bne(&no_heap_number);
+ __ mr(scratch2, input_reg);
+ __ TruncateHeapNumberToI(input_reg, scratch2);
+ __ b(&done);
+
+ // Check for Oddballs. Undefined/False is converted to zero and True to one
+ // for truncating conversions.
+ __ bind(&no_heap_number);
+ __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
+ __ cmp(input_reg, ip);
+ __ bne(&check_bools);
+ __ li(input_reg, Operand::Zero());
+ __ b(&done);
+
+ __ bind(&check_bools);
+ __ LoadRoot(ip, Heap::kTrueValueRootIndex);
+ __ cmp(input_reg, ip);
+ __ bne(&check_false);
+ __ li(input_reg, Operand(1));
+ __ b(&done);
+
+ __ bind(&check_false);
+ __ LoadRoot(ip, Heap::kFalseValueRootIndex);
+ __ cmp(input_reg, ip);
+ DeoptimizeIf(ne, instr, "not a heap number/undefined/true/false", cr7);
+ __ li(input_reg, Operand::Zero());
+ } else {
+ DeoptimizeIf(ne, instr, "not a heap number", cr7);
+
+ __ lfd(double_scratch2,
+ FieldMemOperand(input_reg, HeapNumber::kValueOffset));
+ if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ // preserve heap number pointer in scratch2 for minus zero check below
+ __ mr(scratch2, input_reg);
+ }
+ __ TryDoubleToInt32Exact(input_reg, double_scratch2, scratch1,
+ double_scratch);
+ DeoptimizeIf(ne, instr, "lost precision or NaN", cr7);
+
+ if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ __ cmpi(input_reg, Operand::Zero());
+ __ bne(&done);
+ __ lwz(scratch1,
+ FieldMemOperand(scratch2, HeapNumber::kValueOffset +
+ Register::kExponentOffset));
+ __ cmpwi(scratch1, Operand::Zero());
+ DeoptimizeIf(lt, instr, "minus zero", cr7);
+ }
+ }
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoTaggedToI(LTaggedToI* instr) {
+ class DeferredTaggedToI FINAL : public LDeferredCode {
+ public:
+ DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr)
+ : LDeferredCode(codegen), instr_(instr) {}
+ virtual void Generate() OVERRIDE { codegen()->DoDeferredTaggedToI(instr_); }
+ virtual LInstruction* instr() OVERRIDE { return instr_; }
+
+ private:
+ LTaggedToI* instr_;
+ };
+
+ LOperand* input = instr->value();
+ DCHECK(input->IsRegister());
+ DCHECK(input->Equals(instr->result()));
+
+ Register input_reg = ToRegister(input);
+
+ if (instr->hydrogen()->value()->representation().IsSmi()) {
+ __ SmiUntag(input_reg);
+ } else {
+ DeferredTaggedToI* deferred = new (zone()) DeferredTaggedToI(this, instr);
+
+ // Branch to deferred code if the input is a HeapObject.
+ __ JumpIfNotSmi(input_reg, deferred->entry());
+
+ __ SmiUntag(input_reg);
+ __ bind(deferred->exit());
+ }
+}
+
+
+void LCodeGen::DoNumberUntagD(LNumberUntagD* instr) {
+ LOperand* input = instr->value();
+ DCHECK(input->IsRegister());
+ LOperand* result = instr->result();
+ DCHECK(result->IsDoubleRegister());
+
+ Register input_reg = ToRegister(input);
+ DoubleRegister result_reg = ToDoubleRegister(result);
+
+ HValue* value = instr->hydrogen()->value();
+ NumberUntagDMode mode = value->representation().IsSmi()
+ ? NUMBER_CANDIDATE_IS_SMI
+ : NUMBER_CANDIDATE_IS_ANY_TAGGED;
+
+ EmitNumberUntagD(instr, input_reg, result_reg, mode);
+}
+
+
+void LCodeGen::DoDoubleToI(LDoubleToI* instr) {
+ Register result_reg = ToRegister(instr->result());
+ Register scratch1 = scratch0();
+ DoubleRegister double_input = ToDoubleRegister(instr->value());
+ DoubleRegister double_scratch = double_scratch0();
+
+ if (instr->truncating()) {
+ __ TruncateDoubleToI(result_reg, double_input);
+ } else {
+ __ TryDoubleToInt32Exact(result_reg, double_input, scratch1,
+ double_scratch);
+ // Deoptimize if the input wasn't a int32 (inside a double).
+ DeoptimizeIf(ne, instr, "lost precision or NaN");
+ if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ Label done;
+ __ cmpi(result_reg, Operand::Zero());
+ __ bne(&done);
+#if V8_TARGET_ARCH_PPC64
+ __ MovDoubleToInt64(scratch1, double_input);
+#else
+ __ MovDoubleHighToInt(scratch1, double_input);
+#endif
+ __ cmpi(scratch1, Operand::Zero());
+ DeoptimizeIf(lt, instr, "minus zero");
+ __ bind(&done);
+ }
+ }
+}
+
+
+void LCodeGen::DoDoubleToSmi(LDoubleToSmi* instr) {
+ Register result_reg = ToRegister(instr->result());
+ Register scratch1 = scratch0();
+ DoubleRegister double_input = ToDoubleRegister(instr->value());
+ DoubleRegister double_scratch = double_scratch0();
+
+ if (instr->truncating()) {
+ __ TruncateDoubleToI(result_reg, double_input);
+ } else {
+ __ TryDoubleToInt32Exact(result_reg, double_input, scratch1,
+ double_scratch);
+ // Deoptimize if the input wasn't a int32 (inside a double).
+ DeoptimizeIf(ne, instr, "lost precision or NaN");
+ if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ Label done;
+ __ cmpi(result_reg, Operand::Zero());
+ __ bne(&done);
+#if V8_TARGET_ARCH_PPC64
+ __ MovDoubleToInt64(scratch1, double_input);
+#else
+ __ MovDoubleHighToInt(scratch1, double_input);
+#endif
+ __ cmpi(scratch1, Operand::Zero());
+ DeoptimizeIf(lt, instr, "minus zero");
+ __ bind(&done);
+ }
+ }
+#if V8_TARGET_ARCH_PPC64
+ __ SmiTag(result_reg);
+#else
+ __ SmiTagCheckOverflow(result_reg, r0);
+ DeoptimizeIf(lt, instr, "overflow", cr0);
+#endif
+}
+
+
+void LCodeGen::DoCheckSmi(LCheckSmi* instr) {
+ LOperand* input = instr->value();
+ __ TestIfSmi(ToRegister(input), r0);
+ DeoptimizeIf(ne, instr, "not a Smi", cr0);
+}
+
+
+void LCodeGen::DoCheckNonSmi(LCheckNonSmi* instr) {
+ if (!instr->hydrogen()->value()->type().IsHeapObject()) {
+ LOperand* input = instr->value();
+ __ TestIfSmi(ToRegister(input), r0);
+ DeoptimizeIf(eq, instr, "Smi", cr0);
+ }
+}
+
+
+void LCodeGen::DoCheckInstanceType(LCheckInstanceType* instr) {
+ Register input = ToRegister(instr->value());
+ Register scratch = scratch0();
+
+ __ LoadP(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
+ __ lbz(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
+
+ if (instr->hydrogen()->is_interval_check()) {
+ InstanceType first;
+ InstanceType last;
+ instr->hydrogen()->GetCheckInterval(&first, &last);
+
+ __ cmpli(scratch, Operand(first));
+
+ // If there is only one type in the interval check for equality.
+ if (first == last) {
+ DeoptimizeIf(ne, instr, "wrong instance type");
+ } else {
+ DeoptimizeIf(lt, instr, "wrong instance type");
+ // Omit check for the last type.
+ if (last != LAST_TYPE) {
+ __ cmpli(scratch, Operand(last));
+ DeoptimizeIf(gt, instr, "wrong instance type");
+ }
+ }
+ } else {
+ uint8_t mask;
+ uint8_t tag;
+ instr->hydrogen()->GetCheckMaskAndTag(&mask, &tag);
+
+ if (base::bits::IsPowerOfTwo32(mask)) {
+ DCHECK(tag == 0 || base::bits::IsPowerOfTwo32(tag));
+ __ andi(r0, scratch, Operand(mask));
+ DeoptimizeIf(tag == 0 ? ne : eq, instr, "wrong instance type", cr0);
+ } else {
+ __ andi(scratch, scratch, Operand(mask));
+ __ cmpi(scratch, Operand(tag));
+ DeoptimizeIf(ne, instr, "wrong instance type");
+ }
+ }
+}
+
+
+void LCodeGen::DoCheckValue(LCheckValue* instr) {
+ Register reg = ToRegister(instr->value());
+ Handle<HeapObject> object = instr->hydrogen()->object().handle();
+ AllowDeferredHandleDereference smi_check;
+ if (isolate()->heap()->InNewSpace(*object)) {
+ Register reg = ToRegister(instr->value());
+ Handle<Cell> cell = isolate()->factory()->NewCell(object);
+ __ mov(ip, Operand(Handle<Object>(cell)));
+ __ LoadP(ip, FieldMemOperand(ip, Cell::kValueOffset));
+ __ cmp(reg, ip);
+ } else {
+ __ Cmpi(reg, Operand(object), r0);
+ }
+ DeoptimizeIf(ne, instr, "value mismatch");
+}
+
+
+void LCodeGen::DoDeferredInstanceMigration(LCheckMaps* instr, Register object) {
+ {
+ PushSafepointRegistersScope scope(this);
+ __ push(object);
+ __ li(cp, Operand::Zero());
+ __ CallRuntimeSaveDoubles(Runtime::kTryMigrateInstance);
+ RecordSafepointWithRegisters(instr->pointer_map(), 1,
+ Safepoint::kNoLazyDeopt);
+ __ StoreToSafepointRegisterSlot(r3, scratch0());
+ }
+ __ TestIfSmi(scratch0(), r0);
+ DeoptimizeIf(eq, instr, "instance migration failed", cr0);
+}
+
+
+void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
+ class DeferredCheckMaps FINAL : public LDeferredCode {
+ public:
+ DeferredCheckMaps(LCodeGen* codegen, LCheckMaps* instr, Register object)
+ : LDeferredCode(codegen), instr_(instr), object_(object) {
+ SetExit(check_maps());
+ }
+ virtual void Generate() OVERRIDE {
+ codegen()->DoDeferredInstanceMigration(instr_, object_);
+ }
+ Label* check_maps() { return &check_maps_; }
+ virtual LInstruction* instr() OVERRIDE { return instr_; }
+
+ private:
+ LCheckMaps* instr_;
+ Label check_maps_;
+ Register object_;
+ };
+
+ if (instr->hydrogen()->IsStabilityCheck()) {
+ const UniqueSet<Map>* maps = instr->hydrogen()->maps();
+ for (int i = 0; i < maps->size(); ++i) {
+ AddStabilityDependency(maps->at(i).handle());
+ }
+ return;
+ }
+
+ Register map_reg = scratch0();
+
+ LOperand* input = instr->value();
+ DCHECK(input->IsRegister());
+ Register reg = ToRegister(input);
+
+ __ LoadP(map_reg, FieldMemOperand(reg, HeapObject::kMapOffset));
+
+ DeferredCheckMaps* deferred = NULL;
+ if (instr->hydrogen()->HasMigrationTarget()) {
+ deferred = new (zone()) DeferredCheckMaps(this, instr, reg);
+ __ bind(deferred->check_maps());
+ }
+
+ const UniqueSet<Map>* maps = instr->hydrogen()->maps();
+ Label success;
+ for (int i = 0; i < maps->size() - 1; i++) {
+ Handle<Map> map = maps->at(i).handle();
+ __ CompareMap(map_reg, map, &success);
+ __ beq(&success);
+ }
+
+ Handle<Map> map = maps->at(maps->size() - 1).handle();
+ __ CompareMap(map_reg, map, &success);
+ if (instr->hydrogen()->HasMigrationTarget()) {
+ __ bne(deferred->entry());
+ } else {
+ DeoptimizeIf(ne, instr, "wrong map");
+ }
+
+ __ bind(&success);
+}
+
+
+void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) {
+ DoubleRegister value_reg = ToDoubleRegister(instr->unclamped());
+ Register result_reg = ToRegister(instr->result());
+ __ ClampDoubleToUint8(result_reg, value_reg, double_scratch0());
+}
+
+
+void LCodeGen::DoClampIToUint8(LClampIToUint8* instr) {
+ Register unclamped_reg = ToRegister(instr->unclamped());
+ Register result_reg = ToRegister(instr->result());
+ __ ClampUint8(result_reg, unclamped_reg);
+}
+
+
+void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
+ Register scratch = scratch0();
+ Register input_reg = ToRegister(instr->unclamped());
+ Register result_reg = ToRegister(instr->result());
+ DoubleRegister temp_reg = ToDoubleRegister(instr->temp());
+ Label is_smi, done, heap_number;
+
+ // Both smi and heap number cases are handled.
+ __ UntagAndJumpIfSmi(result_reg, input_reg, &is_smi);
+
+ // Check for heap number
+ __ LoadP(scratch, FieldMemOperand(input_reg, HeapObject::kMapOffset));
+ __ Cmpi(scratch, Operand(factory()->heap_number_map()), r0);
+ __ beq(&heap_number);
+
+ // Check for undefined. Undefined is converted to zero for clamping
+ // conversions.
+ __ Cmpi(input_reg, Operand(factory()->undefined_value()), r0);
+ DeoptimizeIf(ne, instr, "not a heap number/undefined");
+ __ li(result_reg, Operand::Zero());
+ __ b(&done);
+
+ // Heap number
+ __ bind(&heap_number);
+ __ lfd(temp_reg, FieldMemOperand(input_reg, HeapNumber::kValueOffset));
+ __ ClampDoubleToUint8(result_reg, temp_reg, double_scratch0());
+ __ b(&done);
+
+ // smi
+ __ bind(&is_smi);
+ __ ClampUint8(result_reg, result_reg);
+
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoDoubleBits(LDoubleBits* instr) {
+ DoubleRegister value_reg = ToDoubleRegister(instr->value());
+ Register result_reg = ToRegister(instr->result());
+
+ if (instr->hydrogen()->bits() == HDoubleBits::HIGH) {
+ __ MovDoubleHighToInt(result_reg, value_reg);
+ } else {
+ __ MovDoubleLowToInt(result_reg, value_reg);
+ }
+}
+
+
+void LCodeGen::DoConstructDouble(LConstructDouble* instr) {
+ Register hi_reg = ToRegister(instr->hi());
+ Register lo_reg = ToRegister(instr->lo());
+ DoubleRegister result_reg = ToDoubleRegister(instr->result());
+#if V8_TARGET_ARCH_PPC64
+ __ MovInt64ComponentsToDouble(result_reg, hi_reg, lo_reg, r0);
+#else
+ __ MovInt64ToDouble(result_reg, hi_reg, lo_reg);
+#endif
+}
+
+
+void LCodeGen::DoAllocate(LAllocate* instr) {
+ class DeferredAllocate FINAL : public LDeferredCode {
+ public:
+ DeferredAllocate(LCodeGen* codegen, LAllocate* instr)
+ : LDeferredCode(codegen), instr_(instr) {}
+ virtual void Generate() OVERRIDE { codegen()->DoDeferredAllocate(instr_); }
+ virtual LInstruction* instr() OVERRIDE { return instr_; }
+
+ private:
+ LAllocate* instr_;
+ };
+
+ DeferredAllocate* deferred = new (zone()) DeferredAllocate(this, instr);
+
+ Register result = ToRegister(instr->result());
+ Register scratch = ToRegister(instr->temp1());
+ Register scratch2 = ToRegister(instr->temp2());
+
+ // Allocate memory for the object.
+ AllocationFlags flags = TAG_OBJECT;
+ if (instr->hydrogen()->MustAllocateDoubleAligned()) {
+ flags = static_cast<AllocationFlags>(flags | DOUBLE_ALIGNMENT);
+ }
+ if (instr->hydrogen()->IsOldPointerSpaceAllocation()) {
+ DCHECK(!instr->hydrogen()->IsOldDataSpaceAllocation());
+ DCHECK(!instr->hydrogen()->IsNewSpaceAllocation());
+ flags = static_cast<AllocationFlags>(flags | PRETENURE_OLD_POINTER_SPACE);
+ } else if (instr->hydrogen()->IsOldDataSpaceAllocation()) {
+ DCHECK(!instr->hydrogen()->IsNewSpaceAllocation());
+ flags = static_cast<AllocationFlags>(flags | PRETENURE_OLD_DATA_SPACE);
+ }
+
+ if (instr->size()->IsConstantOperand()) {
+ int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
+ if (size <= Page::kMaxRegularHeapObjectSize) {
+ __ Allocate(size, result, scratch, scratch2, deferred->entry(), flags);
+ } else {
+ __ b(deferred->entry());
+ }
+ } else {
+ Register size = ToRegister(instr->size());
+ __ Allocate(size, result, scratch, scratch2, deferred->entry(), flags);
+ }
+
+ __ bind(deferred->exit());
+
+ if (instr->hydrogen()->MustPrefillWithFiller()) {
+ STATIC_ASSERT(kHeapObjectTag == 1);
+ if (instr->size()->IsConstantOperand()) {
+ int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
+ __ LoadIntLiteral(scratch, size - kHeapObjectTag);
+ } else {
+ __ subi(scratch, ToRegister(instr->size()), Operand(kHeapObjectTag));
+ }
+ __ mov(scratch2, Operand(isolate()->factory()->one_pointer_filler_map()));
+ Label loop;
+ __ bind(&loop);
+ __ subi(scratch, scratch, Operand(kPointerSize));
+ __ StorePX(scratch2, MemOperand(result, scratch));
+ __ cmpi(scratch, Operand::Zero());
+ __ bge(&loop);
+ }
+}
+
+
+void LCodeGen::DoDeferredAllocate(LAllocate* instr) {
+ Register result = ToRegister(instr->result());
+
+ // TODO(3095996): Get rid of this. For now, we need to make the
+ // result register contain a valid pointer because it is already
+ // contained in the register pointer map.
+ __ LoadSmiLiteral(result, Smi::FromInt(0));
+
+ PushSafepointRegistersScope scope(this);
+ if (instr->size()->IsRegister()) {
+ Register size = ToRegister(instr->size());
+ DCHECK(!size.is(result));
+ __ SmiTag(size);
+ __ push(size);
+ } else {
+ int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
+#if !V8_TARGET_ARCH_PPC64
+ if (size >= 0 && size <= Smi::kMaxValue) {
+#endif
+ __ Push(Smi::FromInt(size));
+#if !V8_TARGET_ARCH_PPC64
+ } else {
+ // We should never get here at runtime => abort
+ __ stop("invalid allocation size");
+ return;
+ }
+#endif
+ }
+
+ int flags = AllocateDoubleAlignFlag::encode(
+ instr->hydrogen()->MustAllocateDoubleAligned());
+ if (instr->hydrogen()->IsOldPointerSpaceAllocation()) {
+ DCHECK(!instr->hydrogen()->IsOldDataSpaceAllocation());
+ DCHECK(!instr->hydrogen()->IsNewSpaceAllocation());
+ flags = AllocateTargetSpace::update(flags, OLD_POINTER_SPACE);
+ } else if (instr->hydrogen()->IsOldDataSpaceAllocation()) {
+ DCHECK(!instr->hydrogen()->IsNewSpaceAllocation());
+ flags = AllocateTargetSpace::update(flags, OLD_DATA_SPACE);
+ } else {
+ flags = AllocateTargetSpace::update(flags, NEW_SPACE);
+ }
+ __ Push(Smi::FromInt(flags));
+
+ CallRuntimeFromDeferred(Runtime::kAllocateInTargetSpace, 2, instr,
+ instr->context());
+ __ StoreToSafepointRegisterSlot(r3, result);
+}
+
+
+void LCodeGen::DoToFastProperties(LToFastProperties* instr) {
+ DCHECK(ToRegister(instr->value()).is(r3));
+ __ push(r3);
+ CallRuntime(Runtime::kToFastProperties, 1, instr);
+}
+
+
+void LCodeGen::DoRegExpLiteral(LRegExpLiteral* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ Label materialized;
+ // Registers will be used as follows:
+ // r10 = literals array.
+ // r4 = regexp literal.
+ // r3 = regexp literal clone.
+ // r5 and r7-r9 are used as temporaries.
+ int literal_offset =
+ FixedArray::OffsetOfElementAt(instr->hydrogen()->literal_index());
+ __ Move(r10, instr->hydrogen()->literals());
+ __ LoadP(r4, FieldMemOperand(r10, literal_offset));
+ __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
+ __ cmp(r4, ip);
+ __ bne(&materialized);
+
+ // Create regexp literal using runtime function
+ // Result will be in r3.
+ __ LoadSmiLiteral(r9, Smi::FromInt(instr->hydrogen()->literal_index()));
+ __ mov(r8, Operand(instr->hydrogen()->pattern()));
+ __ mov(r7, Operand(instr->hydrogen()->flags()));
+ __ Push(r10, r9, r8, r7);
+ CallRuntime(Runtime::kMaterializeRegExpLiteral, 4, instr);
+ __ mr(r4, r3);
+
+ __ bind(&materialized);
+ int size = JSRegExp::kSize + JSRegExp::kInObjectFieldCount * kPointerSize;
+ Label allocated, runtime_allocate;
+
+ __ Allocate(size, r3, r5, r6, &runtime_allocate, TAG_OBJECT);
+ __ b(&allocated);
+
+ __ bind(&runtime_allocate);
+ __ LoadSmiLiteral(r3, Smi::FromInt(size));
+ __ Push(r4, r3);
+ CallRuntime(Runtime::kAllocateInNewSpace, 1, instr);
+ __ pop(r4);
+
+ __ bind(&allocated);
+ // Copy the content into the newly allocated memory.
+ __ CopyFields(r3, r4, r5.bit(), size / kPointerSize);
+}
+
+
+void LCodeGen::DoFunctionLiteral(LFunctionLiteral* instr) {
+ DCHECK(ToRegister(instr->context()).is(cp));
+ // Use the fast case closure allocation code that allocates in new
+ // space for nested functions that don't need literals cloning.
+ bool pretenure = instr->hydrogen()->pretenure();
+ if (!pretenure && instr->hydrogen()->has_no_literals()) {
+ FastNewClosureStub stub(isolate(), instr->hydrogen()->strict_mode(),
+ instr->hydrogen()->kind());
+ __ mov(r5, Operand(instr->hydrogen()->shared_info()));
+ CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
+ } else {
+ __ mov(r5, Operand(instr->hydrogen()->shared_info()));
+ __ mov(r4, Operand(pretenure ? factory()->true_value()
+ : factory()->false_value()));
+ __ Push(cp, r5, r4);
+ CallRuntime(Runtime::kNewClosure, 3, instr);
+ }
+}
+
+
+void LCodeGen::DoTypeof(LTypeof* instr) {
+ Register input = ToRegister(instr->value());
+ __ push(input);
+ CallRuntime(Runtime::kTypeof, 1, instr);
+}
+
+
+void LCodeGen::DoTypeofIsAndBranch(LTypeofIsAndBranch* instr) {
+ Register input = ToRegister(instr->value());
+
+ Condition final_branch_condition =
+ EmitTypeofIs(instr->TrueLabel(chunk_), instr->FalseLabel(chunk_), input,
+ instr->type_literal());
+ if (final_branch_condition != kNoCondition) {
+ EmitBranch(instr, final_branch_condition);
+ }
+}
+
+
+Condition LCodeGen::EmitTypeofIs(Label* true_label, Label* false_label,
+ Register input, Handle<String> type_name) {
+ Condition final_branch_condition = kNoCondition;
+ Register scratch = scratch0();
+ Factory* factory = isolate()->factory();
+ if (String::Equals(type_name, factory->number_string())) {
+ __ JumpIfSmi(input, true_label);
+ __ LoadP(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
+ __ CompareRoot(scratch, Heap::kHeapNumberMapRootIndex);
+ final_branch_condition = eq;
+
+ } else if (String::Equals(type_name, factory->string_string())) {
+ __ JumpIfSmi(input, false_label);
+ __ CompareObjectType(input, scratch, no_reg, FIRST_NONSTRING_TYPE);
+ __ bge(false_label);
+ __ lbz(scratch, FieldMemOperand(scratch, Map::kBitFieldOffset));
+ __ ExtractBit(r0, scratch, Map::kIsUndetectable);
+ __ cmpi(r0, Operand::Zero());
+ final_branch_condition = eq;
+
+ } else if (String::Equals(type_name, factory->symbol_string())) {
+ __ JumpIfSmi(input, false_label);
+ __ CompareObjectType(input, scratch, no_reg, SYMBOL_TYPE);
+ final_branch_condition = eq;
+
+ } else if (String::Equals(type_name, factory->boolean_string())) {
+ __ CompareRoot(input, Heap::kTrueValueRootIndex);
+ __ beq(true_label);
+ __ CompareRoot(input, Heap::kFalseValueRootIndex);
+ final_branch_condition = eq;
+
+ } else if (String::Equals(type_name, factory->undefined_string())) {
+ __ CompareRoot(input, Heap::kUndefinedValueRootIndex);
+ __ beq(true_label);
+ __ JumpIfSmi(input, false_label);
+ // Check for undetectable objects => true.
+ __ LoadP(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
+ __ lbz(scratch, FieldMemOperand(scratch, Map::kBitFieldOffset));
+ __ ExtractBit(r0, scratch, Map::kIsUndetectable);
+ __ cmpi(r0, Operand::Zero());
+ final_branch_condition = ne;
+
+ } else if (String::Equals(type_name, factory->function_string())) {
+ STATIC_ASSERT(NUM_OF_CALLABLE_SPEC_OBJECT_TYPES == 2);
+ Register type_reg = scratch;
+ __ JumpIfSmi(input, false_label);
+ __ CompareObjectType(input, scratch, type_reg, JS_FUNCTION_TYPE);
+ __ beq(true_label);
+ __ cmpi(type_reg, Operand(JS_FUNCTION_PROXY_TYPE));
+ final_branch_condition = eq;
+
+ } else if (String::Equals(type_name, factory->object_string())) {
+ Register map = scratch;
+ __ JumpIfSmi(input, false_label);
+ __ CompareRoot(input, Heap::kNullValueRootIndex);
+ __ beq(true_label);
+ __ CheckObjectTypeRange(input, map, FIRST_NONCALLABLE_SPEC_OBJECT_TYPE,
+ LAST_NONCALLABLE_SPEC_OBJECT_TYPE, false_label);
+ // Check for undetectable objects => false.
+ __ lbz(scratch, FieldMemOperand(map, Map::kBitFieldOffset));
+ __ ExtractBit(r0, scratch, Map::kIsUndetectable);
+ __ cmpi(r0, Operand::Zero());
+ final_branch_condition = eq;
+
+ } else {
+ __ b(false_label);
+ }
+
+ return final_branch_condition;
+}
+
+
+void LCodeGen::DoIsConstructCallAndBranch(LIsConstructCallAndBranch* instr) {
+ Register temp1 = ToRegister(instr->temp());
+
+ EmitIsConstructCall(temp1, scratch0());
+ EmitBranch(instr, eq);
+}
+
+
+void LCodeGen::EmitIsConstructCall(Register temp1, Register temp2) {
+ DCHECK(!temp1.is(temp2));
+ // Get the frame pointer for the calling frame.
+ __ LoadP(temp1, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+
+ // Skip the arguments adaptor frame if it exists.
+ Label check_frame_marker;
+ __ LoadP(temp2, MemOperand(temp1, StandardFrameConstants::kContextOffset));
+ __ CmpSmiLiteral(temp2, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
+ __ bne(&check_frame_marker);
+ __ LoadP(temp1, MemOperand(temp1, StandardFrameConstants::kCallerFPOffset));
+
+ // Check the marker in the calling frame.
+ __ bind(&check_frame_marker);
+ __ LoadP(temp1, MemOperand(temp1, StandardFrameConstants::kMarkerOffset));
+ __ CmpSmiLiteral(temp1, Smi::FromInt(StackFrame::CONSTRUCT), r0);
+}
+
+
+void LCodeGen::EnsureSpaceForLazyDeopt(int space_needed) {
+ if (!info()->IsStub()) {
+ // Ensure that we have enough space after the previous lazy-bailout
+ // instruction for patching the code here.
+ int current_pc = masm()->pc_offset();
+ if (current_pc < last_lazy_deopt_pc_ + space_needed) {
+ int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
+ DCHECK_EQ(0, padding_size % Assembler::kInstrSize);
+ while (padding_size > 0) {
+ __ nop();
+ padding_size -= Assembler::kInstrSize;
+ }
+ }
+ }
+ last_lazy_deopt_pc_ = masm()->pc_offset();
+}
+
+
+void LCodeGen::DoLazyBailout(LLazyBailout* instr) {
+ last_lazy_deopt_pc_ = masm()->pc_offset();
+ DCHECK(instr->HasEnvironment());
+ LEnvironment* env = instr->environment();
+ RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt);
+ safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
+}
+
+
+void LCodeGen::DoDeoptimize(LDeoptimize* instr) {
+ Deoptimizer::BailoutType type = instr->hydrogen()->type();
+ // TODO(danno): Stubs expect all deopts to be lazy for historical reasons (the
+ // needed return address), even though the implementation of LAZY and EAGER is
+ // now identical. When LAZY is eventually completely folded into EAGER, remove
+ // the special case below.
+ if (info()->IsStub() && type == Deoptimizer::EAGER) {
+ type = Deoptimizer::LAZY;
+ }
+
+ DeoptimizeIf(al, instr, instr->hydrogen()->reason(), type);
+}
+
+
+void LCodeGen::DoDummy(LDummy* instr) {
+ // Nothing to see here, move on!
+}
+
+
+void LCodeGen::DoDummyUse(LDummyUse* instr) {
+ // Nothing to see here, move on!
+}
+
+
+void LCodeGen::DoDeferredStackCheck(LStackCheck* instr) {
+ PushSafepointRegistersScope scope(this);
+ LoadContextFromDeferred(instr->context());
+ __ CallRuntimeSaveDoubles(Runtime::kStackGuard);
+ RecordSafepointWithLazyDeopt(
+ instr, RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
+ DCHECK(instr->HasEnvironment());
+ LEnvironment* env = instr->environment();
+ safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
+}
+
+
+void LCodeGen::DoStackCheck(LStackCheck* instr) {
+ class DeferredStackCheck FINAL : public LDeferredCode {
+ public:
+ DeferredStackCheck(LCodeGen* codegen, LStackCheck* instr)
+ : LDeferredCode(codegen), instr_(instr) {}
+ virtual void Generate() OVERRIDE {
+ codegen()->DoDeferredStackCheck(instr_);
+ }
+ virtual LInstruction* instr() OVERRIDE { return instr_; }
+
+ private:
+ LStackCheck* instr_;
+ };
+
+ DCHECK(instr->HasEnvironment());
+ LEnvironment* env = instr->environment();
+ // There is no LLazyBailout instruction for stack-checks. We have to
+ // prepare for lazy deoptimization explicitly here.
+ if (instr->hydrogen()->is_function_entry()) {
+ // Perform stack overflow check.
+ Label done;
+ __ LoadRoot(ip, Heap::kStackLimitRootIndex);
+ __ cmpl(sp, ip);
+ __ bge(&done);
+ DCHECK(instr->context()->IsRegister());
+ DCHECK(ToRegister(instr->context()).is(cp));
+ CallCode(isolate()->builtins()->StackCheck(), RelocInfo::CODE_TARGET,
+ instr);
+ __ bind(&done);
+ } else {
+ DCHECK(instr->hydrogen()->is_backwards_branch());
+ // Perform stack overflow check if this goto needs it before jumping.
+ DeferredStackCheck* deferred_stack_check =
+ new (zone()) DeferredStackCheck(this, instr);
+ __ LoadRoot(ip, Heap::kStackLimitRootIndex);
+ __ cmpl(sp, ip);
+ __ blt(deferred_stack_check->entry());
+ EnsureSpaceForLazyDeopt(Deoptimizer::patch_size());
+ __ bind(instr->done_label());
+ deferred_stack_check->SetExit(instr->done_label());
+ RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt);
+ // Don't record a deoptimization index for the safepoint here.
+ // This will be done explicitly when emitting call and the safepoint in
+ // the deferred code.
+ }
+}
+
+
+void LCodeGen::DoOsrEntry(LOsrEntry* instr) {
+ // This is a pseudo-instruction that ensures that the environment here is
+ // properly registered for deoptimization and records the assembler's PC
+ // offset.
+ LEnvironment* environment = instr->environment();
+
+ // If the environment were already registered, we would have no way of
+ // backpatching it with the spill slot operands.
+ DCHECK(!environment->HasBeenRegistered());
+ RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);
+
+ GenerateOsrPrologue();
+}
+
+
+void LCodeGen::DoForInPrepareMap(LForInPrepareMap* instr) {
+ __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
+ __ cmp(r3, ip);
+ DeoptimizeIf(eq, instr, "undefined");
+
+ Register null_value = r8;
+ __ LoadRoot(null_value, Heap::kNullValueRootIndex);
+ __ cmp(r3, null_value);
+ DeoptimizeIf(eq, instr, "null");
+
+ __ TestIfSmi(r3, r0);
+ DeoptimizeIf(eq, instr, "Smi", cr0);
+
+ STATIC_ASSERT(FIRST_JS_PROXY_TYPE == FIRST_SPEC_OBJECT_TYPE);
+ __ CompareObjectType(r3, r4, r4, LAST_JS_PROXY_TYPE);
+ DeoptimizeIf(le, instr, "wrong instance type");
+
+ Label use_cache, call_runtime;
+ __ CheckEnumCache(null_value, &call_runtime);
+
+ __ LoadP(r3, FieldMemOperand(r3, HeapObject::kMapOffset));
+ __ b(&use_cache);
+
+ // Get the set of properties to enumerate.
+ __ bind(&call_runtime);
+ __ push(r3);
+ CallRuntime(Runtime::kGetPropertyNamesFast, 1, instr);
+
+ __ LoadP(r4, FieldMemOperand(r3, HeapObject::kMapOffset));
+ __ LoadRoot(ip, Heap::kMetaMapRootIndex);
+ __ cmp(r4, ip);
+ DeoptimizeIf(ne, instr, "wrong map");
+ __ bind(&use_cache);
+}
+
+
+void LCodeGen::DoForInCacheArray(LForInCacheArray* instr) {
+ Register map = ToRegister(instr->map());
+ Register result = ToRegister(instr->result());
+ Label load_cache, done;
+ __ EnumLength(result, map);
+ __ CmpSmiLiteral(result, Smi::FromInt(0), r0);
+ __ bne(&load_cache);
+ __ mov(result, Operand(isolate()->factory()->empty_fixed_array()));
+ __ b(&done);
+
+ __ bind(&load_cache);
+ __ LoadInstanceDescriptors(map, result);
+ __ LoadP(result, FieldMemOperand(result, DescriptorArray::kEnumCacheOffset));
+ __ LoadP(result, FieldMemOperand(result, FixedArray::SizeFor(instr->idx())));
+ __ cmpi(result, Operand::Zero());
+ DeoptimizeIf(eq, instr, "no cache");
+
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoCheckMapValue(LCheckMapValue* instr) {
+ Register object = ToRegister(instr->value());
+ Register map = ToRegister(instr->map());
+ __ LoadP(scratch0(), FieldMemOperand(object, HeapObject::kMapOffset));
+ __ cmp(map, scratch0());
+ DeoptimizeIf(ne, instr, "wrong map");
+}
+
+
+void LCodeGen::DoDeferredLoadMutableDouble(LLoadFieldByIndex* instr,
+ Register result, Register object,
+ Register index) {
+ PushSafepointRegistersScope scope(this);
+ __ Push(object, index);
+ __ li(cp, Operand::Zero());
+ __ CallRuntimeSaveDoubles(Runtime::kLoadMutableDouble);
+ RecordSafepointWithRegisters(instr->pointer_map(), 2,
+ Safepoint::kNoLazyDeopt);
+ __ StoreToSafepointRegisterSlot(r3, result);
+}
+
+
+void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
+ class DeferredLoadMutableDouble FINAL : public LDeferredCode {
+ public:
+ DeferredLoadMutableDouble(LCodeGen* codegen, LLoadFieldByIndex* instr,
+ Register result, Register object, Register index)
+ : LDeferredCode(codegen),
+ instr_(instr),
+ result_(result),
+ object_(object),
+ index_(index) {}
+ virtual void Generate() OVERRIDE {
+ codegen()->DoDeferredLoadMutableDouble(instr_, result_, object_, index_);
+ }
+ virtual LInstruction* instr() OVERRIDE { return instr_; }
+
+ private:
+ LLoadFieldByIndex* instr_;
+ Register result_;
+ Register object_;
+ Register index_;
+ };
+
+ Register object = ToRegister(instr->object());
+ Register index = ToRegister(instr->index());
+ Register result = ToRegister(instr->result());
+ Register scratch = scratch0();
+
+ DeferredLoadMutableDouble* deferred;
+ deferred = new (zone())
+ DeferredLoadMutableDouble(this, instr, result, object, index);
+
+ Label out_of_object, done;
+
+ __ TestBitMask(index, reinterpret_cast<uintptr_t>(Smi::FromInt(1)), r0);
+ __ bne(deferred->entry(), cr0);
+ __ ShiftRightArithImm(index, index, 1);
+
+ __ cmpi(index, Operand::Zero());
+ __ blt(&out_of_object);
+
+ __ SmiToPtrArrayOffset(r0, index);
+ __ add(scratch, object, r0);
+ __ LoadP(result, FieldMemOperand(scratch, JSObject::kHeaderSize));
+
+ __ b(&done);
+
+ __ bind(&out_of_object);
+ __ LoadP(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
+ // Index is equal to negated out of object property index plus 1.
+ __ SmiToPtrArrayOffset(r0, index);
+ __ sub(scratch, result, r0);
+ __ LoadP(result,
+ FieldMemOperand(scratch, FixedArray::kHeaderSize - kPointerSize));
+ __ bind(deferred->exit());
+ __ bind(&done);
+}
+
+
+void LCodeGen::DoStoreFrameContext(LStoreFrameContext* instr) {
+ Register context = ToRegister(instr->context());
+ __ StoreP(context, MemOperand(fp, StandardFrameConstants::kContextOffset));
+}
+
+
+void LCodeGen::DoAllocateBlockContext(LAllocateBlockContext* instr) {
+ Handle<ScopeInfo> scope_info = instr->scope_info();
+ __ Push(scope_info);
+ __ push(ToRegister(instr->function()));
+ CallRuntime(Runtime::kPushBlockContext, 2, instr);
+ RecordSafepoint(Safepoint::kNoLazyDeopt);
+}
+
+
+#undef __
+}
+} // namespace v8::internal
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_PPC_LITHIUM_CODEGEN_PPC_H_
+#define V8_PPC_LITHIUM_CODEGEN_PPC_H_
+
+#include "src/ppc/lithium-ppc.h"
+
+#include "src/ppc/lithium-gap-resolver-ppc.h"
+#include "src/deoptimizer.h"
+#include "src/lithium-codegen.h"
+#include "src/safepoint-table.h"
+#include "src/scopes.h"
+#include "src/utils.h"
+
+namespace v8 {
+namespace internal {
+
+// Forward declarations.
+class LDeferredCode;
+class SafepointGenerator;
+
+class LCodeGen : public LCodeGenBase {
+ public:
+ LCodeGen(LChunk* chunk, MacroAssembler* assembler, CompilationInfo* info)
+ : LCodeGenBase(chunk, assembler, info),
+ deoptimizations_(4, info->zone()),
+ jump_table_(4, info->zone()),
+ deoptimization_literals_(8, info->zone()),
+ inlined_function_count_(0),
+ scope_(info->scope()),
+ translations_(info->zone()),
+ deferred_(8, info->zone()),
+ osr_pc_offset_(-1),
+ frame_is_built_(false),
+ safepoints_(info->zone()),
+ resolver_(this),
+ expected_safepoint_kind_(Safepoint::kSimple) {
+ PopulateDeoptimizationLiteralsWithInlinedFunctions();
+ }
+
+
+ int LookupDestination(int block_id) const {
+ return chunk()->LookupDestination(block_id);
+ }
+
+ bool IsNextEmittedBlock(int block_id) const {
+ return LookupDestination(block_id) == GetNextEmittedBlock();
+ }
+
+ bool NeedsEagerFrame() const {
+ return GetStackSlotCount() > 0 || info()->is_non_deferred_calling() ||
+ !info()->IsStub() || info()->requires_frame();
+ }
+ bool NeedsDeferredFrame() const {
+ return !NeedsEagerFrame() && info()->is_deferred_calling();
+ }
+
+ LinkRegisterStatus GetLinkRegisterState() const {
+ return frame_is_built_ ? kLRHasBeenSaved : kLRHasNotBeenSaved;
+ }
+
+ // Support for converting LOperands to assembler types.
+ // LOperand must be a register.
+ Register ToRegister(LOperand* op) const;
+
+ // LOperand is loaded into scratch, unless already a register.
+ Register EmitLoadRegister(LOperand* op, Register scratch);
+
+ // LConstantOperand must be an Integer32 or Smi
+ void EmitLoadIntegerConstant(LConstantOperand* const_op, Register dst);
+
+ // LOperand must be a double register.
+ DoubleRegister ToDoubleRegister(LOperand* op) const;
+
+ intptr_t ToRepresentation(LConstantOperand* op,
+ const Representation& r) const;
+ int32_t ToInteger32(LConstantOperand* op) const;
+ Smi* ToSmi(LConstantOperand* op) const;
+ double ToDouble(LConstantOperand* op) const;
+ Operand ToOperand(LOperand* op);
+ MemOperand ToMemOperand(LOperand* op) const;
+ // Returns a MemOperand pointing to the high word of a DoubleStackSlot.
+ MemOperand ToHighMemOperand(LOperand* op) const;
+
+ bool IsInteger32(LConstantOperand* op) const;
+ bool IsSmi(LConstantOperand* op) const;
+ Handle<Object> ToHandle(LConstantOperand* op) const;
+
+ // Try to generate code for the entire chunk, but it may fail if the
+ // chunk contains constructs we cannot handle. Returns true if the
+ // code generation attempt succeeded.
+ bool GenerateCode();
+
+ // Finish the code by setting stack height, safepoint, and bailout
+ // information on it.
+ void FinishCode(Handle<Code> code);
+
+ // Deferred code support.
+ void DoDeferredNumberTagD(LNumberTagD* instr);
+
+ enum IntegerSignedness { SIGNED_INT32, UNSIGNED_INT32 };
+ void DoDeferredNumberTagIU(LInstruction* instr, LOperand* value,
+ LOperand* temp1, LOperand* temp2,
+ IntegerSignedness signedness);
+
+ void DoDeferredTaggedToI(LTaggedToI* instr);
+ void DoDeferredMathAbsTaggedHeapNumber(LMathAbs* instr);
+ void DoDeferredStackCheck(LStackCheck* instr);
+ void DoDeferredStringCharCodeAt(LStringCharCodeAt* instr);
+ void DoDeferredStringCharFromCode(LStringCharFromCode* instr);
+ void DoDeferredAllocate(LAllocate* instr);
+ void DoDeferredInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr,
+ Label* map_check);
+ void DoDeferredInstanceMigration(LCheckMaps* instr, Register object);
+ void DoDeferredLoadMutableDouble(LLoadFieldByIndex* instr, Register result,
+ Register object, Register index);
+
+ // Parallel move support.
+ void DoParallelMove(LParallelMove* move);
+ void DoGap(LGap* instr);
+
+ MemOperand PrepareKeyedOperand(Register key, Register base,
+ bool key_is_constant, bool key_is_tagged,
+ int constant_key, int element_size_shift,
+ int base_offset);
+
+ // Emit frame translation commands for an environment.
+ void WriteTranslation(LEnvironment* environment, Translation* translation);
+
+// Declare methods that deal with the individual node types.
+#define DECLARE_DO(type) void Do##type(L##type* node);
+ LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_DO)
+#undef DECLARE_DO
+
+ private:
+ StrictMode strict_mode() const { return info()->strict_mode(); }
+
+ Scope* scope() const { return scope_; }
+
+ Register scratch0() { return r11; }
+ DoubleRegister double_scratch0() { return kScratchDoubleReg; }
+
+ LInstruction* GetNextInstruction();
+
+ void EmitClassOfTest(Label* if_true, Label* if_false,
+ Handle<String> class_name, Register input,
+ Register temporary, Register temporary2);
+
+ int GetStackSlotCount() const { return chunk()->spill_slot_count(); }
+
+ void AddDeferredCode(LDeferredCode* code) { deferred_.Add(code, zone()); }
+
+ void SaveCallerDoubles();
+ void RestoreCallerDoubles();
+
+ // Code generation passes. Returns true if code generation should
+ // continue.
+ void GenerateBodyInstructionPre(LInstruction* instr) OVERRIDE;
+ bool GeneratePrologue();
+ bool GenerateDeferredCode();
+ bool GenerateJumpTable();
+ bool GenerateSafepointTable();
+
+ // Generates the custom OSR entrypoint and sets the osr_pc_offset.
+ void GenerateOsrPrologue();
+
+ enum SafepointMode {
+ RECORD_SIMPLE_SAFEPOINT,
+ RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS
+ };
+
+ void CallCode(Handle<Code> code, RelocInfo::Mode mode, LInstruction* instr);
+
+ void CallCodeGeneric(Handle<Code> code, RelocInfo::Mode mode,
+ LInstruction* instr, SafepointMode safepoint_mode);
+
+ void CallRuntime(const Runtime::Function* function, int num_arguments,
+ LInstruction* instr,
+ SaveFPRegsMode save_doubles = kDontSaveFPRegs);
+
+ void CallRuntime(Runtime::FunctionId id, int num_arguments,
+ LInstruction* instr) {
+ const Runtime::Function* function = Runtime::FunctionForId(id);
+ CallRuntime(function, num_arguments, instr);
+ }
+
+ void LoadContextFromDeferred(LOperand* context);
+ void CallRuntimeFromDeferred(Runtime::FunctionId id, int argc,
+ LInstruction* instr, LOperand* context);
+
+ enum R4State { R4_UNINITIALIZED, R4_CONTAINS_TARGET };
+
+ // Generate a direct call to a known function. Expects the function
+ // to be in r4.
+ void CallKnownFunction(Handle<JSFunction> function,
+ int formal_parameter_count, int arity,
+ LInstruction* instr, R4State r4_state);
+
+ void RecordSafepointWithLazyDeopt(LInstruction* instr,
+ SafepointMode safepoint_mode);
+
+ void RegisterEnvironmentForDeoptimization(LEnvironment* environment,
+ Safepoint::DeoptMode mode);
+ void DeoptimizeIf(Condition condition, LInstruction* instr,
+ const char* detail, Deoptimizer::BailoutType bailout_type,
+ CRegister cr = cr7);
+ void DeoptimizeIf(Condition condition, LInstruction* instr,
+ const char* detail, CRegister cr = cr7);
+
+ void AddToTranslation(LEnvironment* environment, Translation* translation,
+ LOperand* op, bool is_tagged, bool is_uint32,
+ int* object_index_pointer,
+ int* dematerialized_index_pointer);
+ void PopulateDeoptimizationData(Handle<Code> code);
+ int DefineDeoptimizationLiteral(Handle<Object> literal);
+
+ void PopulateDeoptimizationLiteralsWithInlinedFunctions();
+
+ Register ToRegister(int index) const;
+ DoubleRegister ToDoubleRegister(int index) const;
+
+ MemOperand BuildSeqStringOperand(Register string, LOperand* index,
+ String::Encoding encoding);
+
+ void EmitMathAbs(LMathAbs* instr);
+#if V8_TARGET_ARCH_PPC64
+ void EmitInteger32MathAbs(LMathAbs* instr);
+#endif
+
+ // Support for recording safepoint and position information.
+ void RecordSafepoint(LPointerMap* pointers, Safepoint::Kind kind,
+ int arguments, Safepoint::DeoptMode mode);
+ void RecordSafepoint(LPointerMap* pointers, Safepoint::DeoptMode mode);
+ void RecordSafepoint(Safepoint::DeoptMode mode);
+ void RecordSafepointWithRegisters(LPointerMap* pointers, int arguments,
+ Safepoint::DeoptMode mode);
+
+ void RecordAndWritePosition(int position) OVERRIDE;
+
+ static Condition TokenToCondition(Token::Value op);
+ void EmitGoto(int block);
+
+ // EmitBranch expects to be the last instruction of a block.
+ template <class InstrType>
+ void EmitBranch(InstrType instr, Condition condition, CRegister cr = cr7);
+ template <class InstrType>
+ void EmitFalseBranch(InstrType instr, Condition condition,
+ CRegister cr = cr7);
+ void EmitNumberUntagD(LNumberUntagD* instr, Register input,
+ DoubleRegister result, NumberUntagDMode mode);
+
+ // Emits optimized code for typeof x == "y". Modifies input register.
+ // Returns the condition on which a final split to
+ // true and false label should be made, to optimize fallthrough.
+ Condition EmitTypeofIs(Label* true_label, Label* false_label, Register input,
+ Handle<String> type_name);
+
+ // Emits optimized code for %_IsObject(x). Preserves input register.
+ // Returns the condition on which a final split to
+ // true and false label should be made, to optimize fallthrough.
+ Condition EmitIsObject(Register input, Register temp1, Label* is_not_object,
+ Label* is_object);
+
+ // Emits optimized code for %_IsString(x). Preserves input register.
+ // Returns the condition on which a final split to
+ // true and false label should be made, to optimize fallthrough.
+ Condition EmitIsString(Register input, Register temp1, Label* is_not_string,
+ SmiCheck check_needed);
+
+ // Emits optimized code for %_IsConstructCall().
+ // Caller should branch on equal condition.
+ void EmitIsConstructCall(Register temp1, Register temp2);
+
+ // Emits optimized code to deep-copy the contents of statically known
+ // object graphs (e.g. object literal boilerplate).
+ void EmitDeepCopy(Handle<JSObject> object, Register result, Register source,
+ int* offset, AllocationSiteMode mode);
+
+ void EnsureSpaceForLazyDeopt(int space_needed) OVERRIDE;
+ void DoLoadKeyedExternalArray(LLoadKeyed* instr);
+ void DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr);
+ void DoLoadKeyedFixedArray(LLoadKeyed* instr);
+ void DoStoreKeyedExternalArray(LStoreKeyed* instr);
+ void DoStoreKeyedFixedDoubleArray(LStoreKeyed* instr);
+ void DoStoreKeyedFixedArray(LStoreKeyed* instr);
+
+ template <class T>
+ void EmitVectorLoadICRegisters(T* instr);
+
+ ZoneList<LEnvironment*> deoptimizations_;
+ ZoneList<Deoptimizer::JumpTableEntry> jump_table_;
+ ZoneList<Handle<Object> > deoptimization_literals_;
+ int inlined_function_count_;
+ Scope* const scope_;
+ TranslationBuffer translations_;
+ ZoneList<LDeferredCode*> deferred_;
+ int osr_pc_offset_;
+ bool frame_is_built_;
+
+ // Builder that keeps track of safepoints in the code. The table
+ // itself is emitted at the end of the generated code.
+ SafepointTableBuilder safepoints_;
+
+ // Compiler from a set of parallel moves to a sequential list of moves.
+ LGapResolver resolver_;
+
+ Safepoint::Kind expected_safepoint_kind_;
+
+ class PushSafepointRegistersScope FINAL BASE_EMBEDDED {
+ public:
+ explicit PushSafepointRegistersScope(LCodeGen* codegen)
+ : codegen_(codegen) {
+ DCHECK(codegen_->info()->is_calling());
+ DCHECK(codegen_->expected_safepoint_kind_ == Safepoint::kSimple);
+ codegen_->expected_safepoint_kind_ = Safepoint::kWithRegisters;
+ StoreRegistersStateStub stub(codegen_->isolate());
+ codegen_->masm_->CallStub(&stub);
+ }
+
+ ~PushSafepointRegistersScope() {
+ DCHECK(codegen_->expected_safepoint_kind_ == Safepoint::kWithRegisters);
+ RestoreRegistersStateStub stub(codegen_->isolate());
+ codegen_->masm_->CallStub(&stub);
+ codegen_->expected_safepoint_kind_ = Safepoint::kSimple;
+ }
+
+ private:
+ LCodeGen* codegen_;
+ };
+
+ friend class LDeferredCode;
+ friend class LEnvironment;
+ friend class SafepointGenerator;
+ DISALLOW_COPY_AND_ASSIGN(LCodeGen);
+};
+
+
+class LDeferredCode : public ZoneObject {
+ public:
+ explicit LDeferredCode(LCodeGen* codegen)
+ : codegen_(codegen),
+ external_exit_(NULL),
+ instruction_index_(codegen->current_instruction_) {
+ codegen->AddDeferredCode(this);
+ }
+
+ virtual ~LDeferredCode() {}
+ virtual void Generate() = 0;
+ virtual LInstruction* instr() = 0;
+
+ void SetExit(Label* exit) { external_exit_ = exit; }
+ Label* entry() { return &entry_; }
+ Label* exit() { return external_exit_ != NULL ? external_exit_ : &exit_; }
+ int instruction_index() const { return instruction_index_; }
+
+ protected:
+ LCodeGen* codegen() const { return codegen_; }
+ MacroAssembler* masm() const { return codegen_->masm(); }
+
+ private:
+ LCodeGen* codegen_;
+ Label entry_;
+ Label exit_;
+ Label* external_exit_;
+ int instruction_index_;
+};
+}
+} // namespace v8::internal
+
+#endif // V8_PPC_LITHIUM_CODEGEN_PPC_H_
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#include "src/ppc/lithium-codegen-ppc.h"
+#include "src/ppc/lithium-gap-resolver-ppc.h"
+
+namespace v8 {
+namespace internal {
+
+static const Register kSavedValueRegister = {11};
+
+LGapResolver::LGapResolver(LCodeGen* owner)
+ : cgen_(owner),
+ moves_(32, owner->zone()),
+ root_index_(0),
+ in_cycle_(false),
+ saved_destination_(NULL) {}
+
+
+void LGapResolver::Resolve(LParallelMove* parallel_move) {
+ DCHECK(moves_.is_empty());
+ // Build up a worklist of moves.
+ BuildInitialMoveList(parallel_move);
+
+ for (int i = 0; i < moves_.length(); ++i) {
+ LMoveOperands move = moves_[i];
+ // Skip constants to perform them last. They don't block other moves
+ // and skipping such moves with register destinations keeps those
+ // registers free for the whole algorithm.
+ if (!move.IsEliminated() && !move.source()->IsConstantOperand()) {
+ root_index_ = i; // Any cycle is found when by reaching this move again.
+ PerformMove(i);
+ if (in_cycle_) {
+ RestoreValue();
+ }
+ }
+ }
+
+ // Perform the moves with constant sources.
+ for (int i = 0; i < moves_.length(); ++i) {
+ if (!moves_[i].IsEliminated()) {
+ DCHECK(moves_[i].source()->IsConstantOperand());
+ EmitMove(i);
+ }
+ }
+
+ moves_.Rewind(0);
+}
+
+
+void LGapResolver::BuildInitialMoveList(LParallelMove* parallel_move) {
+ // Perform a linear sweep of the moves to add them to the initial list of
+ // moves to perform, ignoring any move that is redundant (the source is
+ // the same as the destination, the destination is ignored and
+ // unallocated, or the move was already eliminated).
+ const ZoneList<LMoveOperands>* moves = parallel_move->move_operands();
+ for (int i = 0; i < moves->length(); ++i) {
+ LMoveOperands move = moves->at(i);
+ if (!move.IsRedundant()) moves_.Add(move, cgen_->zone());
+ }
+ Verify();
+}
+
+
+void LGapResolver::PerformMove(int index) {
+ // Each call to this function performs a move and deletes it from the move
+ // graph. We first recursively perform any move blocking this one. We
+ // mark a move as "pending" on entry to PerformMove in order to detect
+ // cycles in the move graph.
+
+ // We can only find a cycle, when doing a depth-first traversal of moves,
+ // be encountering the starting move again. So by spilling the source of
+ // the starting move, we break the cycle. All moves are then unblocked,
+ // and the starting move is completed by writing the spilled value to
+ // its destination. All other moves from the spilled source have been
+ // completed prior to breaking the cycle.
+ // An additional complication is that moves to MemOperands with large
+ // offsets (more than 1K or 4K) require us to spill this spilled value to
+ // the stack, to free up the register.
+ DCHECK(!moves_[index].IsPending());
+ DCHECK(!moves_[index].IsRedundant());
+
+ // Clear this move's destination to indicate a pending move. The actual
+ // destination is saved in a stack allocated local. Multiple moves can
+ // be pending because this function is recursive.
+ DCHECK(moves_[index].source() != NULL); // Or else it will look eliminated.
+ LOperand* destination = moves_[index].destination();
+ moves_[index].set_destination(NULL);
+
+ // Perform a depth-first traversal of the move graph to resolve
+ // dependencies. Any unperformed, unpending move with a source the same
+ // as this one's destination blocks this one so recursively perform all
+ // such moves.
+ for (int i = 0; i < moves_.length(); ++i) {
+ LMoveOperands other_move = moves_[i];
+ if (other_move.Blocks(destination) && !other_move.IsPending()) {
+ PerformMove(i);
+ // If there is a blocking, pending move it must be moves_[root_index_]
+ // and all other moves with the same source as moves_[root_index_] are
+ // sucessfully executed (because they are cycle-free) by this loop.
+ }
+ }
+
+ // We are about to resolve this move and don't need it marked as
+ // pending, so restore its destination.
+ moves_[index].set_destination(destination);
+
+ // The move may be blocked on a pending move, which must be the starting move.
+ // In this case, we have a cycle, and we save the source of this move to
+ // a scratch register to break it.
+ LMoveOperands other_move = moves_[root_index_];
+ if (other_move.Blocks(destination)) {
+ DCHECK(other_move.IsPending());
+ BreakCycle(index);
+ return;
+ }
+
+ // This move is no longer blocked.
+ EmitMove(index);
+}
+
+
+void LGapResolver::Verify() {
+#ifdef ENABLE_SLOW_DCHECKS
+ // No operand should be the destination for more than one move.
+ for (int i = 0; i < moves_.length(); ++i) {
+ LOperand* destination = moves_[i].destination();
+ for (int j = i + 1; j < moves_.length(); ++j) {
+ SLOW_DCHECK(!destination->Equals(moves_[j].destination()));
+ }
+ }
+#endif
+}
+
+#define __ ACCESS_MASM(cgen_->masm())
+
+void LGapResolver::BreakCycle(int index) {
+ // We save in a register the value that should end up in the source of
+ // moves_[root_index]. After performing all moves in the tree rooted
+ // in that move, we save the value to that source.
+ DCHECK(moves_[index].destination()->Equals(moves_[root_index_].source()));
+ DCHECK(!in_cycle_);
+ in_cycle_ = true;
+ LOperand* source = moves_[index].source();
+ saved_destination_ = moves_[index].destination();
+ if (source->IsRegister()) {
+ __ mr(kSavedValueRegister, cgen_->ToRegister(source));
+ } else if (source->IsStackSlot()) {
+ __ LoadP(kSavedValueRegister, cgen_->ToMemOperand(source));
+ } else if (source->IsDoubleRegister()) {
+ __ fmr(kScratchDoubleReg, cgen_->ToDoubleRegister(source));
+ } else if (source->IsDoubleStackSlot()) {
+ __ lfd(kScratchDoubleReg, cgen_->ToMemOperand(source));
+ } else {
+ UNREACHABLE();
+ }
+ // This move will be done by restoring the saved value to the destination.
+ moves_[index].Eliminate();
+}
+
+
+void LGapResolver::RestoreValue() {
+ DCHECK(in_cycle_);
+ DCHECK(saved_destination_ != NULL);
+
+ // Spilled value is in kSavedValueRegister or kSavedDoubleValueRegister.
+ if (saved_destination_->IsRegister()) {
+ __ mr(cgen_->ToRegister(saved_destination_), kSavedValueRegister);
+ } else if (saved_destination_->IsStackSlot()) {
+ __ StoreP(kSavedValueRegister, cgen_->ToMemOperand(saved_destination_));
+ } else if (saved_destination_->IsDoubleRegister()) {
+ __ fmr(cgen_->ToDoubleRegister(saved_destination_), kScratchDoubleReg);
+ } else if (saved_destination_->IsDoubleStackSlot()) {
+ __ stfd(kScratchDoubleReg, cgen_->ToMemOperand(saved_destination_));
+ } else {
+ UNREACHABLE();
+ }
+
+ in_cycle_ = false;
+ saved_destination_ = NULL;
+}
+
+
+void LGapResolver::EmitMove(int index) {
+ LOperand* source = moves_[index].source();
+ LOperand* destination = moves_[index].destination();
+
+ // Dispatch on the source and destination operand kinds. Not all
+ // combinations are possible.
+
+ if (source->IsRegister()) {
+ Register source_register = cgen_->ToRegister(source);
+ if (destination->IsRegister()) {
+ __ mr(cgen_->ToRegister(destination), source_register);
+ } else {
+ DCHECK(destination->IsStackSlot());
+ __ StoreP(source_register, cgen_->ToMemOperand(destination));
+ }
+ } else if (source->IsStackSlot()) {
+ MemOperand source_operand = cgen_->ToMemOperand(source);
+ if (destination->IsRegister()) {
+ __ LoadP(cgen_->ToRegister(destination), source_operand);
+ } else {
+ DCHECK(destination->IsStackSlot());
+ MemOperand destination_operand = cgen_->ToMemOperand(destination);
+ if (in_cycle_) {
+ __ LoadP(ip, source_operand);
+ __ StoreP(ip, destination_operand);
+ } else {
+ __ LoadP(kSavedValueRegister, source_operand);
+ __ StoreP(kSavedValueRegister, destination_operand);
+ }
+ }
+
+ } else if (source->IsConstantOperand()) {
+ LConstantOperand* constant_source = LConstantOperand::cast(source);
+ if (destination->IsRegister()) {
+ Register dst = cgen_->ToRegister(destination);
+ if (cgen_->IsInteger32(constant_source)) {
+ cgen_->EmitLoadIntegerConstant(constant_source, dst);
+ } else {
+ __ Move(dst, cgen_->ToHandle(constant_source));
+ }
+ } else if (destination->IsDoubleRegister()) {
+ DoubleRegister result = cgen_->ToDoubleRegister(destination);
+ double v = cgen_->ToDouble(constant_source);
+ __ LoadDoubleLiteral(result, v, ip);
+ } else {
+ DCHECK(destination->IsStackSlot());
+ DCHECK(!in_cycle_); // Constant moves happen after all cycles are gone.
+ if (cgen_->IsInteger32(constant_source)) {
+ cgen_->EmitLoadIntegerConstant(constant_source, kSavedValueRegister);
+ } else {
+ __ Move(kSavedValueRegister, cgen_->ToHandle(constant_source));
+ }
+ __ StoreP(kSavedValueRegister, cgen_->ToMemOperand(destination));
+ }
+
+ } else if (source->IsDoubleRegister()) {
+ DoubleRegister source_register = cgen_->ToDoubleRegister(source);
+ if (destination->IsDoubleRegister()) {
+ __ fmr(cgen_->ToDoubleRegister(destination), source_register);
+ } else {
+ DCHECK(destination->IsDoubleStackSlot());
+ __ stfd(source_register, cgen_->ToMemOperand(destination));
+ }
+
+ } else if (source->IsDoubleStackSlot()) {
+ MemOperand source_operand = cgen_->ToMemOperand(source);
+ if (destination->IsDoubleRegister()) {
+ __ lfd(cgen_->ToDoubleRegister(destination), source_operand);
+ } else {
+ DCHECK(destination->IsDoubleStackSlot());
+ MemOperand destination_operand = cgen_->ToMemOperand(destination);
+ if (in_cycle_) {
+// kSavedDoubleValueRegister was used to break the cycle,
+// but kSavedValueRegister is free.
+#if V8_TARGET_ARCH_PPC64
+ __ ld(kSavedValueRegister, source_operand);
+ __ std(kSavedValueRegister, destination_operand);
+#else
+ MemOperand source_high_operand = cgen_->ToHighMemOperand(source);
+ MemOperand destination_high_operand =
+ cgen_->ToHighMemOperand(destination);
+ __ lwz(kSavedValueRegister, source_operand);
+ __ stw(kSavedValueRegister, destination_operand);
+ __ lwz(kSavedValueRegister, source_high_operand);
+ __ stw(kSavedValueRegister, destination_high_operand);
+#endif
+ } else {
+ __ lfd(kScratchDoubleReg, source_operand);
+ __ stfd(kScratchDoubleReg, destination_operand);
+ }
+ }
+ } else {
+ UNREACHABLE();
+ }
+
+ moves_[index].Eliminate();
+}
+
+
+#undef __
+}
+} // namespace v8::internal
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_PPC_LITHIUM_GAP_RESOLVER_PPC_H_
+#define V8_PPC_LITHIUM_GAP_RESOLVER_PPC_H_
+
+#include "src/v8.h"
+
+#include "src/lithium.h"
+
+namespace v8 {
+namespace internal {
+
+class LCodeGen;
+class LGapResolver;
+
+class LGapResolver FINAL BASE_EMBEDDED {
+ public:
+ explicit LGapResolver(LCodeGen* owner);
+
+ // Resolve a set of parallel moves, emitting assembler instructions.
+ void Resolve(LParallelMove* parallel_move);
+
+ private:
+ // Build the initial list of moves.
+ void BuildInitialMoveList(LParallelMove* parallel_move);
+
+ // Perform the move at the moves_ index in question (possibly requiring
+ // other moves to satisfy dependencies).
+ void PerformMove(int index);
+
+ // If a cycle is found in the series of moves, save the blocking value to
+ // a scratch register. The cycle must be found by hitting the root of the
+ // depth-first search.
+ void BreakCycle(int index);
+
+ // After a cycle has been resolved, restore the value from the scratch
+ // register to its proper destination.
+ void RestoreValue();
+
+ // Emit a move and remove it from the move graph.
+ void EmitMove(int index);
+
+ // Verify the move list before performing moves.
+ void Verify();
+
+ LCodeGen* cgen_;
+
+ // List of moves not yet resolved.
+ ZoneList<LMoveOperands> moves_;
+
+ int root_index_;
+ bool in_cycle_;
+ LOperand* saved_destination_;
+};
+}
+} // namespace v8::internal
+
+#endif // V8_PPC_LITHIUM_GAP_RESOLVER_PPC_H_
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <sstream>
+
+#include "src/v8.h"
+
+#include "src/hydrogen-osr.h"
+#include "src/lithium-inl.h"
+#include "src/ppc/lithium-codegen-ppc.h"
+
+namespace v8 {
+namespace internal {
+
+#define DEFINE_COMPILE(type) \
+ void L##type::CompileToNative(LCodeGen* generator) { \
+ generator->Do##type(this); \
+ }
+LITHIUM_CONCRETE_INSTRUCTION_LIST(DEFINE_COMPILE)
+#undef DEFINE_COMPILE
+
+#ifdef DEBUG
+void LInstruction::VerifyCall() {
+ // Call instructions can use only fixed registers as temporaries and
+ // outputs because all registers are blocked by the calling convention.
+ // Inputs operands must use a fixed register or use-at-start policy or
+ // a non-register policy.
+ DCHECK(Output() == NULL || LUnallocated::cast(Output())->HasFixedPolicy() ||
+ !LUnallocated::cast(Output())->HasRegisterPolicy());
+ for (UseIterator it(this); !it.Done(); it.Advance()) {
+ LUnallocated* operand = LUnallocated::cast(it.Current());
+ DCHECK(operand->HasFixedPolicy() || operand->IsUsedAtStart());
+ }
+ for (TempIterator it(this); !it.Done(); it.Advance()) {
+ LUnallocated* operand = LUnallocated::cast(it.Current());
+ DCHECK(operand->HasFixedPolicy() || !operand->HasRegisterPolicy());
+ }
+}
+#endif
+
+
+void LInstruction::PrintTo(StringStream* stream) {
+ stream->Add("%s ", this->Mnemonic());
+
+ PrintOutputOperandTo(stream);
+
+ PrintDataTo(stream);
+
+ if (HasEnvironment()) {
+ stream->Add(" ");
+ environment()->PrintTo(stream);
+ }
+
+ if (HasPointerMap()) {
+ stream->Add(" ");
+ pointer_map()->PrintTo(stream);
+ }
+}
+
+
+void LInstruction::PrintDataTo(StringStream* stream) {
+ stream->Add("= ");
+ for (int i = 0; i < InputCount(); i++) {
+ if (i > 0) stream->Add(" ");
+ if (InputAt(i) == NULL) {
+ stream->Add("NULL");
+ } else {
+ InputAt(i)->PrintTo(stream);
+ }
+ }
+}
+
+
+void LInstruction::PrintOutputOperandTo(StringStream* stream) {
+ if (HasResult()) result()->PrintTo(stream);
+}
+
+
+void LLabel::PrintDataTo(StringStream* stream) {
+ LGap::PrintDataTo(stream);
+ LLabel* rep = replacement();
+ if (rep != NULL) {
+ stream->Add(" Dead block replaced with B%d", rep->block_id());
+ }
+}
+
+
+bool LGap::IsRedundant() const {
+ for (int i = 0; i < 4; i++) {
+ if (parallel_moves_[i] != NULL && !parallel_moves_[i]->IsRedundant()) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+
+void LGap::PrintDataTo(StringStream* stream) {
+ for (int i = 0; i < 4; i++) {
+ stream->Add("(");
+ if (parallel_moves_[i] != NULL) {
+ parallel_moves_[i]->PrintDataTo(stream);
+ }
+ stream->Add(") ");
+ }
+}
+
+
+const char* LArithmeticD::Mnemonic() const {
+ switch (op()) {
+ case Token::ADD:
+ return "add-d";
+ case Token::SUB:
+ return "sub-d";
+ case Token::MUL:
+ return "mul-d";
+ case Token::DIV:
+ return "div-d";
+ case Token::MOD:
+ return "mod-d";
+ default:
+ UNREACHABLE();
+ return NULL;
+ }
+}
+
+
+const char* LArithmeticT::Mnemonic() const {
+ switch (op()) {
+ case Token::ADD:
+ return "add-t";
+ case Token::SUB:
+ return "sub-t";
+ case Token::MUL:
+ return "mul-t";
+ case Token::MOD:
+ return "mod-t";
+ case Token::DIV:
+ return "div-t";
+ case Token::BIT_AND:
+ return "bit-and-t";
+ case Token::BIT_OR:
+ return "bit-or-t";
+ case Token::BIT_XOR:
+ return "bit-xor-t";
+ case Token::ROR:
+ return "ror-t";
+ case Token::SHL:
+ return "shl-t";
+ case Token::SAR:
+ return "sar-t";
+ case Token::SHR:
+ return "shr-t";
+ default:
+ UNREACHABLE();
+ return NULL;
+ }
+}
+
+
+bool LGoto::HasInterestingComment(LCodeGen* gen) const {
+ return !gen->IsNextEmittedBlock(block_id());
+}
+
+
+void LGoto::PrintDataTo(StringStream* stream) {
+ stream->Add("B%d", block_id());
+}
+
+
+void LBranch::PrintDataTo(StringStream* stream) {
+ stream->Add("B%d | B%d on ", true_block_id(), false_block_id());
+ value()->PrintTo(stream);
+}
+
+
+void LCompareNumericAndBranch::PrintDataTo(StringStream* stream) {
+ stream->Add("if ");
+ left()->PrintTo(stream);
+ stream->Add(" %s ", Token::String(op()));
+ right()->PrintTo(stream);
+ stream->Add(" then B%d else B%d", true_block_id(), false_block_id());
+}
+
+
+void LIsObjectAndBranch::PrintDataTo(StringStream* stream) {
+ stream->Add("if is_object(");
+ value()->PrintTo(stream);
+ stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
+}
+
+
+void LIsStringAndBranch::PrintDataTo(StringStream* stream) {
+ stream->Add("if is_string(");
+ value()->PrintTo(stream);
+ stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
+}
+
+
+void LIsSmiAndBranch::PrintDataTo(StringStream* stream) {
+ stream->Add("if is_smi(");
+ value()->PrintTo(stream);
+ stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
+}
+
+
+void LIsUndetectableAndBranch::PrintDataTo(StringStream* stream) {
+ stream->Add("if is_undetectable(");
+ value()->PrintTo(stream);
+ stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
+}
+
+
+void LStringCompareAndBranch::PrintDataTo(StringStream* stream) {
+ stream->Add("if string_compare(");
+ left()->PrintTo(stream);
+ right()->PrintTo(stream);
+ stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
+}
+
+
+void LHasInstanceTypeAndBranch::PrintDataTo(StringStream* stream) {
+ stream->Add("if has_instance_type(");
+ value()->PrintTo(stream);
+ stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
+}
+
+
+void LHasCachedArrayIndexAndBranch::PrintDataTo(StringStream* stream) {
+ stream->Add("if has_cached_array_index(");
+ value()->PrintTo(stream);
+ stream->Add(") then B%d else B%d", true_block_id(), false_block_id());
+}
+
+
+void LClassOfTestAndBranch::PrintDataTo(StringStream* stream) {
+ stream->Add("if class_of_test(");
+ value()->PrintTo(stream);
+ stream->Add(", \"%o\") then B%d else B%d", *hydrogen()->class_name(),
+ true_block_id(), false_block_id());
+}
+
+
+void LTypeofIsAndBranch::PrintDataTo(StringStream* stream) {
+ stream->Add("if typeof ");
+ value()->PrintTo(stream);
+ stream->Add(" == \"%s\" then B%d else B%d",
+ hydrogen()->type_literal()->ToCString().get(), true_block_id(),
+ false_block_id());
+}
+
+
+void LStoreCodeEntry::PrintDataTo(StringStream* stream) {
+ stream->Add(" = ");
+ function()->PrintTo(stream);
+ stream->Add(".code_entry = ");
+ code_object()->PrintTo(stream);
+}
+
+
+void LInnerAllocatedObject::PrintDataTo(StringStream* stream) {
+ stream->Add(" = ");
+ base_object()->PrintTo(stream);
+ stream->Add(" + ");
+ offset()->PrintTo(stream);
+}
+
+
+void LCallJSFunction::PrintDataTo(StringStream* stream) {
+ stream->Add("= ");
+ function()->PrintTo(stream);
+ stream->Add("#%d / ", arity());
+}
+
+
+void LCallWithDescriptor::PrintDataTo(StringStream* stream) {
+ for (int i = 0; i < InputCount(); i++) {
+ InputAt(i)->PrintTo(stream);
+ stream->Add(" ");
+ }
+ stream->Add("#%d / ", arity());
+}
+
+
+void LLoadContextSlot::PrintDataTo(StringStream* stream) {
+ context()->PrintTo(stream);
+ stream->Add("[%d]", slot_index());
+}
+
+
+void LStoreContextSlot::PrintDataTo(StringStream* stream) {
+ context()->PrintTo(stream);
+ stream->Add("[%d] <- ", slot_index());
+ value()->PrintTo(stream);
+}
+
+
+void LInvokeFunction::PrintDataTo(StringStream* stream) {
+ stream->Add("= ");
+ function()->PrintTo(stream);
+ stream->Add(" #%d / ", arity());
+}
+
+
+void LCallNew::PrintDataTo(StringStream* stream) {
+ stream->Add("= ");
+ constructor()->PrintTo(stream);
+ stream->Add(" #%d / ", arity());
+}
+
+
+void LCallNewArray::PrintDataTo(StringStream* stream) {
+ stream->Add("= ");
+ constructor()->PrintTo(stream);
+ stream->Add(" #%d / ", arity());
+ ElementsKind kind = hydrogen()->elements_kind();
+ stream->Add(" (%s) ", ElementsKindToString(kind));
+}
+
+
+void LAccessArgumentsAt::PrintDataTo(StringStream* stream) {
+ arguments()->PrintTo(stream);
+ stream->Add(" length ");
+ length()->PrintTo(stream);
+ stream->Add(" index ");
+ index()->PrintTo(stream);
+}
+
+
+void LStoreNamedField::PrintDataTo(StringStream* stream) {
+ object()->PrintTo(stream);
+ std::ostringstream os;
+ os << hydrogen()->access() << " <- ";
+ stream->Add(os.str().c_str());
+ value()->PrintTo(stream);
+}
+
+
+void LStoreNamedGeneric::PrintDataTo(StringStream* stream) {
+ object()->PrintTo(stream);
+ stream->Add(".");
+ stream->Add(String::cast(*name())->ToCString().get());
+ stream->Add(" <- ");
+ value()->PrintTo(stream);
+}
+
+
+void LLoadKeyed::PrintDataTo(StringStream* stream) {
+ elements()->PrintTo(stream);
+ stream->Add("[");
+ key()->PrintTo(stream);
+ if (hydrogen()->IsDehoisted()) {
+ stream->Add(" + %d]", base_offset());
+ } else {
+ stream->Add("]");
+ }
+}
+
+
+void LStoreKeyed::PrintDataTo(StringStream* stream) {
+ elements()->PrintTo(stream);
+ stream->Add("[");
+ key()->PrintTo(stream);
+ if (hydrogen()->IsDehoisted()) {
+ stream->Add(" + %d] <-", base_offset());
+ } else {
+ stream->Add("] <- ");
+ }
+
+ if (value() == NULL) {
+ DCHECK(hydrogen()->IsConstantHoleStore() &&
+ hydrogen()->value()->representation().IsDouble());
+ stream->Add("<the hole(nan)>");
+ } else {
+ value()->PrintTo(stream);
+ }
+}
+
+
+void LStoreKeyedGeneric::PrintDataTo(StringStream* stream) {
+ object()->PrintTo(stream);
+ stream->Add("[");
+ key()->PrintTo(stream);
+ stream->Add("] <- ");
+ value()->PrintTo(stream);
+}
+
+
+void LTransitionElementsKind::PrintDataTo(StringStream* stream) {
+ object()->PrintTo(stream);
+ stream->Add(" %p -> %p", *original_map(), *transitioned_map());
+}
+
+
+int LPlatformChunk::GetNextSpillIndex(RegisterKind kind) {
+ // Skip a slot if for a double-width slot.
+ if (kind == DOUBLE_REGISTERS) spill_slot_count_++;
+ return spill_slot_count_++;
+}
+
+
+LOperand* LPlatformChunk::GetNextSpillSlot(RegisterKind kind) {
+ int index = GetNextSpillIndex(kind);
+ if (kind == DOUBLE_REGISTERS) {
+ return LDoubleStackSlot::Create(index, zone());
+ } else {
+ DCHECK(kind == GENERAL_REGISTERS);
+ return LStackSlot::Create(index, zone());
+ }
+}
+
+
+LPlatformChunk* LChunkBuilder::Build() {
+ DCHECK(is_unused());
+ chunk_ = new (zone()) LPlatformChunk(info(), graph());
+ LPhase phase("L_Building chunk", chunk_);
+ status_ = BUILDING;
+
+ // If compiling for OSR, reserve space for the unoptimized frame,
+ // which will be subsumed into this frame.
+ if (graph()->has_osr()) {
+ for (int i = graph()->osr()->UnoptimizedFrameSlots(); i > 0; i--) {
+ chunk_->GetNextSpillIndex(GENERAL_REGISTERS);
+ }
+ }
+
+ const ZoneList<HBasicBlock*>* blocks = graph()->blocks();
+ for (int i = 0; i < blocks->length(); i++) {
+ HBasicBlock* next = NULL;
+ if (i < blocks->length() - 1) next = blocks->at(i + 1);
+ DoBasicBlock(blocks->at(i), next);
+ if (is_aborted()) return NULL;
+ }
+ status_ = DONE;
+ return chunk_;
+}
+
+
+LUnallocated* LChunkBuilder::ToUnallocated(Register reg) {
+ return new (zone()) LUnallocated(LUnallocated::FIXED_REGISTER,
+ Register::ToAllocationIndex(reg));
+}
+
+
+LUnallocated* LChunkBuilder::ToUnallocated(DoubleRegister reg) {
+ return new (zone()) LUnallocated(LUnallocated::FIXED_DOUBLE_REGISTER,
+ DoubleRegister::ToAllocationIndex(reg));
+}
+
+
+LOperand* LChunkBuilder::UseFixed(HValue* value, Register fixed_register) {
+ return Use(value, ToUnallocated(fixed_register));
+}
+
+
+LOperand* LChunkBuilder::UseFixedDouble(HValue* value, DoubleRegister reg) {
+ return Use(value, ToUnallocated(reg));
+}
+
+
+LOperand* LChunkBuilder::UseRegister(HValue* value) {
+ return Use(value,
+ new (zone()) LUnallocated(LUnallocated::MUST_HAVE_REGISTER));
+}
+
+
+LOperand* LChunkBuilder::UseRegisterAtStart(HValue* value) {
+ return Use(value, new (zone()) LUnallocated(LUnallocated::MUST_HAVE_REGISTER,
+ LUnallocated::USED_AT_START));
+}
+
+
+LOperand* LChunkBuilder::UseTempRegister(HValue* value) {
+ return Use(value, new (zone()) LUnallocated(LUnallocated::WRITABLE_REGISTER));
+}
+
+
+LOperand* LChunkBuilder::Use(HValue* value) {
+ return Use(value, new (zone()) LUnallocated(LUnallocated::NONE));
+}
+
+
+LOperand* LChunkBuilder::UseAtStart(HValue* value) {
+ return Use(value, new (zone())
+ LUnallocated(LUnallocated::NONE, LUnallocated::USED_AT_START));
+}
+
+
+LOperand* LChunkBuilder::UseOrConstant(HValue* value) {
+ return value->IsConstant()
+ ? chunk_->DefineConstantOperand(HConstant::cast(value))
+ : Use(value);
+}
+
+
+LOperand* LChunkBuilder::UseOrConstantAtStart(HValue* value) {
+ return value->IsConstant()
+ ? chunk_->DefineConstantOperand(HConstant::cast(value))
+ : UseAtStart(value);
+}
+
+
+LOperand* LChunkBuilder::UseRegisterOrConstant(HValue* value) {
+ return value->IsConstant()
+ ? chunk_->DefineConstantOperand(HConstant::cast(value))
+ : UseRegister(value);
+}
+
+
+LOperand* LChunkBuilder::UseRegisterOrConstantAtStart(HValue* value) {
+ return value->IsConstant()
+ ? chunk_->DefineConstantOperand(HConstant::cast(value))
+ : UseRegisterAtStart(value);
+}
+
+
+LOperand* LChunkBuilder::UseConstant(HValue* value) {
+ return chunk_->DefineConstantOperand(HConstant::cast(value));
+}
+
+
+LOperand* LChunkBuilder::UseAny(HValue* value) {
+ return value->IsConstant()
+ ? chunk_->DefineConstantOperand(HConstant::cast(value))
+ : Use(value, new (zone()) LUnallocated(LUnallocated::ANY));
+}
+
+
+LOperand* LChunkBuilder::Use(HValue* value, LUnallocated* operand) {
+ if (value->EmitAtUses()) {
+ HInstruction* instr = HInstruction::cast(value);
+ VisitInstruction(instr);
+ }
+ operand->set_virtual_register(value->id());
+ return operand;
+}
+
+
+LInstruction* LChunkBuilder::Define(LTemplateResultInstruction<1>* instr,
+ LUnallocated* result) {
+ result->set_virtual_register(current_instruction_->id());
+ instr->set_result(result);
+ return instr;
+}
+
+
+LInstruction* LChunkBuilder::DefineAsRegister(
+ LTemplateResultInstruction<1>* instr) {
+ return Define(instr,
+ new (zone()) LUnallocated(LUnallocated::MUST_HAVE_REGISTER));
+}
+
+
+LInstruction* LChunkBuilder::DefineAsSpilled(
+ LTemplateResultInstruction<1>* instr, int index) {
+ return Define(instr,
+ new (zone()) LUnallocated(LUnallocated::FIXED_SLOT, index));
+}
+
+
+LInstruction* LChunkBuilder::DefineSameAsFirst(
+ LTemplateResultInstruction<1>* instr) {
+ return Define(instr,
+ new (zone()) LUnallocated(LUnallocated::SAME_AS_FIRST_INPUT));
+}
+
+
+LInstruction* LChunkBuilder::DefineFixed(LTemplateResultInstruction<1>* instr,
+ Register reg) {
+ return Define(instr, ToUnallocated(reg));
+}
+
+
+LInstruction* LChunkBuilder::DefineFixedDouble(
+ LTemplateResultInstruction<1>* instr, DoubleRegister reg) {
+ return Define(instr, ToUnallocated(reg));
+}
+
+
+LInstruction* LChunkBuilder::AssignEnvironment(LInstruction* instr) {
+ HEnvironment* hydrogen_env = current_block_->last_environment();
+ int argument_index_accumulator = 0;
+ ZoneList<HValue*> objects_to_materialize(0, zone());
+ instr->set_environment(CreateEnvironment(
+ hydrogen_env, &argument_index_accumulator, &objects_to_materialize));
+ return instr;
+}
+
+
+LInstruction* LChunkBuilder::MarkAsCall(LInstruction* instr,
+ HInstruction* hinstr,
+ CanDeoptimize can_deoptimize) {
+ info()->MarkAsNonDeferredCalling();
+#ifdef DEBUG
+ instr->VerifyCall();
+#endif
+ instr->MarkAsCall();
+ instr = AssignPointerMap(instr);
+
+ // If instruction does not have side-effects lazy deoptimization
+ // after the call will try to deoptimize to the point before the call.
+ // Thus we still need to attach environment to this call even if
+ // call sequence can not deoptimize eagerly.
+ bool needs_environment = (can_deoptimize == CAN_DEOPTIMIZE_EAGERLY) ||
+ !hinstr->HasObservableSideEffects();
+ if (needs_environment && !instr->HasEnvironment()) {
+ instr = AssignEnvironment(instr);
+ // We can't really figure out if the environment is needed or not.
+ instr->environment()->set_has_been_used();
+ }
+
+ return instr;
+}
+
+
+LInstruction* LChunkBuilder::AssignPointerMap(LInstruction* instr) {
+ DCHECK(!instr->HasPointerMap());
+ instr->set_pointer_map(new (zone()) LPointerMap(zone()));
+ return instr;
+}
+
+
+LUnallocated* LChunkBuilder::TempRegister() {
+ LUnallocated* operand =
+ new (zone()) LUnallocated(LUnallocated::MUST_HAVE_REGISTER);
+ int vreg = allocator_->GetVirtualRegister();
+ if (!allocator_->AllocationOk()) {
+ Abort(kOutOfVirtualRegistersWhileTryingToAllocateTempRegister);
+ vreg = 0;
+ }
+ operand->set_virtual_register(vreg);
+ return operand;
+}
+
+
+LUnallocated* LChunkBuilder::TempDoubleRegister() {
+ LUnallocated* operand =
+ new (zone()) LUnallocated(LUnallocated::MUST_HAVE_DOUBLE_REGISTER);
+ int vreg = allocator_->GetVirtualRegister();
+ if (!allocator_->AllocationOk()) {
+ Abort(kOutOfVirtualRegistersWhileTryingToAllocateTempRegister);
+ vreg = 0;
+ }
+ operand->set_virtual_register(vreg);
+ return operand;
+}
+
+
+LOperand* LChunkBuilder::FixedTemp(Register reg) {
+ LUnallocated* operand = ToUnallocated(reg);
+ DCHECK(operand->HasFixedPolicy());
+ return operand;
+}
+
+
+LOperand* LChunkBuilder::FixedTemp(DoubleRegister reg) {
+ LUnallocated* operand = ToUnallocated(reg);
+ DCHECK(operand->HasFixedPolicy());
+ return operand;
+}
+
+
+LInstruction* LChunkBuilder::DoBlockEntry(HBlockEntry* instr) {
+ return new (zone()) LLabel(instr->block());
+}
+
+
+LInstruction* LChunkBuilder::DoDummyUse(HDummyUse* instr) {
+ return DefineAsRegister(new (zone()) LDummyUse(UseAny(instr->value())));
+}
+
+
+LInstruction* LChunkBuilder::DoEnvironmentMarker(HEnvironmentMarker* instr) {
+ UNREACHABLE();
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoDeoptimize(HDeoptimize* instr) {
+ return AssignEnvironment(new (zone()) LDeoptimize);
+}
+
+
+LInstruction* LChunkBuilder::DoShift(Token::Value op,
+ HBitwiseBinaryOperation* instr) {
+ if (instr->representation().IsSmiOrInteger32()) {
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ LOperand* left = UseRegisterAtStart(instr->left());
+
+ HValue* right_value = instr->right();
+ LOperand* right = NULL;
+ int constant_value = 0;
+ bool does_deopt = false;
+ if (right_value->IsConstant()) {
+ HConstant* constant = HConstant::cast(right_value);
+ right = chunk_->DefineConstantOperand(constant);
+ constant_value = constant->Integer32Value() & 0x1f;
+ // Left shifts can deoptimize if we shift by > 0 and the result cannot be
+ // truncated to smi.
+ if (instr->representation().IsSmi() && constant_value > 0) {
+ does_deopt = !instr->CheckUsesForFlag(HValue::kTruncatingToSmi);
+ }
+ } else {
+ right = UseRegisterAtStart(right_value);
+ }
+
+ // Shift operations can only deoptimize if we do a logical shift
+ // by 0 and the result cannot be truncated to int32.
+ if (op == Token::SHR && constant_value == 0) {
+ does_deopt = !instr->CheckFlag(HInstruction::kUint32);
+ }
+
+ LInstruction* result =
+ DefineAsRegister(new (zone()) LShiftI(op, left, right, does_deopt));
+ return does_deopt ? AssignEnvironment(result) : result;
+ } else {
+ return DoArithmeticT(op, instr);
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoArithmeticD(Token::Value op,
+ HArithmeticBinaryOperation* instr) {
+ DCHECK(instr->representation().IsDouble());
+ DCHECK(instr->left()->representation().IsDouble());
+ DCHECK(instr->right()->representation().IsDouble());
+ if (op == Token::MOD) {
+ LOperand* left = UseFixedDouble(instr->left(), d1);
+ LOperand* right = UseFixedDouble(instr->right(), d2);
+ LArithmeticD* result = new (zone()) LArithmeticD(op, left, right);
+ // We call a C function for double modulo. It can't trigger a GC. We need
+ // to use fixed result register for the call.
+ // TODO(fschneider): Allow any register as input registers.
+ return MarkAsCall(DefineFixedDouble(result, d1), instr);
+ } else {
+ LOperand* left = UseRegisterAtStart(instr->left());
+ LOperand* right = UseRegisterAtStart(instr->right());
+ LArithmeticD* result = new (zone()) LArithmeticD(op, left, right);
+ return DefineAsRegister(result);
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoArithmeticT(Token::Value op,
+ HBinaryOperation* instr) {
+ HValue* left = instr->left();
+ HValue* right = instr->right();
+ DCHECK(left->representation().IsTagged());
+ DCHECK(right->representation().IsTagged());
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* left_operand = UseFixed(left, r4);
+ LOperand* right_operand = UseFixed(right, r3);
+ LArithmeticT* result =
+ new (zone()) LArithmeticT(op, context, left_operand, right_operand);
+ return MarkAsCall(DefineFixed(result, r3), instr);
+}
+
+
+void LChunkBuilder::DoBasicBlock(HBasicBlock* block, HBasicBlock* next_block) {
+ DCHECK(is_building());
+ current_block_ = block;
+ next_block_ = next_block;
+ if (block->IsStartBlock()) {
+ block->UpdateEnvironment(graph_->start_environment());
+ argument_count_ = 0;
+ } else if (block->predecessors()->length() == 1) {
+ // We have a single predecessor => copy environment and outgoing
+ // argument count from the predecessor.
+ DCHECK(block->phis()->length() == 0);
+ HBasicBlock* pred = block->predecessors()->at(0);
+ HEnvironment* last_environment = pred->last_environment();
+ DCHECK(last_environment != NULL);
+ // Only copy the environment, if it is later used again.
+ if (pred->end()->SecondSuccessor() == NULL) {
+ DCHECK(pred->end()->FirstSuccessor() == block);
+ } else {
+ if (pred->end()->FirstSuccessor()->block_id() > block->block_id() ||
+ pred->end()->SecondSuccessor()->block_id() > block->block_id()) {
+ last_environment = last_environment->Copy();
+ }
+ }
+ block->UpdateEnvironment(last_environment);
+ DCHECK(pred->argument_count() >= 0);
+ argument_count_ = pred->argument_count();
+ } else {
+ // We are at a state join => process phis.
+ HBasicBlock* pred = block->predecessors()->at(0);
+ // No need to copy the environment, it cannot be used later.
+ HEnvironment* last_environment = pred->last_environment();
+ for (int i = 0; i < block->phis()->length(); ++i) {
+ HPhi* phi = block->phis()->at(i);
+ if (phi->HasMergedIndex()) {
+ last_environment->SetValueAt(phi->merged_index(), phi);
+ }
+ }
+ for (int i = 0; i < block->deleted_phis()->length(); ++i) {
+ if (block->deleted_phis()->at(i) < last_environment->length()) {
+ last_environment->SetValueAt(block->deleted_phis()->at(i),
+ graph_->GetConstantUndefined());
+ }
+ }
+ block->UpdateEnvironment(last_environment);
+ // Pick up the outgoing argument count of one of the predecessors.
+ argument_count_ = pred->argument_count();
+ }
+ HInstruction* current = block->first();
+ int start = chunk_->instructions()->length();
+ while (current != NULL && !is_aborted()) {
+ // Code for constants in registers is generated lazily.
+ if (!current->EmitAtUses()) {
+ VisitInstruction(current);
+ }
+ current = current->next();
+ }
+ int end = chunk_->instructions()->length() - 1;
+ if (end >= start) {
+ block->set_first_instruction_index(start);
+ block->set_last_instruction_index(end);
+ }
+ block->set_argument_count(argument_count_);
+ next_block_ = NULL;
+ current_block_ = NULL;
+}
+
+
+void LChunkBuilder::VisitInstruction(HInstruction* current) {
+ HInstruction* old_current = current_instruction_;
+ current_instruction_ = current;
+
+ LInstruction* instr = NULL;
+ if (current->CanReplaceWithDummyUses()) {
+ if (current->OperandCount() == 0) {
+ instr = DefineAsRegister(new (zone()) LDummy());
+ } else {
+ DCHECK(!current->OperandAt(0)->IsControlInstruction());
+ instr = DefineAsRegister(new (zone())
+ LDummyUse(UseAny(current->OperandAt(0))));
+ }
+ for (int i = 1; i < current->OperandCount(); ++i) {
+ if (current->OperandAt(i)->IsControlInstruction()) continue;
+ LInstruction* dummy =
+ new (zone()) LDummyUse(UseAny(current->OperandAt(i)));
+ dummy->set_hydrogen_value(current);
+ chunk_->AddInstruction(dummy, current_block_);
+ }
+ } else {
+ HBasicBlock* successor;
+ if (current->IsControlInstruction() &&
+ HControlInstruction::cast(current)->KnownSuccessorBlock(&successor) &&
+ successor != NULL) {
+ instr = new (zone()) LGoto(successor);
+ } else {
+ instr = current->CompileToLithium(this);
+ }
+ }
+
+ argument_count_ += current->argument_delta();
+ DCHECK(argument_count_ >= 0);
+
+ if (instr != NULL) {
+ AddInstruction(instr, current);
+ }
+
+ current_instruction_ = old_current;
+}
+
+
+void LChunkBuilder::AddInstruction(LInstruction* instr,
+ HInstruction* hydrogen_val) {
+ // Associate the hydrogen instruction first, since we may need it for
+ // the ClobbersRegisters() or ClobbersDoubleRegisters() calls below.
+ instr->set_hydrogen_value(hydrogen_val);
+
+#if DEBUG
+ // Make sure that the lithium instruction has either no fixed register
+ // constraints in temps or the result OR no uses that are only used at
+ // start. If this invariant doesn't hold, the register allocator can decide
+ // to insert a split of a range immediately before the instruction due to an
+ // already allocated register needing to be used for the instruction's fixed
+ // register constraint. In this case, The register allocator won't see an
+ // interference between the split child and the use-at-start (it would if
+ // the it was just a plain use), so it is free to move the split child into
+ // the same register that is used for the use-at-start.
+ // See https://code.google.com/p/chromium/issues/detail?id=201590
+ if (!(instr->ClobbersRegisters() &&
+ instr->ClobbersDoubleRegisters(isolate()))) {
+ int fixed = 0;
+ int used_at_start = 0;
+ for (UseIterator it(instr); !it.Done(); it.Advance()) {
+ LUnallocated* operand = LUnallocated::cast(it.Current());
+ if (operand->IsUsedAtStart()) ++used_at_start;
+ }
+ if (instr->Output() != NULL) {
+ if (LUnallocated::cast(instr->Output())->HasFixedPolicy()) ++fixed;
+ }
+ for (TempIterator it(instr); !it.Done(); it.Advance()) {
+ LUnallocated* operand = LUnallocated::cast(it.Current());
+ if (operand->HasFixedPolicy()) ++fixed;
+ }
+ DCHECK(fixed == 0 || used_at_start == 0);
+ }
+#endif
+
+ if (FLAG_stress_pointer_maps && !instr->HasPointerMap()) {
+ instr = AssignPointerMap(instr);
+ }
+ if (FLAG_stress_environments && !instr->HasEnvironment()) {
+ instr = AssignEnvironment(instr);
+ }
+ chunk_->AddInstruction(instr, current_block_);
+
+ if (instr->IsCall()) {
+ HValue* hydrogen_value_for_lazy_bailout = hydrogen_val;
+ LInstruction* instruction_needing_environment = NULL;
+ if (hydrogen_val->HasObservableSideEffects()) {
+ HSimulate* sim = HSimulate::cast(hydrogen_val->next());
+ instruction_needing_environment = instr;
+ sim->ReplayEnvironment(current_block_->last_environment());
+ hydrogen_value_for_lazy_bailout = sim;
+ }
+ LInstruction* bailout = AssignEnvironment(new (zone()) LLazyBailout());
+ bailout->set_hydrogen_value(hydrogen_value_for_lazy_bailout);
+ chunk_->AddInstruction(bailout, current_block_);
+ if (instruction_needing_environment != NULL) {
+ // Store the lazy deopt environment with the instruction if needed.
+ // Right now it is only used for LInstanceOfKnownGlobal.
+ instruction_needing_environment->SetDeferredLazyDeoptimizationEnvironment(
+ bailout->environment());
+ }
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoGoto(HGoto* instr) {
+ return new (zone()) LGoto(instr->FirstSuccessor());
+}
+
+
+LInstruction* LChunkBuilder::DoBranch(HBranch* instr) {
+ HValue* value = instr->value();
+ Representation r = value->representation();
+ HType type = value->type();
+ ToBooleanStub::Types expected = instr->expected_input_types();
+ if (expected.IsEmpty()) expected = ToBooleanStub::Types::Generic();
+
+ bool easy_case = !r.IsTagged() || type.IsBoolean() || type.IsSmi() ||
+ type.IsJSArray() || type.IsHeapNumber() || type.IsString();
+ LInstruction* branch = new (zone()) LBranch(UseRegister(value));
+ if (!easy_case &&
+ ((!expected.Contains(ToBooleanStub::SMI) && expected.NeedsMap()) ||
+ !expected.IsGeneric())) {
+ branch = AssignEnvironment(branch);
+ }
+ return branch;
+}
+
+
+LInstruction* LChunkBuilder::DoDebugBreak(HDebugBreak* instr) {
+ return new (zone()) LDebugBreak();
+}
+
+
+LInstruction* LChunkBuilder::DoCompareMap(HCompareMap* instr) {
+ DCHECK(instr->value()->representation().IsTagged());
+ LOperand* value = UseRegisterAtStart(instr->value());
+ LOperand* temp = TempRegister();
+ return new (zone()) LCmpMapAndBranch(value, temp);
+}
+
+
+LInstruction* LChunkBuilder::DoArgumentsLength(HArgumentsLength* instr) {
+ info()->MarkAsRequiresFrame();
+ LOperand* value = UseRegister(instr->value());
+ return DefineAsRegister(new (zone()) LArgumentsLength(value));
+}
+
+
+LInstruction* LChunkBuilder::DoArgumentsElements(HArgumentsElements* elems) {
+ info()->MarkAsRequiresFrame();
+ return DefineAsRegister(new (zone()) LArgumentsElements);
+}
+
+
+LInstruction* LChunkBuilder::DoInstanceOf(HInstanceOf* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LInstanceOf* result = new (zone()) LInstanceOf(
+ context, UseFixed(instr->left(), r3), UseFixed(instr->right(), r4));
+ return MarkAsCall(DefineFixed(result, r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoInstanceOfKnownGlobal(
+ HInstanceOfKnownGlobal* instr) {
+ LInstanceOfKnownGlobal* result = new (zone())
+ LInstanceOfKnownGlobal(UseFixed(instr->context(), cp),
+ UseFixed(instr->left(), r3), FixedTemp(r7));
+ return MarkAsCall(DefineFixed(result, r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoWrapReceiver(HWrapReceiver* instr) {
+ LOperand* receiver = UseRegisterAtStart(instr->receiver());
+ LOperand* function = UseRegisterAtStart(instr->function());
+ LWrapReceiver* result = new (zone()) LWrapReceiver(receiver, function);
+ return AssignEnvironment(DefineAsRegister(result));
+}
+
+
+LInstruction* LChunkBuilder::DoApplyArguments(HApplyArguments* instr) {
+ LOperand* function = UseFixed(instr->function(), r4);
+ LOperand* receiver = UseFixed(instr->receiver(), r3);
+ LOperand* length = UseFixed(instr->length(), r5);
+ LOperand* elements = UseFixed(instr->elements(), r6);
+ LApplyArguments* result =
+ new (zone()) LApplyArguments(function, receiver, length, elements);
+ return MarkAsCall(DefineFixed(result, r3), instr, CAN_DEOPTIMIZE_EAGERLY);
+}
+
+
+LInstruction* LChunkBuilder::DoPushArguments(HPushArguments* instr) {
+ int argc = instr->OperandCount();
+ for (int i = 0; i < argc; ++i) {
+ LOperand* argument = Use(instr->argument(i));
+ AddInstruction(new (zone()) LPushArgument(argument), instr);
+ }
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoStoreCodeEntry(
+ HStoreCodeEntry* store_code_entry) {
+ LOperand* function = UseRegister(store_code_entry->function());
+ LOperand* code_object = UseTempRegister(store_code_entry->code_object());
+ return new (zone()) LStoreCodeEntry(function, code_object);
+}
+
+
+LInstruction* LChunkBuilder::DoInnerAllocatedObject(
+ HInnerAllocatedObject* instr) {
+ LOperand* base_object = UseRegisterAtStart(instr->base_object());
+ LOperand* offset = UseRegisterOrConstantAtStart(instr->offset());
+ return DefineAsRegister(new (zone())
+ LInnerAllocatedObject(base_object, offset));
+}
+
+
+LInstruction* LChunkBuilder::DoThisFunction(HThisFunction* instr) {
+ return instr->HasNoUses() ? NULL
+ : DefineAsRegister(new (zone()) LThisFunction);
+}
+
+
+LInstruction* LChunkBuilder::DoContext(HContext* instr) {
+ if (instr->HasNoUses()) return NULL;
+
+ if (info()->IsStub()) {
+ return DefineFixed(new (zone()) LContext, cp);
+ }
+
+ return DefineAsRegister(new (zone()) LContext);
+}
+
+
+LInstruction* LChunkBuilder::DoDeclareGlobals(HDeclareGlobals* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ return MarkAsCall(new (zone()) LDeclareGlobals(context), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoCallJSFunction(HCallJSFunction* instr) {
+ LOperand* function = UseFixed(instr->function(), r4);
+
+ LCallJSFunction* result = new (zone()) LCallJSFunction(function);
+
+ return MarkAsCall(DefineFixed(result, r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoCallWithDescriptor(HCallWithDescriptor* instr) {
+ CallInterfaceDescriptor descriptor = instr->descriptor();
+
+ LOperand* target = UseRegisterOrConstantAtStart(instr->target());
+ ZoneList<LOperand*> ops(instr->OperandCount(), zone());
+ ops.Add(target, zone());
+ for (int i = 1; i < instr->OperandCount(); i++) {
+ LOperand* op =
+ UseFixed(instr->OperandAt(i), descriptor.GetParameterRegister(i - 1));
+ ops.Add(op, zone());
+ }
+
+ LCallWithDescriptor* result =
+ new (zone()) LCallWithDescriptor(descriptor, ops, zone());
+ return MarkAsCall(DefineFixed(result, r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoTailCallThroughMegamorphicCache(
+ HTailCallThroughMegamorphicCache* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* receiver_register =
+ UseFixed(instr->receiver(), LoadDescriptor::ReceiverRegister());
+ LOperand* name_register =
+ UseFixed(instr->name(), LoadDescriptor::NameRegister());
+ // Not marked as call. It can't deoptimize, and it never returns.
+ return new (zone()) LTailCallThroughMegamorphicCache(
+ context, receiver_register, name_register);
+}
+
+
+LInstruction* LChunkBuilder::DoInvokeFunction(HInvokeFunction* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* function = UseFixed(instr->function(), r4);
+ LInvokeFunction* result = new (zone()) LInvokeFunction(context, function);
+ return MarkAsCall(DefineFixed(result, r3), instr, CANNOT_DEOPTIMIZE_EAGERLY);
+}
+
+
+LInstruction* LChunkBuilder::DoUnaryMathOperation(HUnaryMathOperation* instr) {
+ switch (instr->op()) {
+ case kMathFloor:
+ return DoMathFloor(instr);
+ case kMathRound:
+ return DoMathRound(instr);
+ case kMathFround:
+ return DoMathFround(instr);
+ case kMathAbs:
+ return DoMathAbs(instr);
+ case kMathLog:
+ return DoMathLog(instr);
+ case kMathExp:
+ return DoMathExp(instr);
+ case kMathSqrt:
+ return DoMathSqrt(instr);
+ case kMathPowHalf:
+ return DoMathPowHalf(instr);
+ case kMathClz32:
+ return DoMathClz32(instr);
+ default:
+ UNREACHABLE();
+ return NULL;
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoMathFloor(HUnaryMathOperation* instr) {
+ LOperand* input = UseRegister(instr->value());
+ LMathFloor* result = new (zone()) LMathFloor(input);
+ return AssignEnvironment(AssignPointerMap(DefineAsRegister(result)));
+}
+
+
+LInstruction* LChunkBuilder::DoMathRound(HUnaryMathOperation* instr) {
+ LOperand* input = UseRegister(instr->value());
+ LOperand* temp = TempDoubleRegister();
+ LMathRound* result = new (zone()) LMathRound(input, temp);
+ return AssignEnvironment(DefineAsRegister(result));
+}
+
+
+LInstruction* LChunkBuilder::DoMathFround(HUnaryMathOperation* instr) {
+ LOperand* input = UseRegister(instr->value());
+ LMathFround* result = new (zone()) LMathFround(input);
+ return DefineAsRegister(result);
+}
+
+
+LInstruction* LChunkBuilder::DoMathAbs(HUnaryMathOperation* instr) {
+ Representation r = instr->value()->representation();
+ LOperand* context = (r.IsDouble() || r.IsSmiOrInteger32())
+ ? NULL
+ : UseFixed(instr->context(), cp);
+ LOperand* input = UseRegister(instr->value());
+ LInstruction* result =
+ DefineAsRegister(new (zone()) LMathAbs(context, input));
+ if (!r.IsDouble() && !r.IsSmiOrInteger32()) result = AssignPointerMap(result);
+ if (!r.IsDouble()) result = AssignEnvironment(result);
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoMathLog(HUnaryMathOperation* instr) {
+ DCHECK(instr->representation().IsDouble());
+ DCHECK(instr->value()->representation().IsDouble());
+ LOperand* input = UseFixedDouble(instr->value(), d1);
+ return MarkAsCall(DefineFixedDouble(new (zone()) LMathLog(input), d1), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoMathClz32(HUnaryMathOperation* instr) {
+ LOperand* input = UseRegisterAtStart(instr->value());
+ LMathClz32* result = new (zone()) LMathClz32(input);
+ return DefineAsRegister(result);
+}
+
+
+LInstruction* LChunkBuilder::DoMathExp(HUnaryMathOperation* instr) {
+ DCHECK(instr->representation().IsDouble());
+ DCHECK(instr->value()->representation().IsDouble());
+ LOperand* input = UseRegister(instr->value());
+ LOperand* temp1 = TempRegister();
+ LOperand* temp2 = TempRegister();
+ LOperand* double_temp = TempDoubleRegister();
+ LMathExp* result = new (zone()) LMathExp(input, double_temp, temp1, temp2);
+ return DefineAsRegister(result);
+}
+
+
+LInstruction* LChunkBuilder::DoMathSqrt(HUnaryMathOperation* instr) {
+ LOperand* input = UseRegisterAtStart(instr->value());
+ LMathSqrt* result = new (zone()) LMathSqrt(input);
+ return DefineAsRegister(result);
+}
+
+
+LInstruction* LChunkBuilder::DoMathPowHalf(HUnaryMathOperation* instr) {
+ LOperand* input = UseRegisterAtStart(instr->value());
+ LMathPowHalf* result = new (zone()) LMathPowHalf(input);
+ return DefineAsRegister(result);
+}
+
+
+LInstruction* LChunkBuilder::DoCallNew(HCallNew* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* constructor = UseFixed(instr->constructor(), r4);
+ LCallNew* result = new (zone()) LCallNew(context, constructor);
+ return MarkAsCall(DefineFixed(result, r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoCallNewArray(HCallNewArray* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* constructor = UseFixed(instr->constructor(), r4);
+ LCallNewArray* result = new (zone()) LCallNewArray(context, constructor);
+ return MarkAsCall(DefineFixed(result, r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoCallFunction(HCallFunction* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* function = UseFixed(instr->function(), r4);
+ LCallFunction* call = new (zone()) LCallFunction(context, function);
+ return MarkAsCall(DefineFixed(call, r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoCallRuntime(HCallRuntime* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ return MarkAsCall(DefineFixed(new (zone()) LCallRuntime(context), r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoRor(HRor* instr) {
+ return DoShift(Token::ROR, instr);
+}
+
+
+LInstruction* LChunkBuilder::DoShr(HShr* instr) {
+ return DoShift(Token::SHR, instr);
+}
+
+
+LInstruction* LChunkBuilder::DoSar(HSar* instr) {
+ return DoShift(Token::SAR, instr);
+}
+
+
+LInstruction* LChunkBuilder::DoShl(HShl* instr) {
+ return DoShift(Token::SHL, instr);
+}
+
+
+LInstruction* LChunkBuilder::DoBitwise(HBitwise* instr) {
+ if (instr->representation().IsSmiOrInteger32()) {
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ DCHECK(instr->CheckFlag(HValue::kTruncatingToInt32));
+
+ LOperand* left = UseRegisterAtStart(instr->BetterLeftOperand());
+ LOperand* right = UseOrConstantAtStart(instr->BetterRightOperand());
+ return DefineAsRegister(new (zone()) LBitI(left, right));
+ } else {
+ return DoArithmeticT(instr->op(), instr);
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoDivByPowerOf2I(HDiv* instr) {
+ DCHECK(instr->representation().IsSmiOrInteger32());
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ LOperand* dividend = UseRegister(instr->left());
+ int32_t divisor = instr->right()->GetInteger32Constant();
+ LInstruction* result =
+ DefineAsRegister(new (zone()) LDivByPowerOf2I(dividend, divisor));
+ if ((instr->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) ||
+ (instr->CheckFlag(HValue::kCanOverflow) && divisor == -1) ||
+ (!instr->CheckFlag(HInstruction::kAllUsesTruncatingToInt32) &&
+ divisor != 1 && divisor != -1)) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoDivByConstI(HDiv* instr) {
+ DCHECK(instr->representation().IsInteger32());
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ LOperand* dividend = UseRegister(instr->left());
+ int32_t divisor = instr->right()->GetInteger32Constant();
+ LInstruction* result =
+ DefineAsRegister(new (zone()) LDivByConstI(dividend, divisor));
+ if (divisor == 0 ||
+ (instr->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) ||
+ !instr->CheckFlag(HInstruction::kAllUsesTruncatingToInt32)) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoDivI(HDiv* instr) {
+ DCHECK(instr->representation().IsSmiOrInteger32());
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ LOperand* dividend = UseRegister(instr->left());
+ LOperand* divisor = UseRegister(instr->right());
+ LInstruction* result =
+ DefineAsRegister(new (zone()) LDivI(dividend, divisor));
+ if (instr->CheckFlag(HValue::kCanBeDivByZero) ||
+ instr->CheckFlag(HValue::kBailoutOnMinusZero) ||
+ (instr->CheckFlag(HValue::kCanOverflow) &&
+ !instr->CheckFlag(HValue::kAllUsesTruncatingToInt32)) ||
+ (!instr->IsMathFloorOfDiv() &&
+ !instr->CheckFlag(HValue::kAllUsesTruncatingToInt32))) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoDiv(HDiv* instr) {
+ if (instr->representation().IsSmiOrInteger32()) {
+ if (instr->RightIsPowerOf2()) {
+ return DoDivByPowerOf2I(instr);
+ } else if (instr->right()->IsConstant()) {
+ return DoDivByConstI(instr);
+ } else {
+ return DoDivI(instr);
+ }
+ } else if (instr->representation().IsDouble()) {
+ return DoArithmeticD(Token::DIV, instr);
+ } else {
+ return DoArithmeticT(Token::DIV, instr);
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoFlooringDivByPowerOf2I(HMathFloorOfDiv* instr) {
+ LOperand* dividend = UseRegisterAtStart(instr->left());
+ int32_t divisor = instr->right()->GetInteger32Constant();
+ LInstruction* result =
+ DefineAsRegister(new (zone()) LFlooringDivByPowerOf2I(dividend, divisor));
+ if ((instr->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) ||
+ (instr->CheckFlag(HValue::kLeftCanBeMinInt) && divisor == -1)) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoFlooringDivByConstI(HMathFloorOfDiv* instr) {
+ DCHECK(instr->representation().IsInteger32());
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ LOperand* dividend = UseRegister(instr->left());
+ int32_t divisor = instr->right()->GetInteger32Constant();
+ LOperand* temp =
+ ((divisor > 0 && !instr->CheckFlag(HValue::kLeftCanBeNegative)) ||
+ (divisor < 0 && !instr->CheckFlag(HValue::kLeftCanBePositive)))
+ ? NULL
+ : TempRegister();
+ LInstruction* result = DefineAsRegister(
+ new (zone()) LFlooringDivByConstI(dividend, divisor, temp));
+ if (divisor == 0 ||
+ (instr->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0)) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoFlooringDivI(HMathFloorOfDiv* instr) {
+ DCHECK(instr->representation().IsSmiOrInteger32());
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ LOperand* dividend = UseRegister(instr->left());
+ LOperand* divisor = UseRegister(instr->right());
+ LFlooringDivI* div = new (zone()) LFlooringDivI(dividend, divisor);
+ return AssignEnvironment(DefineAsRegister(div));
+}
+
+
+LInstruction* LChunkBuilder::DoMathFloorOfDiv(HMathFloorOfDiv* instr) {
+ if (instr->RightIsPowerOf2()) {
+ return DoFlooringDivByPowerOf2I(instr);
+ } else if (instr->right()->IsConstant()) {
+ return DoFlooringDivByConstI(instr);
+ } else {
+ return DoFlooringDivI(instr);
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoModByPowerOf2I(HMod* instr) {
+ DCHECK(instr->representation().IsSmiOrInteger32());
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ LOperand* dividend = UseRegisterAtStart(instr->left());
+ int32_t divisor = instr->right()->GetInteger32Constant();
+ LInstruction* result =
+ DefineSameAsFirst(new (zone()) LModByPowerOf2I(dividend, divisor));
+ if (instr->CheckFlag(HValue::kLeftCanBeNegative) &&
+ instr->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoModByConstI(HMod* instr) {
+ DCHECK(instr->representation().IsSmiOrInteger32());
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ LOperand* dividend = UseRegister(instr->left());
+ int32_t divisor = instr->right()->GetInteger32Constant();
+ LInstruction* result =
+ DefineAsRegister(new (zone()) LModByConstI(dividend, divisor));
+ if (divisor == 0 || instr->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoModI(HMod* instr) {
+ DCHECK(instr->representation().IsSmiOrInteger32());
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ LOperand* dividend = UseRegister(instr->left());
+ LOperand* divisor = UseRegister(instr->right());
+ LInstruction* result =
+ DefineAsRegister(new (zone()) LModI(dividend, divisor));
+ if (instr->CheckFlag(HValue::kCanBeDivByZero) ||
+ instr->CheckFlag(HValue::kBailoutOnMinusZero)) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoMod(HMod* instr) {
+ if (instr->representation().IsSmiOrInteger32()) {
+ if (instr->RightIsPowerOf2()) {
+ return DoModByPowerOf2I(instr);
+ } else if (instr->right()->IsConstant()) {
+ return DoModByConstI(instr);
+ } else {
+ return DoModI(instr);
+ }
+ } else if (instr->representation().IsDouble()) {
+ return DoArithmeticD(Token::MOD, instr);
+ } else {
+ return DoArithmeticT(Token::MOD, instr);
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoMul(HMul* instr) {
+ if (instr->representation().IsSmiOrInteger32()) {
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ HValue* left = instr->BetterLeftOperand();
+ HValue* right = instr->BetterRightOperand();
+ LOperand* left_op;
+ LOperand* right_op;
+ bool can_overflow = instr->CheckFlag(HValue::kCanOverflow);
+ bool bailout_on_minus_zero = instr->CheckFlag(HValue::kBailoutOnMinusZero);
+
+ if (right->IsConstant()) {
+ HConstant* constant = HConstant::cast(right);
+ int32_t constant_value = constant->Integer32Value();
+ // Constants -1, 0 and 1 can be optimized if the result can overflow.
+ // For other constants, it can be optimized only without overflow.
+ if (!can_overflow || ((constant_value >= -1) && (constant_value <= 1))) {
+ left_op = UseRegisterAtStart(left);
+ right_op = UseConstant(right);
+ } else {
+ if (bailout_on_minus_zero) {
+ left_op = UseRegister(left);
+ } else {
+ left_op = UseRegisterAtStart(left);
+ }
+ right_op = UseRegister(right);
+ }
+ } else {
+ if (bailout_on_minus_zero) {
+ left_op = UseRegister(left);
+ } else {
+ left_op = UseRegisterAtStart(left);
+ }
+ right_op = UseRegister(right);
+ }
+ LMulI* mul = new (zone()) LMulI(left_op, right_op);
+ if (can_overflow || bailout_on_minus_zero) {
+ AssignEnvironment(mul);
+ }
+ return DefineAsRegister(mul);
+
+ } else if (instr->representation().IsDouble()) {
+ if (instr->HasOneUse() &&
+ (instr->uses().value()->IsAdd() || instr->uses().value()->IsSub())) {
+ HBinaryOperation* use = HBinaryOperation::cast(instr->uses().value());
+
+ if (use->IsAdd() && instr == use->left()) {
+ // This mul is the lhs of an add. The add and mul will be folded into a
+ // multiply-add in DoAdd.
+ return NULL;
+ }
+ if (instr == use->right() && use->IsAdd() &&
+ !(use->left()->IsMul() && use->left()->HasOneUse())) {
+ // This mul is the rhs of an add, where the lhs is not another mul.
+ // The add and mul will be folded into a multiply-add in DoAdd.
+ return NULL;
+ }
+ if (instr == use->left() && use->IsSub()) {
+ // This mul is the lhs of a sub. The mul and sub will be folded into a
+ // multiply-sub in DoSub.
+ return NULL;
+ }
+ }
+
+ return DoArithmeticD(Token::MUL, instr);
+ } else {
+ return DoArithmeticT(Token::MUL, instr);
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoSub(HSub* instr) {
+ if (instr->representation().IsSmiOrInteger32()) {
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+
+ if (instr->left()->IsConstant() &&
+ !instr->CheckFlag(HValue::kCanOverflow)) {
+ // If lhs is constant, do reverse subtraction instead.
+ return DoRSub(instr);
+ }
+
+ LOperand* left = UseRegisterAtStart(instr->left());
+ LOperand* right = UseOrConstantAtStart(instr->right());
+ LSubI* sub = new (zone()) LSubI(left, right);
+ LInstruction* result = DefineAsRegister(sub);
+ if (instr->CheckFlag(HValue::kCanOverflow)) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+ } else if (instr->representation().IsDouble()) {
+ if (instr->left()->IsMul() && instr->left()->HasOneUse()) {
+ return DoMultiplySub(instr->right(), HMul::cast(instr->left()));
+ }
+
+ return DoArithmeticD(Token::SUB, instr);
+ } else {
+ return DoArithmeticT(Token::SUB, instr);
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoRSub(HSub* instr) {
+ DCHECK(instr->representation().IsSmiOrInteger32());
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ DCHECK(!instr->CheckFlag(HValue::kCanOverflow));
+
+ // Note: The lhs of the subtraction becomes the rhs of the
+ // reverse-subtraction.
+ LOperand* left = UseRegisterAtStart(instr->right());
+ LOperand* right = UseOrConstantAtStart(instr->left());
+ LRSubI* rsb = new (zone()) LRSubI(left, right);
+ LInstruction* result = DefineAsRegister(rsb);
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoMultiplyAdd(HMul* mul, HValue* addend) {
+ LOperand* multiplier_op = UseRegisterAtStart(mul->left());
+ LOperand* multiplicand_op = UseRegisterAtStart(mul->right());
+ LOperand* addend_op = UseRegisterAtStart(addend);
+ return DefineSameAsFirst(
+ new (zone()) LMultiplyAddD(addend_op, multiplier_op, multiplicand_op));
+}
+
+
+LInstruction* LChunkBuilder::DoMultiplySub(HValue* minuend, HMul* mul) {
+ LOperand* minuend_op = UseRegisterAtStart(minuend);
+ LOperand* multiplier_op = UseRegisterAtStart(mul->left());
+ LOperand* multiplicand_op = UseRegisterAtStart(mul->right());
+
+ return DefineSameAsFirst(
+ new (zone()) LMultiplySubD(minuend_op, multiplier_op, multiplicand_op));
+}
+
+
+LInstruction* LChunkBuilder::DoAdd(HAdd* instr) {
+ if (instr->representation().IsSmiOrInteger32()) {
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ LOperand* left = UseRegisterAtStart(instr->BetterLeftOperand());
+ LOperand* right = UseOrConstantAtStart(instr->BetterRightOperand());
+ LAddI* add = new (zone()) LAddI(left, right);
+ LInstruction* result = DefineAsRegister(add);
+ if (instr->CheckFlag(HValue::kCanOverflow)) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+ } else if (instr->representation().IsExternal()) {
+ DCHECK(instr->left()->representation().IsExternal());
+ DCHECK(instr->right()->representation().IsInteger32());
+ DCHECK(!instr->CheckFlag(HValue::kCanOverflow));
+ LOperand* left = UseRegisterAtStart(instr->left());
+ LOperand* right = UseOrConstantAtStart(instr->right());
+ LAddI* add = new (zone()) LAddI(left, right);
+ LInstruction* result = DefineAsRegister(add);
+ return result;
+ } else if (instr->representation().IsDouble()) {
+ if (instr->left()->IsMul() && instr->left()->HasOneUse()) {
+ return DoMultiplyAdd(HMul::cast(instr->left()), instr->right());
+ }
+
+ if (instr->right()->IsMul() && instr->right()->HasOneUse()) {
+ DCHECK(!instr->left()->IsMul() || !instr->left()->HasOneUse());
+ return DoMultiplyAdd(HMul::cast(instr->right()), instr->left());
+ }
+
+ return DoArithmeticD(Token::ADD, instr);
+ } else {
+ return DoArithmeticT(Token::ADD, instr);
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoMathMinMax(HMathMinMax* instr) {
+ LOperand* left = NULL;
+ LOperand* right = NULL;
+ if (instr->representation().IsSmiOrInteger32()) {
+ DCHECK(instr->left()->representation().Equals(instr->representation()));
+ DCHECK(instr->right()->representation().Equals(instr->representation()));
+ left = UseRegisterAtStart(instr->BetterLeftOperand());
+ right = UseOrConstantAtStart(instr->BetterRightOperand());
+ } else {
+ DCHECK(instr->representation().IsDouble());
+ DCHECK(instr->left()->representation().IsDouble());
+ DCHECK(instr->right()->representation().IsDouble());
+ left = UseRegisterAtStart(instr->left());
+ right = UseRegisterAtStart(instr->right());
+ }
+ return DefineAsRegister(new (zone()) LMathMinMax(left, right));
+}
+
+
+LInstruction* LChunkBuilder::DoPower(HPower* instr) {
+ DCHECK(instr->representation().IsDouble());
+ // We call a C function for double power. It can't trigger a GC.
+ // We need to use fixed result register for the call.
+ Representation exponent_type = instr->right()->representation();
+ DCHECK(instr->left()->representation().IsDouble());
+ LOperand* left = UseFixedDouble(instr->left(), d1);
+ LOperand* right =
+ exponent_type.IsDouble()
+ ? UseFixedDouble(instr->right(), d2)
+ : UseFixed(instr->right(), MathPowTaggedDescriptor::exponent());
+ LPower* result = new (zone()) LPower(left, right);
+ return MarkAsCall(DefineFixedDouble(result, d3), instr,
+ CAN_DEOPTIMIZE_EAGERLY);
+}
+
+
+LInstruction* LChunkBuilder::DoCompareGeneric(HCompareGeneric* instr) {
+ DCHECK(instr->left()->representation().IsTagged());
+ DCHECK(instr->right()->representation().IsTagged());
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* left = UseFixed(instr->left(), r4);
+ LOperand* right = UseFixed(instr->right(), r3);
+ LCmpT* result = new (zone()) LCmpT(context, left, right);
+ return MarkAsCall(DefineFixed(result, r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoCompareNumericAndBranch(
+ HCompareNumericAndBranch* instr) {
+ Representation r = instr->representation();
+ if (r.IsSmiOrInteger32()) {
+ DCHECK(instr->left()->representation().Equals(r));
+ DCHECK(instr->right()->representation().Equals(r));
+ LOperand* left = UseRegisterOrConstantAtStart(instr->left());
+ LOperand* right = UseRegisterOrConstantAtStart(instr->right());
+ return new (zone()) LCompareNumericAndBranch(left, right);
+ } else {
+ DCHECK(r.IsDouble());
+ DCHECK(instr->left()->representation().IsDouble());
+ DCHECK(instr->right()->representation().IsDouble());
+ LOperand* left = UseRegisterAtStart(instr->left());
+ LOperand* right = UseRegisterAtStart(instr->right());
+ return new (zone()) LCompareNumericAndBranch(left, right);
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoCompareObjectEqAndBranch(
+ HCompareObjectEqAndBranch* instr) {
+ LOperand* left = UseRegisterAtStart(instr->left());
+ LOperand* right = UseRegisterAtStart(instr->right());
+ return new (zone()) LCmpObjectEqAndBranch(left, right);
+}
+
+
+LInstruction* LChunkBuilder::DoCompareHoleAndBranch(
+ HCompareHoleAndBranch* instr) {
+ LOperand* value = UseRegisterAtStart(instr->value());
+ return new (zone()) LCmpHoleAndBranch(value);
+}
+
+
+LInstruction* LChunkBuilder::DoCompareMinusZeroAndBranch(
+ HCompareMinusZeroAndBranch* instr) {
+ LOperand* value = UseRegister(instr->value());
+ LOperand* scratch = TempRegister();
+ return new (zone()) LCompareMinusZeroAndBranch(value, scratch);
+}
+
+
+LInstruction* LChunkBuilder::DoIsObjectAndBranch(HIsObjectAndBranch* instr) {
+ DCHECK(instr->value()->representation().IsTagged());
+ LOperand* value = UseRegisterAtStart(instr->value());
+ LOperand* temp = TempRegister();
+ return new (zone()) LIsObjectAndBranch(value, temp);
+}
+
+
+LInstruction* LChunkBuilder::DoIsStringAndBranch(HIsStringAndBranch* instr) {
+ DCHECK(instr->value()->representation().IsTagged());
+ LOperand* value = UseRegisterAtStart(instr->value());
+ LOperand* temp = TempRegister();
+ return new (zone()) LIsStringAndBranch(value, temp);
+}
+
+
+LInstruction* LChunkBuilder::DoIsSmiAndBranch(HIsSmiAndBranch* instr) {
+ DCHECK(instr->value()->representation().IsTagged());
+ return new (zone()) LIsSmiAndBranch(Use(instr->value()));
+}
+
+
+LInstruction* LChunkBuilder::DoIsUndetectableAndBranch(
+ HIsUndetectableAndBranch* instr) {
+ DCHECK(instr->value()->representation().IsTagged());
+ LOperand* value = UseRegisterAtStart(instr->value());
+ return new (zone()) LIsUndetectableAndBranch(value, TempRegister());
+}
+
+
+LInstruction* LChunkBuilder::DoStringCompareAndBranch(
+ HStringCompareAndBranch* instr) {
+ DCHECK(instr->left()->representation().IsTagged());
+ DCHECK(instr->right()->representation().IsTagged());
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* left = UseFixed(instr->left(), r4);
+ LOperand* right = UseFixed(instr->right(), r3);
+ LStringCompareAndBranch* result =
+ new (zone()) LStringCompareAndBranch(context, left, right);
+ return MarkAsCall(result, instr);
+}
+
+
+LInstruction* LChunkBuilder::DoHasInstanceTypeAndBranch(
+ HHasInstanceTypeAndBranch* instr) {
+ DCHECK(instr->value()->representation().IsTagged());
+ LOperand* value = UseRegisterAtStart(instr->value());
+ return new (zone()) LHasInstanceTypeAndBranch(value);
+}
+
+
+LInstruction* LChunkBuilder::DoGetCachedArrayIndex(
+ HGetCachedArrayIndex* instr) {
+ DCHECK(instr->value()->representation().IsTagged());
+ LOperand* value = UseRegisterAtStart(instr->value());
+
+ return DefineAsRegister(new (zone()) LGetCachedArrayIndex(value));
+}
+
+
+LInstruction* LChunkBuilder::DoHasCachedArrayIndexAndBranch(
+ HHasCachedArrayIndexAndBranch* instr) {
+ DCHECK(instr->value()->representation().IsTagged());
+ return new (zone())
+ LHasCachedArrayIndexAndBranch(UseRegisterAtStart(instr->value()));
+}
+
+
+LInstruction* LChunkBuilder::DoClassOfTestAndBranch(
+ HClassOfTestAndBranch* instr) {
+ DCHECK(instr->value()->representation().IsTagged());
+ LOperand* value = UseRegister(instr->value());
+ return new (zone()) LClassOfTestAndBranch(value, TempRegister());
+}
+
+
+LInstruction* LChunkBuilder::DoMapEnumLength(HMapEnumLength* instr) {
+ LOperand* map = UseRegisterAtStart(instr->value());
+ return DefineAsRegister(new (zone()) LMapEnumLength(map));
+}
+
+
+LInstruction* LChunkBuilder::DoDateField(HDateField* instr) {
+ LOperand* object = UseFixed(instr->value(), r3);
+ LDateField* result =
+ new (zone()) LDateField(object, FixedTemp(r4), instr->index());
+ return MarkAsCall(DefineFixed(result, r3), instr, CAN_DEOPTIMIZE_EAGERLY);
+}
+
+
+LInstruction* LChunkBuilder::DoSeqStringGetChar(HSeqStringGetChar* instr) {
+ LOperand* string = UseRegisterAtStart(instr->string());
+ LOperand* index = UseRegisterOrConstantAtStart(instr->index());
+ return DefineAsRegister(new (zone()) LSeqStringGetChar(string, index));
+}
+
+
+LInstruction* LChunkBuilder::DoSeqStringSetChar(HSeqStringSetChar* instr) {
+ LOperand* string = UseRegisterAtStart(instr->string());
+ LOperand* index = FLAG_debug_code
+ ? UseRegisterAtStart(instr->index())
+ : UseRegisterOrConstantAtStart(instr->index());
+ LOperand* value = UseRegisterAtStart(instr->value());
+ LOperand* context = FLAG_debug_code ? UseFixed(instr->context(), cp) : NULL;
+ return new (zone()) LSeqStringSetChar(context, string, index, value);
+}
+
+
+LInstruction* LChunkBuilder::DoBoundsCheck(HBoundsCheck* instr) {
+ if (!FLAG_debug_code && instr->skip_check()) return NULL;
+ LOperand* index = UseRegisterOrConstantAtStart(instr->index());
+ LOperand* length = !index->IsConstantOperand()
+ ? UseRegisterOrConstantAtStart(instr->length())
+ : UseRegisterAtStart(instr->length());
+ LInstruction* result = new (zone()) LBoundsCheck(index, length);
+ if (!FLAG_debug_code || !instr->skip_check()) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoBoundsCheckBaseIndexInformation(
+ HBoundsCheckBaseIndexInformation* instr) {
+ UNREACHABLE();
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoAbnormalExit(HAbnormalExit* instr) {
+ // The control instruction marking the end of a block that completed
+ // abruptly (e.g., threw an exception). There is nothing specific to do.
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoUseConst(HUseConst* instr) { return NULL; }
+
+
+LInstruction* LChunkBuilder::DoForceRepresentation(HForceRepresentation* bad) {
+ // All HForceRepresentation instructions should be eliminated in the
+ // representation change phase of Hydrogen.
+ UNREACHABLE();
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoChange(HChange* instr) {
+ Representation from = instr->from();
+ Representation to = instr->to();
+ HValue* val = instr->value();
+ if (from.IsSmi()) {
+ if (to.IsTagged()) {
+ LOperand* value = UseRegister(val);
+ return DefineSameAsFirst(new (zone()) LDummyUse(value));
+ }
+ from = Representation::Tagged();
+ }
+ if (from.IsTagged()) {
+ if (to.IsDouble()) {
+ LOperand* value = UseRegister(val);
+ LInstruction* result =
+ DefineAsRegister(new (zone()) LNumberUntagD(value));
+ if (!val->representation().IsSmi()) result = AssignEnvironment(result);
+ return result;
+ } else if (to.IsSmi()) {
+ LOperand* value = UseRegister(val);
+ if (val->type().IsSmi()) {
+ return DefineSameAsFirst(new (zone()) LDummyUse(value));
+ }
+ return AssignEnvironment(
+ DefineSameAsFirst(new (zone()) LCheckSmi(value)));
+ } else {
+ DCHECK(to.IsInteger32());
+ if (val->type().IsSmi() || val->representation().IsSmi()) {
+ LOperand* value = UseRegisterAtStart(val);
+ return DefineAsRegister(new (zone()) LSmiUntag(value, false));
+ } else {
+ LOperand* value = UseRegister(val);
+ LOperand* temp1 = TempRegister();
+ LOperand* temp2 = TempDoubleRegister();
+ LInstruction* result =
+ DefineSameAsFirst(new (zone()) LTaggedToI(value, temp1, temp2));
+ if (!val->representation().IsSmi()) result = AssignEnvironment(result);
+ return result;
+ }
+ }
+ } else if (from.IsDouble()) {
+ if (to.IsTagged()) {
+ info()->MarkAsDeferredCalling();
+ LOperand* value = UseRegister(val);
+ LOperand* temp1 = TempRegister();
+ LOperand* temp2 = TempRegister();
+ LUnallocated* result_temp = TempRegister();
+ LNumberTagD* result = new (zone()) LNumberTagD(value, temp1, temp2);
+ return AssignPointerMap(Define(result, result_temp));
+ } else if (to.IsSmi()) {
+ LOperand* value = UseRegister(val);
+ return AssignEnvironment(
+ DefineAsRegister(new (zone()) LDoubleToSmi(value)));
+ } else {
+ DCHECK(to.IsInteger32());
+ LOperand* value = UseRegister(val);
+ LInstruction* result = DefineAsRegister(new (zone()) LDoubleToI(value));
+ if (!instr->CanTruncateToInt32()) result = AssignEnvironment(result);
+ return result;
+ }
+ } else if (from.IsInteger32()) {
+ info()->MarkAsDeferredCalling();
+ if (to.IsTagged()) {
+ if (!instr->CheckFlag(HValue::kCanOverflow)) {
+ LOperand* value = UseRegisterAtStart(val);
+ return DefineAsRegister(new (zone()) LSmiTag(value));
+ } else if (val->CheckFlag(HInstruction::kUint32)) {
+ LOperand* value = UseRegisterAtStart(val);
+ LOperand* temp1 = TempRegister();
+ LOperand* temp2 = TempRegister();
+ LNumberTagU* result = new (zone()) LNumberTagU(value, temp1, temp2);
+ return AssignPointerMap(DefineAsRegister(result));
+ } else {
+ LOperand* value = UseRegisterAtStart(val);
+ LOperand* temp1 = TempRegister();
+ LOperand* temp2 = TempRegister();
+ LNumberTagI* result = new (zone()) LNumberTagI(value, temp1, temp2);
+ return AssignPointerMap(DefineAsRegister(result));
+ }
+ } else if (to.IsSmi()) {
+ LOperand* value = UseRegister(val);
+ LInstruction* result = DefineAsRegister(new (zone()) LSmiTag(value));
+ if (instr->CheckFlag(HValue::kCanOverflow)) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+ } else {
+ DCHECK(to.IsDouble());
+ if (val->CheckFlag(HInstruction::kUint32)) {
+ return DefineAsRegister(new (zone()) LUint32ToDouble(UseRegister(val)));
+ } else {
+ return DefineAsRegister(new (zone()) LInteger32ToDouble(Use(val)));
+ }
+ }
+ }
+ UNREACHABLE();
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoCheckHeapObject(HCheckHeapObject* instr) {
+ LOperand* value = UseRegisterAtStart(instr->value());
+ LInstruction* result = new (zone()) LCheckNonSmi(value);
+ if (!instr->value()->type().IsHeapObject()) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoCheckSmi(HCheckSmi* instr) {
+ LOperand* value = UseRegisterAtStart(instr->value());
+ return AssignEnvironment(new (zone()) LCheckSmi(value));
+}
+
+
+LInstruction* LChunkBuilder::DoCheckInstanceType(HCheckInstanceType* instr) {
+ LOperand* value = UseRegisterAtStart(instr->value());
+ LInstruction* result = new (zone()) LCheckInstanceType(value);
+ return AssignEnvironment(result);
+}
+
+
+LInstruction* LChunkBuilder::DoCheckValue(HCheckValue* instr) {
+ LOperand* value = UseRegisterAtStart(instr->value());
+ return AssignEnvironment(new (zone()) LCheckValue(value));
+}
+
+
+LInstruction* LChunkBuilder::DoCheckMaps(HCheckMaps* instr) {
+ if (instr->IsStabilityCheck()) return new (zone()) LCheckMaps;
+ LOperand* value = UseRegisterAtStart(instr->value());
+ LInstruction* result = AssignEnvironment(new (zone()) LCheckMaps(value));
+ if (instr->HasMigrationTarget()) {
+ info()->MarkAsDeferredCalling();
+ result = AssignPointerMap(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoClampToUint8(HClampToUint8* instr) {
+ HValue* value = instr->value();
+ Representation input_rep = value->representation();
+ LOperand* reg = UseRegister(value);
+ if (input_rep.IsDouble()) {
+ return DefineAsRegister(new (zone()) LClampDToUint8(reg));
+ } else if (input_rep.IsInteger32()) {
+ return DefineAsRegister(new (zone()) LClampIToUint8(reg));
+ } else {
+ DCHECK(input_rep.IsSmiOrTagged());
+ LClampTToUint8* result =
+ new (zone()) LClampTToUint8(reg, TempDoubleRegister());
+ return AssignEnvironment(DefineAsRegister(result));
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoDoubleBits(HDoubleBits* instr) {
+ HValue* value = instr->value();
+ DCHECK(value->representation().IsDouble());
+ return DefineAsRegister(new (zone()) LDoubleBits(UseRegister(value)));
+}
+
+
+LInstruction* LChunkBuilder::DoConstructDouble(HConstructDouble* instr) {
+ LOperand* lo = UseRegister(instr->lo());
+ LOperand* hi = UseRegister(instr->hi());
+ return DefineAsRegister(new (zone()) LConstructDouble(hi, lo));
+}
+
+
+LInstruction* LChunkBuilder::DoReturn(HReturn* instr) {
+ LOperand* context = info()->IsStub() ? UseFixed(instr->context(), cp) : NULL;
+ LOperand* parameter_count = UseRegisterOrConstant(instr->parameter_count());
+ return new (zone())
+ LReturn(UseFixed(instr->value(), r3), context, parameter_count);
+}
+
+
+LInstruction* LChunkBuilder::DoConstant(HConstant* instr) {
+ Representation r = instr->representation();
+ if (r.IsSmi()) {
+ return DefineAsRegister(new (zone()) LConstantS);
+ } else if (r.IsInteger32()) {
+ return DefineAsRegister(new (zone()) LConstantI);
+ } else if (r.IsDouble()) {
+ return DefineAsRegister(new (zone()) LConstantD);
+ } else if (r.IsExternal()) {
+ return DefineAsRegister(new (zone()) LConstantE);
+ } else if (r.IsTagged()) {
+ return DefineAsRegister(new (zone()) LConstantT);
+ } else {
+ UNREACHABLE();
+ return NULL;
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoLoadGlobalCell(HLoadGlobalCell* instr) {
+ LLoadGlobalCell* result = new (zone()) LLoadGlobalCell;
+ return instr->RequiresHoleCheck()
+ ? AssignEnvironment(DefineAsRegister(result))
+ : DefineAsRegister(result);
+}
+
+
+LInstruction* LChunkBuilder::DoLoadGlobalGeneric(HLoadGlobalGeneric* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* global_object =
+ UseFixed(instr->global_object(), LoadDescriptor::ReceiverRegister());
+ LOperand* vector = NULL;
+ if (FLAG_vector_ics) {
+ vector = FixedTemp(VectorLoadICDescriptor::VectorRegister());
+ }
+ LLoadGlobalGeneric* result =
+ new (zone()) LLoadGlobalGeneric(context, global_object, vector);
+ return MarkAsCall(DefineFixed(result, r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoStoreGlobalCell(HStoreGlobalCell* instr) {
+ LOperand* value = UseRegister(instr->value());
+ // Use a temp to check the value in the cell in the case where we perform
+ // a hole check.
+ return instr->RequiresHoleCheck()
+ ? AssignEnvironment(new (zone())
+ LStoreGlobalCell(value, TempRegister()))
+ : new (zone()) LStoreGlobalCell(value, NULL);
+}
+
+
+LInstruction* LChunkBuilder::DoLoadContextSlot(HLoadContextSlot* instr) {
+ LOperand* context = UseRegisterAtStart(instr->value());
+ LInstruction* result =
+ DefineAsRegister(new (zone()) LLoadContextSlot(context));
+ if (instr->RequiresHoleCheck() && instr->DeoptimizesOnHole()) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoStoreContextSlot(HStoreContextSlot* instr) {
+ LOperand* context;
+ LOperand* value;
+ if (instr->NeedsWriteBarrier()) {
+ context = UseTempRegister(instr->context());
+ value = UseTempRegister(instr->value());
+ } else {
+ context = UseRegister(instr->context());
+ value = UseRegister(instr->value());
+ }
+ LInstruction* result = new (zone()) LStoreContextSlot(context, value);
+ if (instr->RequiresHoleCheck() && instr->DeoptimizesOnHole()) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoLoadNamedField(HLoadNamedField* instr) {
+ LOperand* obj = UseRegisterAtStart(instr->object());
+ return DefineAsRegister(new (zone()) LLoadNamedField(obj));
+}
+
+
+LInstruction* LChunkBuilder::DoLoadNamedGeneric(HLoadNamedGeneric* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* object =
+ UseFixed(instr->object(), LoadDescriptor::ReceiverRegister());
+ LOperand* vector = NULL;
+ if (FLAG_vector_ics) {
+ vector = FixedTemp(VectorLoadICDescriptor::VectorRegister());
+ }
+
+ LInstruction* result =
+ DefineFixed(new (zone()) LLoadNamedGeneric(context, object, vector), r3);
+ return MarkAsCall(result, instr);
+}
+
+
+LInstruction* LChunkBuilder::DoLoadFunctionPrototype(
+ HLoadFunctionPrototype* instr) {
+ return AssignEnvironment(DefineAsRegister(
+ new (zone()) LLoadFunctionPrototype(UseRegister(instr->function()))));
+}
+
+
+LInstruction* LChunkBuilder::DoLoadRoot(HLoadRoot* instr) {
+ return DefineAsRegister(new (zone()) LLoadRoot);
+}
+
+
+LInstruction* LChunkBuilder::DoLoadKeyed(HLoadKeyed* instr) {
+ DCHECK(instr->key()->representation().IsSmiOrInteger32());
+ ElementsKind elements_kind = instr->elements_kind();
+ LOperand* key = UseRegisterOrConstantAtStart(instr->key());
+ LInstruction* result = NULL;
+
+ if (!instr->is_typed_elements()) {
+ LOperand* obj = NULL;
+ if (instr->representation().IsDouble()) {
+ obj = UseRegister(instr->elements());
+ } else {
+ obj = UseRegisterAtStart(instr->elements());
+ }
+ result = DefineAsRegister(new (zone()) LLoadKeyed(obj, key));
+ } else {
+ DCHECK((instr->representation().IsInteger32() &&
+ !IsDoubleOrFloatElementsKind(elements_kind)) ||
+ (instr->representation().IsDouble() &&
+ IsDoubleOrFloatElementsKind(elements_kind)));
+ LOperand* backing_store = UseRegister(instr->elements());
+ result = DefineAsRegister(new (zone()) LLoadKeyed(backing_store, key));
+ }
+
+ if ((instr->is_external() || instr->is_fixed_typed_array())
+ ?
+ // see LCodeGen::DoLoadKeyedExternalArray
+ ((elements_kind == EXTERNAL_UINT32_ELEMENTS ||
+ elements_kind == UINT32_ELEMENTS) &&
+ !instr->CheckFlag(HInstruction::kUint32))
+ :
+ // see LCodeGen::DoLoadKeyedFixedDoubleArray and
+ // LCodeGen::DoLoadKeyedFixedArray
+ instr->RequiresHoleCheck()) {
+ result = AssignEnvironment(result);
+ }
+ return result;
+}
+
+
+LInstruction* LChunkBuilder::DoLoadKeyedGeneric(HLoadKeyedGeneric* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* object =
+ UseFixed(instr->object(), LoadDescriptor::ReceiverRegister());
+ LOperand* key = UseFixed(instr->key(), LoadDescriptor::NameRegister());
+ LOperand* vector = NULL;
+ if (FLAG_vector_ics) {
+ vector = FixedTemp(VectorLoadICDescriptor::VectorRegister());
+ }
+
+ LInstruction* result = DefineFixed(
+ new (zone()) LLoadKeyedGeneric(context, object, key, vector), r3);
+ return MarkAsCall(result, instr);
+}
+
+
+LInstruction* LChunkBuilder::DoStoreKeyed(HStoreKeyed* instr) {
+ if (!instr->is_typed_elements()) {
+ DCHECK(instr->elements()->representation().IsTagged());
+ bool needs_write_barrier = instr->NeedsWriteBarrier();
+ LOperand* object = NULL;
+ LOperand* key = NULL;
+ LOperand* val = NULL;
+
+ if (instr->value()->representation().IsDouble()) {
+ object = UseRegisterAtStart(instr->elements());
+ val = UseRegister(instr->value());
+ key = UseRegisterOrConstantAtStart(instr->key());
+ } else {
+ if (needs_write_barrier) {
+ object = UseTempRegister(instr->elements());
+ val = UseTempRegister(instr->value());
+ key = UseTempRegister(instr->key());
+ } else {
+ object = UseRegisterAtStart(instr->elements());
+ val = UseRegisterAtStart(instr->value());
+ key = UseRegisterOrConstantAtStart(instr->key());
+ }
+ }
+
+ return new (zone()) LStoreKeyed(object, key, val);
+ }
+
+ DCHECK((instr->value()->representation().IsInteger32() &&
+ !IsDoubleOrFloatElementsKind(instr->elements_kind())) ||
+ (instr->value()->representation().IsDouble() &&
+ IsDoubleOrFloatElementsKind(instr->elements_kind())));
+ DCHECK((instr->is_fixed_typed_array() &&
+ instr->elements()->representation().IsTagged()) ||
+ (instr->is_external() &&
+ instr->elements()->representation().IsExternal()));
+ LOperand* val = UseRegister(instr->value());
+ LOperand* key = UseRegisterOrConstantAtStart(instr->key());
+ LOperand* backing_store = UseRegister(instr->elements());
+ return new (zone()) LStoreKeyed(backing_store, key, val);
+}
+
+
+LInstruction* LChunkBuilder::DoStoreKeyedGeneric(HStoreKeyedGeneric* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* obj =
+ UseFixed(instr->object(), StoreDescriptor::ReceiverRegister());
+ LOperand* key = UseFixed(instr->key(), StoreDescriptor::NameRegister());
+ LOperand* val = UseFixed(instr->value(), StoreDescriptor::ValueRegister());
+
+ DCHECK(instr->object()->representation().IsTagged());
+ DCHECK(instr->key()->representation().IsTagged());
+ DCHECK(instr->value()->representation().IsTagged());
+
+ return MarkAsCall(new (zone()) LStoreKeyedGeneric(context, obj, key, val),
+ instr);
+}
+
+
+LInstruction* LChunkBuilder::DoTransitionElementsKind(
+ HTransitionElementsKind* instr) {
+ if (IsSimpleMapChangeTransition(instr->from_kind(), instr->to_kind())) {
+ LOperand* object = UseRegister(instr->object());
+ LOperand* new_map_reg = TempRegister();
+ LTransitionElementsKind* result =
+ new (zone()) LTransitionElementsKind(object, NULL, new_map_reg);
+ return result;
+ } else {
+ LOperand* object = UseFixed(instr->object(), r3);
+ LOperand* context = UseFixed(instr->context(), cp);
+ LTransitionElementsKind* result =
+ new (zone()) LTransitionElementsKind(object, context, NULL);
+ return MarkAsCall(result, instr);
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoTrapAllocationMemento(
+ HTrapAllocationMemento* instr) {
+ LOperand* object = UseRegister(instr->object());
+ LOperand* temp = TempRegister();
+ LTrapAllocationMemento* result =
+ new (zone()) LTrapAllocationMemento(object, temp);
+ return AssignEnvironment(result);
+}
+
+
+LInstruction* LChunkBuilder::DoStoreNamedField(HStoreNamedField* instr) {
+ bool is_in_object = instr->access().IsInobject();
+ bool needs_write_barrier = instr->NeedsWriteBarrier();
+ bool needs_write_barrier_for_map =
+ instr->has_transition() && instr->NeedsWriteBarrierForMap();
+
+ LOperand* obj;
+ if (needs_write_barrier) {
+ obj = is_in_object ? UseRegister(instr->object())
+ : UseTempRegister(instr->object());
+ } else {
+ obj = needs_write_barrier_for_map ? UseRegister(instr->object())
+ : UseRegisterAtStart(instr->object());
+ }
+
+ LOperand* val;
+ if (needs_write_barrier) {
+ val = UseTempRegister(instr->value());
+ } else if (instr->field_representation().IsDouble()) {
+ val = UseRegisterAtStart(instr->value());
+ } else {
+ val = UseRegister(instr->value());
+ }
+
+ // We need a temporary register for write barrier of the map field.
+ LOperand* temp = needs_write_barrier_for_map ? TempRegister() : NULL;
+
+ return new (zone()) LStoreNamedField(obj, val, temp);
+}
+
+
+LInstruction* LChunkBuilder::DoStoreNamedGeneric(HStoreNamedGeneric* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* obj =
+ UseFixed(instr->object(), StoreDescriptor::ReceiverRegister());
+ LOperand* val = UseFixed(instr->value(), StoreDescriptor::ValueRegister());
+
+ LInstruction* result = new (zone()) LStoreNamedGeneric(context, obj, val);
+ return MarkAsCall(result, instr);
+}
+
+
+LInstruction* LChunkBuilder::DoStringAdd(HStringAdd* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* left = UseFixed(instr->left(), r4);
+ LOperand* right = UseFixed(instr->right(), r3);
+ return MarkAsCall(
+ DefineFixed(new (zone()) LStringAdd(context, left, right), r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoStringCharCodeAt(HStringCharCodeAt* instr) {
+ LOperand* string = UseTempRegister(instr->string());
+ LOperand* index = UseTempRegister(instr->index());
+ LOperand* context = UseAny(instr->context());
+ LStringCharCodeAt* result =
+ new (zone()) LStringCharCodeAt(context, string, index);
+ return AssignPointerMap(DefineAsRegister(result));
+}
+
+
+LInstruction* LChunkBuilder::DoStringCharFromCode(HStringCharFromCode* instr) {
+ LOperand* char_code = UseRegister(instr->value());
+ LOperand* context = UseAny(instr->context());
+ LStringCharFromCode* result =
+ new (zone()) LStringCharFromCode(context, char_code);
+ return AssignPointerMap(DefineAsRegister(result));
+}
+
+
+LInstruction* LChunkBuilder::DoAllocate(HAllocate* instr) {
+ info()->MarkAsDeferredCalling();
+ LOperand* context = UseAny(instr->context());
+ LOperand* size = UseRegisterOrConstant(instr->size());
+ LOperand* temp1 = TempRegister();
+ LOperand* temp2 = TempRegister();
+ LAllocate* result = new (zone()) LAllocate(context, size, temp1, temp2);
+ return AssignPointerMap(DefineAsRegister(result));
+}
+
+
+LInstruction* LChunkBuilder::DoRegExpLiteral(HRegExpLiteral* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ return MarkAsCall(DefineFixed(new (zone()) LRegExpLiteral(context), r3),
+ instr);
+}
+
+
+LInstruction* LChunkBuilder::DoFunctionLiteral(HFunctionLiteral* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ return MarkAsCall(DefineFixed(new (zone()) LFunctionLiteral(context), r3),
+ instr);
+}
+
+
+LInstruction* LChunkBuilder::DoOsrEntry(HOsrEntry* instr) {
+ DCHECK(argument_count_ == 0);
+ allocator_->MarkAsOsrEntry();
+ current_block_->last_environment()->set_ast_id(instr->ast_id());
+ return AssignEnvironment(new (zone()) LOsrEntry);
+}
+
+
+LInstruction* LChunkBuilder::DoParameter(HParameter* instr) {
+ LParameter* result = new (zone()) LParameter;
+ if (instr->kind() == HParameter::STACK_PARAMETER) {
+ int spill_index = chunk()->GetParameterStackSlot(instr->index());
+ return DefineAsSpilled(result, spill_index);
+ } else {
+ DCHECK(info()->IsStub());
+ CallInterfaceDescriptor descriptor =
+ info()->code_stub()->GetCallInterfaceDescriptor();
+ int index = static_cast<int>(instr->index());
+ Register reg = descriptor.GetEnvironmentParameterRegister(index);
+ return DefineFixed(result, reg);
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoUnknownOSRValue(HUnknownOSRValue* instr) {
+ // Use an index that corresponds to the location in the unoptimized frame,
+ // which the optimized frame will subsume.
+ int env_index = instr->index();
+ int spill_index = 0;
+ if (instr->environment()->is_parameter_index(env_index)) {
+ spill_index = chunk()->GetParameterStackSlot(env_index);
+ } else {
+ spill_index = env_index - instr->environment()->first_local_index();
+ if (spill_index > LUnallocated::kMaxFixedSlotIndex) {
+ Retry(kTooManySpillSlotsNeededForOSR);
+ spill_index = 0;
+ }
+ }
+ return DefineAsSpilled(new (zone()) LUnknownOSRValue, spill_index);
+}
+
+
+LInstruction* LChunkBuilder::DoCallStub(HCallStub* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ return MarkAsCall(DefineFixed(new (zone()) LCallStub(context), r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoArgumentsObject(HArgumentsObject* instr) {
+ // There are no real uses of the arguments object.
+ // arguments.length and element access are supported directly on
+ // stack arguments, and any real arguments object use causes a bailout.
+ // So this value is never used.
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoCapturedObject(HCapturedObject* instr) {
+ instr->ReplayEnvironment(current_block_->last_environment());
+
+ // There are no real uses of a captured object.
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoAccessArgumentsAt(HAccessArgumentsAt* instr) {
+ info()->MarkAsRequiresFrame();
+ LOperand* args = UseRegister(instr->arguments());
+ LOperand* length = UseRegisterOrConstantAtStart(instr->length());
+ LOperand* index = UseRegisterOrConstantAtStart(instr->index());
+ return DefineAsRegister(new (zone()) LAccessArgumentsAt(args, length, index));
+}
+
+
+LInstruction* LChunkBuilder::DoToFastProperties(HToFastProperties* instr) {
+ LOperand* object = UseFixed(instr->value(), r3);
+ LToFastProperties* result = new (zone()) LToFastProperties(object);
+ return MarkAsCall(DefineFixed(result, r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoTypeof(HTypeof* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LTypeof* result = new (zone()) LTypeof(context, UseFixed(instr->value(), r3));
+ return MarkAsCall(DefineFixed(result, r3), instr);
+}
+
+
+LInstruction* LChunkBuilder::DoTypeofIsAndBranch(HTypeofIsAndBranch* instr) {
+ return new (zone()) LTypeofIsAndBranch(UseRegister(instr->value()));
+}
+
+
+LInstruction* LChunkBuilder::DoIsConstructCallAndBranch(
+ HIsConstructCallAndBranch* instr) {
+ return new (zone()) LIsConstructCallAndBranch(TempRegister());
+}
+
+
+LInstruction* LChunkBuilder::DoSimulate(HSimulate* instr) {
+ instr->ReplayEnvironment(current_block_->last_environment());
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoStackCheck(HStackCheck* instr) {
+ if (instr->is_function_entry()) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ return MarkAsCall(new (zone()) LStackCheck(context), instr);
+ } else {
+ DCHECK(instr->is_backwards_branch());
+ LOperand* context = UseAny(instr->context());
+ return AssignEnvironment(
+ AssignPointerMap(new (zone()) LStackCheck(context)));
+ }
+}
+
+
+LInstruction* LChunkBuilder::DoEnterInlined(HEnterInlined* instr) {
+ HEnvironment* outer = current_block_->last_environment();
+ outer->set_ast_id(instr->ReturnId());
+ HConstant* undefined = graph()->GetConstantUndefined();
+ HEnvironment* inner = outer->CopyForInlining(
+ instr->closure(), instr->arguments_count(), instr->function(), undefined,
+ instr->inlining_kind());
+ // Only replay binding of arguments object if it wasn't removed from graph.
+ if (instr->arguments_var() != NULL && instr->arguments_object()->IsLinked()) {
+ inner->Bind(instr->arguments_var(), instr->arguments_object());
+ }
+ inner->BindContext(instr->closure_context());
+ inner->set_entry(instr);
+ current_block_->UpdateEnvironment(inner);
+ chunk_->AddInlinedClosure(instr->closure());
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoLeaveInlined(HLeaveInlined* instr) {
+ LInstruction* pop = NULL;
+
+ HEnvironment* env = current_block_->last_environment();
+
+ if (env->entry()->arguments_pushed()) {
+ int argument_count = env->arguments_environment()->parameter_count();
+ pop = new (zone()) LDrop(argument_count);
+ DCHECK(instr->argument_delta() == -argument_count);
+ }
+
+ HEnvironment* outer =
+ current_block_->last_environment()->DiscardInlined(false);
+ current_block_->UpdateEnvironment(outer);
+
+ return pop;
+}
+
+
+LInstruction* LChunkBuilder::DoForInPrepareMap(HForInPrepareMap* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* object = UseFixed(instr->enumerable(), r3);
+ LForInPrepareMap* result = new (zone()) LForInPrepareMap(context, object);
+ return MarkAsCall(DefineFixed(result, r3), instr, CAN_DEOPTIMIZE_EAGERLY);
+}
+
+
+LInstruction* LChunkBuilder::DoForInCacheArray(HForInCacheArray* instr) {
+ LOperand* map = UseRegister(instr->map());
+ return AssignEnvironment(
+ DefineAsRegister(new (zone()) LForInCacheArray(map)));
+}
+
+
+LInstruction* LChunkBuilder::DoCheckMapValue(HCheckMapValue* instr) {
+ LOperand* value = UseRegisterAtStart(instr->value());
+ LOperand* map = UseRegisterAtStart(instr->map());
+ return AssignEnvironment(new (zone()) LCheckMapValue(value, map));
+}
+
+
+LInstruction* LChunkBuilder::DoLoadFieldByIndex(HLoadFieldByIndex* instr) {
+ LOperand* object = UseRegister(instr->object());
+ LOperand* index = UseTempRegister(instr->index());
+ LLoadFieldByIndex* load = new (zone()) LLoadFieldByIndex(object, index);
+ LInstruction* result = DefineSameAsFirst(load);
+ return AssignPointerMap(result);
+}
+
+
+LInstruction* LChunkBuilder::DoStoreFrameContext(HStoreFrameContext* instr) {
+ LOperand* context = UseRegisterAtStart(instr->context());
+ return new (zone()) LStoreFrameContext(context);
+}
+
+
+LInstruction* LChunkBuilder::DoAllocateBlockContext(
+ HAllocateBlockContext* instr) {
+ LOperand* context = UseFixed(instr->context(), cp);
+ LOperand* function = UseRegisterAtStart(instr->function());
+ LAllocateBlockContext* result =
+ new (zone()) LAllocateBlockContext(context, function);
+ return MarkAsCall(DefineFixed(result, cp), instr);
+}
+}
+} // namespace v8::internal
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_PPC_LITHIUM_PPC_H_
+#define V8_PPC_LITHIUM_PPC_H_
+
+#include "src/hydrogen.h"
+#include "src/lithium.h"
+#include "src/lithium-allocator.h"
+#include "src/safepoint-table.h"
+#include "src/utils.h"
+
+namespace v8 {
+namespace internal {
+
+// Forward declarations.
+class LCodeGen;
+
+#define LITHIUM_CONCRETE_INSTRUCTION_LIST(V) \
+ V(AccessArgumentsAt) \
+ V(AddI) \
+ V(Allocate) \
+ V(AllocateBlockContext) \
+ V(ApplyArguments) \
+ V(ArgumentsElements) \
+ V(ArgumentsLength) \
+ V(ArithmeticD) \
+ V(ArithmeticT) \
+ V(BitI) \
+ V(BoundsCheck) \
+ V(Branch) \
+ V(CallJSFunction) \
+ V(CallWithDescriptor) \
+ V(CallFunction) \
+ V(CallNew) \
+ V(CallNewArray) \
+ V(CallRuntime) \
+ V(CallStub) \
+ V(CheckInstanceType) \
+ V(CheckNonSmi) \
+ V(CheckMaps) \
+ V(CheckMapValue) \
+ V(CheckSmi) \
+ V(CheckValue) \
+ V(ClampDToUint8) \
+ V(ClampIToUint8) \
+ V(ClampTToUint8) \
+ V(ClassOfTestAndBranch) \
+ V(CompareMinusZeroAndBranch) \
+ V(CompareNumericAndBranch) \
+ V(CmpObjectEqAndBranch) \
+ V(CmpHoleAndBranch) \
+ V(CmpMapAndBranch) \
+ V(CmpT) \
+ V(ConstantD) \
+ V(ConstantE) \
+ V(ConstantI) \
+ V(ConstantS) \
+ V(ConstantT) \
+ V(ConstructDouble) \
+ V(Context) \
+ V(DateField) \
+ V(DebugBreak) \
+ V(DeclareGlobals) \
+ V(Deoptimize) \
+ V(DivByConstI) \
+ V(DivByPowerOf2I) \
+ V(DivI) \
+ V(DoubleBits) \
+ V(DoubleToI) \
+ V(DoubleToSmi) \
+ V(Drop) \
+ V(Dummy) \
+ V(DummyUse) \
+ V(FlooringDivByConstI) \
+ V(FlooringDivByPowerOf2I) \
+ V(FlooringDivI) \
+ V(ForInCacheArray) \
+ V(ForInPrepareMap) \
+ V(FunctionLiteral) \
+ V(GetCachedArrayIndex) \
+ V(Goto) \
+ V(HasCachedArrayIndexAndBranch) \
+ V(HasInstanceTypeAndBranch) \
+ V(InnerAllocatedObject) \
+ V(InstanceOf) \
+ V(InstanceOfKnownGlobal) \
+ V(InstructionGap) \
+ V(Integer32ToDouble) \
+ V(InvokeFunction) \
+ V(IsConstructCallAndBranch) \
+ V(IsObjectAndBranch) \
+ V(IsStringAndBranch) \
+ V(IsSmiAndBranch) \
+ V(IsUndetectableAndBranch) \
+ V(Label) \
+ V(LazyBailout) \
+ V(LoadContextSlot) \
+ V(LoadRoot) \
+ V(LoadFieldByIndex) \
+ V(LoadFunctionPrototype) \
+ V(LoadGlobalCell) \
+ V(LoadGlobalGeneric) \
+ V(LoadKeyed) \
+ V(LoadKeyedGeneric) \
+ V(LoadNamedField) \
+ V(LoadNamedGeneric) \
+ V(MapEnumLength) \
+ V(MathAbs) \
+ V(MathClz32) \
+ V(MathExp) \
+ V(MathFloor) \
+ V(MathFround) \
+ V(MathLog) \
+ V(MathMinMax) \
+ V(MathPowHalf) \
+ V(MathRound) \
+ V(MathSqrt) \
+ V(ModByConstI) \
+ V(ModByPowerOf2I) \
+ V(ModI) \
+ V(MulI) \
+ V(MultiplyAddD) \
+ V(MultiplySubD) \
+ V(NumberTagD) \
+ V(NumberTagI) \
+ V(NumberTagU) \
+ V(NumberUntagD) \
+ V(OsrEntry) \
+ V(Parameter) \
+ V(Power) \
+ V(PushArgument) \
+ V(RegExpLiteral) \
+ V(Return) \
+ V(SeqStringGetChar) \
+ V(SeqStringSetChar) \
+ V(ShiftI) \
+ V(SmiTag) \
+ V(SmiUntag) \
+ V(StackCheck) \
+ V(StoreCodeEntry) \
+ V(StoreContextSlot) \
+ V(StoreFrameContext) \
+ V(StoreGlobalCell) \
+ V(StoreKeyed) \
+ V(StoreKeyedGeneric) \
+ V(StoreNamedField) \
+ V(StoreNamedGeneric) \
+ V(StringAdd) \
+ V(StringCharCodeAt) \
+ V(StringCharFromCode) \
+ V(StringCompareAndBranch) \
+ V(SubI) \
+ V(RSubI) \
+ V(TaggedToI) \
+ V(TailCallThroughMegamorphicCache) \
+ V(ThisFunction) \
+ V(ToFastProperties) \
+ V(TransitionElementsKind) \
+ V(TrapAllocationMemento) \
+ V(Typeof) \
+ V(TypeofIsAndBranch) \
+ V(Uint32ToDouble) \
+ V(UnknownOSRValue) \
+ V(WrapReceiver)
+
+
+#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
+ virtual Opcode opcode() const FINAL OVERRIDE { \
+ return LInstruction::k##type; \
+ } \
+ virtual void CompileToNative(LCodeGen* generator) FINAL OVERRIDE; \
+ virtual const char* Mnemonic() const FINAL OVERRIDE { return mnemonic; } \
+ static L##type* cast(LInstruction* instr) { \
+ DCHECK(instr->Is##type()); \
+ return reinterpret_cast<L##type*>(instr); \
+ }
+
+
+#define DECLARE_HYDROGEN_ACCESSOR(type) \
+ H##type* hydrogen() const { return H##type::cast(hydrogen_value()); }
+
+
+class LInstruction : public ZoneObject {
+ public:
+ LInstruction()
+ : environment_(NULL),
+ hydrogen_value_(NULL),
+ bit_field_(IsCallBits::encode(false)) {}
+
+ virtual ~LInstruction() {}
+
+ virtual void CompileToNative(LCodeGen* generator) = 0;
+ virtual const char* Mnemonic() const = 0;
+ virtual void PrintTo(StringStream* stream);
+ virtual void PrintDataTo(StringStream* stream);
+ virtual void PrintOutputOperandTo(StringStream* stream);
+
+ enum Opcode {
+// Declare a unique enum value for each instruction.
+#define DECLARE_OPCODE(type) k##type,
+ LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_OPCODE) kNumberOfInstructions
+#undef DECLARE_OPCODE
+ };
+
+ virtual Opcode opcode() const = 0;
+
+// Declare non-virtual type testers for all leaf IR classes.
+#define DECLARE_PREDICATE(type) \
+ bool Is##type() const { return opcode() == k##type; }
+ LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_PREDICATE)
+#undef DECLARE_PREDICATE
+
+ // Declare virtual predicates for instructions that don't have
+ // an opcode.
+ virtual bool IsGap() const { return false; }
+
+ virtual bool IsControl() const { return false; }
+
+ // Try deleting this instruction if possible.
+ virtual bool TryDelete() { return false; }
+
+ void set_environment(LEnvironment* env) { environment_ = env; }
+ LEnvironment* environment() const { return environment_; }
+ bool HasEnvironment() const { return environment_ != NULL; }
+
+ void set_pointer_map(LPointerMap* p) { pointer_map_.set(p); }
+ LPointerMap* pointer_map() const { return pointer_map_.get(); }
+ bool HasPointerMap() const { return pointer_map_.is_set(); }
+
+ void set_hydrogen_value(HValue* value) { hydrogen_value_ = value; }
+ HValue* hydrogen_value() const { return hydrogen_value_; }
+
+ virtual void SetDeferredLazyDeoptimizationEnvironment(LEnvironment* env) {}
+
+ void MarkAsCall() { bit_field_ = IsCallBits::update(bit_field_, true); }
+ bool IsCall() const { return IsCallBits::decode(bit_field_); }
+
+ // Interface to the register allocator and iterators.
+ bool ClobbersTemps() const { return IsCall(); }
+ bool ClobbersRegisters() const { return IsCall(); }
+ virtual bool ClobbersDoubleRegisters(Isolate* isolate) const {
+ return IsCall();
+ }
+
+ // Interface to the register allocator and iterators.
+ bool IsMarkedAsCall() const { return IsCall(); }
+
+ virtual bool HasResult() const = 0;
+ virtual LOperand* result() const = 0;
+
+ LOperand* FirstInput() { return InputAt(0); }
+ LOperand* Output() { return HasResult() ? result() : NULL; }
+
+ virtual bool HasInterestingComment(LCodeGen* gen) const { return true; }
+
+#ifdef DEBUG
+ void VerifyCall();
+#endif
+
+ virtual int InputCount() = 0;
+ virtual LOperand* InputAt(int i) = 0;
+
+ private:
+ // Iterator support.
+ friend class InputIterator;
+
+ friend class TempIterator;
+ virtual int TempCount() = 0;
+ virtual LOperand* TempAt(int i) = 0;
+
+ class IsCallBits : public BitField<bool, 0, 1> {};
+
+ LEnvironment* environment_;
+ SetOncePointer<LPointerMap> pointer_map_;
+ HValue* hydrogen_value_;
+ int bit_field_;
+};
+
+
+// R = number of result operands (0 or 1).
+template <int R>
+class LTemplateResultInstruction : public LInstruction {
+ public:
+ // Allow 0 or 1 output operands.
+ STATIC_ASSERT(R == 0 || R == 1);
+ virtual bool HasResult() const FINAL OVERRIDE {
+ return R != 0 && result() != NULL;
+ }
+ void set_result(LOperand* operand) { results_[0] = operand; }
+ LOperand* result() const { return results_[0]; }
+
+ protected:
+ EmbeddedContainer<LOperand*, R> results_;
+};
+
+
+// R = number of result operands (0 or 1).
+// I = number of input operands.
+// T = number of temporary operands.
+template <int R, int I, int T>
+class LTemplateInstruction : public LTemplateResultInstruction<R> {
+ protected:
+ EmbeddedContainer<LOperand*, I> inputs_;
+ EmbeddedContainer<LOperand*, T> temps_;
+
+ private:
+ // Iterator support.
+ virtual int InputCount() FINAL OVERRIDE { return I; }
+ virtual LOperand* InputAt(int i) FINAL OVERRIDE { return inputs_[i]; }
+
+ virtual int TempCount() FINAL OVERRIDE { return T; }
+ virtual LOperand* TempAt(int i) FINAL OVERRIDE { return temps_[i]; }
+};
+
+
+class LGap : public LTemplateInstruction<0, 0, 0> {
+ public:
+ explicit LGap(HBasicBlock* block) : block_(block) {
+ parallel_moves_[BEFORE] = NULL;
+ parallel_moves_[START] = NULL;
+ parallel_moves_[END] = NULL;
+ parallel_moves_[AFTER] = NULL;
+ }
+
+ // Can't use the DECLARE-macro here because of sub-classes.
+ virtual bool IsGap() const OVERRIDE { return true; }
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+ static LGap* cast(LInstruction* instr) {
+ DCHECK(instr->IsGap());
+ return reinterpret_cast<LGap*>(instr);
+ }
+
+ bool IsRedundant() const;
+
+ HBasicBlock* block() const { return block_; }
+
+ enum InnerPosition {
+ BEFORE,
+ START,
+ END,
+ AFTER,
+ FIRST_INNER_POSITION = BEFORE,
+ LAST_INNER_POSITION = AFTER
+ };
+
+ LParallelMove* GetOrCreateParallelMove(InnerPosition pos, Zone* zone) {
+ if (parallel_moves_[pos] == NULL) {
+ parallel_moves_[pos] = new (zone) LParallelMove(zone);
+ }
+ return parallel_moves_[pos];
+ }
+
+ LParallelMove* GetParallelMove(InnerPosition pos) {
+ return parallel_moves_[pos];
+ }
+
+ private:
+ LParallelMove* parallel_moves_[LAST_INNER_POSITION + 1];
+ HBasicBlock* block_;
+};
+
+
+class LInstructionGap FINAL : public LGap {
+ public:
+ explicit LInstructionGap(HBasicBlock* block) : LGap(block) {}
+
+ virtual bool HasInterestingComment(LCodeGen* gen) const OVERRIDE {
+ return !IsRedundant();
+ }
+
+ DECLARE_CONCRETE_INSTRUCTION(InstructionGap, "gap")
+};
+
+
+class LGoto FINAL : public LTemplateInstruction<0, 0, 0> {
+ public:
+ explicit LGoto(HBasicBlock* block) : block_(block) {}
+
+ virtual bool HasInterestingComment(LCodeGen* gen) const OVERRIDE;
+ DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+ virtual bool IsControl() const OVERRIDE { return true; }
+
+ int block_id() const { return block_->block_id(); }
+
+ private:
+ HBasicBlock* block_;
+};
+
+
+class LLazyBailout FINAL : public LTemplateInstruction<0, 0, 0> {
+ public:
+ LLazyBailout() : gap_instructions_size_(0) {}
+
+ DECLARE_CONCRETE_INSTRUCTION(LazyBailout, "lazy-bailout")
+
+ void set_gap_instructions_size(int gap_instructions_size) {
+ gap_instructions_size_ = gap_instructions_size;
+ }
+ int gap_instructions_size() { return gap_instructions_size_; }
+
+ private:
+ int gap_instructions_size_;
+};
+
+
+class LDummy FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ LDummy() {}
+ DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy")
+};
+
+
+class LDummyUse FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LDummyUse(LOperand* value) { inputs_[0] = value; }
+ DECLARE_CONCRETE_INSTRUCTION(DummyUse, "dummy-use")
+};
+
+
+class LDeoptimize FINAL : public LTemplateInstruction<0, 0, 0> {
+ public:
+ virtual bool IsControl() const OVERRIDE { return true; }
+ DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")
+ DECLARE_HYDROGEN_ACCESSOR(Deoptimize)
+};
+
+
+class LLabel FINAL : public LGap {
+ public:
+ explicit LLabel(HBasicBlock* block) : LGap(block), replacement_(NULL) {}
+
+ virtual bool HasInterestingComment(LCodeGen* gen) const OVERRIDE {
+ return false;
+ }
+ DECLARE_CONCRETE_INSTRUCTION(Label, "label")
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+
+ int block_id() const { return block()->block_id(); }
+ bool is_loop_header() const { return block()->IsLoopHeader(); }
+ bool is_osr_entry() const { return block()->is_osr_entry(); }
+ Label* label() { return &label_; }
+ LLabel* replacement() const { return replacement_; }
+ void set_replacement(LLabel* label) { replacement_ = label; }
+ bool HasReplacement() const { return replacement_ != NULL; }
+
+ private:
+ Label label_;
+ LLabel* replacement_;
+};
+
+
+class LParameter FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ virtual bool HasInterestingComment(LCodeGen* gen) const { return false; }
+ DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")
+};
+
+
+class LCallStub FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LCallStub(LOperand* context) { inputs_[0] = context; }
+
+ LOperand* context() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CallStub, "call-stub")
+ DECLARE_HYDROGEN_ACCESSOR(CallStub)
+};
+
+
+class LTailCallThroughMegamorphicCache FINAL
+ : public LTemplateInstruction<0, 3, 0> {
+ public:
+ explicit LTailCallThroughMegamorphicCache(LOperand* context,
+ LOperand* receiver,
+ LOperand* name) {
+ inputs_[0] = context;
+ inputs_[1] = receiver;
+ inputs_[2] = name;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* receiver() { return inputs_[1]; }
+ LOperand* name() { return inputs_[2]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(TailCallThroughMegamorphicCache,
+ "tail-call-through-megamorphic-cache")
+ DECLARE_HYDROGEN_ACCESSOR(TailCallThroughMegamorphicCache)
+};
+
+class LUnknownOSRValue FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ virtual bool HasInterestingComment(LCodeGen* gen) const OVERRIDE {
+ return false;
+ }
+ DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")
+};
+
+
+template <int I, int T>
+class LControlInstruction : public LTemplateInstruction<0, I, T> {
+ public:
+ LControlInstruction() : false_label_(NULL), true_label_(NULL) {}
+
+ virtual bool IsControl() const FINAL OVERRIDE { return true; }
+
+ int SuccessorCount() { return hydrogen()->SuccessorCount(); }
+ HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); }
+
+ int TrueDestination(LChunk* chunk) {
+ return chunk->LookupDestination(true_block_id());
+ }
+ int FalseDestination(LChunk* chunk) {
+ return chunk->LookupDestination(false_block_id());
+ }
+
+ Label* TrueLabel(LChunk* chunk) {
+ if (true_label_ == NULL) {
+ true_label_ = chunk->GetAssemblyLabel(TrueDestination(chunk));
+ }
+ return true_label_;
+ }
+ Label* FalseLabel(LChunk* chunk) {
+ if (false_label_ == NULL) {
+ false_label_ = chunk->GetAssemblyLabel(FalseDestination(chunk));
+ }
+ return false_label_;
+ }
+
+ protected:
+ int true_block_id() { return SuccessorAt(0)->block_id(); }
+ int false_block_id() { return SuccessorAt(1)->block_id(); }
+
+ private:
+ HControlInstruction* hydrogen() {
+ return HControlInstruction::cast(this->hydrogen_value());
+ }
+
+ Label* false_label_;
+ Label* true_label_;
+};
+
+
+class LWrapReceiver FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LWrapReceiver(LOperand* receiver, LOperand* function) {
+ inputs_[0] = receiver;
+ inputs_[1] = function;
+ }
+
+ DECLARE_CONCRETE_INSTRUCTION(WrapReceiver, "wrap-receiver")
+ DECLARE_HYDROGEN_ACCESSOR(WrapReceiver)
+
+ LOperand* receiver() { return inputs_[0]; }
+ LOperand* function() { return inputs_[1]; }
+};
+
+
+class LApplyArguments FINAL : public LTemplateInstruction<1, 4, 0> {
+ public:
+ LApplyArguments(LOperand* function, LOperand* receiver, LOperand* length,
+ LOperand* elements) {
+ inputs_[0] = function;
+ inputs_[1] = receiver;
+ inputs_[2] = length;
+ inputs_[3] = elements;
+ }
+
+ DECLARE_CONCRETE_INSTRUCTION(ApplyArguments, "apply-arguments")
+
+ LOperand* function() { return inputs_[0]; }
+ LOperand* receiver() { return inputs_[1]; }
+ LOperand* length() { return inputs_[2]; }
+ LOperand* elements() { return inputs_[3]; }
+};
+
+
+class LAccessArgumentsAt FINAL : public LTemplateInstruction<1, 3, 0> {
+ public:
+ LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) {
+ inputs_[0] = arguments;
+ inputs_[1] = length;
+ inputs_[2] = index;
+ }
+
+ DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt, "access-arguments-at")
+
+ LOperand* arguments() { return inputs_[0]; }
+ LOperand* length() { return inputs_[1]; }
+ LOperand* index() { return inputs_[2]; }
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LArgumentsLength FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LArgumentsLength(LOperand* elements) { inputs_[0] = elements; }
+
+ LOperand* elements() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength, "arguments-length")
+};
+
+
+class LArgumentsElements FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
+ DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements)
+};
+
+
+class LModByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ LModByPowerOf2I(LOperand* dividend, int32_t divisor) {
+ inputs_[0] = dividend;
+ divisor_ = divisor;
+ }
+
+ LOperand* dividend() { return inputs_[0]; }
+ int32_t divisor() const { return divisor_; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ModByPowerOf2I, "mod-by-power-of-2-i")
+ DECLARE_HYDROGEN_ACCESSOR(Mod)
+
+ private:
+ int32_t divisor_;
+};
+
+
+class LModByConstI FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ LModByConstI(LOperand* dividend, int32_t divisor) {
+ inputs_[0] = dividend;
+ divisor_ = divisor;
+ }
+
+ LOperand* dividend() { return inputs_[0]; }
+ int32_t divisor() const { return divisor_; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ModByConstI, "mod-by-const-i")
+ DECLARE_HYDROGEN_ACCESSOR(Mod)
+
+ private:
+ int32_t divisor_;
+};
+
+
+class LModI FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LModI(LOperand* left, LOperand* right) {
+ inputs_[0] = left;
+ inputs_[1] = right;
+ }
+
+ LOperand* left() { return inputs_[0]; }
+ LOperand* right() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ModI, "mod-i")
+ DECLARE_HYDROGEN_ACCESSOR(Mod)
+};
+
+
+class LDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ LDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
+ inputs_[0] = dividend;
+ divisor_ = divisor;
+ }
+
+ LOperand* dividend() { return inputs_[0]; }
+ int32_t divisor() const { return divisor_; }
+
+ DECLARE_CONCRETE_INSTRUCTION(DivByPowerOf2I, "div-by-power-of-2-i")
+ DECLARE_HYDROGEN_ACCESSOR(Div)
+
+ private:
+ int32_t divisor_;
+};
+
+
+class LDivByConstI FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ LDivByConstI(LOperand* dividend, int32_t divisor) {
+ inputs_[0] = dividend;
+ divisor_ = divisor;
+ }
+
+ LOperand* dividend() { return inputs_[0]; }
+ int32_t divisor() const { return divisor_; }
+
+ DECLARE_CONCRETE_INSTRUCTION(DivByConstI, "div-by-const-i")
+ DECLARE_HYDROGEN_ACCESSOR(Div)
+
+ private:
+ int32_t divisor_;
+};
+
+
+class LDivI FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LDivI(LOperand* dividend, LOperand* divisor) {
+ inputs_[0] = dividend;
+ inputs_[1] = divisor;
+ }
+
+ LOperand* dividend() { return inputs_[0]; }
+ LOperand* divisor() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(DivI, "div-i")
+ DECLARE_HYDROGEN_ACCESSOR(BinaryOperation)
+};
+
+
+class LFlooringDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
+ inputs_[0] = dividend;
+ divisor_ = divisor;
+ }
+
+ LOperand* dividend() { return inputs_[0]; }
+ int32_t divisor() { return divisor_; }
+
+ DECLARE_CONCRETE_INSTRUCTION(FlooringDivByPowerOf2I,
+ "flooring-div-by-power-of-2-i")
+ DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv)
+
+ private:
+ int32_t divisor_;
+};
+
+
+class LFlooringDivByConstI FINAL : public LTemplateInstruction<1, 1, 1> {
+ public:
+ LFlooringDivByConstI(LOperand* dividend, int32_t divisor, LOperand* temp) {
+ inputs_[0] = dividend;
+ divisor_ = divisor;
+ temps_[0] = temp;
+ }
+
+ LOperand* dividend() { return inputs_[0]; }
+ int32_t divisor() const { return divisor_; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(FlooringDivByConstI, "flooring-div-by-const-i")
+ DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv)
+
+ private:
+ int32_t divisor_;
+};
+
+
+class LFlooringDivI FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LFlooringDivI(LOperand* dividend, LOperand* divisor) {
+ inputs_[0] = dividend;
+ inputs_[1] = divisor;
+ }
+
+ LOperand* dividend() { return inputs_[0]; }
+ LOperand* divisor() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(FlooringDivI, "flooring-div-i")
+ DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv)
+};
+
+
+class LMulI FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LMulI(LOperand* left, LOperand* right) {
+ inputs_[0] = left;
+ inputs_[1] = right;
+ }
+
+ LOperand* left() { return inputs_[0]; }
+ LOperand* right() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MulI, "mul-i")
+ DECLARE_HYDROGEN_ACCESSOR(Mul)
+};
+
+
+// Instruction for computing multiplier * multiplicand + addend.
+class LMultiplyAddD FINAL : public LTemplateInstruction<1, 3, 0> {
+ public:
+ LMultiplyAddD(LOperand* addend, LOperand* multiplier,
+ LOperand* multiplicand) {
+ inputs_[0] = addend;
+ inputs_[1] = multiplier;
+ inputs_[2] = multiplicand;
+ }
+
+ LOperand* addend() { return inputs_[0]; }
+ LOperand* multiplier() { return inputs_[1]; }
+ LOperand* multiplicand() { return inputs_[2]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MultiplyAddD, "multiply-add-d")
+};
+
+
+// Instruction for computing minuend - multiplier * multiplicand.
+class LMultiplySubD FINAL : public LTemplateInstruction<1, 3, 0> {
+ public:
+ LMultiplySubD(LOperand* minuend, LOperand* multiplier,
+ LOperand* multiplicand) {
+ inputs_[0] = minuend;
+ inputs_[1] = multiplier;
+ inputs_[2] = multiplicand;
+ }
+
+ LOperand* minuend() { return inputs_[0]; }
+ LOperand* multiplier() { return inputs_[1]; }
+ LOperand* multiplicand() { return inputs_[2]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MultiplySubD, "multiply-sub-d")
+};
+
+
+class LDebugBreak FINAL : public LTemplateInstruction<0, 0, 0> {
+ public:
+ DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break")
+};
+
+
+class LCompareNumericAndBranch FINAL : public LControlInstruction<2, 0> {
+ public:
+ LCompareNumericAndBranch(LOperand* left, LOperand* right) {
+ inputs_[0] = left;
+ inputs_[1] = right;
+ }
+
+ LOperand* left() { return inputs_[0]; }
+ LOperand* right() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch,
+ "compare-numeric-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(CompareNumericAndBranch)
+
+ Token::Value op() const { return hydrogen()->token(); }
+ bool is_double() const { return hydrogen()->representation().IsDouble(); }
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LMathFloor FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LMathFloor(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MathFloor, "math-floor")
+ DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)
+};
+
+
+class LMathRound FINAL : public LTemplateInstruction<1, 1, 1> {
+ public:
+ LMathRound(LOperand* value, LOperand* temp) {
+ inputs_[0] = value;
+ temps_[0] = temp;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MathRound, "math-round")
+ DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)
+};
+
+
+class LMathFround FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LMathFround(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MathFround, "math-fround")
+};
+
+
+class LMathAbs FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LMathAbs(LOperand* context, LOperand* value) {
+ inputs_[1] = context;
+ inputs_[0] = value;
+ }
+
+ LOperand* context() { return inputs_[1]; }
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MathAbs, "math-abs")
+ DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)
+};
+
+
+class LMathLog FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LMathLog(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MathLog, "math-log")
+};
+
+
+class LMathClz32 FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LMathClz32(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MathClz32, "math-clz32")
+};
+
+
+class LMathExp FINAL : public LTemplateInstruction<1, 1, 3> {
+ public:
+ LMathExp(LOperand* value, LOperand* double_temp, LOperand* temp1,
+ LOperand* temp2) {
+ inputs_[0] = value;
+ temps_[0] = temp1;
+ temps_[1] = temp2;
+ temps_[2] = double_temp;
+ ExternalReference::InitializeMathExpData();
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp1() { return temps_[0]; }
+ LOperand* temp2() { return temps_[1]; }
+ LOperand* double_temp() { return temps_[2]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MathExp, "math-exp")
+};
+
+
+class LMathSqrt FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LMathSqrt(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MathSqrt, "math-sqrt")
+};
+
+
+class LMathPowHalf FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LMathPowHalf(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MathPowHalf, "math-pow-half")
+};
+
+
+class LCmpObjectEqAndBranch FINAL : public LControlInstruction<2, 0> {
+ public:
+ LCmpObjectEqAndBranch(LOperand* left, LOperand* right) {
+ inputs_[0] = left;
+ inputs_[1] = right;
+ }
+
+ LOperand* left() { return inputs_[0]; }
+ LOperand* right() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CmpObjectEqAndBranch, "cmp-object-eq-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(CompareObjectEqAndBranch)
+};
+
+
+class LCmpHoleAndBranch FINAL : public LControlInstruction<1, 0> {
+ public:
+ explicit LCmpHoleAndBranch(LOperand* object) { inputs_[0] = object; }
+
+ LOperand* object() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CmpHoleAndBranch, "cmp-hole-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(CompareHoleAndBranch)
+};
+
+
+class LCompareMinusZeroAndBranch FINAL : public LControlInstruction<1, 1> {
+ public:
+ LCompareMinusZeroAndBranch(LOperand* value, LOperand* temp) {
+ inputs_[0] = value;
+ temps_[0] = temp;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CompareMinusZeroAndBranch,
+ "cmp-minus-zero-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(CompareMinusZeroAndBranch)
+};
+
+
+class LIsObjectAndBranch FINAL : public LControlInstruction<1, 1> {
+ public:
+ LIsObjectAndBranch(LOperand* value, LOperand* temp) {
+ inputs_[0] = value;
+ temps_[0] = temp;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(IsObjectAndBranch)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LIsStringAndBranch FINAL : public LControlInstruction<1, 1> {
+ public:
+ LIsStringAndBranch(LOperand* value, LOperand* temp) {
+ inputs_[0] = value;
+ temps_[0] = temp;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LIsSmiAndBranch FINAL : public LControlInstruction<1, 0> {
+ public:
+ explicit LIsSmiAndBranch(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LIsUndetectableAndBranch FINAL : public LControlInstruction<1, 1> {
+ public:
+ explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) {
+ inputs_[0] = value;
+ temps_[0] = temp;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(IsUndetectableAndBranch,
+ "is-undetectable-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LStringCompareAndBranch FINAL : public LControlInstruction<3, 0> {
+ public:
+ LStringCompareAndBranch(LOperand* context, LOperand* left, LOperand* right) {
+ inputs_[0] = context;
+ inputs_[1] = left;
+ inputs_[2] = right;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* left() { return inputs_[1]; }
+ LOperand* right() { return inputs_[2]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(StringCompareAndBranch,
+ "string-compare-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(StringCompareAndBranch)
+
+ Token::Value op() const { return hydrogen()->token(); }
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LHasInstanceTypeAndBranch FINAL : public LControlInstruction<1, 0> {
+ public:
+ explicit LHasInstanceTypeAndBranch(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(HasInstanceTypeAndBranch,
+ "has-instance-type-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LGetCachedArrayIndex FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LGetCachedArrayIndex(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex, "get-cached-array-index")
+ DECLARE_HYDROGEN_ACCESSOR(GetCachedArrayIndex)
+};
+
+
+class LHasCachedArrayIndexAndBranch FINAL : public LControlInstruction<1, 0> {
+ public:
+ explicit LHasCachedArrayIndexAndBranch(LOperand* value) {
+ inputs_[0] = value;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch,
+ "has-cached-array-index-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndexAndBranch)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LClassOfTestAndBranch FINAL : public LControlInstruction<1, 1> {
+ public:
+ LClassOfTestAndBranch(LOperand* value, LOperand* temp) {
+ inputs_[0] = value;
+ temps_[0] = temp;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch, "class-of-test-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LCmpT FINAL : public LTemplateInstruction<1, 3, 0> {
+ public:
+ LCmpT(LOperand* context, LOperand* left, LOperand* right) {
+ inputs_[0] = context;
+ inputs_[1] = left;
+ inputs_[2] = right;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* left() { return inputs_[1]; }
+ LOperand* right() { return inputs_[2]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CmpT, "cmp-t")
+ DECLARE_HYDROGEN_ACCESSOR(CompareGeneric)
+
+ Token::Value op() const { return hydrogen()->token(); }
+};
+
+
+class LInstanceOf FINAL : public LTemplateInstruction<1, 3, 0> {
+ public:
+ LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {
+ inputs_[0] = context;
+ inputs_[1] = left;
+ inputs_[2] = right;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* left() { return inputs_[1]; }
+ LOperand* right() { return inputs_[2]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(InstanceOf, "instance-of")
+};
+
+
+class LInstanceOfKnownGlobal FINAL : public LTemplateInstruction<1, 2, 1> {
+ public:
+ LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) {
+ inputs_[0] = context;
+ inputs_[1] = value;
+ temps_[0] = temp;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* value() { return inputs_[1]; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(InstanceOfKnownGlobal,
+ "instance-of-known-global")
+ DECLARE_HYDROGEN_ACCESSOR(InstanceOfKnownGlobal)
+
+ Handle<JSFunction> function() const { return hydrogen()->function(); }
+ LEnvironment* GetDeferredLazyDeoptimizationEnvironment() {
+ return lazy_deopt_env_;
+ }
+ virtual void SetDeferredLazyDeoptimizationEnvironment(
+ LEnvironment* env) OVERRIDE {
+ lazy_deopt_env_ = env;
+ }
+
+ private:
+ LEnvironment* lazy_deopt_env_;
+};
+
+
+class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 0> {
+ public:
+ LBoundsCheck(LOperand* index, LOperand* length) {
+ inputs_[0] = index;
+ inputs_[1] = length;
+ }
+
+ LOperand* index() { return inputs_[0]; }
+ LOperand* length() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(BoundsCheck, "bounds-check")
+ DECLARE_HYDROGEN_ACCESSOR(BoundsCheck)
+};
+
+
+class LBitI FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LBitI(LOperand* left, LOperand* right) {
+ inputs_[0] = left;
+ inputs_[1] = right;
+ }
+
+ LOperand* left() { return inputs_[0]; }
+ LOperand* right() { return inputs_[1]; }
+
+ Token::Value op() const { return hydrogen()->op(); }
+
+ DECLARE_CONCRETE_INSTRUCTION(BitI, "bit-i")
+ DECLARE_HYDROGEN_ACCESSOR(Bitwise)
+};
+
+
+class LShiftI FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)
+ : op_(op), can_deopt_(can_deopt) {
+ inputs_[0] = left;
+ inputs_[1] = right;
+ }
+
+ Token::Value op() const { return op_; }
+ LOperand* left() { return inputs_[0]; }
+ LOperand* right() { return inputs_[1]; }
+ bool can_deopt() const { return can_deopt_; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ShiftI, "shift-i")
+
+ private:
+ Token::Value op_;
+ bool can_deopt_;
+};
+
+
+class LSubI FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LSubI(LOperand* left, LOperand* right) {
+ inputs_[0] = left;
+ inputs_[1] = right;
+ }
+
+ LOperand* left() { return inputs_[0]; }
+ LOperand* right() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(SubI, "sub-i")
+ DECLARE_HYDROGEN_ACCESSOR(Sub)
+};
+
+
+class LRSubI FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LRSubI(LOperand* left, LOperand* right) {
+ inputs_[0] = left;
+ inputs_[1] = right;
+ }
+
+ LOperand* left() { return inputs_[0]; }
+ LOperand* right() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(RSubI, "rsub-i")
+ DECLARE_HYDROGEN_ACCESSOR(Sub)
+};
+
+
+class LConstantI FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")
+ DECLARE_HYDROGEN_ACCESSOR(Constant)
+
+ int32_t value() const { return hydrogen()->Integer32Value(); }
+};
+
+
+class LConstantS FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")
+ DECLARE_HYDROGEN_ACCESSOR(Constant)
+
+ Smi* value() const { return Smi::FromInt(hydrogen()->Integer32Value()); }
+};
+
+
+class LConstantD FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d")
+ DECLARE_HYDROGEN_ACCESSOR(Constant)
+
+ double value() const { return hydrogen()->DoubleValue(); }
+};
+
+
+class LConstantE FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")
+ DECLARE_HYDROGEN_ACCESSOR(Constant)
+
+ ExternalReference value() const {
+ return hydrogen()->ExternalReferenceValue();
+ }
+};
+
+
+class LConstantT FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")
+ DECLARE_HYDROGEN_ACCESSOR(Constant)
+
+ Handle<Object> value(Isolate* isolate) const {
+ return hydrogen()->handle(isolate);
+ }
+};
+
+
+class LBranch FINAL : public LControlInstruction<1, 0> {
+ public:
+ explicit LBranch(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")
+ DECLARE_HYDROGEN_ACCESSOR(Branch)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LCmpMapAndBranch FINAL : public LControlInstruction<1, 1> {
+ public:
+ LCmpMapAndBranch(LOperand* value, LOperand* temp) {
+ inputs_[0] = value;
+ temps_[0] = temp;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CmpMapAndBranch, "cmp-map-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(CompareMap)
+
+ Handle<Map> map() const { return hydrogen()->map().handle(); }
+};
+
+
+class LMapEnumLength FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LMapEnumLength(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MapEnumLength, "map-enum-length")
+};
+
+
+class LDateField FINAL : public LTemplateInstruction<1, 1, 1> {
+ public:
+ LDateField(LOperand* date, LOperand* temp, Smi* index) : index_(index) {
+ inputs_[0] = date;
+ temps_[0] = temp;
+ }
+
+ LOperand* date() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+ Smi* index() const { return index_; }
+
+ DECLARE_CONCRETE_INSTRUCTION(DateField, "date-field")
+ DECLARE_HYDROGEN_ACCESSOR(DateField)
+
+ private:
+ Smi* index_;
+};
+
+
+class LSeqStringGetChar FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LSeqStringGetChar(LOperand* string, LOperand* index) {
+ inputs_[0] = string;
+ inputs_[1] = index;
+ }
+
+ LOperand* string() const { return inputs_[0]; }
+ LOperand* index() const { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(SeqStringGetChar, "seq-string-get-char")
+ DECLARE_HYDROGEN_ACCESSOR(SeqStringGetChar)
+};
+
+
+class LSeqStringSetChar FINAL : public LTemplateInstruction<1, 4, 0> {
+ public:
+ LSeqStringSetChar(LOperand* context, LOperand* string, LOperand* index,
+ LOperand* value) {
+ inputs_[0] = context;
+ inputs_[1] = string;
+ inputs_[2] = index;
+ inputs_[3] = value;
+ }
+
+ LOperand* string() { return inputs_[1]; }
+ LOperand* index() { return inputs_[2]; }
+ LOperand* value() { return inputs_[3]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(SeqStringSetChar, "seq-string-set-char")
+ DECLARE_HYDROGEN_ACCESSOR(SeqStringSetChar)
+};
+
+
+class LAddI FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LAddI(LOperand* left, LOperand* right) {
+ inputs_[0] = left;
+ inputs_[1] = right;
+ }
+
+ LOperand* left() { return inputs_[0]; }
+ LOperand* right() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(AddI, "add-i")
+ DECLARE_HYDROGEN_ACCESSOR(Add)
+};
+
+
+class LMathMinMax FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LMathMinMax(LOperand* left, LOperand* right) {
+ inputs_[0] = left;
+ inputs_[1] = right;
+ }
+
+ LOperand* left() { return inputs_[0]; }
+ LOperand* right() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(MathMinMax, "math-min-max")
+ DECLARE_HYDROGEN_ACCESSOR(MathMinMax)
+};
+
+
+class LPower FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LPower(LOperand* left, LOperand* right) {
+ inputs_[0] = left;
+ inputs_[1] = right;
+ }
+
+ LOperand* left() { return inputs_[0]; }
+ LOperand* right() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(Power, "power")
+ DECLARE_HYDROGEN_ACCESSOR(Power)
+};
+
+
+class LArithmeticD FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LArithmeticD(Token::Value op, LOperand* left, LOperand* right) : op_(op) {
+ inputs_[0] = left;
+ inputs_[1] = right;
+ }
+
+ Token::Value op() const { return op_; }
+ LOperand* left() { return inputs_[0]; }
+ LOperand* right() { return inputs_[1]; }
+
+ virtual Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticD; }
+ virtual void CompileToNative(LCodeGen* generator) OVERRIDE;
+ virtual const char* Mnemonic() const OVERRIDE;
+
+ private:
+ Token::Value op_;
+};
+
+
+class LArithmeticT FINAL : public LTemplateInstruction<1, 3, 0> {
+ public:
+ LArithmeticT(Token::Value op, LOperand* context, LOperand* left,
+ LOperand* right)
+ : op_(op) {
+ inputs_[0] = context;
+ inputs_[1] = left;
+ inputs_[2] = right;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* left() { return inputs_[1]; }
+ LOperand* right() { return inputs_[2]; }
+ Token::Value op() const { return op_; }
+
+ virtual Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticT; }
+ virtual void CompileToNative(LCodeGen* generator) OVERRIDE;
+ virtual const char* Mnemonic() const OVERRIDE;
+
+ private:
+ Token::Value op_;
+};
+
+
+class LReturn FINAL : public LTemplateInstruction<0, 3, 0> {
+ public:
+ LReturn(LOperand* value, LOperand* context, LOperand* parameter_count) {
+ inputs_[0] = value;
+ inputs_[1] = context;
+ inputs_[2] = parameter_count;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+
+ bool has_constant_parameter_count() {
+ return parameter_count()->IsConstantOperand();
+ }
+ LConstantOperand* constant_parameter_count() {
+ DCHECK(has_constant_parameter_count());
+ return LConstantOperand::cast(parameter_count());
+ }
+ LOperand* parameter_count() { return inputs_[2]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(Return, "return")
+};
+
+
+class LLoadNamedField FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LLoadNamedField(LOperand* object) { inputs_[0] = object; }
+
+ LOperand* object() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(LoadNamedField, "load-named-field")
+ DECLARE_HYDROGEN_ACCESSOR(LoadNamedField)
+};
+
+
+class LLoadNamedGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+ public:
+ LLoadNamedGeneric(LOperand* context, LOperand* object, LOperand* vector) {
+ inputs_[0] = context;
+ inputs_[1] = object;
+ temps_[0] = vector;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* object() { return inputs_[1]; }
+ LOperand* temp_vector() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric, "load-named-generic")
+ DECLARE_HYDROGEN_ACCESSOR(LoadNamedGeneric)
+
+ Handle<Object> name() const { return hydrogen()->name(); }
+};
+
+
+class LLoadFunctionPrototype FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LLoadFunctionPrototype(LOperand* function) { inputs_[0] = function; }
+
+ LOperand* function() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype, "load-function-prototype")
+ DECLARE_HYDROGEN_ACCESSOR(LoadFunctionPrototype)
+};
+
+
+class LLoadRoot FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root")
+ DECLARE_HYDROGEN_ACCESSOR(LoadRoot)
+
+ Heap::RootListIndex index() const { return hydrogen()->index(); }
+};
+
+
+class LLoadKeyed FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LLoadKeyed(LOperand* elements, LOperand* key) {
+ inputs_[0] = elements;
+ inputs_[1] = key;
+ }
+
+ LOperand* elements() { return inputs_[0]; }
+ LOperand* key() { return inputs_[1]; }
+ ElementsKind elements_kind() const { return hydrogen()->elements_kind(); }
+ bool is_external() const { return hydrogen()->is_external(); }
+ bool is_fixed_typed_array() const {
+ return hydrogen()->is_fixed_typed_array();
+ }
+ bool is_typed_elements() const {
+ return is_external() || is_fixed_typed_array();
+ }
+
+ DECLARE_CONCRETE_INSTRUCTION(LoadKeyed, "load-keyed")
+ DECLARE_HYDROGEN_ACCESSOR(LoadKeyed)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+ uint32_t base_offset() const { return hydrogen()->base_offset(); }
+};
+
+
+class LLoadKeyedGeneric FINAL : public LTemplateInstruction<1, 3, 1> {
+ public:
+ LLoadKeyedGeneric(LOperand* context, LOperand* object, LOperand* key,
+ LOperand* vector) {
+ inputs_[0] = context;
+ inputs_[1] = object;
+ inputs_[2] = key;
+ temps_[0] = vector;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* object() { return inputs_[1]; }
+ LOperand* key() { return inputs_[2]; }
+ LOperand* temp_vector() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric, "load-keyed-generic")
+ DECLARE_HYDROGEN_ACCESSOR(LoadKeyedGeneric)
+};
+
+
+class LLoadGlobalCell FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ DECLARE_CONCRETE_INSTRUCTION(LoadGlobalCell, "load-global-cell")
+ DECLARE_HYDROGEN_ACCESSOR(LoadGlobalCell)
+};
+
+
+class LLoadGlobalGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+ public:
+ LLoadGlobalGeneric(LOperand* context, LOperand* global_object,
+ LOperand* vector) {
+ inputs_[0] = context;
+ inputs_[1] = global_object;
+ temps_[0] = vector;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* global_object() { return inputs_[1]; }
+ LOperand* temp_vector() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric, "load-global-generic")
+ DECLARE_HYDROGEN_ACCESSOR(LoadGlobalGeneric)
+
+ Handle<Object> name() const { return hydrogen()->name(); }
+ bool for_typeof() const { return hydrogen()->for_typeof(); }
+};
+
+
+class LStoreGlobalCell FINAL : public LTemplateInstruction<0, 1, 1> {
+ public:
+ LStoreGlobalCell(LOperand* value, LOperand* temp) {
+ inputs_[0] = value;
+ temps_[0] = temp;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(StoreGlobalCell, "store-global-cell")
+ DECLARE_HYDROGEN_ACCESSOR(StoreGlobalCell)
+};
+
+
+class LLoadContextSlot FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LLoadContextSlot(LOperand* context) { inputs_[0] = context; }
+
+ LOperand* context() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot, "load-context-slot")
+ DECLARE_HYDROGEN_ACCESSOR(LoadContextSlot)
+
+ int slot_index() { return hydrogen()->slot_index(); }
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LStoreContextSlot FINAL : public LTemplateInstruction<0, 2, 0> {
+ public:
+ LStoreContextSlot(LOperand* context, LOperand* value) {
+ inputs_[0] = context;
+ inputs_[1] = value;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* value() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot, "store-context-slot")
+ DECLARE_HYDROGEN_ACCESSOR(StoreContextSlot)
+
+ int slot_index() { return hydrogen()->slot_index(); }
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LPushArgument FINAL : public LTemplateInstruction<0, 1, 0> {
+ public:
+ explicit LPushArgument(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(PushArgument, "push-argument")
+};
+
+
+class LDrop FINAL : public LTemplateInstruction<0, 0, 0> {
+ public:
+ explicit LDrop(int count) : count_(count) {}
+
+ int count() const { return count_; }
+
+ DECLARE_CONCRETE_INSTRUCTION(Drop, "drop")
+
+ private:
+ int count_;
+};
+
+
+class LStoreCodeEntry FINAL : public LTemplateInstruction<0, 2, 0> {
+ public:
+ LStoreCodeEntry(LOperand* function, LOperand* code_object) {
+ inputs_[0] = function;
+ inputs_[1] = code_object;
+ }
+
+ LOperand* function() { return inputs_[0]; }
+ LOperand* code_object() { return inputs_[1]; }
+
+ virtual void PrintDataTo(StringStream* stream);
+
+ DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry")
+ DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry)
+};
+
+
+class LInnerAllocatedObject FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LInnerAllocatedObject(LOperand* base_object, LOperand* offset) {
+ inputs_[0] = base_object;
+ inputs_[1] = offset;
+ }
+
+ LOperand* base_object() const { return inputs_[0]; }
+ LOperand* offset() const { return inputs_[1]; }
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+
+ DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object")
+};
+
+
+class LThisFunction FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
+ DECLARE_HYDROGEN_ACCESSOR(ThisFunction)
+};
+
+
+class LContext FINAL : public LTemplateInstruction<1, 0, 0> {
+ public:
+ DECLARE_CONCRETE_INSTRUCTION(Context, "context")
+ DECLARE_HYDROGEN_ACCESSOR(Context)
+};
+
+
+class LDeclareGlobals FINAL : public LTemplateInstruction<0, 1, 0> {
+ public:
+ explicit LDeclareGlobals(LOperand* context) { inputs_[0] = context; }
+
+ LOperand* context() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals, "declare-globals")
+ DECLARE_HYDROGEN_ACCESSOR(DeclareGlobals)
+};
+
+
+class LCallJSFunction FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LCallJSFunction(LOperand* function) { inputs_[0] = function; }
+
+ LOperand* function() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function")
+ DECLARE_HYDROGEN_ACCESSOR(CallJSFunction)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+
+ int arity() const { return hydrogen()->argument_count() - 1; }
+};
+
+
+class LCallWithDescriptor FINAL : public LTemplateResultInstruction<1> {
+ public:
+ LCallWithDescriptor(CallInterfaceDescriptor descriptor,
+ const ZoneList<LOperand*>& operands, Zone* zone)
+ : descriptor_(descriptor),
+ inputs_(descriptor.GetRegisterParameterCount() + 1, zone) {
+ DCHECK(descriptor.GetRegisterParameterCount() + 1 == operands.length());
+ inputs_.AddAll(operands, zone);
+ }
+
+ LOperand* target() const { return inputs_[0]; }
+
+ const CallInterfaceDescriptor descriptor() { return descriptor_; }
+
+ private:
+ DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor")
+ DECLARE_HYDROGEN_ACCESSOR(CallWithDescriptor)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+
+ int arity() const { return hydrogen()->argument_count() - 1; }
+
+ CallInterfaceDescriptor descriptor_;
+ ZoneList<LOperand*> inputs_;
+
+ // Iterator support.
+ virtual int InputCount() FINAL OVERRIDE { return inputs_.length(); }
+ virtual LOperand* InputAt(int i) FINAL OVERRIDE { return inputs_[i]; }
+
+ virtual int TempCount() FINAL OVERRIDE { return 0; }
+ virtual LOperand* TempAt(int i) FINAL OVERRIDE { return NULL; }
+};
+
+
+class LInvokeFunction FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LInvokeFunction(LOperand* context, LOperand* function) {
+ inputs_[0] = context;
+ inputs_[1] = function;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* function() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
+ DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+
+ int arity() const { return hydrogen()->argument_count() - 1; }
+};
+
+
+class LCallFunction FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LCallFunction(LOperand* context, LOperand* function) {
+ inputs_[0] = context;
+ inputs_[1] = function;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* function() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CallFunction, "call-function")
+ DECLARE_HYDROGEN_ACCESSOR(CallFunction)
+
+ int arity() const { return hydrogen()->argument_count() - 1; }
+};
+
+
+class LCallNew FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LCallNew(LOperand* context, LOperand* constructor) {
+ inputs_[0] = context;
+ inputs_[1] = constructor;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* constructor() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")
+ DECLARE_HYDROGEN_ACCESSOR(CallNew)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+
+ int arity() const { return hydrogen()->argument_count() - 1; }
+};
+
+
+class LCallNewArray FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LCallNewArray(LOperand* context, LOperand* constructor) {
+ inputs_[0] = context;
+ inputs_[1] = constructor;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* constructor() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array")
+ DECLARE_HYDROGEN_ACCESSOR(CallNewArray)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+
+ int arity() const { return hydrogen()->argument_count() - 1; }
+};
+
+
+class LCallRuntime FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LCallRuntime(LOperand* context) { inputs_[0] = context; }
+
+ LOperand* context() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")
+ DECLARE_HYDROGEN_ACCESSOR(CallRuntime)
+
+ virtual bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE {
+ return save_doubles() == kDontSaveFPRegs;
+ }
+
+ const Runtime::Function* function() const { return hydrogen()->function(); }
+ int arity() const { return hydrogen()->argument_count(); }
+ SaveFPRegsMode save_doubles() const { return hydrogen()->save_doubles(); }
+};
+
+
+class LInteger32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LInteger32ToDouble(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(Integer32ToDouble, "int32-to-double")
+};
+
+
+class LUint32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LUint32ToDouble(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(Uint32ToDouble, "uint32-to-double")
+};
+
+
+class LNumberTagI FINAL : public LTemplateInstruction<1, 1, 2> {
+ public:
+ LNumberTagI(LOperand* value, LOperand* temp1, LOperand* temp2) {
+ inputs_[0] = value;
+ temps_[0] = temp1;
+ temps_[1] = temp2;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp1() { return temps_[0]; }
+ LOperand* temp2() { return temps_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(NumberTagI, "number-tag-i")
+};
+
+
+class LNumberTagU FINAL : public LTemplateInstruction<1, 1, 2> {
+ public:
+ LNumberTagU(LOperand* value, LOperand* temp1, LOperand* temp2) {
+ inputs_[0] = value;
+ temps_[0] = temp1;
+ temps_[1] = temp2;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp1() { return temps_[0]; }
+ LOperand* temp2() { return temps_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(NumberTagU, "number-tag-u")
+};
+
+
+class LNumberTagD FINAL : public LTemplateInstruction<1, 1, 2> {
+ public:
+ LNumberTagD(LOperand* value, LOperand* temp, LOperand* temp2) {
+ inputs_[0] = value;
+ temps_[0] = temp;
+ temps_[1] = temp2;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+ LOperand* temp2() { return temps_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(NumberTagD, "number-tag-d")
+ DECLARE_HYDROGEN_ACCESSOR(Change)
+};
+
+
+class LDoubleToSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LDoubleToSmi(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(DoubleToSmi, "double-to-smi")
+ DECLARE_HYDROGEN_ACCESSOR(UnaryOperation)
+
+ bool truncating() { return hydrogen()->CanTruncateToInt32(); }
+};
+
+
+// Sometimes truncating conversion from a tagged value to an int32.
+class LDoubleToI FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LDoubleToI(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(DoubleToI, "double-to-i")
+ DECLARE_HYDROGEN_ACCESSOR(UnaryOperation)
+
+ bool truncating() { return hydrogen()->CanTruncateToInt32(); }
+};
+
+
+// Truncating conversion from a tagged value to an int32.
+class LTaggedToI FINAL : public LTemplateInstruction<1, 1, 2> {
+ public:
+ LTaggedToI(LOperand* value, LOperand* temp, LOperand* temp2) {
+ inputs_[0] = value;
+ temps_[0] = temp;
+ temps_[1] = temp2;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+ LOperand* temp2() { return temps_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(TaggedToI, "tagged-to-i")
+ DECLARE_HYDROGEN_ACCESSOR(Change)
+
+ bool truncating() { return hydrogen()->CanTruncateToInt32(); }
+};
+
+
+class LSmiTag FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LSmiTag(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(SmiTag, "smi-tag")
+ DECLARE_HYDROGEN_ACCESSOR(Change)
+};
+
+
+class LNumberUntagD FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LNumberUntagD(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(NumberUntagD, "double-untag")
+ DECLARE_HYDROGEN_ACCESSOR(Change)
+};
+
+
+class LSmiUntag FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ LSmiUntag(LOperand* value, bool needs_check) : needs_check_(needs_check) {
+ inputs_[0] = value;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ bool needs_check() const { return needs_check_; }
+
+ DECLARE_CONCRETE_INSTRUCTION(SmiUntag, "smi-untag")
+
+ private:
+ bool needs_check_;
+};
+
+
+class LStoreNamedField FINAL : public LTemplateInstruction<0, 2, 1> {
+ public:
+ LStoreNamedField(LOperand* object, LOperand* value, LOperand* temp) {
+ inputs_[0] = object;
+ inputs_[1] = value;
+ temps_[0] = temp;
+ }
+
+ LOperand* object() { return inputs_[0]; }
+ LOperand* value() { return inputs_[1]; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field")
+ DECLARE_HYDROGEN_ACCESSOR(StoreNamedField)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+
+ Representation representation() const {
+ return hydrogen()->field_representation();
+ }
+};
+
+
+class LStoreNamedGeneric FINAL : public LTemplateInstruction<0, 3, 0> {
+ public:
+ LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) {
+ inputs_[0] = context;
+ inputs_[1] = object;
+ inputs_[2] = value;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* object() { return inputs_[1]; }
+ LOperand* value() { return inputs_[2]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
+ DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+
+ Handle<Object> name() const { return hydrogen()->name(); }
+ StrictMode strict_mode() { return hydrogen()->strict_mode(); }
+};
+
+
+class LStoreKeyed FINAL : public LTemplateInstruction<0, 3, 0> {
+ public:
+ LStoreKeyed(LOperand* object, LOperand* key, LOperand* value) {
+ inputs_[0] = object;
+ inputs_[1] = key;
+ inputs_[2] = value;
+ }
+
+ bool is_external() const { return hydrogen()->is_external(); }
+ bool is_fixed_typed_array() const {
+ return hydrogen()->is_fixed_typed_array();
+ }
+ bool is_typed_elements() const {
+ return is_external() || is_fixed_typed_array();
+ }
+ LOperand* elements() { return inputs_[0]; }
+ LOperand* key() { return inputs_[1]; }
+ LOperand* value() { return inputs_[2]; }
+ ElementsKind elements_kind() const { return hydrogen()->elements_kind(); }
+
+ DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed")
+ DECLARE_HYDROGEN_ACCESSOR(StoreKeyed)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+ bool NeedsCanonicalization() {
+ if (hydrogen()->value()->IsAdd() || hydrogen()->value()->IsSub() ||
+ hydrogen()->value()->IsMul() || hydrogen()->value()->IsDiv()) {
+ return false;
+ }
+ return hydrogen()->NeedsCanonicalization();
+ }
+ uint32_t base_offset() const { return hydrogen()->base_offset(); }
+};
+
+
+class LStoreKeyedGeneric FINAL : public LTemplateInstruction<0, 4, 0> {
+ public:
+ LStoreKeyedGeneric(LOperand* context, LOperand* obj, LOperand* key,
+ LOperand* value) {
+ inputs_[0] = context;
+ inputs_[1] = obj;
+ inputs_[2] = key;
+ inputs_[3] = value;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* object() { return inputs_[1]; }
+ LOperand* key() { return inputs_[2]; }
+ LOperand* value() { return inputs_[3]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")
+ DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+
+ StrictMode strict_mode() { return hydrogen()->strict_mode(); }
+};
+
+
+class LTransitionElementsKind FINAL : public LTemplateInstruction<0, 2, 1> {
+ public:
+ LTransitionElementsKind(LOperand* object, LOperand* context,
+ LOperand* new_map_temp) {
+ inputs_[0] = object;
+ inputs_[1] = context;
+ temps_[0] = new_map_temp;
+ }
+
+ LOperand* context() { return inputs_[1]; }
+ LOperand* object() { return inputs_[0]; }
+ LOperand* new_map_temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind,
+ "transition-elements-kind")
+ DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind)
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+
+ Handle<Map> original_map() { return hydrogen()->original_map().handle(); }
+ Handle<Map> transitioned_map() {
+ return hydrogen()->transitioned_map().handle();
+ }
+ ElementsKind from_kind() { return hydrogen()->from_kind(); }
+ ElementsKind to_kind() { return hydrogen()->to_kind(); }
+};
+
+
+class LTrapAllocationMemento FINAL : public LTemplateInstruction<0, 1, 1> {
+ public:
+ LTrapAllocationMemento(LOperand* object, LOperand* temp) {
+ inputs_[0] = object;
+ temps_[0] = temp;
+ }
+
+ LOperand* object() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(TrapAllocationMemento, "trap-allocation-memento")
+};
+
+
+class LStringAdd FINAL : public LTemplateInstruction<1, 3, 0> {
+ public:
+ LStringAdd(LOperand* context, LOperand* left, LOperand* right) {
+ inputs_[0] = context;
+ inputs_[1] = left;
+ inputs_[2] = right;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* left() { return inputs_[1]; }
+ LOperand* right() { return inputs_[2]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(StringAdd, "string-add")
+ DECLARE_HYDROGEN_ACCESSOR(StringAdd)
+};
+
+
+class LStringCharCodeAt FINAL : public LTemplateInstruction<1, 3, 0> {
+ public:
+ LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) {
+ inputs_[0] = context;
+ inputs_[1] = string;
+ inputs_[2] = index;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* string() { return inputs_[1]; }
+ LOperand* index() { return inputs_[2]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt, "string-char-code-at")
+ DECLARE_HYDROGEN_ACCESSOR(StringCharCodeAt)
+};
+
+
+class LStringCharFromCode FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ explicit LStringCharFromCode(LOperand* context, LOperand* char_code) {
+ inputs_[0] = context;
+ inputs_[1] = char_code;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* char_code() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode, "string-char-from-code")
+ DECLARE_HYDROGEN_ACCESSOR(StringCharFromCode)
+};
+
+
+class LCheckValue FINAL : public LTemplateInstruction<0, 1, 0> {
+ public:
+ explicit LCheckValue(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CheckValue, "check-value")
+ DECLARE_HYDROGEN_ACCESSOR(CheckValue)
+};
+
+
+class LCheckInstanceType FINAL : public LTemplateInstruction<0, 1, 0> {
+ public:
+ explicit LCheckInstanceType(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CheckInstanceType, "check-instance-type")
+ DECLARE_HYDROGEN_ACCESSOR(CheckInstanceType)
+};
+
+
+class LCheckMaps FINAL : public LTemplateInstruction<0, 1, 0> {
+ public:
+ explicit LCheckMaps(LOperand* value = NULL) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CheckMaps, "check-maps")
+ DECLARE_HYDROGEN_ACCESSOR(CheckMaps)
+};
+
+
+class LCheckSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LCheckSmi(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CheckSmi, "check-smi")
+};
+
+
+class LCheckNonSmi FINAL : public LTemplateInstruction<0, 1, 0> {
+ public:
+ explicit LCheckNonSmi(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CheckNonSmi, "check-non-smi")
+ DECLARE_HYDROGEN_ACCESSOR(CheckHeapObject)
+};
+
+
+class LClampDToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LClampDToUint8(LOperand* unclamped) { inputs_[0] = unclamped; }
+
+ LOperand* unclamped() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ClampDToUint8, "clamp-d-to-uint8")
+};
+
+
+class LClampIToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LClampIToUint8(LOperand* unclamped) { inputs_[0] = unclamped; }
+
+ LOperand* unclamped() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ClampIToUint8, "clamp-i-to-uint8")
+};
+
+
+class LClampTToUint8 FINAL : public LTemplateInstruction<1, 1, 1> {
+ public:
+ LClampTToUint8(LOperand* unclamped, LOperand* temp) {
+ inputs_[0] = unclamped;
+ temps_[0] = temp;
+ }
+
+ LOperand* unclamped() { return inputs_[0]; }
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ClampTToUint8, "clamp-t-to-uint8")
+};
+
+
+class LDoubleBits FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LDoubleBits(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(DoubleBits, "double-bits")
+ DECLARE_HYDROGEN_ACCESSOR(DoubleBits)
+};
+
+
+class LConstructDouble FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LConstructDouble(LOperand* hi, LOperand* lo) {
+ inputs_[0] = hi;
+ inputs_[1] = lo;
+ }
+
+ LOperand* hi() { return inputs_[0]; }
+ LOperand* lo() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ConstructDouble, "construct-double")
+};
+
+
+class LAllocate FINAL : public LTemplateInstruction<1, 2, 2> {
+ public:
+ LAllocate(LOperand* context, LOperand* size, LOperand* temp1,
+ LOperand* temp2) {
+ inputs_[0] = context;
+ inputs_[1] = size;
+ temps_[0] = temp1;
+ temps_[1] = temp2;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* size() { return inputs_[1]; }
+ LOperand* temp1() { return temps_[0]; }
+ LOperand* temp2() { return temps_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(Allocate, "allocate")
+ DECLARE_HYDROGEN_ACCESSOR(Allocate)
+};
+
+
+class LRegExpLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LRegExpLiteral(LOperand* context) { inputs_[0] = context; }
+
+ LOperand* context() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(RegExpLiteral, "regexp-literal")
+ DECLARE_HYDROGEN_ACCESSOR(RegExpLiteral)
+};
+
+
+class LFunctionLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LFunctionLiteral(LOperand* context) { inputs_[0] = context; }
+
+ LOperand* context() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(FunctionLiteral, "function-literal")
+ DECLARE_HYDROGEN_ACCESSOR(FunctionLiteral)
+};
+
+
+class LToFastProperties FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LToFastProperties(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ToFastProperties, "to-fast-properties")
+ DECLARE_HYDROGEN_ACCESSOR(ToFastProperties)
+};
+
+
+class LTypeof FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LTypeof(LOperand* context, LOperand* value) {
+ inputs_[0] = context;
+ inputs_[1] = value;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* value() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof")
+};
+
+
+class LTypeofIsAndBranch FINAL : public LControlInstruction<1, 0> {
+ public:
+ explicit LTypeofIsAndBranch(LOperand* value) { inputs_[0] = value; }
+
+ LOperand* value() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch, "typeof-is-and-branch")
+ DECLARE_HYDROGEN_ACCESSOR(TypeofIsAndBranch)
+
+ Handle<String> type_literal() { return hydrogen()->type_literal(); }
+
+ virtual void PrintDataTo(StringStream* stream) OVERRIDE;
+};
+
+
+class LIsConstructCallAndBranch FINAL : public LControlInstruction<0, 1> {
+ public:
+ explicit LIsConstructCallAndBranch(LOperand* temp) { temps_[0] = temp; }
+
+ LOperand* temp() { return temps_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(IsConstructCallAndBranch,
+ "is-construct-call-and-branch")
+};
+
+
+class LOsrEntry FINAL : public LTemplateInstruction<0, 0, 0> {
+ public:
+ LOsrEntry() {}
+
+ virtual bool HasInterestingComment(LCodeGen* gen) const OVERRIDE {
+ return false;
+ }
+ DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry")
+};
+
+
+class LStackCheck FINAL : public LTemplateInstruction<0, 1, 0> {
+ public:
+ explicit LStackCheck(LOperand* context) { inputs_[0] = context; }
+
+ LOperand* context() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(StackCheck, "stack-check")
+ DECLARE_HYDROGEN_ACCESSOR(StackCheck)
+
+ Label* done_label() { return &done_label_; }
+
+ private:
+ Label done_label_;
+};
+
+
+class LForInPrepareMap FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LForInPrepareMap(LOperand* context, LOperand* object) {
+ inputs_[0] = context;
+ inputs_[1] = object;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* object() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ForInPrepareMap, "for-in-prepare-map")
+};
+
+
+class LForInCacheArray FINAL : public LTemplateInstruction<1, 1, 0> {
+ public:
+ explicit LForInCacheArray(LOperand* map) { inputs_[0] = map; }
+
+ LOperand* map() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(ForInCacheArray, "for-in-cache-array")
+
+ int idx() { return HForInCacheArray::cast(this->hydrogen_value())->idx(); }
+};
+
+
+class LCheckMapValue FINAL : public LTemplateInstruction<0, 2, 0> {
+ public:
+ LCheckMapValue(LOperand* value, LOperand* map) {
+ inputs_[0] = value;
+ inputs_[1] = map;
+ }
+
+ LOperand* value() { return inputs_[0]; }
+ LOperand* map() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(CheckMapValue, "check-map-value")
+};
+
+
+class LLoadFieldByIndex FINAL : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LLoadFieldByIndex(LOperand* object, LOperand* index) {
+ inputs_[0] = object;
+ inputs_[1] = index;
+ }
+
+ LOperand* object() { return inputs_[0]; }
+ LOperand* index() { return inputs_[1]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex, "load-field-by-index")
+};
+
+
+class LStoreFrameContext : public LTemplateInstruction<0, 1, 0> {
+ public:
+ explicit LStoreFrameContext(LOperand* context) { inputs_[0] = context; }
+
+ LOperand* context() { return inputs_[0]; }
+
+ DECLARE_CONCRETE_INSTRUCTION(StoreFrameContext, "store-frame-context")
+};
+
+
+class LAllocateBlockContext : public LTemplateInstruction<1, 2, 0> {
+ public:
+ LAllocateBlockContext(LOperand* context, LOperand* function) {
+ inputs_[0] = context;
+ inputs_[1] = function;
+ }
+
+ LOperand* context() { return inputs_[0]; }
+ LOperand* function() { return inputs_[1]; }
+
+ Handle<ScopeInfo> scope_info() { return hydrogen()->scope_info(); }
+
+ DECLARE_CONCRETE_INSTRUCTION(AllocateBlockContext, "allocate-block-context")
+ DECLARE_HYDROGEN_ACCESSOR(AllocateBlockContext)
+};
+
+
+class LChunkBuilder;
+class LPlatformChunk FINAL : public LChunk {
+ public:
+ LPlatformChunk(CompilationInfo* info, HGraph* graph) : LChunk(info, graph) {}
+
+ int GetNextSpillIndex(RegisterKind kind);
+ LOperand* GetNextSpillSlot(RegisterKind kind);
+};
+
+
+class LChunkBuilder FINAL : public LChunkBuilderBase {
+ public:
+ LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator)
+ : LChunkBuilderBase(info, graph),
+ current_instruction_(NULL),
+ current_block_(NULL),
+ next_block_(NULL),
+ allocator_(allocator) {}
+
+ // Build the sequence for the graph.
+ LPlatformChunk* Build();
+
+// Declare methods that deal with the individual node types.
+#define DECLARE_DO(type) LInstruction* Do##type(H##type* node);
+ HYDROGEN_CONCRETE_INSTRUCTION_LIST(DECLARE_DO)
+#undef DECLARE_DO
+
+ LInstruction* DoMultiplyAdd(HMul* mul, HValue* addend);
+ LInstruction* DoMultiplySub(HValue* minuend, HMul* mul);
+ LInstruction* DoRSub(HSub* instr);
+
+ static bool HasMagicNumberForDivisor(int32_t divisor);
+
+ LInstruction* DoMathFloor(HUnaryMathOperation* instr);
+ LInstruction* DoMathRound(HUnaryMathOperation* instr);
+ LInstruction* DoMathFround(HUnaryMathOperation* instr);
+ LInstruction* DoMathAbs(HUnaryMathOperation* instr);
+ LInstruction* DoMathLog(HUnaryMathOperation* instr);
+ LInstruction* DoMathExp(HUnaryMathOperation* instr);
+ LInstruction* DoMathSqrt(HUnaryMathOperation* instr);
+ LInstruction* DoMathPowHalf(HUnaryMathOperation* instr);
+ LInstruction* DoMathClz32(HUnaryMathOperation* instr);
+ LInstruction* DoDivByPowerOf2I(HDiv* instr);
+ LInstruction* DoDivByConstI(HDiv* instr);
+ LInstruction* DoDivI(HDiv* instr);
+ LInstruction* DoModByPowerOf2I(HMod* instr);
+ LInstruction* DoModByConstI(HMod* instr);
+ LInstruction* DoModI(HMod* instr);
+ LInstruction* DoFlooringDivByPowerOf2I(HMathFloorOfDiv* instr);
+ LInstruction* DoFlooringDivByConstI(HMathFloorOfDiv* instr);
+ LInstruction* DoFlooringDivI(HMathFloorOfDiv* instr);
+
+ private:
+ // Methods for getting operands for Use / Define / Temp.
+ LUnallocated* ToUnallocated(Register reg);
+ LUnallocated* ToUnallocated(DoubleRegister reg);
+
+ // Methods for setting up define-use relationships.
+ MUST_USE_RESULT LOperand* Use(HValue* value, LUnallocated* operand);
+ MUST_USE_RESULT LOperand* UseFixed(HValue* value, Register fixed_register);
+ MUST_USE_RESULT LOperand* UseFixedDouble(HValue* value,
+ DoubleRegister fixed_register);
+
+ // A value that is guaranteed to be allocated to a register.
+ // Operand created by UseRegister is guaranteed to be live until the end of
+ // instruction. This means that register allocator will not reuse it's
+ // register for any other operand inside instruction.
+ // Operand created by UseRegisterAtStart is guaranteed to be live only at
+ // instruction start. Register allocator is free to assign the same register
+ // to some other operand used inside instruction (i.e. temporary or
+ // output).
+ MUST_USE_RESULT LOperand* UseRegister(HValue* value);
+ MUST_USE_RESULT LOperand* UseRegisterAtStart(HValue* value);
+
+ // An input operand in a register that may be trashed.
+ MUST_USE_RESULT LOperand* UseTempRegister(HValue* value);
+
+ // An input operand in a register or stack slot.
+ MUST_USE_RESULT LOperand* Use(HValue* value);
+ MUST_USE_RESULT LOperand* UseAtStart(HValue* value);
+
+ // An input operand in a register, stack slot or a constant operand.
+ MUST_USE_RESULT LOperand* UseOrConstant(HValue* value);
+ MUST_USE_RESULT LOperand* UseOrConstantAtStart(HValue* value);
+
+ // An input operand in a register or a constant operand.
+ MUST_USE_RESULT LOperand* UseRegisterOrConstant(HValue* value);
+ MUST_USE_RESULT LOperand* UseRegisterOrConstantAtStart(HValue* value);
+
+ // An input operand in a constant operand.
+ MUST_USE_RESULT LOperand* UseConstant(HValue* value);
+
+ // An input operand in register, stack slot or a constant operand.
+ // Will not be moved to a register even if one is freely available.
+ virtual MUST_USE_RESULT LOperand* UseAny(HValue* value) OVERRIDE;
+
+ // Temporary operand that must be in a register.
+ MUST_USE_RESULT LUnallocated* TempRegister();
+ MUST_USE_RESULT LUnallocated* TempDoubleRegister();
+ MUST_USE_RESULT LOperand* FixedTemp(Register reg);
+ MUST_USE_RESULT LOperand* FixedTemp(DoubleRegister reg);
+
+ // Methods for setting up define-use relationships.
+ // Return the same instruction that they are passed.
+ LInstruction* Define(LTemplateResultInstruction<1>* instr,
+ LUnallocated* result);
+ LInstruction* DefineAsRegister(LTemplateResultInstruction<1>* instr);
+ LInstruction* DefineAsSpilled(LTemplateResultInstruction<1>* instr,
+ int index);
+ LInstruction* DefineSameAsFirst(LTemplateResultInstruction<1>* instr);
+ LInstruction* DefineFixed(LTemplateResultInstruction<1>* instr, Register reg);
+ LInstruction* DefineFixedDouble(LTemplateResultInstruction<1>* instr,
+ DoubleRegister reg);
+ LInstruction* AssignEnvironment(LInstruction* instr);
+ LInstruction* AssignPointerMap(LInstruction* instr);
+
+ enum CanDeoptimize { CAN_DEOPTIMIZE_EAGERLY, CANNOT_DEOPTIMIZE_EAGERLY };
+
+ // By default we assume that instruction sequences generated for calls
+ // cannot deoptimize eagerly and we do not attach environment to this
+ // instruction.
+ LInstruction* MarkAsCall(
+ LInstruction* instr, HInstruction* hinstr,
+ CanDeoptimize can_deoptimize = CANNOT_DEOPTIMIZE_EAGERLY);
+
+ void VisitInstruction(HInstruction* current);
+ void AddInstruction(LInstruction* instr, HInstruction* current);
+
+ void DoBasicBlock(HBasicBlock* block, HBasicBlock* next_block);
+ LInstruction* DoShift(Token::Value op, HBitwiseBinaryOperation* instr);
+ LInstruction* DoArithmeticD(Token::Value op,
+ HArithmeticBinaryOperation* instr);
+ LInstruction* DoArithmeticT(Token::Value op, HBinaryOperation* instr);
+
+ HInstruction* current_instruction_;
+ HBasicBlock* current_block_;
+ HBasicBlock* next_block_;
+ LAllocator* allocator_;
+
+ DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
+};
+
+#undef DECLARE_HYDROGEN_ACCESSOR
+#undef DECLARE_CONCRETE_INSTRUCTION
+}
+} // namespace v8::internal
+
+#endif // V8_PPC_LITHIUM_PPC_H_
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <assert.h> // For assert
+#include <limits.h> // For LONG_MIN, LONG_MAX.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/base/bits.h"
+#include "src/base/division-by-constant.h"
+#include "src/bootstrapper.h"
+#include "src/codegen.h"
+#include "src/cpu-profiler.h"
+#include "src/debug.h"
+#include "src/isolate-inl.h"
+#include "src/runtime/runtime.h"
+
+namespace v8 {
+namespace internal {
+
+MacroAssembler::MacroAssembler(Isolate* arg_isolate, void* buffer, int size)
+ : Assembler(arg_isolate, buffer, size),
+ generating_stub_(false),
+ has_frame_(false) {
+ if (isolate() != NULL) {
+ code_object_ =
+ Handle<Object>(isolate()->heap()->undefined_value(), isolate());
+ }
+}
+
+
+void MacroAssembler::Jump(Register target) {
+ mtctr(target);
+ bctr();
+}
+
+
+void MacroAssembler::JumpToJSEntry(Register target) {
+ Move(ip, target);
+ Jump(ip);
+}
+
+
+void MacroAssembler::Jump(intptr_t target, RelocInfo::Mode rmode,
+ Condition cond, CRegister cr) {
+ Label skip;
+
+ if (cond != al) b(NegateCondition(cond), &skip, cr);
+
+ DCHECK(rmode == RelocInfo::CODE_TARGET || rmode == RelocInfo::RUNTIME_ENTRY);
+
+ mov(ip, Operand(target, rmode));
+ mtctr(ip);
+ bctr();
+
+ bind(&skip);
+}
+
+
+void MacroAssembler::Jump(Address target, RelocInfo::Mode rmode, Condition cond,
+ CRegister cr) {
+ DCHECK(!RelocInfo::IsCodeTarget(rmode));
+ Jump(reinterpret_cast<intptr_t>(target), rmode, cond, cr);
+}
+
+
+void MacroAssembler::Jump(Handle<Code> code, RelocInfo::Mode rmode,
+ Condition cond) {
+ DCHECK(RelocInfo::IsCodeTarget(rmode));
+ // 'code' is always generated ppc code, never THUMB code
+ AllowDeferredHandleDereference embedding_raw_address;
+ Jump(reinterpret_cast<intptr_t>(code.location()), rmode, cond);
+}
+
+
+int MacroAssembler::CallSize(Register target) { return 2 * kInstrSize; }
+
+
+void MacroAssembler::Call(Register target) {
+ BlockTrampolinePoolScope block_trampoline_pool(this);
+ Label start;
+ bind(&start);
+
+ // Statement positions are expected to be recorded when the target
+ // address is loaded.
+ positions_recorder()->WriteRecordedPositions();
+
+ // branch via link register and set LK bit for return point
+ mtctr(target);
+ bctrl();
+
+ DCHECK_EQ(CallSize(target), SizeOfCodeGeneratedSince(&start));
+}
+
+
+void MacroAssembler::CallJSEntry(Register target) {
+ DCHECK(target.is(ip));
+ Call(target);
+}
+
+
+int MacroAssembler::CallSize(Address target, RelocInfo::Mode rmode,
+ Condition cond) {
+ Operand mov_operand = Operand(reinterpret_cast<intptr_t>(target), rmode);
+ return (2 + instructions_required_for_mov(mov_operand)) * kInstrSize;
+}
+
+
+int MacroAssembler::CallSizeNotPredictableCodeSize(Address target,
+ RelocInfo::Mode rmode,
+ Condition cond) {
+ return (2 + kMovInstructionsNoConstantPool) * kInstrSize;
+}
+
+
+void MacroAssembler::Call(Address target, RelocInfo::Mode rmode,
+ Condition cond) {
+ BlockTrampolinePoolScope block_trampoline_pool(this);
+ DCHECK(cond == al);
+
+#ifdef DEBUG
+ // Check the expected size before generating code to ensure we assume the same
+ // constant pool availability (e.g., whether constant pool is full or not).
+ int expected_size = CallSize(target, rmode, cond);
+ Label start;
+ bind(&start);
+#endif
+
+ // Statement positions are expected to be recorded when the target
+ // address is loaded.
+ positions_recorder()->WriteRecordedPositions();
+
+ // This can likely be optimized to make use of bc() with 24bit relative
+ //
+ // RecordRelocInfo(x.rmode_, x.imm_);
+ // bc( BA, .... offset, LKset);
+ //
+
+ mov(ip, Operand(reinterpret_cast<intptr_t>(target), rmode));
+ mtctr(ip);
+ bctrl();
+
+ DCHECK_EQ(expected_size, SizeOfCodeGeneratedSince(&start));
+}
+
+
+int MacroAssembler::CallSize(Handle<Code> code, RelocInfo::Mode rmode,
+ TypeFeedbackId ast_id, Condition cond) {
+ AllowDeferredHandleDereference using_raw_address;
+ return CallSize(reinterpret_cast<Address>(code.location()), rmode, cond);
+}
+
+
+void MacroAssembler::Call(Handle<Code> code, RelocInfo::Mode rmode,
+ TypeFeedbackId ast_id, Condition cond) {
+ BlockTrampolinePoolScope block_trampoline_pool(this);
+ DCHECK(RelocInfo::IsCodeTarget(rmode));
+
+#ifdef DEBUG
+ // Check the expected size before generating code to ensure we assume the same
+ // constant pool availability (e.g., whether constant pool is full or not).
+ int expected_size = CallSize(code, rmode, ast_id, cond);
+ Label start;
+ bind(&start);
+#endif
+
+ if (rmode == RelocInfo::CODE_TARGET && !ast_id.IsNone()) {
+ SetRecordedAstId(ast_id);
+ rmode = RelocInfo::CODE_TARGET_WITH_ID;
+ }
+ AllowDeferredHandleDereference using_raw_address;
+ Call(reinterpret_cast<Address>(code.location()), rmode, cond);
+ DCHECK_EQ(expected_size, SizeOfCodeGeneratedSince(&start));
+}
+
+
+void MacroAssembler::Ret(Condition cond) {
+ DCHECK(cond == al);
+ blr();
+}
+
+
+void MacroAssembler::Drop(int count, Condition cond) {
+ DCHECK(cond == al);
+ if (count > 0) {
+ Add(sp, sp, count * kPointerSize, r0);
+ }
+}
+
+
+void MacroAssembler::Ret(int drop, Condition cond) {
+ Drop(drop, cond);
+ Ret(cond);
+}
+
+
+void MacroAssembler::Call(Label* target) { b(target, SetLK); }
+
+
+void MacroAssembler::Push(Handle<Object> handle) {
+ mov(r0, Operand(handle));
+ push(r0);
+}
+
+
+void MacroAssembler::Move(Register dst, Handle<Object> value) {
+ AllowDeferredHandleDereference smi_check;
+ if (value->IsSmi()) {
+ LoadSmiLiteral(dst, reinterpret_cast<Smi*>(*value));
+ } else {
+ DCHECK(value->IsHeapObject());
+ if (isolate()->heap()->InNewSpace(*value)) {
+ Handle<Cell> cell = isolate()->factory()->NewCell(value);
+ mov(dst, Operand(cell));
+ LoadP(dst, FieldMemOperand(dst, Cell::kValueOffset));
+ } else {
+ mov(dst, Operand(value));
+ }
+ }
+}
+
+
+void MacroAssembler::Move(Register dst, Register src, Condition cond) {
+ DCHECK(cond == al);
+ if (!dst.is(src)) {
+ mr(dst, src);
+ }
+}
+
+
+void MacroAssembler::Move(DoubleRegister dst, DoubleRegister src) {
+ if (!dst.is(src)) {
+ fmr(dst, src);
+ }
+}
+
+
+void MacroAssembler::MultiPush(RegList regs) {
+ int16_t num_to_push = NumberOfBitsSet(regs);
+ int16_t stack_offset = num_to_push * kPointerSize;
+
+ subi(sp, sp, Operand(stack_offset));
+ for (int16_t i = kNumRegisters - 1; i >= 0; i--) {
+ if ((regs & (1 << i)) != 0) {
+ stack_offset -= kPointerSize;
+ StoreP(ToRegister(i), MemOperand(sp, stack_offset));
+ }
+ }
+}
+
+
+void MacroAssembler::MultiPop(RegList regs) {
+ int16_t stack_offset = 0;
+
+ for (int16_t i = 0; i < kNumRegisters; i++) {
+ if ((regs & (1 << i)) != 0) {
+ LoadP(ToRegister(i), MemOperand(sp, stack_offset));
+ stack_offset += kPointerSize;
+ }
+ }
+ addi(sp, sp, Operand(stack_offset));
+}
+
+
+void MacroAssembler::LoadRoot(Register destination, Heap::RootListIndex index,
+ Condition cond) {
+ DCHECK(cond == al);
+ LoadP(destination, MemOperand(kRootRegister, index << kPointerSizeLog2), r0);
+}
+
+
+void MacroAssembler::StoreRoot(Register source, Heap::RootListIndex index,
+ Condition cond) {
+ DCHECK(cond == al);
+ StoreP(source, MemOperand(kRootRegister, index << kPointerSizeLog2), r0);
+}
+
+
+void MacroAssembler::InNewSpace(Register object, Register scratch,
+ Condition cond, Label* branch) {
+ // N.B. scratch may be same register as object
+ DCHECK(cond == eq || cond == ne);
+ mov(r0, Operand(ExternalReference::new_space_mask(isolate())));
+ and_(scratch, object, r0);
+ mov(r0, Operand(ExternalReference::new_space_start(isolate())));
+ cmp(scratch, r0);
+ b(cond, branch);
+}
+
+
+void MacroAssembler::RecordWriteField(
+ Register object, int offset, Register value, Register dst,
+ LinkRegisterStatus lr_status, SaveFPRegsMode save_fp,
+ RememberedSetAction remembered_set_action, SmiCheck smi_check,
+ PointersToHereCheck pointers_to_here_check_for_value) {
+ // First, check if a write barrier is even needed. The tests below
+ // catch stores of Smis.
+ Label done;
+
+ // Skip barrier if writing a smi.
+ if (smi_check == INLINE_SMI_CHECK) {
+ JumpIfSmi(value, &done);
+ }
+
+ // Although the object register is tagged, the offset is relative to the start
+ // of the object, so so offset must be a multiple of kPointerSize.
+ DCHECK(IsAligned(offset, kPointerSize));
+
+ Add(dst, object, offset - kHeapObjectTag, r0);
+ if (emit_debug_code()) {
+ Label ok;
+ andi(r0, dst, Operand((1 << kPointerSizeLog2) - 1));
+ beq(&ok, cr0);
+ stop("Unaligned cell in write barrier");
+ bind(&ok);
+ }
+
+ RecordWrite(object, dst, value, lr_status, save_fp, remembered_set_action,
+ OMIT_SMI_CHECK, pointers_to_here_check_for_value);
+
+ bind(&done);
+
+ // Clobber clobbered input registers when running with the debug-code flag
+ // turned on to provoke errors.
+ if (emit_debug_code()) {
+ mov(value, Operand(bit_cast<intptr_t>(kZapValue + 4)));
+ mov(dst, Operand(bit_cast<intptr_t>(kZapValue + 8)));
+ }
+}
+
+
+// Will clobber 4 registers: object, map, dst, ip. The
+// register 'object' contains a heap object pointer.
+void MacroAssembler::RecordWriteForMap(Register object, Register map,
+ Register dst,
+ LinkRegisterStatus lr_status,
+ SaveFPRegsMode fp_mode) {
+ if (emit_debug_code()) {
+ LoadP(dst, FieldMemOperand(map, HeapObject::kMapOffset));
+ Cmpi(dst, Operand(isolate()->factory()->meta_map()), r0);
+ Check(eq, kWrongAddressOrValuePassedToRecordWrite);
+ }
+
+ if (!FLAG_incremental_marking) {
+ return;
+ }
+
+ if (emit_debug_code()) {
+ LoadP(ip, FieldMemOperand(object, HeapObject::kMapOffset));
+ cmp(ip, map);
+ Check(eq, kWrongAddressOrValuePassedToRecordWrite);
+ }
+
+ Label done;
+
+ // A single check of the map's pages interesting flag suffices, since it is
+ // only set during incremental collection, and then it's also guaranteed that
+ // the from object's page's interesting flag is also set. This optimization
+ // relies on the fact that maps can never be in new space.
+ CheckPageFlag(map,
+ map, // Used as scratch.
+ MemoryChunk::kPointersToHereAreInterestingMask, eq, &done);
+
+ addi(dst, object, Operand(HeapObject::kMapOffset - kHeapObjectTag));
+ if (emit_debug_code()) {
+ Label ok;
+ andi(r0, dst, Operand((1 << kPointerSizeLog2) - 1));
+ beq(&ok, cr0);
+ stop("Unaligned cell in write barrier");
+ bind(&ok);
+ }
+
+ // Record the actual write.
+ if (lr_status == kLRHasNotBeenSaved) {
+ mflr(r0);
+ push(r0);
+ }
+ RecordWriteStub stub(isolate(), object, map, dst, OMIT_REMEMBERED_SET,
+ fp_mode);
+ CallStub(&stub);
+ if (lr_status == kLRHasNotBeenSaved) {
+ pop(r0);
+ mtlr(r0);
+ }
+
+ bind(&done);
+
+ // Count number of write barriers in generated code.
+ isolate()->counters()->write_barriers_static()->Increment();
+ IncrementCounter(isolate()->counters()->write_barriers_dynamic(), 1, ip, dst);
+
+ // Clobber clobbered registers when running with the debug-code flag
+ // turned on to provoke errors.
+ if (emit_debug_code()) {
+ mov(dst, Operand(bit_cast<intptr_t>(kZapValue + 12)));
+ mov(map, Operand(bit_cast<intptr_t>(kZapValue + 16)));
+ }
+}
+
+
+// Will clobber 4 registers: object, address, scratch, ip. The
+// register 'object' contains a heap object pointer. The heap object
+// tag is shifted away.
+void MacroAssembler::RecordWrite(
+ Register object, Register address, Register value,
+ LinkRegisterStatus lr_status, SaveFPRegsMode fp_mode,
+ RememberedSetAction remembered_set_action, SmiCheck smi_check,
+ PointersToHereCheck pointers_to_here_check_for_value) {
+ DCHECK(!object.is(value));
+ if (emit_debug_code()) {
+ LoadP(r0, MemOperand(address));
+ cmp(r0, value);
+ Check(eq, kWrongAddressOrValuePassedToRecordWrite);
+ }
+
+ if (remembered_set_action == OMIT_REMEMBERED_SET &&
+ !FLAG_incremental_marking) {
+ return;
+ }
+
+ // First, check if a write barrier is even needed. The tests below
+ // catch stores of smis and stores into the young generation.
+ Label done;
+
+ if (smi_check == INLINE_SMI_CHECK) {
+ JumpIfSmi(value, &done);
+ }
+
+ if (pointers_to_here_check_for_value != kPointersToHereAreAlwaysInteresting) {
+ CheckPageFlag(value,
+ value, // Used as scratch.
+ MemoryChunk::kPointersToHereAreInterestingMask, eq, &done);
+ }
+ CheckPageFlag(object,
+ value, // Used as scratch.
+ MemoryChunk::kPointersFromHereAreInterestingMask, eq, &done);
+
+ // Record the actual write.
+ if (lr_status == kLRHasNotBeenSaved) {
+ mflr(r0);
+ push(r0);
+ }
+ RecordWriteStub stub(isolate(), object, value, address, remembered_set_action,
+ fp_mode);
+ CallStub(&stub);
+ if (lr_status == kLRHasNotBeenSaved) {
+ pop(r0);
+ mtlr(r0);
+ }
+
+ bind(&done);
+
+ // Count number of write barriers in generated code.
+ isolate()->counters()->write_barriers_static()->Increment();
+ IncrementCounter(isolate()->counters()->write_barriers_dynamic(), 1, ip,
+ value);
+
+ // Clobber clobbered registers when running with the debug-code flag
+ // turned on to provoke errors.
+ if (emit_debug_code()) {
+ mov(address, Operand(bit_cast<intptr_t>(kZapValue + 12)));
+ mov(value, Operand(bit_cast<intptr_t>(kZapValue + 16)));
+ }
+}
+
+
+void MacroAssembler::RememberedSetHelper(Register object, // For debug tests.
+ Register address, Register scratch,
+ SaveFPRegsMode fp_mode,
+ RememberedSetFinalAction and_then) {
+ Label done;
+ if (emit_debug_code()) {
+ Label ok;
+ JumpIfNotInNewSpace(object, scratch, &ok);
+ stop("Remembered set pointer is in new space");
+ bind(&ok);
+ }
+ // Load store buffer top.
+ ExternalReference store_buffer =
+ ExternalReference::store_buffer_top(isolate());
+ mov(ip, Operand(store_buffer));
+ LoadP(scratch, MemOperand(ip));
+ // Store pointer to buffer and increment buffer top.
+ StoreP(address, MemOperand(scratch));
+ addi(scratch, scratch, Operand(kPointerSize));
+ // Write back new top of buffer.
+ StoreP(scratch, MemOperand(ip));
+ // Call stub on end of buffer.
+ // Check for end of buffer.
+ mov(r0, Operand(StoreBuffer::kStoreBufferOverflowBit));
+ and_(r0, scratch, r0, SetRC);
+
+ if (and_then == kFallThroughAtEnd) {
+ beq(&done, cr0);
+ } else {
+ DCHECK(and_then == kReturnAtEnd);
+ beq(&done, cr0);
+ }
+ mflr(r0);
+ push(r0);
+ StoreBufferOverflowStub store_buffer_overflow(isolate(), fp_mode);
+ CallStub(&store_buffer_overflow);
+ pop(r0);
+ mtlr(r0);
+ bind(&done);
+ if (and_then == kReturnAtEnd) {
+ Ret();
+ }
+}
+
+
+void MacroAssembler::PushFixedFrame(Register marker_reg) {
+ mflr(r0);
+#if V8_OOL_CONSTANT_POOL
+ if (marker_reg.is_valid()) {
+ Push(r0, fp, kConstantPoolRegister, cp, marker_reg);
+ } else {
+ Push(r0, fp, kConstantPoolRegister, cp);
+ }
+#else
+ if (marker_reg.is_valid()) {
+ Push(r0, fp, cp, marker_reg);
+ } else {
+ Push(r0, fp, cp);
+ }
+#endif
+}
+
+
+void MacroAssembler::PopFixedFrame(Register marker_reg) {
+#if V8_OOL_CONSTANT_POOL
+ if (marker_reg.is_valid()) {
+ Pop(r0, fp, kConstantPoolRegister, cp, marker_reg);
+ } else {
+ Pop(r0, fp, kConstantPoolRegister, cp);
+ }
+#else
+ if (marker_reg.is_valid()) {
+ Pop(r0, fp, cp, marker_reg);
+ } else {
+ Pop(r0, fp, cp);
+ }
+#endif
+ mtlr(r0);
+}
+
+
+// Push and pop all registers that can hold pointers.
+void MacroAssembler::PushSafepointRegisters() {
+ // Safepoints expect a block of kNumSafepointRegisters values on the
+ // stack, so adjust the stack for unsaved registers.
+ const int num_unsaved = kNumSafepointRegisters - kNumSafepointSavedRegisters;
+ DCHECK(num_unsaved >= 0);
+ if (num_unsaved > 0) {
+ subi(sp, sp, Operand(num_unsaved * kPointerSize));
+ }
+ MultiPush(kSafepointSavedRegisters);
+}
+
+
+void MacroAssembler::PopSafepointRegisters() {
+ const int num_unsaved = kNumSafepointRegisters - kNumSafepointSavedRegisters;
+ MultiPop(kSafepointSavedRegisters);
+ if (num_unsaved > 0) {
+ addi(sp, sp, Operand(num_unsaved * kPointerSize));
+ }
+}
+
+
+void MacroAssembler::StoreToSafepointRegisterSlot(Register src, Register dst) {
+ StoreP(src, SafepointRegisterSlot(dst));
+}
+
+
+void MacroAssembler::LoadFromSafepointRegisterSlot(Register dst, Register src) {
+ LoadP(dst, SafepointRegisterSlot(src));
+}
+
+
+int MacroAssembler::SafepointRegisterStackIndex(int reg_code) {
+ // The registers are pushed starting with the highest encoding,
+ // which means that lowest encodings are closest to the stack pointer.
+ RegList regs = kSafepointSavedRegisters;
+ int index = 0;
+
+ DCHECK(reg_code >= 0 && reg_code < kNumRegisters);
+
+ for (int16_t i = 0; i < reg_code; i++) {
+ if ((regs & (1 << i)) != 0) {
+ index++;
+ }
+ }
+
+ return index;
+}
+
+
+MemOperand MacroAssembler::SafepointRegisterSlot(Register reg) {
+ return MemOperand(sp, SafepointRegisterStackIndex(reg.code()) * kPointerSize);
+}
+
+
+MemOperand MacroAssembler::SafepointRegistersAndDoublesSlot(Register reg) {
+ // General purpose registers are pushed last on the stack.
+ int doubles_size = DoubleRegister::NumAllocatableRegisters() * kDoubleSize;
+ int register_offset = SafepointRegisterStackIndex(reg.code()) * kPointerSize;
+ return MemOperand(sp, doubles_size + register_offset);
+}
+
+
+void MacroAssembler::CanonicalizeNaN(const DoubleRegister dst,
+ const DoubleRegister src) {
+ Label done;
+
+ // Test for NaN
+ fcmpu(src, src);
+
+ if (dst.is(src)) {
+ bordered(&done);
+ } else {
+ Label is_nan;
+ bunordered(&is_nan);
+ fmr(dst, src);
+ b(&done);
+ bind(&is_nan);
+ }
+
+ // Replace with canonical NaN.
+ double nan_value = FixedDoubleArray::canonical_not_the_hole_nan_as_double();
+ LoadDoubleLiteral(dst, nan_value, r0);
+
+ bind(&done);
+}
+
+
+void MacroAssembler::ConvertIntToDouble(Register src,
+ DoubleRegister double_dst) {
+ MovIntToDouble(double_dst, src, r0);
+ fcfid(double_dst, double_dst);
+}
+
+
+void MacroAssembler::ConvertUnsignedIntToDouble(Register src,
+ DoubleRegister double_dst) {
+ MovUnsignedIntToDouble(double_dst, src, r0);
+ fcfid(double_dst, double_dst);
+}
+
+
+void MacroAssembler::ConvertIntToFloat(const DoubleRegister dst,
+ const Register src,
+ const Register int_scratch) {
+ MovIntToDouble(dst, src, int_scratch);
+ fcfid(dst, dst);
+ frsp(dst, dst);
+}
+
+
+void MacroAssembler::ConvertDoubleToInt64(const DoubleRegister double_input,
+#if !V8_TARGET_ARCH_PPC64
+ const Register dst_hi,
+#endif
+ const Register dst,
+ const DoubleRegister double_dst,
+ FPRoundingMode rounding_mode) {
+ if (rounding_mode == kRoundToZero) {
+ fctidz(double_dst, double_input);
+ } else {
+ SetRoundingMode(rounding_mode);
+ fctid(double_dst, double_input);
+ ResetRoundingMode();
+ }
+
+ MovDoubleToInt64(
+#if !V8_TARGET_ARCH_PPC64
+ dst_hi,
+#endif
+ dst, double_dst);
+}
+
+
+#if V8_OOL_CONSTANT_POOL
+void MacroAssembler::LoadConstantPoolPointerRegister(
+ CodeObjectAccessMethod access_method, int ip_code_entry_delta) {
+ Register base;
+ int constant_pool_offset = Code::kConstantPoolOffset - Code::kHeaderSize;
+ if (access_method == CAN_USE_IP) {
+ base = ip;
+ constant_pool_offset += ip_code_entry_delta;
+ } else {
+ DCHECK(access_method == CONSTRUCT_INTERNAL_REFERENCE);
+ base = kConstantPoolRegister;
+ ConstantPoolUnavailableScope constant_pool_unavailable(this);
+
+ // CheckBuffer() is called too frequently. This will pre-grow
+ // the buffer if needed to avoid spliting the relocation and instructions
+ EnsureSpaceFor(kMovInstructionsNoConstantPool * kInstrSize);
+
+ uintptr_t code_start = reinterpret_cast<uintptr_t>(pc_) - pc_offset();
+ mov(base, Operand(code_start, RelocInfo::INTERNAL_REFERENCE));
+ }
+ LoadP(kConstantPoolRegister, MemOperand(base, constant_pool_offset));
+}
+#endif
+
+
+void MacroAssembler::StubPrologue(int prologue_offset) {
+ LoadSmiLiteral(r11, Smi::FromInt(StackFrame::STUB));
+ PushFixedFrame(r11);
+ // Adjust FP to point to saved FP.
+ addi(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
+#if V8_OOL_CONSTANT_POOL
+ // ip contains prologue address
+ LoadConstantPoolPointerRegister(CAN_USE_IP, -prologue_offset);
+ set_ool_constant_pool_available(true);
+#endif
+}
+
+
+void MacroAssembler::Prologue(bool code_pre_aging, int prologue_offset) {
+ {
+ PredictableCodeSizeScope predictible_code_size_scope(
+ this, kNoCodeAgeSequenceLength);
+ Assembler::BlockTrampolinePoolScope block_trampoline_pool(this);
+ // The following instructions must remain together and unmodified
+ // for code aging to work properly.
+ if (code_pre_aging) {
+ // Pre-age the code.
+ // This matches the code found in PatchPlatformCodeAge()
+ Code* stub = Code::GetPreAgedCodeAgeStub(isolate());
+ intptr_t target = reinterpret_cast<intptr_t>(stub->instruction_start());
+ // Don't use Call -- we need to preserve ip and lr
+ nop(); // marker to detect sequence (see IsOld)
+ mov(r3, Operand(target));
+ Jump(r3);
+ for (int i = 0; i < kCodeAgingSequenceNops; i++) {
+ nop();
+ }
+ } else {
+ // This matches the code found in GetNoCodeAgeSequence()
+ PushFixedFrame(r4);
+ // Adjust fp to point to saved fp.
+ addi(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
+ for (int i = 0; i < kNoCodeAgeSequenceNops; i++) {
+ nop();
+ }
+ }
+ }
+#if V8_OOL_CONSTANT_POOL
+ // ip contains prologue address
+ LoadConstantPoolPointerRegister(CAN_USE_IP, -prologue_offset);
+ set_ool_constant_pool_available(true);
+#endif
+}
+
+
+void MacroAssembler::EnterFrame(StackFrame::Type type,
+ bool load_constant_pool_pointer_reg) {
+ if (FLAG_enable_ool_constant_pool && load_constant_pool_pointer_reg) {
+ PushFixedFrame();
+#if V8_OOL_CONSTANT_POOL
+ // This path should not rely on ip containing code entry.
+ LoadConstantPoolPointerRegister(CONSTRUCT_INTERNAL_REFERENCE);
+#endif
+ LoadSmiLiteral(ip, Smi::FromInt(type));
+ push(ip);
+ } else {
+ LoadSmiLiteral(ip, Smi::FromInt(type));
+ PushFixedFrame(ip);
+ }
+ // Adjust FP to point to saved FP.
+ addi(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
+
+ mov(r0, Operand(CodeObject()));
+ push(r0);
+}
+
+
+int MacroAssembler::LeaveFrame(StackFrame::Type type, int stack_adjustment) {
+#if V8_OOL_CONSTANT_POOL
+ ConstantPoolUnavailableScope constant_pool_unavailable(this);
+#endif
+ // r3: preserved
+ // r4: preserved
+ // r5: preserved
+
+ // Drop the execution stack down to the frame pointer and restore
+ // the caller frame pointer, return address and constant pool pointer.
+ int frame_ends;
+ LoadP(r0, MemOperand(fp, StandardFrameConstants::kCallerPCOffset));
+ LoadP(ip, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
+#if V8_OOL_CONSTANT_POOL
+ const int exitOffset = ExitFrameConstants::kConstantPoolOffset;
+ const int standardOffset = StandardFrameConstants::kConstantPoolOffset;
+ const int offset = ((type == StackFrame::EXIT) ? exitOffset : standardOffset);
+ LoadP(kConstantPoolRegister, MemOperand(fp, offset));
+#endif
+ mtlr(r0);
+ frame_ends = pc_offset();
+ Add(sp, fp, StandardFrameConstants::kCallerSPOffset + stack_adjustment, r0);
+ mr(fp, ip);
+ return frame_ends;
+}
+
+
+// ExitFrame layout (probably wrongish.. needs updating)
+//
+// SP -> previousSP
+// LK reserved
+// code
+// sp_on_exit (for debug?)
+// oldSP->prev SP
+// LK
+// <parameters on stack>
+
+// Prior to calling EnterExitFrame, we've got a bunch of parameters
+// on the stack that we need to wrap a real frame around.. so first
+// we reserve a slot for LK and push the previous SP which is captured
+// in the fp register (r31)
+// Then - we buy a new frame
+
+void MacroAssembler::EnterExitFrame(bool save_doubles, int stack_space) {
+ // Set up the frame structure on the stack.
+ DCHECK_EQ(2 * kPointerSize, ExitFrameConstants::kCallerSPDisplacement);
+ DCHECK_EQ(1 * kPointerSize, ExitFrameConstants::kCallerPCOffset);
+ DCHECK_EQ(0 * kPointerSize, ExitFrameConstants::kCallerFPOffset);
+ DCHECK(stack_space > 0);
+
+ // This is an opportunity to build a frame to wrap
+ // all of the pushes that have happened inside of V8
+ // since we were called from C code
+
+ // replicate ARM frame - TODO make this more closely follow PPC ABI
+ mflr(r0);
+ Push(r0, fp);
+ mr(fp, sp);
+ // Reserve room for saved entry sp and code object.
+ subi(sp, sp, Operand(ExitFrameConstants::kFrameSize));
+
+ if (emit_debug_code()) {
+ li(r8, Operand::Zero());
+ StoreP(r8, MemOperand(fp, ExitFrameConstants::kSPOffset));
+ }
+#if V8_OOL_CONSTANT_POOL
+ StoreP(kConstantPoolRegister,
+ MemOperand(fp, ExitFrameConstants::kConstantPoolOffset));
+#endif
+ mov(r8, Operand(CodeObject()));
+ StoreP(r8, MemOperand(fp, ExitFrameConstants::kCodeOffset));
+
+ // Save the frame pointer and the context in top.
+ mov(r8, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate())));
+ StoreP(fp, MemOperand(r8));
+ mov(r8, Operand(ExternalReference(Isolate::kContextAddress, isolate())));
+ StoreP(cp, MemOperand(r8));
+
+ // Optionally save all volatile double registers.
+ if (save_doubles) {
+ SaveFPRegs(sp, 0, DoubleRegister::kNumVolatileRegisters);
+ // Note that d0 will be accessible at
+ // fp - ExitFrameConstants::kFrameSize -
+ // kNumVolatileRegisters * kDoubleSize,
+ // since the sp slot and code slot were pushed after the fp.
+ }
+
+ addi(sp, sp, Operand(-stack_space * kPointerSize));
+
+ // Allocate and align the frame preparing for calling the runtime
+ // function.
+ const int frame_alignment = ActivationFrameAlignment();
+ if (frame_alignment > kPointerSize) {
+ DCHECK(base::bits::IsPowerOfTwo32(frame_alignment));
+ ClearRightImm(sp, sp, Operand(WhichPowerOf2(frame_alignment)));
+ }
+ li(r0, Operand::Zero());
+ StorePU(r0, MemOperand(sp, -kNumRequiredStackFrameSlots * kPointerSize));
+
+ // Set the exit frame sp value to point just before the return address
+ // location.
+ addi(r8, sp, Operand((kStackFrameExtraParamSlot + 1) * kPointerSize));
+ StoreP(r8, MemOperand(fp, ExitFrameConstants::kSPOffset));
+}
+
+
+void MacroAssembler::InitializeNewString(Register string, Register length,
+ Heap::RootListIndex map_index,
+ Register scratch1, Register scratch2) {
+ SmiTag(scratch1, length);
+ LoadRoot(scratch2, map_index);
+ StoreP(scratch1, FieldMemOperand(string, String::kLengthOffset), r0);
+ li(scratch1, Operand(String::kEmptyHashField));
+ StoreP(scratch2, FieldMemOperand(string, HeapObject::kMapOffset), r0);
+ StoreP(scratch1, FieldMemOperand(string, String::kHashFieldSlot), r0);
+}
+
+
+int MacroAssembler::ActivationFrameAlignment() {
+#if !defined(USE_SIMULATOR)
+ // Running on the real platform. Use the alignment as mandated by the local
+ // environment.
+ // Note: This will break if we ever start generating snapshots on one PPC
+ // platform for another PPC platform with a different alignment.
+ return base::OS::ActivationFrameAlignment();
+#else // Simulated
+ // If we are using the simulator then we should always align to the expected
+ // alignment. As the simulator is used to generate snapshots we do not know
+ // if the target platform will need alignment, so this is controlled from a
+ // flag.
+ return FLAG_sim_stack_alignment;
+#endif
+}
+
+
+void MacroAssembler::LeaveExitFrame(bool save_doubles, Register argument_count,
+ bool restore_context) {
+#if V8_OOL_CONSTANT_POOL
+ ConstantPoolUnavailableScope constant_pool_unavailable(this);
+#endif
+ // Optionally restore all double registers.
+ if (save_doubles) {
+ // Calculate the stack location of the saved doubles and restore them.
+ const int kNumRegs = DoubleRegister::kNumVolatileRegisters;
+ const int offset =
+ (ExitFrameConstants::kFrameSize + kNumRegs * kDoubleSize);
+ addi(r6, fp, Operand(-offset));
+ RestoreFPRegs(r6, 0, kNumRegs);
+ }
+
+ // Clear top frame.
+ li(r6, Operand::Zero());
+ mov(ip, Operand(ExternalReference(Isolate::kCEntryFPAddress, isolate())));
+ StoreP(r6, MemOperand(ip));
+
+ // Restore current context from top and clear it in debug mode.
+ if (restore_context) {
+ mov(ip, Operand(ExternalReference(Isolate::kContextAddress, isolate())));
+ LoadP(cp, MemOperand(ip));
+ }
+#ifdef DEBUG
+ mov(ip, Operand(ExternalReference(Isolate::kContextAddress, isolate())));
+ StoreP(r6, MemOperand(ip));
+#endif
+
+ // Tear down the exit frame, pop the arguments, and return.
+ LeaveFrame(StackFrame::EXIT);
+
+ if (argument_count.is_valid()) {
+ ShiftLeftImm(argument_count, argument_count, Operand(kPointerSizeLog2));
+ add(sp, sp, argument_count);
+ }
+}
+
+
+void MacroAssembler::MovFromFloatResult(const DoubleRegister dst) {
+ Move(dst, d1);
+}
+
+
+void MacroAssembler::MovFromFloatParameter(const DoubleRegister dst) {
+ Move(dst, d1);
+}
+
+
+void MacroAssembler::InvokePrologue(const ParameterCount& expected,
+ const ParameterCount& actual,
+ Handle<Code> code_constant,
+ Register code_reg, Label* done,
+ bool* definitely_mismatches,
+ InvokeFlag flag,
+ const CallWrapper& call_wrapper) {
+ bool definitely_matches = false;
+ *definitely_mismatches = false;
+ Label regular_invoke;
+
+ // Check whether the expected and actual arguments count match. If not,
+ // setup registers according to contract with ArgumentsAdaptorTrampoline:
+ // r3: actual arguments count
+ // r4: function (passed through to callee)
+ // r5: expected arguments count
+
+ // The code below is made a lot easier because the calling code already sets
+ // up actual and expected registers according to the contract if values are
+ // passed in registers.
+
+ // ARM has some sanity checks as per below, considering add them for PPC
+ // DCHECK(actual.is_immediate() || actual.reg().is(r3));
+ // DCHECK(expected.is_immediate() || expected.reg().is(r5));
+ // DCHECK((!code_constant.is_null() && code_reg.is(no_reg))
+ // || code_reg.is(r6));
+
+ if (expected.is_immediate()) {
+ DCHECK(actual.is_immediate());
+ if (expected.immediate() == actual.immediate()) {
+ definitely_matches = true;
+ } else {
+ mov(r3, Operand(actual.immediate()));
+ const int sentinel = SharedFunctionInfo::kDontAdaptArgumentsSentinel;
+ if (expected.immediate() == sentinel) {
+ // Don't worry about adapting arguments for builtins that
+ // don't want that done. Skip adaption code by making it look
+ // like we have a match between expected and actual number of
+ // arguments.
+ definitely_matches = true;
+ } else {
+ *definitely_mismatches = true;
+ mov(r5, Operand(expected.immediate()));
+ }
+ }
+ } else {
+ if (actual.is_immediate()) {
+ cmpi(expected.reg(), Operand(actual.immediate()));
+ beq(®ular_invoke);
+ mov(r3, Operand(actual.immediate()));
+ } else {
+ cmp(expected.reg(), actual.reg());
+ beq(®ular_invoke);
+ }
+ }
+
+ if (!definitely_matches) {
+ if (!code_constant.is_null()) {
+ mov(r6, Operand(code_constant));
+ addi(r6, r6, Operand(Code::kHeaderSize - kHeapObjectTag));
+ }
+
+ Handle<Code> adaptor = isolate()->builtins()->ArgumentsAdaptorTrampoline();
+ if (flag == CALL_FUNCTION) {
+ call_wrapper.BeforeCall(CallSize(adaptor));
+ Call(adaptor);
+ call_wrapper.AfterCall();
+ if (!*definitely_mismatches) {
+ b(done);
+ }
+ } else {
+ Jump(adaptor, RelocInfo::CODE_TARGET);
+ }
+ bind(®ular_invoke);
+ }
+}
+
+
+void MacroAssembler::InvokeCode(Register code, const ParameterCount& expected,
+ const ParameterCount& actual, InvokeFlag flag,
+ const CallWrapper& call_wrapper) {
+ // You can't call a function without a valid frame.
+ DCHECK(flag == JUMP_FUNCTION || has_frame());
+
+ Label done;
+ bool definitely_mismatches = false;
+ InvokePrologue(expected, actual, Handle<Code>::null(), code, &done,
+ &definitely_mismatches, flag, call_wrapper);
+ if (!definitely_mismatches) {
+ if (flag == CALL_FUNCTION) {
+ call_wrapper.BeforeCall(CallSize(code));
+ CallJSEntry(code);
+ call_wrapper.AfterCall();
+ } else {
+ DCHECK(flag == JUMP_FUNCTION);
+ JumpToJSEntry(code);
+ }
+
+ // Continue here if InvokePrologue does handle the invocation due to
+ // mismatched parameter counts.
+ bind(&done);
+ }
+}
+
+
+void MacroAssembler::InvokeFunction(Register fun, const ParameterCount& actual,
+ InvokeFlag flag,
+ const CallWrapper& call_wrapper) {
+ // You can't call a function without a valid frame.
+ DCHECK(flag == JUMP_FUNCTION || has_frame());
+
+ // Contract with called JS functions requires that function is passed in r4.
+ DCHECK(fun.is(r4));
+
+ Register expected_reg = r5;
+ Register code_reg = ip;
+
+ LoadP(code_reg, FieldMemOperand(r4, JSFunction::kSharedFunctionInfoOffset));
+ LoadP(cp, FieldMemOperand(r4, JSFunction::kContextOffset));
+ LoadWordArith(expected_reg,
+ FieldMemOperand(
+ code_reg, SharedFunctionInfo::kFormalParameterCountOffset));
+#if !defined(V8_TARGET_ARCH_PPC64)
+ SmiUntag(expected_reg);
+#endif
+ LoadP(code_reg, FieldMemOperand(r4, JSFunction::kCodeEntryOffset));
+
+ ParameterCount expected(expected_reg);
+ InvokeCode(code_reg, expected, actual, flag, call_wrapper);
+}
+
+
+void MacroAssembler::InvokeFunction(Register function,
+ const ParameterCount& expected,
+ const ParameterCount& actual,
+ InvokeFlag flag,
+ const CallWrapper& call_wrapper) {
+ // You can't call a function without a valid frame.
+ DCHECK(flag == JUMP_FUNCTION || has_frame());
+
+ // Contract with called JS functions requires that function is passed in r4.
+ DCHECK(function.is(r4));
+
+ // Get the function and setup the context.
+ LoadP(cp, FieldMemOperand(r4, JSFunction::kContextOffset));
+
+ // We call indirectly through the code field in the function to
+ // allow recompilation to take effect without changing any of the
+ // call sites.
+ LoadP(ip, FieldMemOperand(r4, JSFunction::kCodeEntryOffset));
+ InvokeCode(ip, expected, actual, flag, call_wrapper);
+}
+
+
+void MacroAssembler::InvokeFunction(Handle<JSFunction> function,
+ const ParameterCount& expected,
+ const ParameterCount& actual,
+ InvokeFlag flag,
+ const CallWrapper& call_wrapper) {
+ Move(r4, function);
+ InvokeFunction(r4, expected, actual, flag, call_wrapper);
+}
+
+
+void MacroAssembler::IsObjectJSObjectType(Register heap_object, Register map,
+ Register scratch, Label* fail) {
+ LoadP(map, FieldMemOperand(heap_object, HeapObject::kMapOffset));
+ IsInstanceJSObjectType(map, scratch, fail);
+}
+
+
+void MacroAssembler::IsInstanceJSObjectType(Register map, Register scratch,
+ Label* fail) {
+ lbz(scratch, FieldMemOperand(map, Map::kInstanceTypeOffset));
+ cmpi(scratch, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
+ blt(fail);
+ cmpi(scratch, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE));
+ bgt(fail);
+}
+
+
+void MacroAssembler::IsObjectJSStringType(Register object, Register scratch,
+ Label* fail) {
+ DCHECK(kNotStringTag != 0);
+
+ LoadP(scratch, FieldMemOperand(object, HeapObject::kMapOffset));
+ lbz(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
+ andi(r0, scratch, Operand(kIsNotStringMask));
+ bne(fail, cr0);
+}
+
+
+void MacroAssembler::IsObjectNameType(Register object, Register scratch,
+ Label* fail) {
+ LoadP(scratch, FieldMemOperand(object, HeapObject::kMapOffset));
+ lbz(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
+ cmpi(scratch, Operand(LAST_NAME_TYPE));
+ bgt(fail);
+}
+
+
+void MacroAssembler::DebugBreak() {
+ li(r3, Operand::Zero());
+ mov(r4, Operand(ExternalReference(Runtime::kDebugBreak, isolate())));
+ CEntryStub ces(isolate(), 1);
+ DCHECK(AllowThisStubCall(&ces));
+ Call(ces.GetCode(), RelocInfo::DEBUG_BREAK);
+}
+
+
+void MacroAssembler::PushTryHandler(StackHandler::Kind kind,
+ int handler_index) {
+ // Adjust this code if not the case.
+ STATIC_ASSERT(StackHandlerConstants::kSize == 5 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize);
+
+ // For the JSEntry handler, we must preserve r1-r7, r0,r8-r15 are available.
+ // We want the stack to look like
+ // sp -> NextOffset
+ // CodeObject
+ // state
+ // context
+ // frame pointer
+
+ // Link the current handler as the next handler.
+ mov(r8, Operand(ExternalReference(Isolate::kHandlerAddress, isolate())));
+ LoadP(r0, MemOperand(r8));
+ StorePU(r0, MemOperand(sp, -StackHandlerConstants::kSize));
+ // Set this new handler as the current one.
+ StoreP(sp, MemOperand(r8));
+
+ if (kind == StackHandler::JS_ENTRY) {
+ li(r8, Operand::Zero()); // NULL frame pointer.
+ StoreP(r8, MemOperand(sp, StackHandlerConstants::kFPOffset));
+ LoadSmiLiteral(r8, Smi::FromInt(0)); // Indicates no context.
+ StoreP(r8, MemOperand(sp, StackHandlerConstants::kContextOffset));
+ } else {
+ // still not sure if fp is right
+ StoreP(fp, MemOperand(sp, StackHandlerConstants::kFPOffset));
+ StoreP(cp, MemOperand(sp, StackHandlerConstants::kContextOffset));
+ }
+ unsigned state = StackHandler::IndexField::encode(handler_index) |
+ StackHandler::KindField::encode(kind);
+ LoadIntLiteral(r8, state);
+ StoreP(r8, MemOperand(sp, StackHandlerConstants::kStateOffset));
+ mov(r8, Operand(CodeObject()));
+ StoreP(r8, MemOperand(sp, StackHandlerConstants::kCodeOffset));
+}
+
+
+void MacroAssembler::PopTryHandler() {
+ STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
+ pop(r4);
+ mov(ip, Operand(ExternalReference(Isolate::kHandlerAddress, isolate())));
+ addi(sp, sp, Operand(StackHandlerConstants::kSize - kPointerSize));
+ StoreP(r4, MemOperand(ip));
+}
+
+
+// PPC - make use of ip as a temporary register
+void MacroAssembler::JumpToHandlerEntry() {
+// Compute the handler entry address and jump to it. The handler table is
+// a fixed array of (smi-tagged) code offsets.
+// r3 = exception, r4 = code object, r5 = state.
+#if V8_OOL_CONSTANT_POOL
+ ConstantPoolUnavailableScope constant_pool_unavailable(this);
+ LoadP(kConstantPoolRegister, FieldMemOperand(r4, Code::kConstantPoolOffset));
+#endif
+ LoadP(r6, FieldMemOperand(r4, Code::kHandlerTableOffset)); // Handler table.
+ addi(r6, r6, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
+ srwi(r5, r5, Operand(StackHandler::kKindWidth)); // Handler index.
+ slwi(ip, r5, Operand(kPointerSizeLog2));
+ add(ip, r6, ip);
+ LoadP(r5, MemOperand(ip)); // Smi-tagged offset.
+ addi(r4, r4, Operand(Code::kHeaderSize - kHeapObjectTag)); // Code start.
+ SmiUntag(ip, r5);
+ add(r0, r4, ip);
+ mtctr(r0);
+ bctr();
+}
+
+
+void MacroAssembler::Throw(Register value) {
+ // Adjust this code if not the case.
+ STATIC_ASSERT(StackHandlerConstants::kSize == 5 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
+ STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize);
+ Label skip;
+
+ // The exception is expected in r3.
+ if (!value.is(r3)) {
+ mr(r3, value);
+ }
+ // Drop the stack pointer to the top of the top handler.
+ mov(r6, Operand(ExternalReference(Isolate::kHandlerAddress, isolate())));
+ LoadP(sp, MemOperand(r6));
+ // Restore the next handler.
+ pop(r5);
+ StoreP(r5, MemOperand(r6));
+
+ // Get the code object (r4) and state (r5). Restore the context and frame
+ // pointer.
+ pop(r4);
+ pop(r5);
+ pop(cp);
+ pop(fp);
+
+ // If the handler is a JS frame, restore the context to the frame.
+ // (kind == ENTRY) == (fp == 0) == (cp == 0), so we could test either fp
+ // or cp.
+ cmpi(cp, Operand::Zero());
+ beq(&skip);
+ StoreP(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+ bind(&skip);
+
+ JumpToHandlerEntry();
+}
+
+
+void MacroAssembler::ThrowUncatchable(Register value) {
+ // Adjust this code if not the case.
+ STATIC_ASSERT(StackHandlerConstants::kSize == 5 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize);
+ STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize);
+
+ // The exception is expected in r3.
+ if (!value.is(r3)) {
+ mr(r3, value);
+ }
+ // Drop the stack pointer to the top of the top stack handler.
+ mov(r6, Operand(ExternalReference(Isolate::kHandlerAddress, isolate())));
+ LoadP(sp, MemOperand(r6));
+
+ // Unwind the handlers until the ENTRY handler is found.
+ Label fetch_next, check_kind;
+ b(&check_kind);
+ bind(&fetch_next);
+ LoadP(sp, MemOperand(sp, StackHandlerConstants::kNextOffset));
+
+ bind(&check_kind);
+ STATIC_ASSERT(StackHandler::JS_ENTRY == 0);
+ LoadP(r5, MemOperand(sp, StackHandlerConstants::kStateOffset));
+ andi(r0, r5, Operand(StackHandler::KindField::kMask));
+ bne(&fetch_next, cr0);
+
+ // Set the top handler address to next handler past the top ENTRY handler.
+ pop(r5);
+ StoreP(r5, MemOperand(r6));
+ // Get the code object (r4) and state (r5). Clear the context and frame
+ // pointer (0 was saved in the handler).
+ pop(r4);
+ pop(r5);
+ pop(cp);
+ pop(fp);
+
+ JumpToHandlerEntry();
+}
+
+
+void MacroAssembler::CheckAccessGlobalProxy(Register holder_reg,
+ Register scratch, Label* miss) {
+ Label same_contexts;
+
+ DCHECK(!holder_reg.is(scratch));
+ DCHECK(!holder_reg.is(ip));
+ DCHECK(!scratch.is(ip));
+
+ // Load current lexical context from the stack frame.
+ LoadP(scratch, MemOperand(fp, StandardFrameConstants::kContextOffset));
+// In debug mode, make sure the lexical context is set.
+#ifdef DEBUG
+ cmpi(scratch, Operand::Zero());
+ Check(ne, kWeShouldNotHaveAnEmptyLexicalContext);
+#endif
+
+ // Load the native context of the current context.
+ int offset =
+ Context::kHeaderSize + Context::GLOBAL_OBJECT_INDEX * kPointerSize;
+ LoadP(scratch, FieldMemOperand(scratch, offset));
+ LoadP(scratch, FieldMemOperand(scratch, GlobalObject::kNativeContextOffset));
+
+ // Check the context is a native context.
+ if (emit_debug_code()) {
+ // Cannot use ip as a temporary in this verification code. Due to the fact
+ // that ip is clobbered as part of cmp with an object Operand.
+ push(holder_reg); // Temporarily save holder on the stack.
+ // Read the first word and compare to the native_context_map.
+ LoadP(holder_reg, FieldMemOperand(scratch, HeapObject::kMapOffset));
+ LoadRoot(ip, Heap::kNativeContextMapRootIndex);
+ cmp(holder_reg, ip);
+ Check(eq, kJSGlobalObjectNativeContextShouldBeANativeContext);
+ pop(holder_reg); // Restore holder.
+ }
+
+ // Check if both contexts are the same.
+ LoadP(ip, FieldMemOperand(holder_reg, JSGlobalProxy::kNativeContextOffset));
+ cmp(scratch, ip);
+ beq(&same_contexts);
+
+ // Check the context is a native context.
+ if (emit_debug_code()) {
+ // Cannot use ip as a temporary in this verification code. Due to the fact
+ // that ip is clobbered as part of cmp with an object Operand.
+ push(holder_reg); // Temporarily save holder on the stack.
+ mr(holder_reg, ip); // Move ip to its holding place.
+ LoadRoot(ip, Heap::kNullValueRootIndex);
+ cmp(holder_reg, ip);
+ Check(ne, kJSGlobalProxyContextShouldNotBeNull);
+
+ LoadP(holder_reg, FieldMemOperand(holder_reg, HeapObject::kMapOffset));
+ LoadRoot(ip, Heap::kNativeContextMapRootIndex);
+ cmp(holder_reg, ip);
+ Check(eq, kJSGlobalObjectNativeContextShouldBeANativeContext);
+ // Restore ip is not needed. ip is reloaded below.
+ pop(holder_reg); // Restore holder.
+ // Restore ip to holder's context.
+ LoadP(ip, FieldMemOperand(holder_reg, JSGlobalProxy::kNativeContextOffset));
+ }
+
+ // Check that the security token in the calling global object is
+ // compatible with the security token in the receiving global
+ // object.
+ int token_offset =
+ Context::kHeaderSize + Context::SECURITY_TOKEN_INDEX * kPointerSize;
+
+ LoadP(scratch, FieldMemOperand(scratch, token_offset));
+ LoadP(ip, FieldMemOperand(ip, token_offset));
+ cmp(scratch, ip);
+ bne(miss);
+
+ bind(&same_contexts);
+}
+
+
+// Compute the hash code from the untagged key. This must be kept in sync with
+// ComputeIntegerHash in utils.h and KeyedLoadGenericStub in
+// code-stub-hydrogen.cc
+void MacroAssembler::GetNumberHash(Register t0, Register scratch) {
+ // First of all we assign the hash seed to scratch.
+ LoadRoot(scratch, Heap::kHashSeedRootIndex);
+ SmiUntag(scratch);
+
+ // Xor original key with a seed.
+ xor_(t0, t0, scratch);
+
+ // Compute the hash code from the untagged key. This must be kept in sync
+ // with ComputeIntegerHash in utils.h.
+ //
+ // hash = ~hash + (hash << 15);
+ notx(scratch, t0);
+ slwi(t0, t0, Operand(15));
+ add(t0, scratch, t0);
+ // hash = hash ^ (hash >> 12);
+ srwi(scratch, t0, Operand(12));
+ xor_(t0, t0, scratch);
+ // hash = hash + (hash << 2);
+ slwi(scratch, t0, Operand(2));
+ add(t0, t0, scratch);
+ // hash = hash ^ (hash >> 4);
+ srwi(scratch, t0, Operand(4));
+ xor_(t0, t0, scratch);
+ // hash = hash * 2057;
+ mr(r0, t0);
+ slwi(scratch, t0, Operand(3));
+ add(t0, t0, scratch);
+ slwi(scratch, r0, Operand(11));
+ add(t0, t0, scratch);
+ // hash = hash ^ (hash >> 16);
+ srwi(scratch, t0, Operand(16));
+ xor_(t0, t0, scratch);
+}
+
+
+void MacroAssembler::LoadFromNumberDictionary(Label* miss, Register elements,
+ Register key, Register result,
+ Register t0, Register t1,
+ Register t2) {
+ // Register use:
+ //
+ // elements - holds the slow-case elements of the receiver on entry.
+ // Unchanged unless 'result' is the same register.
+ //
+ // key - holds the smi key on entry.
+ // Unchanged unless 'result' is the same register.
+ //
+ // result - holds the result on exit if the load succeeded.
+ // Allowed to be the same as 'key' or 'result'.
+ // Unchanged on bailout so 'key' or 'result' can be used
+ // in further computation.
+ //
+ // Scratch registers:
+ //
+ // t0 - holds the untagged key on entry and holds the hash once computed.
+ //
+ // t1 - used to hold the capacity mask of the dictionary
+ //
+ // t2 - used for the index into the dictionary.
+ Label done;
+
+ GetNumberHash(t0, t1);
+
+ // Compute the capacity mask.
+ LoadP(t1, FieldMemOperand(elements, SeededNumberDictionary::kCapacityOffset));
+ SmiUntag(t1);
+ subi(t1, t1, Operand(1));
+
+ // Generate an unrolled loop that performs a few probes before giving up.
+ for (int i = 0; i < kNumberDictionaryProbes; i++) {
+ // Use t2 for index calculations and keep the hash intact in t0.
+ mr(t2, t0);
+ // Compute the masked index: (hash + i + i * i) & mask.
+ if (i > 0) {
+ addi(t2, t2, Operand(SeededNumberDictionary::GetProbeOffset(i)));
+ }
+ and_(t2, t2, t1);
+
+ // Scale the index by multiplying by the element size.
+ DCHECK(SeededNumberDictionary::kEntrySize == 3);
+ slwi(ip, t2, Operand(1));
+ add(t2, t2, ip); // t2 = t2 * 3
+
+ // Check if the key is identical to the name.
+ slwi(t2, t2, Operand(kPointerSizeLog2));
+ add(t2, elements, t2);
+ LoadP(ip,
+ FieldMemOperand(t2, SeededNumberDictionary::kElementsStartOffset));
+ cmp(key, ip);
+ if (i != kNumberDictionaryProbes - 1) {
+ beq(&done);
+ } else {
+ bne(miss);
+ }
+ }
+
+ bind(&done);
+ // Check that the value is a normal property.
+ // t2: elements + (index * kPointerSize)
+ const int kDetailsOffset =
+ SeededNumberDictionary::kElementsStartOffset + 2 * kPointerSize;
+ LoadP(t1, FieldMemOperand(t2, kDetailsOffset));
+ LoadSmiLiteral(ip, Smi::FromInt(PropertyDetails::TypeField::kMask));
+ and_(r0, t1, ip, SetRC);
+ bne(miss, cr0);
+
+ // Get the value at the masked, scaled index and return.
+ const int kValueOffset =
+ SeededNumberDictionary::kElementsStartOffset + kPointerSize;
+ LoadP(result, FieldMemOperand(t2, kValueOffset));
+}
+
+
+void MacroAssembler::Allocate(int object_size, Register result,
+ Register scratch1, Register scratch2,
+ Label* gc_required, AllocationFlags flags) {
+ DCHECK(object_size <= Page::kMaxRegularHeapObjectSize);
+ if (!FLAG_inline_new) {
+ if (emit_debug_code()) {
+ // Trash the registers to simulate an allocation failure.
+ li(result, Operand(0x7091));
+ li(scratch1, Operand(0x7191));
+ li(scratch2, Operand(0x7291));
+ }
+ b(gc_required);
+ return;
+ }
+
+ DCHECK(!result.is(scratch1));
+ DCHECK(!result.is(scratch2));
+ DCHECK(!scratch1.is(scratch2));
+ DCHECK(!scratch1.is(ip));
+ DCHECK(!scratch2.is(ip));
+
+ // Make object size into bytes.
+ if ((flags & SIZE_IN_WORDS) != 0) {
+ object_size *= kPointerSize;
+ }
+ DCHECK_EQ(0, static_cast<int>(object_size & kObjectAlignmentMask));
+
+ // Check relative positions of allocation top and limit addresses.
+ ExternalReference allocation_top =
+ AllocationUtils::GetAllocationTopReference(isolate(), flags);
+ ExternalReference allocation_limit =
+ AllocationUtils::GetAllocationLimitReference(isolate(), flags);
+
+ intptr_t top = reinterpret_cast<intptr_t>(allocation_top.address());
+ intptr_t limit = reinterpret_cast<intptr_t>(allocation_limit.address());
+ DCHECK((limit - top) == kPointerSize);
+
+ // Set up allocation top address register.
+ Register topaddr = scratch1;
+ mov(topaddr, Operand(allocation_top));
+
+ // This code stores a temporary value in ip. This is OK, as the code below
+ // does not need ip for implicit literal generation.
+ if ((flags & RESULT_CONTAINS_TOP) == 0) {
+ // Load allocation top into result and allocation limit into ip.
+ LoadP(result, MemOperand(topaddr));
+ LoadP(ip, MemOperand(topaddr, kPointerSize));
+ } else {
+ if (emit_debug_code()) {
+ // Assert that result actually contains top on entry. ip is used
+ // immediately below so this use of ip does not cause difference with
+ // respect to register content between debug and release mode.
+ LoadP(ip, MemOperand(topaddr));
+ cmp(result, ip);
+ Check(eq, kUnexpectedAllocationTop);
+ }
+ // Load allocation limit into ip. Result already contains allocation top.
+ LoadP(ip, MemOperand(topaddr, limit - top), r0);
+ }
+
+ if ((flags & DOUBLE_ALIGNMENT) != 0) {
+ // Align the next allocation. Storing the filler map without checking top is
+ // safe in new-space because the limit of the heap is aligned there.
+ DCHECK((flags & PRETENURE_OLD_POINTER_SPACE) == 0);
+#if V8_TARGET_ARCH_PPC64
+ STATIC_ASSERT(kPointerAlignment == kDoubleAlignment);
+#else
+ STATIC_ASSERT(kPointerAlignment * 2 == kDoubleAlignment);
+ andi(scratch2, result, Operand(kDoubleAlignmentMask));
+ Label aligned;
+ beq(&aligned, cr0);
+ if ((flags & PRETENURE_OLD_DATA_SPACE) != 0) {
+ cmpl(result, ip);
+ bge(gc_required);
+ }
+ mov(scratch2, Operand(isolate()->factory()->one_pointer_filler_map()));
+ stw(scratch2, MemOperand(result));
+ addi(result, result, Operand(kDoubleSize / 2));
+ bind(&aligned);
+#endif
+ }
+
+ // Calculate new top and bail out if new space is exhausted. Use result
+ // to calculate the new top.
+ sub(r0, ip, result);
+ if (is_int16(object_size)) {
+ cmpi(r0, Operand(object_size));
+ blt(gc_required);
+ addi(scratch2, result, Operand(object_size));
+ } else {
+ Cmpi(r0, Operand(object_size), scratch2);
+ blt(gc_required);
+ add(scratch2, result, scratch2);
+ }
+ StoreP(scratch2, MemOperand(topaddr));
+
+ // Tag object if requested.
+ if ((flags & TAG_OBJECT) != 0) {
+ addi(result, result, Operand(kHeapObjectTag));
+ }
+}
+
+
+void MacroAssembler::Allocate(Register object_size, Register result,
+ Register scratch1, Register scratch2,
+ Label* gc_required, AllocationFlags flags) {
+ if (!FLAG_inline_new) {
+ if (emit_debug_code()) {
+ // Trash the registers to simulate an allocation failure.
+ li(result, Operand(0x7091));
+ li(scratch1, Operand(0x7191));
+ li(scratch2, Operand(0x7291));
+ }
+ b(gc_required);
+ return;
+ }
+
+ // Assert that the register arguments are different and that none of
+ // them are ip. ip is used explicitly in the code generated below.
+ DCHECK(!result.is(scratch1));
+ DCHECK(!result.is(scratch2));
+ DCHECK(!scratch1.is(scratch2));
+ DCHECK(!object_size.is(ip));
+ DCHECK(!result.is(ip));
+ DCHECK(!scratch1.is(ip));
+ DCHECK(!scratch2.is(ip));
+
+ // Check relative positions of allocation top and limit addresses.
+ ExternalReference allocation_top =
+ AllocationUtils::GetAllocationTopReference(isolate(), flags);
+ ExternalReference allocation_limit =
+ AllocationUtils::GetAllocationLimitReference(isolate(), flags);
+ intptr_t top = reinterpret_cast<intptr_t>(allocation_top.address());
+ intptr_t limit = reinterpret_cast<intptr_t>(allocation_limit.address());
+ DCHECK((limit - top) == kPointerSize);
+
+ // Set up allocation top address.
+ Register topaddr = scratch1;
+ mov(topaddr, Operand(allocation_top));
+
+ // This code stores a temporary value in ip. This is OK, as the code below
+ // does not need ip for implicit literal generation.
+ if ((flags & RESULT_CONTAINS_TOP) == 0) {
+ // Load allocation top into result and allocation limit into ip.
+ LoadP(result, MemOperand(topaddr));
+ LoadP(ip, MemOperand(topaddr, kPointerSize));
+ } else {
+ if (emit_debug_code()) {
+ // Assert that result actually contains top on entry. ip is used
+ // immediately below so this use of ip does not cause difference with
+ // respect to register content between debug and release mode.
+ LoadP(ip, MemOperand(topaddr));
+ cmp(result, ip);
+ Check(eq, kUnexpectedAllocationTop);
+ }
+ // Load allocation limit into ip. Result already contains allocation top.
+ LoadP(ip, MemOperand(topaddr, limit - top));
+ }
+
+ if ((flags & DOUBLE_ALIGNMENT) != 0) {
+ // Align the next allocation. Storing the filler map without checking top is
+ // safe in new-space because the limit of the heap is aligned there.
+ DCHECK((flags & PRETENURE_OLD_POINTER_SPACE) == 0);
+#if V8_TARGET_ARCH_PPC64
+ STATIC_ASSERT(kPointerAlignment == kDoubleAlignment);
+#else
+ STATIC_ASSERT(kPointerAlignment * 2 == kDoubleAlignment);
+ andi(scratch2, result, Operand(kDoubleAlignmentMask));
+ Label aligned;
+ beq(&aligned, cr0);
+ if ((flags & PRETENURE_OLD_DATA_SPACE) != 0) {
+ cmpl(result, ip);
+ bge(gc_required);
+ }
+ mov(scratch2, Operand(isolate()->factory()->one_pointer_filler_map()));
+ stw(scratch2, MemOperand(result));
+ addi(result, result, Operand(kDoubleSize / 2));
+ bind(&aligned);
+#endif
+ }
+
+ // Calculate new top and bail out if new space is exhausted. Use result
+ // to calculate the new top. Object size may be in words so a shift is
+ // required to get the number of bytes.
+ sub(r0, ip, result);
+ if ((flags & SIZE_IN_WORDS) != 0) {
+ ShiftLeftImm(scratch2, object_size, Operand(kPointerSizeLog2));
+ cmp(r0, scratch2);
+ blt(gc_required);
+ add(scratch2, result, scratch2);
+ } else {
+ cmp(r0, object_size);
+ blt(gc_required);
+ add(scratch2, result, object_size);
+ }
+
+ // Update allocation top. result temporarily holds the new top.
+ if (emit_debug_code()) {
+ andi(r0, scratch2, Operand(kObjectAlignmentMask));
+ Check(eq, kUnalignedAllocationInNewSpace, cr0);
+ }
+ StoreP(scratch2, MemOperand(topaddr));
+
+ // Tag object if requested.
+ if ((flags & TAG_OBJECT) != 0) {
+ addi(result, result, Operand(kHeapObjectTag));
+ }
+}
+
+
+void MacroAssembler::UndoAllocationInNewSpace(Register object,
+ Register scratch) {
+ ExternalReference new_space_allocation_top =
+ ExternalReference::new_space_allocation_top_address(isolate());
+
+ // Make sure the object has no tag before resetting top.
+ mov(r0, Operand(~kHeapObjectTagMask));
+ and_(object, object, r0);
+// was.. and_(object, object, Operand(~kHeapObjectTagMask));
+#ifdef DEBUG
+ // Check that the object un-allocated is below the current top.
+ mov(scratch, Operand(new_space_allocation_top));
+ LoadP(scratch, MemOperand(scratch));
+ cmp(object, scratch);
+ Check(lt, kUndoAllocationOfNonAllocatedMemory);
+#endif
+ // Write the address of the object to un-allocate as the current top.
+ mov(scratch, Operand(new_space_allocation_top));
+ StoreP(object, MemOperand(scratch));
+}
+
+
+void MacroAssembler::AllocateTwoByteString(Register result, Register length,
+ Register scratch1, Register scratch2,
+ Register scratch3,
+ Label* gc_required) {
+ // Calculate the number of bytes needed for the characters in the string while
+ // observing object alignment.
+ DCHECK((SeqTwoByteString::kHeaderSize & kObjectAlignmentMask) == 0);
+ slwi(scratch1, length, Operand(1)); // Length in bytes, not chars.
+ addi(scratch1, scratch1,
+ Operand(kObjectAlignmentMask + SeqTwoByteString::kHeaderSize));
+ mov(r0, Operand(~kObjectAlignmentMask));
+ and_(scratch1, scratch1, r0);
+
+ // Allocate two-byte string in new space.
+ Allocate(scratch1, result, scratch2, scratch3, gc_required, TAG_OBJECT);
+
+ // Set the map, length and hash field.
+ InitializeNewString(result, length, Heap::kStringMapRootIndex, scratch1,
+ scratch2);
+}
+
+
+void MacroAssembler::AllocateOneByteString(Register result, Register length,
+ Register scratch1, Register scratch2,
+ Register scratch3,
+ Label* gc_required) {
+ // Calculate the number of bytes needed for the characters in the string while
+ // observing object alignment.
+ DCHECK((SeqOneByteString::kHeaderSize & kObjectAlignmentMask) == 0);
+ DCHECK(kCharSize == 1);
+ addi(scratch1, length,
+ Operand(kObjectAlignmentMask + SeqOneByteString::kHeaderSize));
+ li(r0, Operand(~kObjectAlignmentMask));
+ and_(scratch1, scratch1, r0);
+
+ // Allocate one-byte string in new space.
+ Allocate(scratch1, result, scratch2, scratch3, gc_required, TAG_OBJECT);
+
+ // Set the map, length and hash field.
+ InitializeNewString(result, length, Heap::kOneByteStringMapRootIndex,
+ scratch1, scratch2);
+}
+
+
+void MacroAssembler::AllocateTwoByteConsString(Register result, Register length,
+ Register scratch1,
+ Register scratch2,
+ Label* gc_required) {
+ Allocate(ConsString::kSize, result, scratch1, scratch2, gc_required,
+ TAG_OBJECT);
+
+ InitializeNewString(result, length, Heap::kConsStringMapRootIndex, scratch1,
+ scratch2);
+}
+
+
+void MacroAssembler::AllocateOneByteConsString(Register result, Register length,
+ Register scratch1,
+ Register scratch2,
+ Label* gc_required) {
+ Allocate(ConsString::kSize, result, scratch1, scratch2, gc_required,
+ TAG_OBJECT);
+
+ InitializeNewString(result, length, Heap::kConsOneByteStringMapRootIndex,
+ scratch1, scratch2);
+}
+
+
+void MacroAssembler::AllocateTwoByteSlicedString(Register result,
+ Register length,
+ Register scratch1,
+ Register scratch2,
+ Label* gc_required) {
+ Allocate(SlicedString::kSize, result, scratch1, scratch2, gc_required,
+ TAG_OBJECT);
+
+ InitializeNewString(result, length, Heap::kSlicedStringMapRootIndex, scratch1,
+ scratch2);
+}
+
+
+void MacroAssembler::AllocateOneByteSlicedString(Register result,
+ Register length,
+ Register scratch1,
+ Register scratch2,
+ Label* gc_required) {
+ Allocate(SlicedString::kSize, result, scratch1, scratch2, gc_required,
+ TAG_OBJECT);
+
+ InitializeNewString(result, length, Heap::kSlicedOneByteStringMapRootIndex,
+ scratch1, scratch2);
+}
+
+
+void MacroAssembler::CompareObjectType(Register object, Register map,
+ Register type_reg, InstanceType type) {
+ const Register temp = type_reg.is(no_reg) ? r0 : type_reg;
+
+ LoadP(map, FieldMemOperand(object, HeapObject::kMapOffset));
+ CompareInstanceType(map, temp, type);
+}
+
+
+void MacroAssembler::CheckObjectTypeRange(Register object, Register map,
+ InstanceType min_type,
+ InstanceType max_type,
+ Label* false_label) {
+ STATIC_ASSERT(Map::kInstanceTypeOffset < 4096);
+ STATIC_ASSERT(LAST_TYPE < 256);
+ LoadP(map, FieldMemOperand(object, HeapObject::kMapOffset));
+ lbz(ip, FieldMemOperand(map, Map::kInstanceTypeOffset));
+ subi(ip, ip, Operand(min_type));
+ cmpli(ip, Operand(max_type - min_type));
+ bgt(false_label);
+}
+
+
+void MacroAssembler::CompareInstanceType(Register map, Register type_reg,
+ InstanceType type) {
+ STATIC_ASSERT(Map::kInstanceTypeOffset < 4096);
+ STATIC_ASSERT(LAST_TYPE < 256);
+ lbz(type_reg, FieldMemOperand(map, Map::kInstanceTypeOffset));
+ cmpi(type_reg, Operand(type));
+}
+
+
+void MacroAssembler::CompareRoot(Register obj, Heap::RootListIndex index) {
+ DCHECK(!obj.is(r0));
+ LoadRoot(r0, index);
+ cmp(obj, r0);
+}
+
+
+void MacroAssembler::CheckFastElements(Register map, Register scratch,
+ Label* fail) {
+ STATIC_ASSERT(FAST_SMI_ELEMENTS == 0);
+ STATIC_ASSERT(FAST_HOLEY_SMI_ELEMENTS == 1);
+ STATIC_ASSERT(FAST_ELEMENTS == 2);
+ STATIC_ASSERT(FAST_HOLEY_ELEMENTS == 3);
+ lbz(scratch, FieldMemOperand(map, Map::kBitField2Offset));
+ STATIC_ASSERT(Map::kMaximumBitField2FastHoleyElementValue < 0x8000);
+ cmpli(scratch, Operand(Map::kMaximumBitField2FastHoleyElementValue));
+ bgt(fail);
+}
+
+
+void MacroAssembler::CheckFastObjectElements(Register map, Register scratch,
+ Label* fail) {
+ STATIC_ASSERT(FAST_SMI_ELEMENTS == 0);
+ STATIC_ASSERT(FAST_HOLEY_SMI_ELEMENTS == 1);
+ STATIC_ASSERT(FAST_ELEMENTS == 2);
+ STATIC_ASSERT(FAST_HOLEY_ELEMENTS == 3);
+ lbz(scratch, FieldMemOperand(map, Map::kBitField2Offset));
+ cmpli(scratch, Operand(Map::kMaximumBitField2FastHoleySmiElementValue));
+ ble(fail);
+ cmpli(scratch, Operand(Map::kMaximumBitField2FastHoleyElementValue));
+ bgt(fail);
+}
+
+
+void MacroAssembler::CheckFastSmiElements(Register map, Register scratch,
+ Label* fail) {
+ STATIC_ASSERT(FAST_SMI_ELEMENTS == 0);
+ STATIC_ASSERT(FAST_HOLEY_SMI_ELEMENTS == 1);
+ lbz(scratch, FieldMemOperand(map, Map::kBitField2Offset));
+ cmpli(scratch, Operand(Map::kMaximumBitField2FastHoleySmiElementValue));
+ bgt(fail);
+}
+
+
+void MacroAssembler::StoreNumberToDoubleElements(
+ Register value_reg, Register key_reg, Register elements_reg,
+ Register scratch1, DoubleRegister double_scratch, Label* fail,
+ int elements_offset) {
+ Label smi_value, store;
+
+ // Handle smi values specially.
+ JumpIfSmi(value_reg, &smi_value);
+
+ // Ensure that the object is a heap number
+ CheckMap(value_reg, scratch1, isolate()->factory()->heap_number_map(), fail,
+ DONT_DO_SMI_CHECK);
+
+ lfd(double_scratch, FieldMemOperand(value_reg, HeapNumber::kValueOffset));
+ // Force a canonical NaN.
+ CanonicalizeNaN(double_scratch);
+ b(&store);
+
+ bind(&smi_value);
+ SmiToDouble(double_scratch, value_reg);
+
+ bind(&store);
+ SmiToDoubleArrayOffset(scratch1, key_reg);
+ add(scratch1, elements_reg, scratch1);
+ stfd(double_scratch, FieldMemOperand(scratch1, FixedDoubleArray::kHeaderSize -
+ elements_offset));
+}
+
+
+void MacroAssembler::AddAndCheckForOverflow(Register dst, Register left,
+ Register right,
+ Register overflow_dst,
+ Register scratch) {
+ DCHECK(!dst.is(overflow_dst));
+ DCHECK(!dst.is(scratch));
+ DCHECK(!overflow_dst.is(scratch));
+ DCHECK(!overflow_dst.is(left));
+ DCHECK(!overflow_dst.is(right));
+
+ // C = A+B; C overflows if A/B have same sign and C has diff sign than A
+ if (dst.is(left)) {
+ mr(scratch, left); // Preserve left.
+ add(dst, left, right); // Left is overwritten.
+ xor_(scratch, dst, scratch); // Original left.
+ xor_(overflow_dst, dst, right);
+ } else if (dst.is(right)) {
+ mr(scratch, right); // Preserve right.
+ add(dst, left, right); // Right is overwritten.
+ xor_(scratch, dst, scratch); // Original right.
+ xor_(overflow_dst, dst, left);
+ } else {
+ add(dst, left, right);
+ xor_(overflow_dst, dst, left);
+ xor_(scratch, dst, right);
+ }
+ and_(overflow_dst, scratch, overflow_dst, SetRC);
+}
+
+
+void MacroAssembler::AddAndCheckForOverflow(Register dst, Register left,
+ intptr_t right,
+ Register overflow_dst,
+ Register scratch) {
+ Register original_left = left;
+ DCHECK(!dst.is(overflow_dst));
+ DCHECK(!dst.is(scratch));
+ DCHECK(!overflow_dst.is(scratch));
+ DCHECK(!overflow_dst.is(left));
+
+ // C = A+B; C overflows if A/B have same sign and C has diff sign than A
+ if (dst.is(left)) {
+ // Preserve left.
+ original_left = overflow_dst;
+ mr(original_left, left);
+ }
+ Add(dst, left, right, scratch);
+ xor_(overflow_dst, dst, original_left);
+ if (right >= 0) {
+ and_(overflow_dst, overflow_dst, dst, SetRC);
+ } else {
+ andc(overflow_dst, overflow_dst, dst, SetRC);
+ }
+}
+
+
+void MacroAssembler::SubAndCheckForOverflow(Register dst, Register left,
+ Register right,
+ Register overflow_dst,
+ Register scratch) {
+ DCHECK(!dst.is(overflow_dst));
+ DCHECK(!dst.is(scratch));
+ DCHECK(!overflow_dst.is(scratch));
+ DCHECK(!overflow_dst.is(left));
+ DCHECK(!overflow_dst.is(right));
+
+ // C = A-B; C overflows if A/B have diff signs and C has diff sign than A
+ if (dst.is(left)) {
+ mr(scratch, left); // Preserve left.
+ sub(dst, left, right); // Left is overwritten.
+ xor_(overflow_dst, dst, scratch);
+ xor_(scratch, scratch, right);
+ and_(overflow_dst, overflow_dst, scratch, SetRC);
+ } else if (dst.is(right)) {
+ mr(scratch, right); // Preserve right.
+ sub(dst, left, right); // Right is overwritten.
+ xor_(overflow_dst, dst, left);
+ xor_(scratch, left, scratch);
+ and_(overflow_dst, overflow_dst, scratch, SetRC);
+ } else {
+ sub(dst, left, right);
+ xor_(overflow_dst, dst, left);
+ xor_(scratch, left, right);
+ and_(overflow_dst, scratch, overflow_dst, SetRC);
+ }
+}
+
+
+void MacroAssembler::CompareMap(Register obj, Register scratch, Handle<Map> map,
+ Label* early_success) {
+ LoadP(scratch, FieldMemOperand(obj, HeapObject::kMapOffset));
+ CompareMap(scratch, map, early_success);
+}
+
+
+void MacroAssembler::CompareMap(Register obj_map, Handle<Map> map,
+ Label* early_success) {
+ mov(r0, Operand(map));
+ cmp(obj_map, r0);
+}
+
+
+void MacroAssembler::CheckMap(Register obj, Register scratch, Handle<Map> map,
+ Label* fail, SmiCheckType smi_check_type) {
+ if (smi_check_type == DO_SMI_CHECK) {
+ JumpIfSmi(obj, fail);
+ }
+
+ Label success;
+ CompareMap(obj, scratch, map, &success);
+ bne(fail);
+ bind(&success);
+}
+
+
+void MacroAssembler::CheckMap(Register obj, Register scratch,
+ Heap::RootListIndex index, Label* fail,
+ SmiCheckType smi_check_type) {
+ if (smi_check_type == DO_SMI_CHECK) {
+ JumpIfSmi(obj, fail);
+ }
+ LoadP(scratch, FieldMemOperand(obj, HeapObject::kMapOffset));
+ LoadRoot(r0, index);
+ cmp(scratch, r0);
+ bne(fail);
+}
+
+
+void MacroAssembler::DispatchMap(Register obj, Register scratch,
+ Handle<Map> map, Handle<Code> success,
+ SmiCheckType smi_check_type) {
+ Label fail;
+ if (smi_check_type == DO_SMI_CHECK) {
+ JumpIfSmi(obj, &fail);
+ }
+ LoadP(scratch, FieldMemOperand(obj, HeapObject::kMapOffset));
+ mov(r0, Operand(map));
+ cmp(scratch, r0);
+ bne(&fail);
+ Jump(success, RelocInfo::CODE_TARGET, al);
+ bind(&fail);
+}
+
+
+void MacroAssembler::TryGetFunctionPrototype(Register function, Register result,
+ Register scratch, Label* miss,
+ bool miss_on_bound_function) {
+ Label non_instance;
+ if (miss_on_bound_function) {
+ // Check that the receiver isn't a smi.
+ JumpIfSmi(function, miss);
+
+ // Check that the function really is a function. Load map into result reg.
+ CompareObjectType(function, result, scratch, JS_FUNCTION_TYPE);
+ bne(miss);
+
+ LoadP(scratch,
+ FieldMemOperand(function, JSFunction::kSharedFunctionInfoOffset));
+ lwz(scratch,
+ FieldMemOperand(scratch, SharedFunctionInfo::kCompilerHintsOffset));
+ TestBit(scratch,
+#if V8_TARGET_ARCH_PPC64
+ SharedFunctionInfo::kBoundFunction,
+#else
+ SharedFunctionInfo::kBoundFunction + kSmiTagSize,
+#endif
+ r0);
+ bne(miss, cr0);
+
+ // Make sure that the function has an instance prototype.
+ lbz(scratch, FieldMemOperand(result, Map::kBitFieldOffset));
+ andi(r0, scratch, Operand(1 << Map::kHasNonInstancePrototype));
+ bne(&non_instance, cr0);
+ }
+
+ // Get the prototype or initial map from the function.
+ LoadP(result,
+ FieldMemOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
+
+ // If the prototype or initial map is the hole, don't return it and
+ // simply miss the cache instead. This will allow us to allocate a
+ // prototype object on-demand in the runtime system.
+ LoadRoot(r0, Heap::kTheHoleValueRootIndex);
+ cmp(result, r0);
+ beq(miss);
+
+ // If the function does not have an initial map, we're done.
+ Label done;
+ CompareObjectType(result, scratch, scratch, MAP_TYPE);
+ bne(&done);
+
+ // Get the prototype from the initial map.
+ LoadP(result, FieldMemOperand(result, Map::kPrototypeOffset));
+
+ if (miss_on_bound_function) {
+ b(&done);
+
+ // Non-instance prototype: Fetch prototype from constructor field
+ // in initial map.
+ bind(&non_instance);
+ LoadP(result, FieldMemOperand(result, Map::kConstructorOffset));
+ }
+
+ // All done.
+ bind(&done);
+}
+
+
+void MacroAssembler::CallStub(CodeStub* stub, TypeFeedbackId ast_id,
+ Condition cond) {
+ DCHECK(AllowThisStubCall(stub)); // Stub calls are not allowed in some stubs.
+ Call(stub->GetCode(), RelocInfo::CODE_TARGET, ast_id, cond);
+}
+
+
+void MacroAssembler::TailCallStub(CodeStub* stub, Condition cond) {
+ Jump(stub->GetCode(), RelocInfo::CODE_TARGET, cond);
+}
+
+
+static int AddressOffset(ExternalReference ref0, ExternalReference ref1) {
+ return ref0.address() - ref1.address();
+}
+
+
+void MacroAssembler::CallApiFunctionAndReturn(
+ Register function_address, ExternalReference thunk_ref, int stack_space,
+ MemOperand return_value_operand, MemOperand* context_restore_operand) {
+ ExternalReference next_address =
+ ExternalReference::handle_scope_next_address(isolate());
+ const int kNextOffset = 0;
+ const int kLimitOffset = AddressOffset(
+ ExternalReference::handle_scope_limit_address(isolate()), next_address);
+ const int kLevelOffset = AddressOffset(
+ ExternalReference::handle_scope_level_address(isolate()), next_address);
+
+ DCHECK(function_address.is(r4) || function_address.is(r5));
+ Register scratch = r6;
+
+ Label profiler_disabled;
+ Label end_profiler_check;
+ mov(scratch, Operand(ExternalReference::is_profiling_address(isolate())));
+ lbz(scratch, MemOperand(scratch, 0));
+ cmpi(scratch, Operand::Zero());
+ beq(&profiler_disabled);
+
+ // Additional parameter is the address of the actual callback.
+ mov(scratch, Operand(thunk_ref));
+ jmp(&end_profiler_check);
+
+ bind(&profiler_disabled);
+ mr(scratch, function_address);
+ bind(&end_profiler_check);
+
+ // Allocate HandleScope in callee-save registers.
+ // r17 - next_address
+ // r14 - next_address->kNextOffset
+ // r15 - next_address->kLimitOffset
+ // r16 - next_address->kLevelOffset
+ mov(r17, Operand(next_address));
+ LoadP(r14, MemOperand(r17, kNextOffset));
+ LoadP(r15, MemOperand(r17, kLimitOffset));
+ lwz(r16, MemOperand(r17, kLevelOffset));
+ addi(r16, r16, Operand(1));
+ stw(r16, MemOperand(r17, kLevelOffset));
+
+ if (FLAG_log_timer_events) {
+ FrameScope frame(this, StackFrame::MANUAL);
+ PushSafepointRegisters();
+ PrepareCallCFunction(1, r3);
+ mov(r3, Operand(ExternalReference::isolate_address(isolate())));
+ CallCFunction(ExternalReference::log_enter_external_function(isolate()), 1);
+ PopSafepointRegisters();
+ }
+
+ // Native call returns to the DirectCEntry stub which redirects to the
+ // return address pushed on stack (could have moved after GC).
+ // DirectCEntry stub itself is generated early and never moves.
+ DirectCEntryStub stub(isolate());
+ stub.GenerateCall(this, scratch);
+
+ if (FLAG_log_timer_events) {
+ FrameScope frame(this, StackFrame::MANUAL);
+ PushSafepointRegisters();
+ PrepareCallCFunction(1, r3);
+ mov(r3, Operand(ExternalReference::isolate_address(isolate())));
+ CallCFunction(ExternalReference::log_leave_external_function(isolate()), 1);
+ PopSafepointRegisters();
+ }
+
+ Label promote_scheduled_exception;
+ Label exception_handled;
+ Label delete_allocated_handles;
+ Label leave_exit_frame;
+ Label return_value_loaded;
+
+ // load value from ReturnValue
+ LoadP(r3, return_value_operand);
+ bind(&return_value_loaded);
+ // No more valid handles (the result handle was the last one). Restore
+ // previous handle scope.
+ StoreP(r14, MemOperand(r17, kNextOffset));
+ if (emit_debug_code()) {
+ lwz(r4, MemOperand(r17, kLevelOffset));
+ cmp(r4, r16);
+ Check(eq, kUnexpectedLevelAfterReturnFromApiCall);
+ }
+ subi(r16, r16, Operand(1));
+ stw(r16, MemOperand(r17, kLevelOffset));
+ LoadP(r0, MemOperand(r17, kLimitOffset));
+ cmp(r15, r0);
+ bne(&delete_allocated_handles);
+
+ // Check if the function scheduled an exception.
+ bind(&leave_exit_frame);
+ LoadRoot(r14, Heap::kTheHoleValueRootIndex);
+ mov(r15, Operand(ExternalReference::scheduled_exception_address(isolate())));
+ LoadP(r15, MemOperand(r15));
+ cmp(r14, r15);
+ bne(&promote_scheduled_exception);
+ bind(&exception_handled);
+
+ bool restore_context = context_restore_operand != NULL;
+ if (restore_context) {
+ LoadP(cp, *context_restore_operand);
+ }
+ // LeaveExitFrame expects unwind space to be in a register.
+ mov(r14, Operand(stack_space));
+ LeaveExitFrame(false, r14, !restore_context);
+ blr();
+
+ bind(&promote_scheduled_exception);
+ {
+ FrameScope frame(this, StackFrame::INTERNAL);
+ CallExternalReference(
+ ExternalReference(Runtime::kPromoteScheduledException, isolate()), 0);
+ }
+ jmp(&exception_handled);
+
+ // HandleScope limit has changed. Delete allocated extensions.
+ bind(&delete_allocated_handles);
+ StoreP(r15, MemOperand(r17, kLimitOffset));
+ mr(r14, r3);
+ PrepareCallCFunction(1, r15);
+ mov(r3, Operand(ExternalReference::isolate_address(isolate())));
+ CallCFunction(ExternalReference::delete_handle_scope_extensions(isolate()),
+ 1);
+ mr(r3, r14);
+ b(&leave_exit_frame);
+}
+
+
+bool MacroAssembler::AllowThisStubCall(CodeStub* stub) {
+ return has_frame_ || !stub->SometimesSetsUpAFrame();
+}
+
+
+void MacroAssembler::IndexFromHash(Register hash, Register index) {
+ // If the hash field contains an array index pick it out. The assert checks
+ // that the constants for the maximum number of digits for an array index
+ // cached in the hash field and the number of bits reserved for it does not
+ // conflict.
+ DCHECK(TenToThe(String::kMaxCachedArrayIndexLength) <
+ (1 << String::kArrayIndexValueBits));
+ DecodeFieldToSmi<String::ArrayIndexValueBits>(index, hash);
+}
+
+
+void MacroAssembler::SmiToDouble(DoubleRegister value, Register smi) {
+ SmiUntag(ip, smi);
+ ConvertIntToDouble(ip, value);
+}
+
+
+void MacroAssembler::TestDoubleIsInt32(DoubleRegister double_input,
+ Register scratch1, Register scratch2,
+ DoubleRegister double_scratch) {
+ TryDoubleToInt32Exact(scratch1, double_input, scratch2, double_scratch);
+}
+
+
+void MacroAssembler::TryDoubleToInt32Exact(Register result,
+ DoubleRegister double_input,
+ Register scratch,
+ DoubleRegister double_scratch) {
+ Label done;
+ DCHECK(!double_input.is(double_scratch));
+
+ ConvertDoubleToInt64(double_input,
+#if !V8_TARGET_ARCH_PPC64
+ scratch,
+#endif
+ result, double_scratch);
+
+#if V8_TARGET_ARCH_PPC64
+ TestIfInt32(result, scratch, r0);
+#else
+ TestIfInt32(scratch, result, r0);
+#endif
+ bne(&done);
+
+ // convert back and compare
+ fcfid(double_scratch, double_scratch);
+ fcmpu(double_scratch, double_input);
+ bind(&done);
+}
+
+
+void MacroAssembler::TryInt32Floor(Register result, DoubleRegister double_input,
+ Register input_high, Register scratch,
+ DoubleRegister double_scratch, Label* done,
+ Label* exact) {
+ DCHECK(!result.is(input_high));
+ DCHECK(!double_input.is(double_scratch));
+ Label exception;
+
+ MovDoubleHighToInt(input_high, double_input);
+
+ // Test for NaN/Inf
+ ExtractBitMask(result, input_high, HeapNumber::kExponentMask);
+ cmpli(result, Operand(0x7ff));
+ beq(&exception);
+
+ // Convert (rounding to -Inf)
+ ConvertDoubleToInt64(double_input,
+#if !V8_TARGET_ARCH_PPC64
+ scratch,
+#endif
+ result, double_scratch, kRoundToMinusInf);
+
+// Test for overflow
+#if V8_TARGET_ARCH_PPC64
+ TestIfInt32(result, scratch, r0);
+#else
+ TestIfInt32(scratch, result, r0);
+#endif
+ bne(&exception);
+
+ // Test for exactness
+ fcfid(double_scratch, double_scratch);
+ fcmpu(double_scratch, double_input);
+ beq(exact);
+ b(done);
+
+ bind(&exception);
+}
+
+
+void MacroAssembler::TryInlineTruncateDoubleToI(Register result,
+ DoubleRegister double_input,
+ Label* done) {
+ DoubleRegister double_scratch = kScratchDoubleReg;
+ Register scratch = ip;
+
+ ConvertDoubleToInt64(double_input,
+#if !V8_TARGET_ARCH_PPC64
+ scratch,
+#endif
+ result, double_scratch);
+
+// Test for overflow
+#if V8_TARGET_ARCH_PPC64
+ TestIfInt32(result, scratch, r0);
+#else
+ TestIfInt32(scratch, result, r0);
+#endif
+ beq(done);
+}
+
+
+void MacroAssembler::TruncateDoubleToI(Register result,
+ DoubleRegister double_input) {
+ Label done;
+
+ TryInlineTruncateDoubleToI(result, double_input, &done);
+
+ // If we fell through then inline version didn't succeed - call stub instead.
+ mflr(r0);
+ push(r0);
+ // Put input on stack.
+ stfdu(double_input, MemOperand(sp, -kDoubleSize));
+
+ DoubleToIStub stub(isolate(), sp, result, 0, true, true);
+ CallStub(&stub);
+
+ addi(sp, sp, Operand(kDoubleSize));
+ pop(r0);
+ mtlr(r0);
+
+ bind(&done);
+}
+
+
+void MacroAssembler::TruncateHeapNumberToI(Register result, Register object) {
+ Label done;
+ DoubleRegister double_scratch = kScratchDoubleReg;
+ DCHECK(!result.is(object));
+
+ lfd(double_scratch, FieldMemOperand(object, HeapNumber::kValueOffset));
+ TryInlineTruncateDoubleToI(result, double_scratch, &done);
+
+ // If we fell through then inline version didn't succeed - call stub instead.
+ mflr(r0);
+ push(r0);
+ DoubleToIStub stub(isolate(), object, result,
+ HeapNumber::kValueOffset - kHeapObjectTag, true, true);
+ CallStub(&stub);
+ pop(r0);
+ mtlr(r0);
+
+ bind(&done);
+}
+
+
+void MacroAssembler::TruncateNumberToI(Register object, Register result,
+ Register heap_number_map,
+ Register scratch1, Label* not_number) {
+ Label done;
+ DCHECK(!result.is(object));
+
+ UntagAndJumpIfSmi(result, object, &done);
+ JumpIfNotHeapNumber(object, heap_number_map, scratch1, not_number);
+ TruncateHeapNumberToI(result, object);
+
+ bind(&done);
+}
+
+
+void MacroAssembler::GetLeastBitsFromSmi(Register dst, Register src,
+ int num_least_bits) {
+#if V8_TARGET_ARCH_PPC64
+ rldicl(dst, src, kBitsPerPointer - kSmiShift,
+ kBitsPerPointer - num_least_bits);
+#else
+ rlwinm(dst, src, kBitsPerPointer - kSmiShift,
+ kBitsPerPointer - num_least_bits, 31);
+#endif
+}
+
+
+void MacroAssembler::GetLeastBitsFromInt32(Register dst, Register src,
+ int num_least_bits) {
+ rlwinm(dst, src, 0, 32 - num_least_bits, 31);
+}
+
+
+void MacroAssembler::CallRuntime(const Runtime::Function* f, int num_arguments,
+ SaveFPRegsMode save_doubles) {
+ // All parameters are on the stack. r3 has the return value after call.
+
+ // If the expected number of arguments of the runtime function is
+ // constant, we check that the actual number of arguments match the
+ // expectation.
+ CHECK(f->nargs < 0 || f->nargs == num_arguments);
+
+ // TODO(1236192): Most runtime routines don't need the number of
+ // arguments passed in because it is constant. At some point we
+ // should remove this need and make the runtime routine entry code
+ // smarter.
+ mov(r3, Operand(num_arguments));
+ mov(r4, Operand(ExternalReference(f, isolate())));
+ CEntryStub stub(isolate(),
+#if V8_TARGET_ARCH_PPC64
+ f->result_size,
+#else
+ 1,
+#endif
+ save_doubles);
+ CallStub(&stub);
+}
+
+
+void MacroAssembler::CallExternalReference(const ExternalReference& ext,
+ int num_arguments) {
+ mov(r3, Operand(num_arguments));
+ mov(r4, Operand(ext));
+
+ CEntryStub stub(isolate(), 1);
+ CallStub(&stub);
+}
+
+
+void MacroAssembler::TailCallExternalReference(const ExternalReference& ext,
+ int num_arguments,
+ int result_size) {
+ // TODO(1236192): Most runtime routines don't need the number of
+ // arguments passed in because it is constant. At some point we
+ // should remove this need and make the runtime routine entry code
+ // smarter.
+ mov(r3, Operand(num_arguments));
+ JumpToExternalReference(ext);
+}
+
+
+void MacroAssembler::TailCallRuntime(Runtime::FunctionId fid, int num_arguments,
+ int result_size) {
+ TailCallExternalReference(ExternalReference(fid, isolate()), num_arguments,
+ result_size);
+}
+
+
+void MacroAssembler::JumpToExternalReference(const ExternalReference& builtin) {
+ mov(r4, Operand(builtin));
+ CEntryStub stub(isolate(), 1);
+ Jump(stub.GetCode(), RelocInfo::CODE_TARGET);
+}
+
+
+void MacroAssembler::InvokeBuiltin(Builtins::JavaScript id, InvokeFlag flag,
+ const CallWrapper& call_wrapper) {
+ // You can't call a builtin without a valid frame.
+ DCHECK(flag == JUMP_FUNCTION || has_frame());
+
+ GetBuiltinEntry(ip, id);
+ if (flag == CALL_FUNCTION) {
+ call_wrapper.BeforeCall(CallSize(ip));
+ CallJSEntry(ip);
+ call_wrapper.AfterCall();
+ } else {
+ DCHECK(flag == JUMP_FUNCTION);
+ JumpToJSEntry(ip);
+ }
+}
+
+
+void MacroAssembler::GetBuiltinFunction(Register target,
+ Builtins::JavaScript id) {
+ // Load the builtins object into target register.
+ LoadP(target,
+ MemOperand(cp, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
+ LoadP(target, FieldMemOperand(target, GlobalObject::kBuiltinsOffset));
+ // Load the JavaScript builtin function from the builtins object.
+ LoadP(target,
+ FieldMemOperand(target, JSBuiltinsObject::OffsetOfFunctionWithId(id)),
+ r0);
+}
+
+
+void MacroAssembler::GetBuiltinEntry(Register target, Builtins::JavaScript id) {
+ DCHECK(!target.is(r4));
+ GetBuiltinFunction(r4, id);
+ // Load the code entry point from the builtins object.
+ LoadP(target, FieldMemOperand(r4, JSFunction::kCodeEntryOffset));
+}
+
+
+void MacroAssembler::SetCounter(StatsCounter* counter, int value,
+ Register scratch1, Register scratch2) {
+ if (FLAG_native_code_counters && counter->Enabled()) {
+ mov(scratch1, Operand(value));
+ mov(scratch2, Operand(ExternalReference(counter)));
+ stw(scratch1, MemOperand(scratch2));
+ }
+}
+
+
+void MacroAssembler::IncrementCounter(StatsCounter* counter, int value,
+ Register scratch1, Register scratch2) {
+ DCHECK(value > 0);
+ if (FLAG_native_code_counters && counter->Enabled()) {
+ mov(scratch2, Operand(ExternalReference(counter)));
+ lwz(scratch1, MemOperand(scratch2));
+ addi(scratch1, scratch1, Operand(value));
+ stw(scratch1, MemOperand(scratch2));
+ }
+}
+
+
+void MacroAssembler::DecrementCounter(StatsCounter* counter, int value,
+ Register scratch1, Register scratch2) {
+ DCHECK(value > 0);
+ if (FLAG_native_code_counters && counter->Enabled()) {
+ mov(scratch2, Operand(ExternalReference(counter)));
+ lwz(scratch1, MemOperand(scratch2));
+ subi(scratch1, scratch1, Operand(value));
+ stw(scratch1, MemOperand(scratch2));
+ }
+}
+
+
+void MacroAssembler::Assert(Condition cond, BailoutReason reason,
+ CRegister cr) {
+ if (emit_debug_code()) Check(cond, reason, cr);
+}
+
+
+void MacroAssembler::AssertFastElements(Register elements) {
+ if (emit_debug_code()) {
+ DCHECK(!elements.is(r0));
+ Label ok;
+ push(elements);
+ LoadP(elements, FieldMemOperand(elements, HeapObject::kMapOffset));
+ LoadRoot(r0, Heap::kFixedArrayMapRootIndex);
+ cmp(elements, r0);
+ beq(&ok);
+ LoadRoot(r0, Heap::kFixedDoubleArrayMapRootIndex);
+ cmp(elements, r0);
+ beq(&ok);
+ LoadRoot(r0, Heap::kFixedCOWArrayMapRootIndex);
+ cmp(elements, r0);
+ beq(&ok);
+ Abort(kJSObjectWithFastElementsMapHasSlowElements);
+ bind(&ok);
+ pop(elements);
+ }
+}
+
+
+void MacroAssembler::Check(Condition cond, BailoutReason reason, CRegister cr) {
+ Label L;
+ b(cond, &L, cr);
+ Abort(reason);
+ // will not return here
+ bind(&L);
+}
+
+
+void MacroAssembler::Abort(BailoutReason reason) {
+ Label abort_start;
+ bind(&abort_start);
+#ifdef DEBUG
+ const char* msg = GetBailoutReason(reason);
+ if (msg != NULL) {
+ RecordComment("Abort message: ");
+ RecordComment(msg);
+ }
+
+ if (FLAG_trap_on_abort) {
+ stop(msg);
+ return;
+ }
+#endif
+
+ LoadSmiLiteral(r0, Smi::FromInt(reason));
+ push(r0);
+ // Disable stub call restrictions to always allow calls to abort.
+ if (!has_frame_) {
+ // We don't actually want to generate a pile of code for this, so just
+ // claim there is a stack frame, without generating one.
+ FrameScope scope(this, StackFrame::NONE);
+ CallRuntime(Runtime::kAbort, 1);
+ } else {
+ CallRuntime(Runtime::kAbort, 1);
+ }
+ // will not return here
+}
+
+
+void MacroAssembler::LoadContext(Register dst, int context_chain_length) {
+ if (context_chain_length > 0) {
+ // Move up the chain of contexts to the context containing the slot.
+ LoadP(dst, MemOperand(cp, Context::SlotOffset(Context::PREVIOUS_INDEX)));
+ for (int i = 1; i < context_chain_length; i++) {
+ LoadP(dst, MemOperand(dst, Context::SlotOffset(Context::PREVIOUS_INDEX)));
+ }
+ } else {
+ // Slot is in the current function context. Move it into the
+ // destination register in case we store into it (the write barrier
+ // cannot be allowed to destroy the context in esi).
+ mr(dst, cp);
+ }
+}
+
+
+void MacroAssembler::LoadTransitionedArrayMapConditional(
+ ElementsKind expected_kind, ElementsKind transitioned_kind,
+ Register map_in_out, Register scratch, Label* no_map_match) {
+ // Load the global or builtins object from the current context.
+ LoadP(scratch,
+ MemOperand(cp, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
+ LoadP(scratch, FieldMemOperand(scratch, GlobalObject::kNativeContextOffset));
+
+ // Check that the function's map is the same as the expected cached map.
+ LoadP(scratch,
+ MemOperand(scratch, Context::SlotOffset(Context::JS_ARRAY_MAPS_INDEX)));
+ size_t offset = expected_kind * kPointerSize + FixedArrayBase::kHeaderSize;
+ LoadP(scratch, FieldMemOperand(scratch, offset));
+ cmp(map_in_out, scratch);
+ bne(no_map_match);
+
+ // Use the transitioned cached map.
+ offset = transitioned_kind * kPointerSize + FixedArrayBase::kHeaderSize;
+ LoadP(map_in_out, FieldMemOperand(scratch, offset));
+}
+
+
+void MacroAssembler::LoadGlobalFunction(int index, Register function) {
+ // Load the global or builtins object from the current context.
+ LoadP(function,
+ MemOperand(cp, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
+ // Load the native context from the global or builtins object.
+ LoadP(function,
+ FieldMemOperand(function, GlobalObject::kNativeContextOffset));
+ // Load the function from the native context.
+ LoadP(function, MemOperand(function, Context::SlotOffset(index)), r0);
+}
+
+
+void MacroAssembler::LoadGlobalFunctionInitialMap(Register function,
+ Register map,
+ Register scratch) {
+ // Load the initial map. The global functions all have initial maps.
+ LoadP(map,
+ FieldMemOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
+ if (emit_debug_code()) {
+ Label ok, fail;
+ CheckMap(map, scratch, Heap::kMetaMapRootIndex, &fail, DO_SMI_CHECK);
+ b(&ok);
+ bind(&fail);
+ Abort(kGlobalFunctionsMustHaveInitialMap);
+ bind(&ok);
+ }
+}
+
+
+void MacroAssembler::JumpIfNotPowerOfTwoOrZero(
+ Register reg, Register scratch, Label* not_power_of_two_or_zero) {
+ subi(scratch, reg, Operand(1));
+ cmpi(scratch, Operand::Zero());
+ blt(not_power_of_two_or_zero);
+ and_(r0, scratch, reg, SetRC);
+ bne(not_power_of_two_or_zero, cr0);
+}
+
+
+void MacroAssembler::JumpIfNotPowerOfTwoOrZeroAndNeg(Register reg,
+ Register scratch,
+ Label* zero_and_neg,
+ Label* not_power_of_two) {
+ subi(scratch, reg, Operand(1));
+ cmpi(scratch, Operand::Zero());
+ blt(zero_and_neg);
+ and_(r0, scratch, reg, SetRC);
+ bne(not_power_of_two, cr0);
+}
+
+#if !V8_TARGET_ARCH_PPC64
+void MacroAssembler::SmiTagCheckOverflow(Register reg, Register overflow) {
+ DCHECK(!reg.is(overflow));
+ mr(overflow, reg); // Save original value.
+ SmiTag(reg);
+ xor_(overflow, overflow, reg, SetRC); // Overflow if (value ^ 2 * value) < 0.
+}
+
+
+void MacroAssembler::SmiTagCheckOverflow(Register dst, Register src,
+ Register overflow) {
+ if (dst.is(src)) {
+ // Fall back to slower case.
+ SmiTagCheckOverflow(dst, overflow);
+ } else {
+ DCHECK(!dst.is(src));
+ DCHECK(!dst.is(overflow));
+ DCHECK(!src.is(overflow));
+ SmiTag(dst, src);
+ xor_(overflow, dst, src, SetRC); // Overflow if (value ^ 2 * value) < 0.
+ }
+}
+#endif
+
+void MacroAssembler::JumpIfNotBothSmi(Register reg1, Register reg2,
+ Label* on_not_both_smi) {
+ STATIC_ASSERT(kSmiTag == 0);
+ DCHECK_EQ(1, static_cast<int>(kSmiTagMask));
+ orx(r0, reg1, reg2, LeaveRC);
+ JumpIfNotSmi(r0, on_not_both_smi);
+}
+
+
+void MacroAssembler::UntagAndJumpIfSmi(Register dst, Register src,
+ Label* smi_case) {
+ STATIC_ASSERT(kSmiTag == 0);
+ STATIC_ASSERT(kSmiTagSize == 1);
+ TestBit(src, 0, r0);
+ SmiUntag(dst, src);
+ beq(smi_case, cr0);
+}
+
+
+void MacroAssembler::UntagAndJumpIfNotSmi(Register dst, Register src,
+ Label* non_smi_case) {
+ STATIC_ASSERT(kSmiTag == 0);
+ STATIC_ASSERT(kSmiTagSize == 1);
+ TestBit(src, 0, r0);
+ SmiUntag(dst, src);
+ bne(non_smi_case, cr0);
+}
+
+
+void MacroAssembler::JumpIfEitherSmi(Register reg1, Register reg2,
+ Label* on_either_smi) {
+ STATIC_ASSERT(kSmiTag == 0);
+ JumpIfSmi(reg1, on_either_smi);
+ JumpIfSmi(reg2, on_either_smi);
+}
+
+
+void MacroAssembler::AssertNotSmi(Register object) {
+ if (emit_debug_code()) {
+ STATIC_ASSERT(kSmiTag == 0);
+ TestIfSmi(object, r0);
+ Check(ne, kOperandIsASmi, cr0);
+ }
+}
+
+
+void MacroAssembler::AssertSmi(Register object) {
+ if (emit_debug_code()) {
+ STATIC_ASSERT(kSmiTag == 0);
+ TestIfSmi(object, r0);
+ Check(eq, kOperandIsNotSmi, cr0);
+ }
+}
+
+
+void MacroAssembler::AssertString(Register object) {
+ if (emit_debug_code()) {
+ STATIC_ASSERT(kSmiTag == 0);
+ TestIfSmi(object, r0);
+ Check(ne, kOperandIsASmiAndNotAString, cr0);
+ push(object);
+ LoadP(object, FieldMemOperand(object, HeapObject::kMapOffset));
+ CompareInstanceType(object, object, FIRST_NONSTRING_TYPE);
+ pop(object);
+ Check(lt, kOperandIsNotAString);
+ }
+}
+
+
+void MacroAssembler::AssertName(Register object) {
+ if (emit_debug_code()) {
+ STATIC_ASSERT(kSmiTag == 0);
+ TestIfSmi(object, r0);
+ Check(ne, kOperandIsASmiAndNotAName, cr0);
+ push(object);
+ LoadP(object, FieldMemOperand(object, HeapObject::kMapOffset));
+ CompareInstanceType(object, object, LAST_NAME_TYPE);
+ pop(object);
+ Check(le, kOperandIsNotAName);
+ }
+}
+
+
+void MacroAssembler::AssertUndefinedOrAllocationSite(Register object,
+ Register scratch) {
+ if (emit_debug_code()) {
+ Label done_checking;
+ AssertNotSmi(object);
+ CompareRoot(object, Heap::kUndefinedValueRootIndex);
+ beq(&done_checking);
+ LoadP(scratch, FieldMemOperand(object, HeapObject::kMapOffset));
+ CompareRoot(scratch, Heap::kAllocationSiteMapRootIndex);
+ Assert(eq, kExpectedUndefinedOrCell);
+ bind(&done_checking);
+ }
+}
+
+
+void MacroAssembler::AssertIsRoot(Register reg, Heap::RootListIndex index) {
+ if (emit_debug_code()) {
+ CompareRoot(reg, index);
+ Check(eq, kHeapNumberMapRegisterClobbered);
+ }
+}
+
+
+void MacroAssembler::JumpIfNotHeapNumber(Register object,
+ Register heap_number_map,
+ Register scratch,
+ Label* on_not_heap_number) {
+ LoadP(scratch, FieldMemOperand(object, HeapObject::kMapOffset));
+ AssertIsRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
+ cmp(scratch, heap_number_map);
+ bne(on_not_heap_number);
+}
+
+
+void MacroAssembler::LookupNumberStringCache(Register object, Register result,
+ Register scratch1,
+ Register scratch2,
+ Register scratch3,
+ Label* not_found) {
+ // Use of registers. Register result is used as a temporary.
+ Register number_string_cache = result;
+ Register mask = scratch3;
+
+ // Load the number string cache.
+ LoadRoot(number_string_cache, Heap::kNumberStringCacheRootIndex);
+
+ // Make the hash mask from the length of the number string cache. It
+ // contains two elements (number and string) for each cache entry.
+ LoadP(mask, FieldMemOperand(number_string_cache, FixedArray::kLengthOffset));
+ // Divide length by two (length is a smi).
+ ShiftRightArithImm(mask, mask, kSmiTagSize + kSmiShiftSize + 1);
+ subi(mask, mask, Operand(1)); // Make mask.
+
+ // Calculate the entry in the number string cache. The hash value in the
+ // number string cache for smis is just the smi value, and the hash for
+ // doubles is the xor of the upper and lower words. See
+ // Heap::GetNumberStringCache.
+ Label is_smi;
+ Label load_result_from_cache;
+ JumpIfSmi(object, &is_smi);
+ CheckMap(object, scratch1, Heap::kHeapNumberMapRootIndex, not_found,
+ DONT_DO_SMI_CHECK);
+
+ STATIC_ASSERT(8 == kDoubleSize);
+ lwz(scratch1, FieldMemOperand(object, HeapNumber::kExponentOffset));
+ lwz(scratch2, FieldMemOperand(object, HeapNumber::kMantissaOffset));
+ xor_(scratch1, scratch1, scratch2);
+ and_(scratch1, scratch1, mask);
+
+ // Calculate address of entry in string cache: each entry consists
+ // of two pointer sized fields.
+ ShiftLeftImm(scratch1, scratch1, Operand(kPointerSizeLog2 + 1));
+ add(scratch1, number_string_cache, scratch1);
+
+ Register probe = mask;
+ LoadP(probe, FieldMemOperand(scratch1, FixedArray::kHeaderSize));
+ JumpIfSmi(probe, not_found);
+ lfd(d0, FieldMemOperand(object, HeapNumber::kValueOffset));
+ lfd(d1, FieldMemOperand(probe, HeapNumber::kValueOffset));
+ fcmpu(d0, d1);
+ bne(not_found); // The cache did not contain this value.
+ b(&load_result_from_cache);
+
+ bind(&is_smi);
+ Register scratch = scratch1;
+ SmiUntag(scratch, object);
+ and_(scratch, mask, scratch);
+ // Calculate address of entry in string cache: each entry consists
+ // of two pointer sized fields.
+ ShiftLeftImm(scratch, scratch, Operand(kPointerSizeLog2 + 1));
+ add(scratch, number_string_cache, scratch);
+
+ // Check if the entry is the smi we are looking for.
+ LoadP(probe, FieldMemOperand(scratch, FixedArray::kHeaderSize));
+ cmp(object, probe);
+ bne(not_found);
+
+ // Get the result from the cache.
+ bind(&load_result_from_cache);
+ LoadP(result,
+ FieldMemOperand(scratch, FixedArray::kHeaderSize + kPointerSize));
+ IncrementCounter(isolate()->counters()->number_to_string_native(), 1,
+ scratch1, scratch2);
+}
+
+
+void MacroAssembler::JumpIfNonSmisNotBothSequentialOneByteStrings(
+ Register first, Register second, Register scratch1, Register scratch2,
+ Label* failure) {
+ // Test that both first and second are sequential one-byte strings.
+ // Assume that they are non-smis.
+ LoadP(scratch1, FieldMemOperand(first, HeapObject::kMapOffset));
+ LoadP(scratch2, FieldMemOperand(second, HeapObject::kMapOffset));
+ lbz(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset));
+ lbz(scratch2, FieldMemOperand(scratch2, Map::kInstanceTypeOffset));
+
+ JumpIfBothInstanceTypesAreNotSequentialOneByte(scratch1, scratch2, scratch1,
+ scratch2, failure);
+}
+
+void MacroAssembler::JumpIfNotBothSequentialOneByteStrings(Register first,
+ Register second,
+ Register scratch1,
+ Register scratch2,
+ Label* failure) {
+ // Check that neither is a smi.
+ and_(scratch1, first, second);
+ JumpIfSmi(scratch1, failure);
+ JumpIfNonSmisNotBothSequentialOneByteStrings(first, second, scratch1,
+ scratch2, failure);
+}
+
+
+void MacroAssembler::JumpIfNotUniqueNameInstanceType(Register reg,
+ Label* not_unique_name) {
+ STATIC_ASSERT(kInternalizedTag == 0 && kStringTag == 0);
+ Label succeed;
+ andi(r0, reg, Operand(kIsNotStringMask | kIsNotInternalizedMask));
+ beq(&succeed, cr0);
+ cmpi(reg, Operand(SYMBOL_TYPE));
+ bne(not_unique_name);
+
+ bind(&succeed);
+}
+
+
+// Allocates a heap number or jumps to the need_gc label if the young space
+// is full and a scavenge is needed.
+void MacroAssembler::AllocateHeapNumber(Register result, Register scratch1,
+ Register scratch2,
+ Register heap_number_map,
+ Label* gc_required,
+ TaggingMode tagging_mode,
+ MutableMode mode) {
+ // Allocate an object in the heap for the heap number and tag it as a heap
+ // object.
+ Allocate(HeapNumber::kSize, result, scratch1, scratch2, gc_required,
+ tagging_mode == TAG_RESULT ? TAG_OBJECT : NO_ALLOCATION_FLAGS);
+
+ Heap::RootListIndex map_index = mode == MUTABLE
+ ? Heap::kMutableHeapNumberMapRootIndex
+ : Heap::kHeapNumberMapRootIndex;
+ AssertIsRoot(heap_number_map, map_index);
+
+ // Store heap number map in the allocated object.
+ if (tagging_mode == TAG_RESULT) {
+ StoreP(heap_number_map, FieldMemOperand(result, HeapObject::kMapOffset),
+ r0);
+ } else {
+ StoreP(heap_number_map, MemOperand(result, HeapObject::kMapOffset));
+ }
+}
+
+
+void MacroAssembler::AllocateHeapNumberWithValue(
+ Register result, DoubleRegister value, Register scratch1, Register scratch2,
+ Register heap_number_map, Label* gc_required) {
+ AllocateHeapNumber(result, scratch1, scratch2, heap_number_map, gc_required);
+ stfd(value, FieldMemOperand(result, HeapNumber::kValueOffset));
+}
+
+
+// Copies a fixed number of fields of heap objects from src to dst.
+void MacroAssembler::CopyFields(Register dst, Register src, RegList temps,
+ int field_count) {
+ // At least one bit set in the first 15 registers.
+ DCHECK((temps & ((1 << 15) - 1)) != 0);
+ DCHECK((temps & dst.bit()) == 0);
+ DCHECK((temps & src.bit()) == 0);
+ // Primitive implementation using only one temporary register.
+
+ Register tmp = no_reg;
+ // Find a temp register in temps list.
+ for (int i = 0; i < 15; i++) {
+ if ((temps & (1 << i)) != 0) {
+ tmp.set_code(i);
+ break;
+ }
+ }
+ DCHECK(!tmp.is(no_reg));
+
+ for (int i = 0; i < field_count; i++) {
+ LoadP(tmp, FieldMemOperand(src, i * kPointerSize), r0);
+ StoreP(tmp, FieldMemOperand(dst, i * kPointerSize), r0);
+ }
+}
+
+
+void MacroAssembler::CopyBytes(Register src, Register dst, Register length,
+ Register scratch) {
+ Label align_loop, aligned, word_loop, byte_loop, byte_loop_1, done;
+
+ DCHECK(!scratch.is(r0));
+
+ cmpi(length, Operand::Zero());
+ beq(&done);
+
+ // Check src alignment and length to see whether word_loop is possible
+ andi(scratch, src, Operand(kPointerSize - 1));
+ beq(&aligned, cr0);
+ subfic(scratch, scratch, Operand(kPointerSize * 2));
+ cmp(length, scratch);
+ blt(&byte_loop);
+
+ // Align src before copying in word size chunks.
+ subi(scratch, scratch, Operand(kPointerSize));
+ mtctr(scratch);
+ bind(&align_loop);
+ lbz(scratch, MemOperand(src));
+ addi(src, src, Operand(1));
+ subi(length, length, Operand(1));
+ stb(scratch, MemOperand(dst));
+ addi(dst, dst, Operand(1));
+ bdnz(&align_loop);
+
+ bind(&aligned);
+
+ // Copy bytes in word size chunks.
+ if (emit_debug_code()) {
+ andi(r0, src, Operand(kPointerSize - 1));
+ Assert(eq, kExpectingAlignmentForCopyBytes, cr0);
+ }
+
+ ShiftRightImm(scratch, length, Operand(kPointerSizeLog2));
+ cmpi(scratch, Operand::Zero());
+ beq(&byte_loop);
+
+ mtctr(scratch);
+ bind(&word_loop);
+ LoadP(scratch, MemOperand(src));
+ addi(src, src, Operand(kPointerSize));
+ subi(length, length, Operand(kPointerSize));
+ if (CpuFeatures::IsSupported(UNALIGNED_ACCESSES)) {
+ // currently false for PPC - but possible future opt
+ StoreP(scratch, MemOperand(dst));
+ addi(dst, dst, Operand(kPointerSize));
+ } else {
+#if V8_TARGET_LITTLE_ENDIAN
+ stb(scratch, MemOperand(dst, 0));
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 1));
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 2));
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 3));
+#if V8_TARGET_ARCH_PPC64
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 4));
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 5));
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 6));
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 7));
+#endif
+#else
+#if V8_TARGET_ARCH_PPC64
+ stb(scratch, MemOperand(dst, 7));
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 6));
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 5));
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 4));
+ ShiftRightImm(scratch, scratch, Operand(8));
+#endif
+ stb(scratch, MemOperand(dst, 3));
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 2));
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 1));
+ ShiftRightImm(scratch, scratch, Operand(8));
+ stb(scratch, MemOperand(dst, 0));
+#endif
+ addi(dst, dst, Operand(kPointerSize));
+ }
+ bdnz(&word_loop);
+
+ // Copy the last bytes if any left.
+ cmpi(length, Operand::Zero());
+ beq(&done);
+
+ bind(&byte_loop);
+ mtctr(length);
+ bind(&byte_loop_1);
+ lbz(scratch, MemOperand(src));
+ addi(src, src, Operand(1));
+ stb(scratch, MemOperand(dst));
+ addi(dst, dst, Operand(1));
+ bdnz(&byte_loop_1);
+
+ bind(&done);
+}
+
+
+void MacroAssembler::InitializeNFieldsWithFiller(Register start_offset,
+ Register count,
+ Register filler) {
+ Label loop;
+ mtctr(count);
+ bind(&loop);
+ StoreP(filler, MemOperand(start_offset));
+ addi(start_offset, start_offset, Operand(kPointerSize));
+ bdnz(&loop);
+}
+
+void MacroAssembler::InitializeFieldsWithFiller(Register start_offset,
+ Register end_offset,
+ Register filler) {
+ Label done;
+ sub(r0, end_offset, start_offset, LeaveOE, SetRC);
+ beq(&done, cr0);
+ ShiftRightImm(r0, r0, Operand(kPointerSizeLog2));
+ InitializeNFieldsWithFiller(start_offset, r0, filler);
+ bind(&done);
+}
+
+
+void MacroAssembler::SaveFPRegs(Register location, int first, int count) {
+ DCHECK(count > 0);
+ int cur = first;
+ subi(location, location, Operand(count * kDoubleSize));
+ for (int i = 0; i < count; i++) {
+ DoubleRegister reg = DoubleRegister::from_code(cur++);
+ stfd(reg, MemOperand(location, i * kDoubleSize));
+ }
+}
+
+
+void MacroAssembler::RestoreFPRegs(Register location, int first, int count) {
+ DCHECK(count > 0);
+ int cur = first + count - 1;
+ for (int i = count - 1; i >= 0; i--) {
+ DoubleRegister reg = DoubleRegister::from_code(cur--);
+ lfd(reg, MemOperand(location, i * kDoubleSize));
+ }
+ addi(location, location, Operand(count * kDoubleSize));
+}
+
+
+void MacroAssembler::JumpIfBothInstanceTypesAreNotSequentialOneByte(
+ Register first, Register second, Register scratch1, Register scratch2,
+ Label* failure) {
+ const int kFlatOneByteStringMask =
+ kIsNotStringMask | kStringEncodingMask | kStringRepresentationMask;
+ const int kFlatOneByteStringTag =
+ kStringTag | kOneByteStringTag | kSeqStringTag;
+ andi(scratch1, first, Operand(kFlatOneByteStringMask));
+ andi(scratch2, second, Operand(kFlatOneByteStringMask));
+ cmpi(scratch1, Operand(kFlatOneByteStringTag));
+ bne(failure);
+ cmpi(scratch2, Operand(kFlatOneByteStringTag));
+ bne(failure);
+}
+
+
+void MacroAssembler::JumpIfInstanceTypeIsNotSequentialOneByte(Register type,
+ Register scratch,
+ Label* failure) {
+ const int kFlatOneByteStringMask =
+ kIsNotStringMask | kStringEncodingMask | kStringRepresentationMask;
+ const int kFlatOneByteStringTag =
+ kStringTag | kOneByteStringTag | kSeqStringTag;
+ andi(scratch, type, Operand(kFlatOneByteStringMask));
+ cmpi(scratch, Operand(kFlatOneByteStringTag));
+ bne(failure);
+}
+
+static const int kRegisterPassedArguments = 8;
+
+
+int MacroAssembler::CalculateStackPassedWords(int num_reg_arguments,
+ int num_double_arguments) {
+ int stack_passed_words = 0;
+ if (num_double_arguments > DoubleRegister::kNumRegisters) {
+ stack_passed_words +=
+ 2 * (num_double_arguments - DoubleRegister::kNumRegisters);
+ }
+ // Up to 8 simple arguments are passed in registers r3..r10.
+ if (num_reg_arguments > kRegisterPassedArguments) {
+ stack_passed_words += num_reg_arguments - kRegisterPassedArguments;
+ }
+ return stack_passed_words;
+}
+
+
+void MacroAssembler::EmitSeqStringSetCharCheck(Register string, Register index,
+ Register value,
+ uint32_t encoding_mask) {
+ Label is_object;
+ TestIfSmi(string, r0);
+ Check(ne, kNonObject, cr0);
+
+ LoadP(ip, FieldMemOperand(string, HeapObject::kMapOffset));
+ lbz(ip, FieldMemOperand(ip, Map::kInstanceTypeOffset));
+
+ andi(ip, ip, Operand(kStringRepresentationMask | kStringEncodingMask));
+ cmpi(ip, Operand(encoding_mask));
+ Check(eq, kUnexpectedStringType);
+
+// The index is assumed to be untagged coming in, tag it to compare with the
+// string length without using a temp register, it is restored at the end of
+// this function.
+#if !V8_TARGET_ARCH_PPC64
+ Label index_tag_ok, index_tag_bad;
+ JumpIfNotSmiCandidate(index, r0, &index_tag_bad);
+#endif
+ SmiTag(index, index);
+#if !V8_TARGET_ARCH_PPC64
+ b(&index_tag_ok);
+ bind(&index_tag_bad);
+ Abort(kIndexIsTooLarge);
+ bind(&index_tag_ok);
+#endif
+
+ LoadP(ip, FieldMemOperand(string, String::kLengthOffset));
+ cmp(index, ip);
+ Check(lt, kIndexIsTooLarge);
+
+ DCHECK(Smi::FromInt(0) == 0);
+ cmpi(index, Operand::Zero());
+ Check(ge, kIndexIsNegative);
+
+ SmiUntag(index, index);
+}
+
+
+void MacroAssembler::PrepareCallCFunction(int num_reg_arguments,
+ int num_double_arguments,
+ Register scratch) {
+ int frame_alignment = ActivationFrameAlignment();
+ int stack_passed_arguments =
+ CalculateStackPassedWords(num_reg_arguments, num_double_arguments);
+ int stack_space = kNumRequiredStackFrameSlots;
+
+ if (frame_alignment > kPointerSize) {
+ // Make stack end at alignment and make room for stack arguments
+ // -- preserving original value of sp.
+ mr(scratch, sp);
+ addi(sp, sp, Operand(-(stack_passed_arguments + 1) * kPointerSize));
+ DCHECK(base::bits::IsPowerOfTwo32(frame_alignment));
+ ClearRightImm(sp, sp, Operand(WhichPowerOf2(frame_alignment)));
+ StoreP(scratch, MemOperand(sp, stack_passed_arguments * kPointerSize));
+ } else {
+ // Make room for stack arguments
+ stack_space += stack_passed_arguments;
+ }
+
+ // Allocate frame with required slots to make ABI work.
+ li(r0, Operand::Zero());
+ StorePU(r0, MemOperand(sp, -stack_space * kPointerSize));
+}
+
+
+void MacroAssembler::PrepareCallCFunction(int num_reg_arguments,
+ Register scratch) {
+ PrepareCallCFunction(num_reg_arguments, 0, scratch);
+}
+
+
+void MacroAssembler::MovToFloatParameter(DoubleRegister src) { Move(d1, src); }
+
+
+void MacroAssembler::MovToFloatResult(DoubleRegister src) { Move(d1, src); }
+
+
+void MacroAssembler::MovToFloatParameters(DoubleRegister src1,
+ DoubleRegister src2) {
+ if (src2.is(d1)) {
+ DCHECK(!src1.is(d2));
+ Move(d2, src2);
+ Move(d1, src1);
+ } else {
+ Move(d1, src1);
+ Move(d2, src2);
+ }
+}
+
+
+void MacroAssembler::CallCFunction(ExternalReference function,
+ int num_reg_arguments,
+ int num_double_arguments) {
+ mov(ip, Operand(function));
+ CallCFunctionHelper(ip, num_reg_arguments, num_double_arguments);
+}
+
+
+void MacroAssembler::CallCFunction(Register function, int num_reg_arguments,
+ int num_double_arguments) {
+ CallCFunctionHelper(function, num_reg_arguments, num_double_arguments);
+}
+
+
+void MacroAssembler::CallCFunction(ExternalReference function,
+ int num_arguments) {
+ CallCFunction(function, num_arguments, 0);
+}
+
+
+void MacroAssembler::CallCFunction(Register function, int num_arguments) {
+ CallCFunction(function, num_arguments, 0);
+}
+
+
+void MacroAssembler::CallCFunctionHelper(Register function,
+ int num_reg_arguments,
+ int num_double_arguments) {
+ DCHECK(has_frame());
+// Just call directly. The function called cannot cause a GC, or
+// allow preemption, so the return address in the link register
+// stays correct.
+#if ABI_USES_FUNCTION_DESCRIPTORS && !defined(USE_SIMULATOR)
+ // AIX uses a function descriptor. When calling C code be aware
+ // of this descriptor and pick up values from it
+ LoadP(ToRegister(ABI_TOC_REGISTER), MemOperand(function, kPointerSize));
+ LoadP(ip, MemOperand(function, 0));
+ Register dest = ip;
+#elif ABI_TOC_ADDRESSABILITY_VIA_IP
+ Move(ip, function);
+ Register dest = ip;
+#else
+ Register dest = function;
+#endif
+
+ Call(dest);
+
+ // Remove frame bought in PrepareCallCFunction
+ int stack_passed_arguments =
+ CalculateStackPassedWords(num_reg_arguments, num_double_arguments);
+ int stack_space = kNumRequiredStackFrameSlots + stack_passed_arguments;
+ if (ActivationFrameAlignment() > kPointerSize) {
+ LoadP(sp, MemOperand(sp, stack_space * kPointerSize));
+ } else {
+ addi(sp, sp, Operand(stack_space * kPointerSize));
+ }
+}
+
+
+void MacroAssembler::FlushICache(Register address, size_t size,
+ Register scratch) {
+ if (CpuFeatures::IsSupported(INSTR_AND_DATA_CACHE_COHERENCY)) {
+ sync();
+ icbi(r0, address);
+ isync();
+ return;
+ }
+
+ Label done;
+
+ dcbf(r0, address);
+ sync();
+ icbi(r0, address);
+ isync();
+
+ // This code handles ranges which cross a single cacheline boundary.
+ // scratch is last cacheline which intersects range.
+ const int kCacheLineSizeLog2 = WhichPowerOf2(CpuFeatures::cache_line_size());
+
+ DCHECK(size > 0 && size <= (size_t)(1 << kCacheLineSizeLog2));
+ addi(scratch, address, Operand(size - 1));
+ ClearRightImm(scratch, scratch, Operand(kCacheLineSizeLog2));
+ cmpl(scratch, address);
+ ble(&done);
+
+ dcbf(r0, scratch);
+ sync();
+ icbi(r0, scratch);
+ isync();
+
+ bind(&done);
+}
+
+
+void MacroAssembler::SetRelocatedValue(Register location, Register scratch,
+ Register new_value) {
+ lwz(scratch, MemOperand(location));
+
+#if V8_OOL_CONSTANT_POOL
+ if (emit_debug_code()) {
+// Check that the instruction sequence is a load from the constant pool
+#if V8_TARGET_ARCH_PPC64
+ And(scratch, scratch, Operand(kOpcodeMask | (0x1f * B16)));
+ Cmpi(scratch, Operand(ADDI), r0);
+ Check(eq, kTheInstructionShouldBeALi);
+ lwz(scratch, MemOperand(location, kInstrSize));
+#endif
+ ExtractBitMask(scratch, scratch, 0x1f * B16);
+ cmpi(scratch, Operand(kConstantPoolRegister.code()));
+ Check(eq, kTheInstructionToPatchShouldBeALoadFromConstantPool);
+ // Scratch was clobbered. Restore it.
+ lwz(scratch, MemOperand(location));
+ }
+ // Get the address of the constant and patch it.
+ andi(scratch, scratch, Operand(kImm16Mask));
+ StorePX(new_value, MemOperand(kConstantPoolRegister, scratch));
+#else
+ // This code assumes a FIXED_SEQUENCE for lis/ori
+
+ // At this point scratch is a lis instruction.
+ if (emit_debug_code()) {
+ And(scratch, scratch, Operand(kOpcodeMask | (0x1f * B16)));
+ Cmpi(scratch, Operand(ADDIS), r0);
+ Check(eq, kTheInstructionToPatchShouldBeALis);
+ lwz(scratch, MemOperand(location));
+ }
+
+// insert new high word into lis instruction
+#if V8_TARGET_ARCH_PPC64
+ srdi(ip, new_value, Operand(32));
+ rlwimi(scratch, ip, 16, 16, 31);
+#else
+ rlwimi(scratch, new_value, 16, 16, 31);
+#endif
+
+ stw(scratch, MemOperand(location));
+
+ lwz(scratch, MemOperand(location, kInstrSize));
+ // scratch is now ori.
+ if (emit_debug_code()) {
+ And(scratch, scratch, Operand(kOpcodeMask));
+ Cmpi(scratch, Operand(ORI), r0);
+ Check(eq, kTheInstructionShouldBeAnOri);
+ lwz(scratch, MemOperand(location, kInstrSize));
+ }
+
+// insert new low word into ori instruction
+#if V8_TARGET_ARCH_PPC64
+ rlwimi(scratch, ip, 0, 16, 31);
+#else
+ rlwimi(scratch, new_value, 0, 16, 31);
+#endif
+ stw(scratch, MemOperand(location, kInstrSize));
+
+#if V8_TARGET_ARCH_PPC64
+ if (emit_debug_code()) {
+ lwz(scratch, MemOperand(location, 2 * kInstrSize));
+ // scratch is now sldi.
+ And(scratch, scratch, Operand(kOpcodeMask | kExt5OpcodeMask));
+ Cmpi(scratch, Operand(EXT5 | RLDICR), r0);
+ Check(eq, kTheInstructionShouldBeASldi);
+ }
+
+ lwz(scratch, MemOperand(location, 3 * kInstrSize));
+ // scratch is now ori.
+ if (emit_debug_code()) {
+ And(scratch, scratch, Operand(kOpcodeMask));
+ Cmpi(scratch, Operand(ORIS), r0);
+ Check(eq, kTheInstructionShouldBeAnOris);
+ lwz(scratch, MemOperand(location, 3 * kInstrSize));
+ }
+
+ rlwimi(scratch, new_value, 16, 16, 31);
+ stw(scratch, MemOperand(location, 3 * kInstrSize));
+
+ lwz(scratch, MemOperand(location, 4 * kInstrSize));
+ // scratch is now ori.
+ if (emit_debug_code()) {
+ And(scratch, scratch, Operand(kOpcodeMask));
+ Cmpi(scratch, Operand(ORI), r0);
+ Check(eq, kTheInstructionShouldBeAnOri);
+ lwz(scratch, MemOperand(location, 4 * kInstrSize));
+ }
+ rlwimi(scratch, new_value, 0, 16, 31);
+ stw(scratch, MemOperand(location, 4 * kInstrSize));
+#endif
+
+// Update the I-cache so the new lis and addic can be executed.
+#if V8_TARGET_ARCH_PPC64
+ FlushICache(location, 5 * kInstrSize, scratch);
+#else
+ FlushICache(location, 2 * kInstrSize, scratch);
+#endif
+#endif
+}
+
+
+void MacroAssembler::GetRelocatedValue(Register location, Register result,
+ Register scratch) {
+ lwz(result, MemOperand(location));
+
+#if V8_OOL_CONSTANT_POOL
+ if (emit_debug_code()) {
+// Check that the instruction sequence is a load from the constant pool
+#if V8_TARGET_ARCH_PPC64
+ And(result, result, Operand(kOpcodeMask | (0x1f * B16)));
+ Cmpi(result, Operand(ADDI), r0);
+ Check(eq, kTheInstructionShouldBeALi);
+ lwz(result, MemOperand(location, kInstrSize));
+#endif
+ ExtractBitMask(result, result, 0x1f * B16);
+ cmpi(result, Operand(kConstantPoolRegister.code()));
+ Check(eq, kTheInstructionToPatchShouldBeALoadFromConstantPool);
+ lwz(result, MemOperand(location));
+ }
+ // Get the address of the constant and retrieve it.
+ andi(result, result, Operand(kImm16Mask));
+ LoadPX(result, MemOperand(kConstantPoolRegister, result));
+#else
+ // This code assumes a FIXED_SEQUENCE for lis/ori
+ if (emit_debug_code()) {
+ And(result, result, Operand(kOpcodeMask | (0x1f * B16)));
+ Cmpi(result, Operand(ADDIS), r0);
+ Check(eq, kTheInstructionShouldBeALis);
+ lwz(result, MemOperand(location));
+ }
+
+ // result now holds a lis instruction. Extract the immediate.
+ slwi(result, result, Operand(16));
+
+ lwz(scratch, MemOperand(location, kInstrSize));
+ if (emit_debug_code()) {
+ And(scratch, scratch, Operand(kOpcodeMask));
+ Cmpi(scratch, Operand(ORI), r0);
+ Check(eq, kTheInstructionShouldBeAnOri);
+ lwz(scratch, MemOperand(location, kInstrSize));
+ }
+ // Copy the low 16bits from ori instruction into result
+ rlwimi(result, scratch, 0, 16, 31);
+
+#if V8_TARGET_ARCH_PPC64
+ if (emit_debug_code()) {
+ lwz(scratch, MemOperand(location, 2 * kInstrSize));
+ // scratch is now sldi.
+ And(scratch, scratch, Operand(kOpcodeMask | kExt5OpcodeMask));
+ Cmpi(scratch, Operand(EXT5 | RLDICR), r0);
+ Check(eq, kTheInstructionShouldBeASldi);
+ }
+
+ lwz(scratch, MemOperand(location, 3 * kInstrSize));
+ // scratch is now ori.
+ if (emit_debug_code()) {
+ And(scratch, scratch, Operand(kOpcodeMask));
+ Cmpi(scratch, Operand(ORIS), r0);
+ Check(eq, kTheInstructionShouldBeAnOris);
+ lwz(scratch, MemOperand(location, 3 * kInstrSize));
+ }
+ sldi(result, result, Operand(16));
+ rldimi(result, scratch, 0, 48);
+
+ lwz(scratch, MemOperand(location, 4 * kInstrSize));
+ // scratch is now ori.
+ if (emit_debug_code()) {
+ And(scratch, scratch, Operand(kOpcodeMask));
+ Cmpi(scratch, Operand(ORI), r0);
+ Check(eq, kTheInstructionShouldBeAnOri);
+ lwz(scratch, MemOperand(location, 4 * kInstrSize));
+ }
+ sldi(result, result, Operand(16));
+ rldimi(result, scratch, 0, 48);
+#endif
+#endif
+}
+
+
+void MacroAssembler::CheckPageFlag(
+ Register object,
+ Register scratch, // scratch may be same register as object
+ int mask, Condition cc, Label* condition_met) {
+ DCHECK(cc == ne || cc == eq);
+ ClearRightImm(scratch, object, Operand(kPageSizeBits));
+ LoadP(scratch, MemOperand(scratch, MemoryChunk::kFlagsOffset));
+
+ And(r0, scratch, Operand(mask), SetRC);
+
+ if (cc == ne) {
+ bne(condition_met, cr0);
+ }
+ if (cc == eq) {
+ beq(condition_met, cr0);
+ }
+}
+
+
+void MacroAssembler::CheckMapDeprecated(Handle<Map> map, Register scratch,
+ Label* if_deprecated) {
+ if (map->CanBeDeprecated()) {
+ mov(scratch, Operand(map));
+ lwz(scratch, FieldMemOperand(scratch, Map::kBitField3Offset));
+ ExtractBitMask(scratch, scratch, Map::Deprecated::kMask, SetRC);
+ bne(if_deprecated, cr0);
+ }
+}
+
+
+void MacroAssembler::JumpIfBlack(Register object, Register scratch0,
+ Register scratch1, Label* on_black) {
+ HasColor(object, scratch0, scratch1, on_black, 1, 0); // kBlackBitPattern.
+ DCHECK(strcmp(Marking::kBlackBitPattern, "10") == 0);
+}
+
+
+void MacroAssembler::HasColor(Register object, Register bitmap_scratch,
+ Register mask_scratch, Label* has_color,
+ int first_bit, int second_bit) {
+ DCHECK(!AreAliased(object, bitmap_scratch, mask_scratch, no_reg));
+
+ GetMarkBits(object, bitmap_scratch, mask_scratch);
+
+ Label other_color, word_boundary;
+ lwz(ip, MemOperand(bitmap_scratch, MemoryChunk::kHeaderSize));
+ // Test the first bit
+ and_(r0, ip, mask_scratch, SetRC);
+ b(first_bit == 1 ? eq : ne, &other_color, cr0);
+ // Shift left 1
+ // May need to load the next cell
+ slwi(mask_scratch, mask_scratch, Operand(1), SetRC);
+ beq(&word_boundary, cr0);
+ // Test the second bit
+ and_(r0, ip, mask_scratch, SetRC);
+ b(second_bit == 1 ? ne : eq, has_color, cr0);
+ b(&other_color);
+
+ bind(&word_boundary);
+ lwz(ip, MemOperand(bitmap_scratch, MemoryChunk::kHeaderSize + kIntSize));
+ andi(r0, ip, Operand(1));
+ b(second_bit == 1 ? ne : eq, has_color, cr0);
+ bind(&other_color);
+}
+
+
+// Detect some, but not all, common pointer-free objects. This is used by the
+// incremental write barrier which doesn't care about oddballs (they are always
+// marked black immediately so this code is not hit).
+void MacroAssembler::JumpIfDataObject(Register value, Register scratch,
+ Label* not_data_object) {
+ Label is_data_object;
+ LoadP(scratch, FieldMemOperand(value, HeapObject::kMapOffset));
+ CompareRoot(scratch, Heap::kHeapNumberMapRootIndex);
+ beq(&is_data_object);
+ DCHECK(kIsIndirectStringTag == 1 && kIsIndirectStringMask == 1);
+ DCHECK(kNotStringTag == 0x80 && kIsNotStringMask == 0x80);
+ // If it's a string and it's not a cons string then it's an object containing
+ // no GC pointers.
+ lbz(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
+ STATIC_ASSERT((kIsIndirectStringMask | kIsNotStringMask) == 0x81);
+ andi(scratch, scratch, Operand(kIsIndirectStringMask | kIsNotStringMask));
+ bne(not_data_object, cr0);
+ bind(&is_data_object);
+}
+
+
+void MacroAssembler::GetMarkBits(Register addr_reg, Register bitmap_reg,
+ Register mask_reg) {
+ DCHECK(!AreAliased(addr_reg, bitmap_reg, mask_reg, no_reg));
+ DCHECK((~Page::kPageAlignmentMask & 0xffff) == 0);
+ lis(r0, Operand((~Page::kPageAlignmentMask >> 16)));
+ and_(bitmap_reg, addr_reg, r0);
+ const int kLowBits = kPointerSizeLog2 + Bitmap::kBitsPerCellLog2;
+ ExtractBitRange(mask_reg, addr_reg, kLowBits - 1, kPointerSizeLog2);
+ ExtractBitRange(ip, addr_reg, kPageSizeBits - 1, kLowBits);
+ ShiftLeftImm(ip, ip, Operand(Bitmap::kBytesPerCellLog2));
+ add(bitmap_reg, bitmap_reg, ip);
+ li(ip, Operand(1));
+ slw(mask_reg, ip, mask_reg);
+}
+
+
+void MacroAssembler::EnsureNotWhite(Register value, Register bitmap_scratch,
+ Register mask_scratch,
+ Register load_scratch,
+ Label* value_is_white_and_not_data) {
+ DCHECK(!AreAliased(value, bitmap_scratch, mask_scratch, ip));
+ GetMarkBits(value, bitmap_scratch, mask_scratch);
+
+ // If the value is black or grey we don't need to do anything.
+ DCHECK(strcmp(Marking::kWhiteBitPattern, "00") == 0);
+ DCHECK(strcmp(Marking::kBlackBitPattern, "10") == 0);
+ DCHECK(strcmp(Marking::kGreyBitPattern, "11") == 0);
+ DCHECK(strcmp(Marking::kImpossibleBitPattern, "01") == 0);
+
+ Label done;
+
+ // Since both black and grey have a 1 in the first position and white does
+ // not have a 1 there we only need to check one bit.
+ lwz(load_scratch, MemOperand(bitmap_scratch, MemoryChunk::kHeaderSize));
+ and_(r0, mask_scratch, load_scratch, SetRC);
+ bne(&done, cr0);
+
+ if (emit_debug_code()) {
+ // Check for impossible bit pattern.
+ Label ok;
+ // LSL may overflow, making the check conservative.
+ slwi(r0, mask_scratch, Operand(1));
+ and_(r0, load_scratch, r0, SetRC);
+ beq(&ok, cr0);
+ stop("Impossible marking bit pattern");
+ bind(&ok);
+ }
+
+ // Value is white. We check whether it is data that doesn't need scanning.
+ // Currently only checks for HeapNumber and non-cons strings.
+ Register map = load_scratch; // Holds map while checking type.
+ Register length = load_scratch; // Holds length of object after testing type.
+ Label is_data_object, maybe_string_object, is_string_object, is_encoded;
+#if V8_TARGET_ARCH_PPC64
+ Label length_computed;
+#endif
+
+
+ // Check for heap-number
+ LoadP(map, FieldMemOperand(value, HeapObject::kMapOffset));
+ CompareRoot(map, Heap::kHeapNumberMapRootIndex);
+ bne(&maybe_string_object);
+ li(length, Operand(HeapNumber::kSize));
+ b(&is_data_object);
+ bind(&maybe_string_object);
+
+ // Check for strings.
+ DCHECK(kIsIndirectStringTag == 1 && kIsIndirectStringMask == 1);
+ DCHECK(kNotStringTag == 0x80 && kIsNotStringMask == 0x80);
+ // If it's a string and it's not a cons string then it's an object containing
+ // no GC pointers.
+ Register instance_type = load_scratch;
+ lbz(instance_type, FieldMemOperand(map, Map::kInstanceTypeOffset));
+ andi(r0, instance_type, Operand(kIsIndirectStringMask | kIsNotStringMask));
+ bne(value_is_white_and_not_data, cr0);
+ // It's a non-indirect (non-cons and non-slice) string.
+ // If it's external, the length is just ExternalString::kSize.
+ // Otherwise it's String::kHeaderSize + string->length() * (1 or 2).
+ // External strings are the only ones with the kExternalStringTag bit
+ // set.
+ DCHECK_EQ(0, kSeqStringTag & kExternalStringTag);
+ DCHECK_EQ(0, kConsStringTag & kExternalStringTag);
+ andi(r0, instance_type, Operand(kExternalStringTag));
+ beq(&is_string_object, cr0);
+ li(length, Operand(ExternalString::kSize));
+ b(&is_data_object);
+ bind(&is_string_object);
+
+ // Sequential string, either Latin1 or UC16.
+ // For Latin1 (char-size of 1) we untag the smi to get the length.
+ // For UC16 (char-size of 2):
+ // - (32-bit) we just leave the smi tag in place, thereby getting
+ // the length multiplied by 2.
+ // - (64-bit) we compute the offset in the 2-byte array
+ DCHECK(kOneByteStringTag == 4 && kStringEncodingMask == 4);
+ LoadP(ip, FieldMemOperand(value, String::kLengthOffset));
+ andi(r0, instance_type, Operand(kStringEncodingMask));
+ beq(&is_encoded, cr0);
+ SmiUntag(ip);
+#if V8_TARGET_ARCH_PPC64
+ b(&length_computed);
+#endif
+ bind(&is_encoded);
+#if V8_TARGET_ARCH_PPC64
+ SmiToShortArrayOffset(ip, ip);
+ bind(&length_computed);
+#else
+ DCHECK(kSmiShift == 1);
+#endif
+ addi(length, ip, Operand(SeqString::kHeaderSize + kObjectAlignmentMask));
+ li(r0, Operand(~kObjectAlignmentMask));
+ and_(length, length, r0);
+
+ bind(&is_data_object);
+ // Value is a data object, and it is white. Mark it black. Since we know
+ // that the object is white we can make it black by flipping one bit.
+ lwz(ip, MemOperand(bitmap_scratch, MemoryChunk::kHeaderSize));
+ orx(ip, ip, mask_scratch);
+ stw(ip, MemOperand(bitmap_scratch, MemoryChunk::kHeaderSize));
+
+ mov(ip, Operand(~Page::kPageAlignmentMask));
+ and_(bitmap_scratch, bitmap_scratch, ip);
+ lwz(ip, MemOperand(bitmap_scratch, MemoryChunk::kLiveBytesOffset));
+ add(ip, ip, length);
+ stw(ip, MemOperand(bitmap_scratch, MemoryChunk::kLiveBytesOffset));
+
+ bind(&done);
+}
+
+
+// Saturate a value into 8-bit unsigned integer
+// if input_value < 0, output_value is 0
+// if input_value > 255, output_value is 255
+// otherwise output_value is the input_value
+void MacroAssembler::ClampUint8(Register output_reg, Register input_reg) {
+ Label done, negative_label, overflow_label;
+ int satval = (1 << 8) - 1;
+
+ cmpi(input_reg, Operand::Zero());
+ blt(&negative_label);
+
+ cmpi(input_reg, Operand(satval));
+ bgt(&overflow_label);
+ if (!output_reg.is(input_reg)) {
+ mr(output_reg, input_reg);
+ }
+ b(&done);
+
+ bind(&negative_label);
+ li(output_reg, Operand::Zero()); // set to 0 if negative
+ b(&done);
+
+
+ bind(&overflow_label); // set to satval if > satval
+ li(output_reg, Operand(satval));
+
+ bind(&done);
+}
+
+
+void MacroAssembler::SetRoundingMode(FPRoundingMode RN) { mtfsfi(7, RN); }
+
+
+void MacroAssembler::ResetRoundingMode() {
+ mtfsfi(7, kRoundToNearest); // reset (default is kRoundToNearest)
+}
+
+
+void MacroAssembler::ClampDoubleToUint8(Register result_reg,
+ DoubleRegister input_reg,
+ DoubleRegister double_scratch) {
+ Label above_zero;
+ Label done;
+ Label in_bounds;
+
+ LoadDoubleLiteral(double_scratch, 0.0, result_reg);
+ fcmpu(input_reg, double_scratch);
+ bgt(&above_zero);
+
+ // Double value is less than zero, NaN or Inf, return 0.
+ LoadIntLiteral(result_reg, 0);
+ b(&done);
+
+ // Double value is >= 255, return 255.
+ bind(&above_zero);
+ LoadDoubleLiteral(double_scratch, 255.0, result_reg);
+ fcmpu(input_reg, double_scratch);
+ ble(&in_bounds);
+ LoadIntLiteral(result_reg, 255);
+ b(&done);
+
+ // In 0-255 range, round and truncate.
+ bind(&in_bounds);
+
+ // round to nearest (default rounding mode)
+ fctiw(double_scratch, input_reg);
+ MovDoubleLowToInt(result_reg, double_scratch);
+ bind(&done);
+}
+
+
+void MacroAssembler::LoadInstanceDescriptors(Register map,
+ Register descriptors) {
+ LoadP(descriptors, FieldMemOperand(map, Map::kDescriptorsOffset));
+}
+
+
+void MacroAssembler::NumberOfOwnDescriptors(Register dst, Register map) {
+ lwz(dst, FieldMemOperand(map, Map::kBitField3Offset));
+ DecodeField<Map::NumberOfOwnDescriptorsBits>(dst);
+}
+
+
+void MacroAssembler::EnumLength(Register dst, Register map) {
+ STATIC_ASSERT(Map::EnumLengthBits::kShift == 0);
+ lwz(dst, FieldMemOperand(map, Map::kBitField3Offset));
+ ExtractBitMask(dst, dst, Map::EnumLengthBits::kMask);
+ SmiTag(dst);
+}
+
+
+void MacroAssembler::CheckEnumCache(Register null_value, Label* call_runtime) {
+ Register empty_fixed_array_value = r9;
+ LoadRoot(empty_fixed_array_value, Heap::kEmptyFixedArrayRootIndex);
+ Label next, start;
+ mr(r5, r3);
+
+ // Check if the enum length field is properly initialized, indicating that
+ // there is an enum cache.
+ LoadP(r4, FieldMemOperand(r5, HeapObject::kMapOffset));
+
+ EnumLength(r6, r4);
+ CmpSmiLiteral(r6, Smi::FromInt(kInvalidEnumCacheSentinel), r0);
+ beq(call_runtime);
+
+ b(&start);
+
+ bind(&next);
+ LoadP(r4, FieldMemOperand(r5, HeapObject::kMapOffset));
+
+ // For all objects but the receiver, check that the cache is empty.
+ EnumLength(r6, r4);
+ CmpSmiLiteral(r6, Smi::FromInt(0), r0);
+ bne(call_runtime);
+
+ bind(&start);
+
+ // Check that there are no elements. Register r5 contains the current JS
+ // object we've reached through the prototype chain.
+ Label no_elements;
+ LoadP(r5, FieldMemOperand(r5, JSObject::kElementsOffset));
+ cmp(r5, empty_fixed_array_value);
+ beq(&no_elements);
+
+ // Second chance, the object may be using the empty slow element dictionary.
+ CompareRoot(r5, Heap::kEmptySlowElementDictionaryRootIndex);
+ bne(call_runtime);
+
+ bind(&no_elements);
+ LoadP(r5, FieldMemOperand(r4, Map::kPrototypeOffset));
+ cmp(r5, null_value);
+ bne(&next);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// New MacroAssembler Interfaces added for PPC
+//
+////////////////////////////////////////////////////////////////////////////////
+void MacroAssembler::LoadIntLiteral(Register dst, int value) {
+ mov(dst, Operand(value));
+}
+
+
+void MacroAssembler::LoadSmiLiteral(Register dst, Smi* smi) {
+ mov(dst, Operand(smi));
+}
+
+
+void MacroAssembler::LoadDoubleLiteral(DoubleRegister result, double value,
+ Register scratch) {
+#if V8_OOL_CONSTANT_POOL
+ // TODO(mbrandy): enable extended constant pool usage for doubles.
+ // See ARM commit e27ab337 for a reference.
+ if (is_ool_constant_pool_available() && !is_constant_pool_full()) {
+ RelocInfo rinfo(pc_, value);
+ ConstantPoolAddEntry(rinfo);
+#if V8_TARGET_ARCH_PPC64
+ // We use 2 instruction sequence here for consistency with mov.
+ li(scratch, Operand::Zero());
+ lfdx(result, MemOperand(kConstantPoolRegister, scratch));
+#else
+ lfd(result, MemOperand(kConstantPoolRegister, 0));
+#endif
+ return;
+ }
+#endif
+
+ // avoid gcc strict aliasing error using union cast
+ union {
+ double dval;
+#if V8_TARGET_ARCH_PPC64
+ intptr_t ival;
+#else
+ intptr_t ival[2];
+#endif
+ } litVal;
+
+ litVal.dval = value;
+
+#if V8_TARGET_ARCH_PPC64
+ if (CpuFeatures::IsSupported(FPR_GPR_MOV)) {
+ mov(scratch, Operand(litVal.ival));
+ mtfprd(result, scratch);
+ return;
+ }
+#endif
+
+ addi(sp, sp, Operand(-kDoubleSize));
+#if V8_TARGET_ARCH_PPC64
+ mov(scratch, Operand(litVal.ival));
+ std(scratch, MemOperand(sp));
+#else
+ LoadIntLiteral(scratch, litVal.ival[0]);
+ stw(scratch, MemOperand(sp, 0));
+ LoadIntLiteral(scratch, litVal.ival[1]);
+ stw(scratch, MemOperand(sp, 4));
+#endif
+ nop(GROUP_ENDING_NOP); // LHS/RAW optimization
+ lfd(result, MemOperand(sp, 0));
+ addi(sp, sp, Operand(kDoubleSize));
+}
+
+
+void MacroAssembler::MovIntToDouble(DoubleRegister dst, Register src,
+ Register scratch) {
+// sign-extend src to 64-bit
+#if V8_TARGET_ARCH_PPC64
+ if (CpuFeatures::IsSupported(FPR_GPR_MOV)) {
+ mtfprwa(dst, src);
+ return;
+ }
+#endif
+
+ DCHECK(!src.is(scratch));
+ subi(sp, sp, Operand(kDoubleSize));
+#if V8_TARGET_ARCH_PPC64
+ extsw(scratch, src);
+ std(scratch, MemOperand(sp, 0));
+#else
+ srawi(scratch, src, 31);
+ stw(scratch, MemOperand(sp, Register::kExponentOffset));
+ stw(src, MemOperand(sp, Register::kMantissaOffset));
+#endif
+ nop(GROUP_ENDING_NOP); // LHS/RAW optimization
+ lfd(dst, MemOperand(sp, 0));
+ addi(sp, sp, Operand(kDoubleSize));
+}
+
+
+void MacroAssembler::MovUnsignedIntToDouble(DoubleRegister dst, Register src,
+ Register scratch) {
+// zero-extend src to 64-bit
+#if V8_TARGET_ARCH_PPC64
+ if (CpuFeatures::IsSupported(FPR_GPR_MOV)) {
+ mtfprwz(dst, src);
+ return;
+ }
+#endif
+
+ DCHECK(!src.is(scratch));
+ subi(sp, sp, Operand(kDoubleSize));
+#if V8_TARGET_ARCH_PPC64
+ clrldi(scratch, src, Operand(32));
+ std(scratch, MemOperand(sp, 0));
+#else
+ li(scratch, Operand::Zero());
+ stw(scratch, MemOperand(sp, Register::kExponentOffset));
+ stw(src, MemOperand(sp, Register::kMantissaOffset));
+#endif
+ nop(GROUP_ENDING_NOP); // LHS/RAW optimization
+ lfd(dst, MemOperand(sp, 0));
+ addi(sp, sp, Operand(kDoubleSize));
+}
+
+
+void MacroAssembler::MovInt64ToDouble(DoubleRegister dst,
+#if !V8_TARGET_ARCH_PPC64
+ Register src_hi,
+#endif
+ Register src) {
+#if V8_TARGET_ARCH_PPC64
+ if (CpuFeatures::IsSupported(FPR_GPR_MOV)) {
+ mtfprd(dst, src);
+ return;
+ }
+#endif
+
+ subi(sp, sp, Operand(kDoubleSize));
+#if V8_TARGET_ARCH_PPC64
+ std(src, MemOperand(sp, 0));
+#else
+ stw(src_hi, MemOperand(sp, Register::kExponentOffset));
+ stw(src, MemOperand(sp, Register::kMantissaOffset));
+#endif
+ nop(GROUP_ENDING_NOP); // LHS/RAW optimization
+ lfd(dst, MemOperand(sp, 0));
+ addi(sp, sp, Operand(kDoubleSize));
+}
+
+
+#if V8_TARGET_ARCH_PPC64
+void MacroAssembler::MovInt64ComponentsToDouble(DoubleRegister dst,
+ Register src_hi,
+ Register src_lo,
+ Register scratch) {
+ if (CpuFeatures::IsSupported(FPR_GPR_MOV)) {
+ sldi(scratch, src_hi, Operand(32));
+ rldimi(scratch, src_lo, 0, 32);
+ mtfprd(dst, scratch);
+ return;
+ }
+
+ subi(sp, sp, Operand(kDoubleSize));
+ stw(src_hi, MemOperand(sp, Register::kExponentOffset));
+ stw(src_lo, MemOperand(sp, Register::kMantissaOffset));
+ nop(GROUP_ENDING_NOP); // LHS/RAW optimization
+ lfd(dst, MemOperand(sp));
+ addi(sp, sp, Operand(kDoubleSize));
+}
+#endif
+
+
+void MacroAssembler::MovDoubleLowToInt(Register dst, DoubleRegister src) {
+#if V8_TARGET_ARCH_PPC64
+ if (CpuFeatures::IsSupported(FPR_GPR_MOV)) {
+ mffprwz(dst, src);
+ return;
+ }
+#endif
+
+ subi(sp, sp, Operand(kDoubleSize));
+ stfd(src, MemOperand(sp));
+ nop(GROUP_ENDING_NOP); // LHS/RAW optimization
+ lwz(dst, MemOperand(sp, Register::kMantissaOffset));
+ addi(sp, sp, Operand(kDoubleSize));
+}
+
+
+void MacroAssembler::MovDoubleHighToInt(Register dst, DoubleRegister src) {
+#if V8_TARGET_ARCH_PPC64
+ if (CpuFeatures::IsSupported(FPR_GPR_MOV)) {
+ mffprd(dst, src);
+ srdi(dst, dst, Operand(32));
+ return;
+ }
+#endif
+
+ subi(sp, sp, Operand(kDoubleSize));
+ stfd(src, MemOperand(sp));
+ nop(GROUP_ENDING_NOP); // LHS/RAW optimization
+ lwz(dst, MemOperand(sp, Register::kExponentOffset));
+ addi(sp, sp, Operand(kDoubleSize));
+}
+
+
+void MacroAssembler::MovDoubleToInt64(
+#if !V8_TARGET_ARCH_PPC64
+ Register dst_hi,
+#endif
+ Register dst, DoubleRegister src) {
+#if V8_TARGET_ARCH_PPC64
+ if (CpuFeatures::IsSupported(FPR_GPR_MOV)) {
+ mffprd(dst, src);
+ return;
+ }
+#endif
+
+ subi(sp, sp, Operand(kDoubleSize));
+ stfd(src, MemOperand(sp));
+ nop(GROUP_ENDING_NOP); // LHS/RAW optimization
+#if V8_TARGET_ARCH_PPC64
+ ld(dst, MemOperand(sp, 0));
+#else
+ lwz(dst_hi, MemOperand(sp, Register::kExponentOffset));
+ lwz(dst, MemOperand(sp, Register::kMantissaOffset));
+#endif
+ addi(sp, sp, Operand(kDoubleSize));
+}
+
+
+void MacroAssembler::Add(Register dst, Register src, intptr_t value,
+ Register scratch) {
+ if (is_int16(value)) {
+ addi(dst, src, Operand(value));
+ } else {
+ mov(scratch, Operand(value));
+ add(dst, src, scratch);
+ }
+}
+
+
+void MacroAssembler::Cmpi(Register src1, const Operand& src2, Register scratch,
+ CRegister cr) {
+ intptr_t value = src2.immediate();
+ if (is_int16(value)) {
+ cmpi(src1, src2, cr);
+ } else {
+ mov(scratch, src2);
+ cmp(src1, scratch, cr);
+ }
+}
+
+
+void MacroAssembler::Cmpli(Register src1, const Operand& src2, Register scratch,
+ CRegister cr) {
+ intptr_t value = src2.immediate();
+ if (is_uint16(value)) {
+ cmpli(src1, src2, cr);
+ } else {
+ mov(scratch, src2);
+ cmpl(src1, scratch, cr);
+ }
+}
+
+
+void MacroAssembler::Cmpwi(Register src1, const Operand& src2, Register scratch,
+ CRegister cr) {
+ intptr_t value = src2.immediate();
+ if (is_int16(value)) {
+ cmpwi(src1, src2, cr);
+ } else {
+ mov(scratch, src2);
+ cmpw(src1, scratch, cr);
+ }
+}
+
+
+void MacroAssembler::Cmplwi(Register src1, const Operand& src2,
+ Register scratch, CRegister cr) {
+ intptr_t value = src2.immediate();
+ if (is_uint16(value)) {
+ cmplwi(src1, src2, cr);
+ } else {
+ mov(scratch, src2);
+ cmplw(src1, scratch, cr);
+ }
+}
+
+
+void MacroAssembler::And(Register ra, Register rs, const Operand& rb,
+ RCBit rc) {
+ if (rb.is_reg()) {
+ and_(ra, rs, rb.rm(), rc);
+ } else {
+ if (is_uint16(rb.imm_) && RelocInfo::IsNone(rb.rmode_) && rc == SetRC) {
+ andi(ra, rs, rb);
+ } else {
+ // mov handles the relocation.
+ DCHECK(!rs.is(r0));
+ mov(r0, rb);
+ and_(ra, rs, r0, rc);
+ }
+ }
+}
+
+
+void MacroAssembler::Or(Register ra, Register rs, const Operand& rb, RCBit rc) {
+ if (rb.is_reg()) {
+ orx(ra, rs, rb.rm(), rc);
+ } else {
+ if (is_uint16(rb.imm_) && RelocInfo::IsNone(rb.rmode_) && rc == LeaveRC) {
+ ori(ra, rs, rb);
+ } else {
+ // mov handles the relocation.
+ DCHECK(!rs.is(r0));
+ mov(r0, rb);
+ orx(ra, rs, r0, rc);
+ }
+ }
+}
+
+
+void MacroAssembler::Xor(Register ra, Register rs, const Operand& rb,
+ RCBit rc) {
+ if (rb.is_reg()) {
+ xor_(ra, rs, rb.rm(), rc);
+ } else {
+ if (is_uint16(rb.imm_) && RelocInfo::IsNone(rb.rmode_) && rc == LeaveRC) {
+ xori(ra, rs, rb);
+ } else {
+ // mov handles the relocation.
+ DCHECK(!rs.is(r0));
+ mov(r0, rb);
+ xor_(ra, rs, r0, rc);
+ }
+ }
+}
+
+
+void MacroAssembler::CmpSmiLiteral(Register src1, Smi* smi, Register scratch,
+ CRegister cr) {
+#if V8_TARGET_ARCH_PPC64
+ LoadSmiLiteral(scratch, smi);
+ cmp(src1, scratch, cr);
+#else
+ Cmpi(src1, Operand(smi), scratch, cr);
+#endif
+}
+
+
+void MacroAssembler::CmplSmiLiteral(Register src1, Smi* smi, Register scratch,
+ CRegister cr) {
+#if V8_TARGET_ARCH_PPC64
+ LoadSmiLiteral(scratch, smi);
+ cmpl(src1, scratch, cr);
+#else
+ Cmpli(src1, Operand(smi), scratch, cr);
+#endif
+}
+
+
+void MacroAssembler::AddSmiLiteral(Register dst, Register src, Smi* smi,
+ Register scratch) {
+#if V8_TARGET_ARCH_PPC64
+ LoadSmiLiteral(scratch, smi);
+ add(dst, src, scratch);
+#else
+ Add(dst, src, reinterpret_cast<intptr_t>(smi), scratch);
+#endif
+}
+
+
+void MacroAssembler::SubSmiLiteral(Register dst, Register src, Smi* smi,
+ Register scratch) {
+#if V8_TARGET_ARCH_PPC64
+ LoadSmiLiteral(scratch, smi);
+ sub(dst, src, scratch);
+#else
+ Add(dst, src, -(reinterpret_cast<intptr_t>(smi)), scratch);
+#endif
+}
+
+
+void MacroAssembler::AndSmiLiteral(Register dst, Register src, Smi* smi,
+ Register scratch, RCBit rc) {
+#if V8_TARGET_ARCH_PPC64
+ LoadSmiLiteral(scratch, smi);
+ and_(dst, src, scratch, rc);
+#else
+ And(dst, src, Operand(smi), rc);
+#endif
+}
+
+
+// Load a "pointer" sized value from the memory location
+void MacroAssembler::LoadP(Register dst, const MemOperand& mem,
+ Register scratch) {
+ int offset = mem.offset();
+
+ if (!scratch.is(no_reg) && !is_int16(offset)) {
+ /* cannot use d-form */
+ LoadIntLiteral(scratch, offset);
+#if V8_TARGET_ARCH_PPC64
+ ldx(dst, MemOperand(mem.ra(), scratch));
+#else
+ lwzx(dst, MemOperand(mem.ra(), scratch));
+#endif
+ } else {
+#if V8_TARGET_ARCH_PPC64
+ int misaligned = (offset & 3);
+ if (misaligned) {
+ // adjust base to conform to offset alignment requirements
+ // Todo: enhance to use scratch if dst is unsuitable
+ DCHECK(!dst.is(r0));
+ addi(dst, mem.ra(), Operand((offset & 3) - 4));
+ ld(dst, MemOperand(dst, (offset & ~3) + 4));
+ } else {
+ ld(dst, mem);
+ }
+#else
+ lwz(dst, mem);
+#endif
+ }
+}
+
+
+// Store a "pointer" sized value to the memory location
+void MacroAssembler::StoreP(Register src, const MemOperand& mem,
+ Register scratch) {
+ int offset = mem.offset();
+
+ if (!scratch.is(no_reg) && !is_int16(offset)) {
+ /* cannot use d-form */
+ LoadIntLiteral(scratch, offset);
+#if V8_TARGET_ARCH_PPC64
+ stdx(src, MemOperand(mem.ra(), scratch));
+#else
+ stwx(src, MemOperand(mem.ra(), scratch));
+#endif
+ } else {
+#if V8_TARGET_ARCH_PPC64
+ int misaligned = (offset & 3);
+ if (misaligned) {
+ // adjust base to conform to offset alignment requirements
+ // a suitable scratch is required here
+ DCHECK(!scratch.is(no_reg));
+ if (scratch.is(r0)) {
+ LoadIntLiteral(scratch, offset);
+ stdx(src, MemOperand(mem.ra(), scratch));
+ } else {
+ addi(scratch, mem.ra(), Operand((offset & 3) - 4));
+ std(src, MemOperand(scratch, (offset & ~3) + 4));
+ }
+ } else {
+ std(src, mem);
+ }
+#else
+ stw(src, mem);
+#endif
+ }
+}
+
+void MacroAssembler::LoadWordArith(Register dst, const MemOperand& mem,
+ Register scratch) {
+ int offset = mem.offset();
+
+ if (!scratch.is(no_reg) && !is_int16(offset)) {
+ /* cannot use d-form */
+ LoadIntLiteral(scratch, offset);
+#if V8_TARGET_ARCH_PPC64
+ // lwax(dst, MemOperand(mem.ra(), scratch));
+ DCHECK(0); // lwax not yet implemented
+#else
+ lwzx(dst, MemOperand(mem.ra(), scratch));
+#endif
+ } else {
+#if V8_TARGET_ARCH_PPC64
+ int misaligned = (offset & 3);
+ if (misaligned) {
+ // adjust base to conform to offset alignment requirements
+ // Todo: enhance to use scratch if dst is unsuitable
+ DCHECK(!dst.is(r0));
+ addi(dst, mem.ra(), Operand((offset & 3) - 4));
+ lwa(dst, MemOperand(dst, (offset & ~3) + 4));
+ } else {
+ lwa(dst, mem);
+ }
+#else
+ lwz(dst, mem);
+#endif
+ }
+}
+
+
+// Variable length depending on whether offset fits into immediate field
+// MemOperand currently only supports d-form
+void MacroAssembler::LoadWord(Register dst, const MemOperand& mem,
+ Register scratch) {
+ Register base = mem.ra();
+ int offset = mem.offset();
+
+ if (!is_int16(offset)) {
+ LoadIntLiteral(scratch, offset);
+ lwzx(dst, MemOperand(base, scratch));
+ } else {
+ lwz(dst, mem);
+ }
+}
+
+
+// Variable length depending on whether offset fits into immediate field
+// MemOperand current only supports d-form
+void MacroAssembler::StoreWord(Register src, const MemOperand& mem,
+ Register scratch) {
+ Register base = mem.ra();
+ int offset = mem.offset();
+
+ if (!is_int16(offset)) {
+ LoadIntLiteral(scratch, offset);
+ stwx(src, MemOperand(base, scratch));
+ } else {
+ stw(src, mem);
+ }
+}
+
+
+// Variable length depending on whether offset fits into immediate field
+// MemOperand currently only supports d-form
+void MacroAssembler::LoadHalfWord(Register dst, const MemOperand& mem,
+ Register scratch) {
+ Register base = mem.ra();
+ int offset = mem.offset();
+
+ if (!is_int16(offset)) {
+ LoadIntLiteral(scratch, offset);
+ lhzx(dst, MemOperand(base, scratch));
+ } else {
+ lhz(dst, mem);
+ }
+}
+
+
+// Variable length depending on whether offset fits into immediate field
+// MemOperand current only supports d-form
+void MacroAssembler::StoreHalfWord(Register src, const MemOperand& mem,
+ Register scratch) {
+ Register base = mem.ra();
+ int offset = mem.offset();
+
+ if (!is_int16(offset)) {
+ LoadIntLiteral(scratch, offset);
+ sthx(src, MemOperand(base, scratch));
+ } else {
+ sth(src, mem);
+ }
+}
+
+
+// Variable length depending on whether offset fits into immediate field
+// MemOperand currently only supports d-form
+void MacroAssembler::LoadByte(Register dst, const MemOperand& mem,
+ Register scratch) {
+ Register base = mem.ra();
+ int offset = mem.offset();
+
+ if (!is_int16(offset)) {
+ LoadIntLiteral(scratch, offset);
+ lbzx(dst, MemOperand(base, scratch));
+ } else {
+ lbz(dst, mem);
+ }
+}
+
+
+// Variable length depending on whether offset fits into immediate field
+// MemOperand current only supports d-form
+void MacroAssembler::StoreByte(Register src, const MemOperand& mem,
+ Register scratch) {
+ Register base = mem.ra();
+ int offset = mem.offset();
+
+ if (!is_int16(offset)) {
+ LoadIntLiteral(scratch, offset);
+ stbx(src, MemOperand(base, scratch));
+ } else {
+ stb(src, mem);
+ }
+}
+
+
+void MacroAssembler::LoadRepresentation(Register dst, const MemOperand& mem,
+ Representation r, Register scratch) {
+ DCHECK(!r.IsDouble());
+ if (r.IsInteger8()) {
+ LoadByte(dst, mem, scratch);
+ extsb(dst, dst);
+ } else if (r.IsUInteger8()) {
+ LoadByte(dst, mem, scratch);
+ } else if (r.IsInteger16()) {
+ LoadHalfWord(dst, mem, scratch);
+ extsh(dst, dst);
+ } else if (r.IsUInteger16()) {
+ LoadHalfWord(dst, mem, scratch);
+#if V8_TARGET_ARCH_PPC64
+ } else if (r.IsInteger32()) {
+ LoadWord(dst, mem, scratch);
+#endif
+ } else {
+ LoadP(dst, mem, scratch);
+ }
+}
+
+
+void MacroAssembler::StoreRepresentation(Register src, const MemOperand& mem,
+ Representation r, Register scratch) {
+ DCHECK(!r.IsDouble());
+ if (r.IsInteger8() || r.IsUInteger8()) {
+ StoreByte(src, mem, scratch);
+ } else if (r.IsInteger16() || r.IsUInteger16()) {
+ StoreHalfWord(src, mem, scratch);
+#if V8_TARGET_ARCH_PPC64
+ } else if (r.IsInteger32()) {
+ StoreWord(src, mem, scratch);
+#endif
+ } else {
+ if (r.IsHeapObject()) {
+ AssertNotSmi(src);
+ } else if (r.IsSmi()) {
+ AssertSmi(src);
+ }
+ StoreP(src, mem, scratch);
+ }
+}
+
+
+void MacroAssembler::TestJSArrayForAllocationMemento(Register receiver_reg,
+ Register scratch_reg,
+ Label* no_memento_found) {
+ ExternalReference new_space_start =
+ ExternalReference::new_space_start(isolate());
+ ExternalReference new_space_allocation_top =
+ ExternalReference::new_space_allocation_top_address(isolate());
+ addi(scratch_reg, receiver_reg,
+ Operand(JSArray::kSize + AllocationMemento::kSize - kHeapObjectTag));
+ Cmpi(scratch_reg, Operand(new_space_start), r0);
+ blt(no_memento_found);
+ mov(ip, Operand(new_space_allocation_top));
+ LoadP(ip, MemOperand(ip));
+ cmp(scratch_reg, ip);
+ bgt(no_memento_found);
+ LoadP(scratch_reg, MemOperand(scratch_reg, -AllocationMemento::kSize));
+ Cmpi(scratch_reg, Operand(isolate()->factory()->allocation_memento_map()),
+ r0);
+}
+
+
+Register GetRegisterThatIsNotOneOf(Register reg1, Register reg2, Register reg3,
+ Register reg4, Register reg5,
+ Register reg6) {
+ RegList regs = 0;
+ if (reg1.is_valid()) regs |= reg1.bit();
+ if (reg2.is_valid()) regs |= reg2.bit();
+ if (reg3.is_valid()) regs |= reg3.bit();
+ if (reg4.is_valid()) regs |= reg4.bit();
+ if (reg5.is_valid()) regs |= reg5.bit();
+ if (reg6.is_valid()) regs |= reg6.bit();
+
+ for (int i = 0; i < Register::NumAllocatableRegisters(); i++) {
+ Register candidate = Register::FromAllocationIndex(i);
+ if (regs & candidate.bit()) continue;
+ return candidate;
+ }
+ UNREACHABLE();
+ return no_reg;
+}
+
+
+void MacroAssembler::JumpIfDictionaryInPrototypeChain(Register object,
+ Register scratch0,
+ Register scratch1,
+ Label* found) {
+ DCHECK(!scratch1.is(scratch0));
+ Factory* factory = isolate()->factory();
+ Register current = scratch0;
+ Label loop_again;
+
+ // scratch contained elements pointer.
+ mr(current, object);
+
+ // Loop based on the map going up the prototype chain.
+ bind(&loop_again);
+ LoadP(current, FieldMemOperand(current, HeapObject::kMapOffset));
+ lbz(scratch1, FieldMemOperand(current, Map::kBitField2Offset));
+ DecodeField<Map::ElementsKindBits>(scratch1);
+ cmpi(scratch1, Operand(DICTIONARY_ELEMENTS));
+ beq(found);
+ LoadP(current, FieldMemOperand(current, Map::kPrototypeOffset));
+ Cmpi(current, Operand(factory->null_value()), r0);
+ bne(&loop_again);
+}
+
+
+#ifdef DEBUG
+bool AreAliased(Register reg1, Register reg2, Register reg3, Register reg4,
+ Register reg5, Register reg6, Register reg7, Register reg8) {
+ int n_of_valid_regs = reg1.is_valid() + reg2.is_valid() + reg3.is_valid() +
+ reg4.is_valid() + reg5.is_valid() + reg6.is_valid() +
+ reg7.is_valid() + reg8.is_valid();
+
+ RegList regs = 0;
+ if (reg1.is_valid()) regs |= reg1.bit();
+ if (reg2.is_valid()) regs |= reg2.bit();
+ if (reg3.is_valid()) regs |= reg3.bit();
+ if (reg4.is_valid()) regs |= reg4.bit();
+ if (reg5.is_valid()) regs |= reg5.bit();
+ if (reg6.is_valid()) regs |= reg6.bit();
+ if (reg7.is_valid()) regs |= reg7.bit();
+ if (reg8.is_valid()) regs |= reg8.bit();
+ int n_of_non_aliasing_regs = NumRegs(regs);
+
+ return n_of_valid_regs != n_of_non_aliasing_regs;
+}
+#endif
+
+
+CodePatcher::CodePatcher(byte* address, int instructions,
+ FlushICache flush_cache)
+ : address_(address),
+ size_(instructions * Assembler::kInstrSize),
+ masm_(NULL, address, size_ + Assembler::kGap),
+ flush_cache_(flush_cache) {
+ // Create a new macro assembler pointing to the address of the code to patch.
+ // The size is adjusted with kGap on order for the assembler to generate size
+ // bytes of instructions without failing with buffer size constraints.
+ DCHECK(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
+}
+
+
+CodePatcher::~CodePatcher() {
+ // Indicate that code has changed.
+ if (flush_cache_ == FLUSH) {
+ CpuFeatures::FlushICache(address_, size_);
+ }
+
+ // Check that the code was patched as expected.
+ DCHECK(masm_.pc_ == address_ + size_);
+ DCHECK(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
+}
+
+
+void CodePatcher::Emit(Instr instr) { masm()->emit(instr); }
+
+
+void CodePatcher::EmitCondition(Condition cond) {
+ Instr instr = Assembler::instr_at(masm_.pc_);
+ switch (cond) {
+ case eq:
+ instr = (instr & ~kCondMask) | BT;
+ break;
+ case ne:
+ instr = (instr & ~kCondMask) | BF;
+ break;
+ default:
+ UNIMPLEMENTED();
+ }
+ masm_.emit(instr);
+}
+
+
+void MacroAssembler::TruncatingDiv(Register result, Register dividend,
+ int32_t divisor) {
+ DCHECK(!dividend.is(result));
+ DCHECK(!dividend.is(r0));
+ DCHECK(!result.is(r0));
+ base::MagicNumbersForDivision<uint32_t> mag =
+ base::SignedDivisionByConstant(static_cast<uint32_t>(divisor));
+ mov(r0, Operand(mag.multiplier));
+ mulhw(result, dividend, r0);
+ bool neg = (mag.multiplier & (static_cast<uint32_t>(1) << 31)) != 0;
+ if (divisor > 0 && neg) {
+ add(result, result, dividend);
+ }
+ if (divisor < 0 && !neg && mag.multiplier > 0) {
+ sub(result, result, dividend);
+ }
+ if (mag.shift > 0) srawi(result, result, mag.shift);
+ ExtractBit(r0, dividend, 31);
+ add(result, result, r0);
+}
+
+} // namespace internal
+} // namespace v8
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_PPC_MACRO_ASSEMBLER_PPC_H_
+#define V8_PPC_MACRO_ASSEMBLER_PPC_H_
+
+#include "src/assembler.h"
+#include "src/bailout-reason.h"
+#include "src/frames.h"
+#include "src/globals.h"
+
+namespace v8 {
+namespace internal {
+
+// ----------------------------------------------------------------------------
+// Static helper functions
+
+// Generate a MemOperand for loading a field from an object.
+inline MemOperand FieldMemOperand(Register object, int offset) {
+ return MemOperand(object, offset - kHeapObjectTag);
+}
+
+
+// Flags used for AllocateHeapNumber
+enum TaggingMode {
+ // Tag the result.
+ TAG_RESULT,
+ // Don't tag
+ DONT_TAG_RESULT
+};
+
+
+enum RememberedSetAction { EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET };
+enum SmiCheck { INLINE_SMI_CHECK, OMIT_SMI_CHECK };
+enum PointersToHereCheck {
+ kPointersToHereMaybeInteresting,
+ kPointersToHereAreAlwaysInteresting
+};
+enum LinkRegisterStatus { kLRHasNotBeenSaved, kLRHasBeenSaved };
+
+
+Register GetRegisterThatIsNotOneOf(Register reg1, Register reg2 = no_reg,
+ Register reg3 = no_reg,
+ Register reg4 = no_reg,
+ Register reg5 = no_reg,
+ Register reg6 = no_reg);
+
+
+#ifdef DEBUG
+bool AreAliased(Register reg1, Register reg2, Register reg3 = no_reg,
+ Register reg4 = no_reg, Register reg5 = no_reg,
+ Register reg6 = no_reg, Register reg7 = no_reg,
+ Register reg8 = no_reg);
+#endif
+
+// These exist to provide portability between 32 and 64bit
+#if V8_TARGET_ARCH_PPC64
+#define LoadPU ldu
+#define LoadPX ldx
+#define LoadPUX ldux
+#define StorePU stdu
+#define StorePX stdx
+#define StorePUX stdux
+#define ShiftLeftImm sldi
+#define ShiftRightImm srdi
+#define ClearLeftImm clrldi
+#define ClearRightImm clrrdi
+#define ShiftRightArithImm sradi
+#define ShiftLeft_ sld
+#define ShiftRight_ srd
+#define ShiftRightArith srad
+#define Mul mulld
+#define Div divd
+#else
+#define LoadPU lwzu
+#define LoadPX lwzx
+#define LoadPUX lwzux
+#define StorePU stwu
+#define StorePX stwx
+#define StorePUX stwux
+#define ShiftLeftImm slwi
+#define ShiftRightImm srwi
+#define ClearLeftImm clrlwi
+#define ClearRightImm clrrwi
+#define ShiftRightArithImm srawi
+#define ShiftLeft_ slw
+#define ShiftRight_ srw
+#define ShiftRightArith sraw
+#define Mul mullw
+#define Div divw
+#endif
+
+
+// MacroAssembler implements a collection of frequently used macros.
+class MacroAssembler : public Assembler {
+ public:
+ // The isolate parameter can be NULL if the macro assembler should
+ // not use isolate-dependent functionality. In this case, it's the
+ // responsibility of the caller to never invoke such function on the
+ // macro assembler.
+ MacroAssembler(Isolate* isolate, void* buffer, int size);
+
+
+ // Returns the size of a call in instructions. Note, the value returned is
+ // only valid as long as no entries are added to the constant pool between
+ // checking the call size and emitting the actual call.
+ static int CallSize(Register target);
+ int CallSize(Address target, RelocInfo::Mode rmode, Condition cond = al);
+ static int CallSizeNotPredictableCodeSize(Address target,
+ RelocInfo::Mode rmode,
+ Condition cond = al);
+
+ // Jump, Call, and Ret pseudo instructions implementing inter-working.
+ void Jump(Register target);
+ void JumpToJSEntry(Register target);
+ void Jump(Address target, RelocInfo::Mode rmode, Condition cond = al,
+ CRegister cr = cr7);
+ void Jump(Handle<Code> code, RelocInfo::Mode rmode, Condition cond = al);
+ void Call(Register target);
+ void CallJSEntry(Register target);
+ void Call(Address target, RelocInfo::Mode rmode, Condition cond = al);
+ int CallSize(Handle<Code> code,
+ RelocInfo::Mode rmode = RelocInfo::CODE_TARGET,
+ TypeFeedbackId ast_id = TypeFeedbackId::None(),
+ Condition cond = al);
+ void Call(Handle<Code> code, RelocInfo::Mode rmode = RelocInfo::CODE_TARGET,
+ TypeFeedbackId ast_id = TypeFeedbackId::None(),
+ Condition cond = al);
+ void Ret(Condition cond = al);
+
+ // Emit code to discard a non-negative number of pointer-sized elements
+ // from the stack, clobbering only the sp register.
+ void Drop(int count, Condition cond = al);
+
+ void Ret(int drop, Condition cond = al);
+
+ void Call(Label* target);
+
+ // Emit call to the code we are currently generating.
+ void CallSelf() {
+ Handle<Code> self(reinterpret_cast<Code**>(CodeObject().location()));
+ Call(self, RelocInfo::CODE_TARGET);
+ }
+
+ // Register move. May do nothing if the registers are identical.
+ void Move(Register dst, Handle<Object> value);
+ void Move(Register dst, Register src, Condition cond = al);
+ void Move(DoubleRegister dst, DoubleRegister src);
+
+ void MultiPush(RegList regs);
+ void MultiPop(RegList regs);
+
+ // Load an object from the root table.
+ void LoadRoot(Register destination, Heap::RootListIndex index,
+ Condition cond = al);
+ // Store an object to the root table.
+ void StoreRoot(Register source, Heap::RootListIndex index,
+ Condition cond = al);
+
+ // ---------------------------------------------------------------------------
+ // GC Support
+
+ void IncrementalMarkingRecordWriteHelper(Register object, Register value,
+ Register address);
+
+ enum RememberedSetFinalAction { kReturnAtEnd, kFallThroughAtEnd };
+
+ // Record in the remembered set the fact that we have a pointer to new space
+ // at the address pointed to by the addr register. Only works if addr is not
+ // in new space.
+ void RememberedSetHelper(Register object, // Used for debug code.
+ Register addr, Register scratch,
+ SaveFPRegsMode save_fp,
+ RememberedSetFinalAction and_then);
+
+ void CheckPageFlag(Register object, Register scratch, int mask, Condition cc,
+ Label* condition_met);
+
+ void CheckMapDeprecated(Handle<Map> map, Register scratch,
+ Label* if_deprecated);
+
+ // Check if object is in new space. Jumps if the object is not in new space.
+ // The register scratch can be object itself, but scratch will be clobbered.
+ void JumpIfNotInNewSpace(Register object, Register scratch, Label* branch) {
+ InNewSpace(object, scratch, ne, branch);
+ }
+
+ // Check if object is in new space. Jumps if the object is in new space.
+ // The register scratch can be object itself, but it will be clobbered.
+ void JumpIfInNewSpace(Register object, Register scratch, Label* branch) {
+ InNewSpace(object, scratch, eq, branch);
+ }
+
+ // Check if an object has a given incremental marking color.
+ void HasColor(Register object, Register scratch0, Register scratch1,
+ Label* has_color, int first_bit, int second_bit);
+
+ void JumpIfBlack(Register object, Register scratch0, Register scratch1,
+ Label* on_black);
+
+ // Checks the color of an object. If the object is already grey or black
+ // then we just fall through, since it is already live. If it is white and
+ // we can determine that it doesn't need to be scanned, then we just mark it
+ // black and fall through. For the rest we jump to the label so the
+ // incremental marker can fix its assumptions.
+ void EnsureNotWhite(Register object, Register scratch1, Register scratch2,
+ Register scratch3, Label* object_is_white_and_not_data);
+
+ // Detects conservatively whether an object is data-only, i.e. it does need to
+ // be scanned by the garbage collector.
+ void JumpIfDataObject(Register value, Register scratch,
+ Label* not_data_object);
+
+ // Notify the garbage collector that we wrote a pointer into an object.
+ // |object| is the object being stored into, |value| is the object being
+ // stored. value and scratch registers are clobbered by the operation.
+ // The offset is the offset from the start of the object, not the offset from
+ // the tagged HeapObject pointer. For use with FieldOperand(reg, off).
+ void RecordWriteField(
+ Register object, int offset, Register value, Register scratch,
+ LinkRegisterStatus lr_status, SaveFPRegsMode save_fp,
+ RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
+ SmiCheck smi_check = INLINE_SMI_CHECK,
+ PointersToHereCheck pointers_to_here_check_for_value =
+ kPointersToHereMaybeInteresting);
+
+ // As above, but the offset has the tag presubtracted. For use with
+ // MemOperand(reg, off).
+ inline void RecordWriteContextSlot(
+ Register context, int offset, Register value, Register scratch,
+ LinkRegisterStatus lr_status, SaveFPRegsMode save_fp,
+ RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
+ SmiCheck smi_check = INLINE_SMI_CHECK,
+ PointersToHereCheck pointers_to_here_check_for_value =
+ kPointersToHereMaybeInteresting) {
+ RecordWriteField(context, offset + kHeapObjectTag, value, scratch,
+ lr_status, save_fp, remembered_set_action, smi_check,
+ pointers_to_here_check_for_value);
+ }
+
+ void RecordWriteForMap(Register object, Register map, Register dst,
+ LinkRegisterStatus lr_status, SaveFPRegsMode save_fp);
+
+ // For a given |object| notify the garbage collector that the slot |address|
+ // has been written. |value| is the object being stored. The value and
+ // address registers are clobbered by the operation.
+ void RecordWrite(
+ Register object, Register address, Register value,
+ LinkRegisterStatus lr_status, SaveFPRegsMode save_fp,
+ RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
+ SmiCheck smi_check = INLINE_SMI_CHECK,
+ PointersToHereCheck pointers_to_here_check_for_value =
+ kPointersToHereMaybeInteresting);
+
+ void Push(Register src) { push(src); }
+
+ // Push a handle.
+ void Push(Handle<Object> handle);
+ void Push(Smi* smi) { Push(Handle<Smi>(smi, isolate())); }
+
+ // Push two registers. Pushes leftmost register first (to highest address).
+ void Push(Register src1, Register src2) {
+ StorePU(src2, MemOperand(sp, -2 * kPointerSize));
+ StoreP(src1, MemOperand(sp, kPointerSize));
+ }
+
+ // Push three registers. Pushes leftmost register first (to highest address).
+ void Push(Register src1, Register src2, Register src3) {
+ StorePU(src3, MemOperand(sp, -3 * kPointerSize));
+ StoreP(src2, MemOperand(sp, kPointerSize));
+ StoreP(src1, MemOperand(sp, 2 * kPointerSize));
+ }
+
+ // Push four registers. Pushes leftmost register first (to highest address).
+ void Push(Register src1, Register src2, Register src3, Register src4) {
+ StorePU(src4, MemOperand(sp, -4 * kPointerSize));
+ StoreP(src3, MemOperand(sp, kPointerSize));
+ StoreP(src2, MemOperand(sp, 2 * kPointerSize));
+ StoreP(src1, MemOperand(sp, 3 * kPointerSize));
+ }
+
+ // Push five registers. Pushes leftmost register first (to highest address).
+ void Push(Register src1, Register src2, Register src3, Register src4,
+ Register src5) {
+ StorePU(src5, MemOperand(sp, -5 * kPointerSize));
+ StoreP(src4, MemOperand(sp, kPointerSize));
+ StoreP(src3, MemOperand(sp, 2 * kPointerSize));
+ StoreP(src2, MemOperand(sp, 3 * kPointerSize));
+ StoreP(src1, MemOperand(sp, 4 * kPointerSize));
+ }
+
+ void Pop(Register dst) { pop(dst); }
+
+ // Pop two registers. Pops rightmost register first (from lower address).
+ void Pop(Register src1, Register src2) {
+ LoadP(src2, MemOperand(sp, 0));
+ LoadP(src1, MemOperand(sp, kPointerSize));
+ addi(sp, sp, Operand(2 * kPointerSize));
+ }
+
+ // Pop three registers. Pops rightmost register first (from lower address).
+ void Pop(Register src1, Register src2, Register src3) {
+ LoadP(src3, MemOperand(sp, 0));
+ LoadP(src2, MemOperand(sp, kPointerSize));
+ LoadP(src1, MemOperand(sp, 2 * kPointerSize));
+ addi(sp, sp, Operand(3 * kPointerSize));
+ }
+
+ // Pop four registers. Pops rightmost register first (from lower address).
+ void Pop(Register src1, Register src2, Register src3, Register src4) {
+ LoadP(src4, MemOperand(sp, 0));
+ LoadP(src3, MemOperand(sp, kPointerSize));
+ LoadP(src2, MemOperand(sp, 2 * kPointerSize));
+ LoadP(src1, MemOperand(sp, 3 * kPointerSize));
+ addi(sp, sp, Operand(4 * kPointerSize));
+ }
+
+ // Pop five registers. Pops rightmost register first (from lower address).
+ void Pop(Register src1, Register src2, Register src3, Register src4,
+ Register src5) {
+ LoadP(src5, MemOperand(sp, 0));
+ LoadP(src4, MemOperand(sp, kPointerSize));
+ LoadP(src3, MemOperand(sp, 2 * kPointerSize));
+ LoadP(src2, MemOperand(sp, 3 * kPointerSize));
+ LoadP(src1, MemOperand(sp, 4 * kPointerSize));
+ addi(sp, sp, Operand(5 * kPointerSize));
+ }
+
+ // Push a fixed frame, consisting of lr, fp, context and
+ // JS function / marker id if marker_reg is a valid register.
+ void PushFixedFrame(Register marker_reg = no_reg);
+ void PopFixedFrame(Register marker_reg = no_reg);
+
+ // Push and pop the registers that can hold pointers, as defined by the
+ // RegList constant kSafepointSavedRegisters.
+ void PushSafepointRegisters();
+ void PopSafepointRegisters();
+ // Store value in register src in the safepoint stack slot for
+ // register dst.
+ void StoreToSafepointRegisterSlot(Register src, Register dst);
+ // Load the value of the src register from its safepoint stack slot
+ // into register dst.
+ void LoadFromSafepointRegisterSlot(Register dst, Register src);
+
+ // Flush the I-cache from asm code. You should use CpuFeatures::FlushICache
+ // from C.
+ // Does not handle errors.
+ void FlushICache(Register address, size_t size, Register scratch);
+
+ // If the value is a NaN, canonicalize the value else, do nothing.
+ void CanonicalizeNaN(const DoubleRegister dst, const DoubleRegister src);
+ void CanonicalizeNaN(const DoubleRegister value) {
+ CanonicalizeNaN(value, value);
+ }
+
+ // Converts the integer (untagged smi) in |src| to a double, storing
+ // the result to |double_dst|
+ void ConvertIntToDouble(Register src, DoubleRegister double_dst);
+
+ // Converts the unsigned integer (untagged smi) in |src| to
+ // a double, storing the result to |double_dst|
+ void ConvertUnsignedIntToDouble(Register src, DoubleRegister double_dst);
+
+ // Converts the integer (untagged smi) in |src| to
+ // a float, storing the result in |dst|
+ // Warning: The value in |int_scrach| will be changed in the process!
+ void ConvertIntToFloat(const DoubleRegister dst, const Register src,
+ const Register int_scratch);
+
+ // Converts the double_input to an integer. Note that, upon return,
+ // the contents of double_dst will also hold the fixed point representation.
+ void ConvertDoubleToInt64(const DoubleRegister double_input,
+#if !V8_TARGET_ARCH_PPC64
+ const Register dst_hi,
+#endif
+ const Register dst, const DoubleRegister double_dst,
+ FPRoundingMode rounding_mode = kRoundToZero);
+
+ // Generates function and stub prologue code.
+ void StubPrologue(int prologue_offset = 0);
+ void Prologue(bool code_pre_aging, int prologue_offset = 0);
+
+ // Enter exit frame.
+ // stack_space - extra stack space, used for alignment before call to C.
+ void EnterExitFrame(bool save_doubles, int stack_space = 0);
+
+ // Leave the current exit frame. Expects the return value in r0.
+ // Expect the number of values, pushed prior to the exit frame, to
+ // remove in a register (or no_reg, if there is nothing to remove).
+ void LeaveExitFrame(bool save_doubles, Register argument_count,
+ bool restore_context);
+
+ // Get the actual activation frame alignment for target environment.
+ static int ActivationFrameAlignment();
+
+ void LoadContext(Register dst, int context_chain_length);
+
+ // Conditionally load the cached Array transitioned map of type
+ // transitioned_kind from the native context if the map in register
+ // map_in_out is the cached Array map in the native context of
+ // expected_kind.
+ void LoadTransitionedArrayMapConditional(ElementsKind expected_kind,
+ ElementsKind transitioned_kind,
+ Register map_in_out,
+ Register scratch,
+ Label* no_map_match);
+
+ void LoadGlobalFunction(int index, Register function);
+
+ // Load the initial map from the global function. The registers
+ // function and map can be the same, function is then overwritten.
+ void LoadGlobalFunctionInitialMap(Register function, Register map,
+ Register scratch);
+
+ void InitializeRootRegister() {
+ ExternalReference roots_array_start =
+ ExternalReference::roots_array_start(isolate());
+ mov(kRootRegister, Operand(roots_array_start));
+ }
+
+ // ----------------------------------------------------------------
+ // new PPC macro-assembler interfaces that are slightly higher level
+ // than assembler-ppc and may generate variable length sequences
+
+ // load a literal signed int value <value> to GPR <dst>
+ void LoadIntLiteral(Register dst, int value);
+
+ // load an SMI value <value> to GPR <dst>
+ void LoadSmiLiteral(Register dst, Smi* smi);
+
+ // load a literal double value <value> to FPR <result>
+ void LoadDoubleLiteral(DoubleRegister result, double value, Register scratch);
+
+ void LoadWord(Register dst, const MemOperand& mem, Register scratch);
+
+ void LoadWordArith(Register dst, const MemOperand& mem,
+ Register scratch = no_reg);
+
+ void StoreWord(Register src, const MemOperand& mem, Register scratch);
+
+ void LoadHalfWord(Register dst, const MemOperand& mem, Register scratch);
+
+ void StoreHalfWord(Register src, const MemOperand& mem, Register scratch);
+
+ void LoadByte(Register dst, const MemOperand& mem, Register scratch);
+
+ void StoreByte(Register src, const MemOperand& mem, Register scratch);
+
+ void LoadRepresentation(Register dst, const MemOperand& mem, Representation r,
+ Register scratch = no_reg);
+
+ void StoreRepresentation(Register src, const MemOperand& mem,
+ Representation r, Register scratch = no_reg);
+
+ // Move values between integer and floating point registers.
+ void MovIntToDouble(DoubleRegister dst, Register src, Register scratch);
+ void MovUnsignedIntToDouble(DoubleRegister dst, Register src,
+ Register scratch);
+ void MovInt64ToDouble(DoubleRegister dst,
+#if !V8_TARGET_ARCH_PPC64
+ Register src_hi,
+#endif
+ Register src);
+#if V8_TARGET_ARCH_PPC64
+ void MovInt64ComponentsToDouble(DoubleRegister dst, Register src_hi,
+ Register src_lo, Register scratch);
+#endif
+ void MovDoubleLowToInt(Register dst, DoubleRegister src);
+ void MovDoubleHighToInt(Register dst, DoubleRegister src);
+ void MovDoubleToInt64(
+#if !V8_TARGET_ARCH_PPC64
+ Register dst_hi,
+#endif
+ Register dst, DoubleRegister src);
+
+ void Add(Register dst, Register src, intptr_t value, Register scratch);
+ void Cmpi(Register src1, const Operand& src2, Register scratch,
+ CRegister cr = cr7);
+ void Cmpli(Register src1, const Operand& src2, Register scratch,
+ CRegister cr = cr7);
+ void Cmpwi(Register src1, const Operand& src2, Register scratch,
+ CRegister cr = cr7);
+ void Cmplwi(Register src1, const Operand& src2, Register scratch,
+ CRegister cr = cr7);
+ void And(Register ra, Register rs, const Operand& rb, RCBit rc = LeaveRC);
+ void Or(Register ra, Register rs, const Operand& rb, RCBit rc = LeaveRC);
+ void Xor(Register ra, Register rs, const Operand& rb, RCBit rc = LeaveRC);
+
+ void AddSmiLiteral(Register dst, Register src, Smi* smi, Register scratch);
+ void SubSmiLiteral(Register dst, Register src, Smi* smi, Register scratch);
+ void CmpSmiLiteral(Register src1, Smi* smi, Register scratch,
+ CRegister cr = cr7);
+ void CmplSmiLiteral(Register src1, Smi* smi, Register scratch,
+ CRegister cr = cr7);
+ void AndSmiLiteral(Register dst, Register src, Smi* smi, Register scratch,
+ RCBit rc = LeaveRC);
+
+ // Set new rounding mode RN to FPSCR
+ void SetRoundingMode(FPRoundingMode RN);
+
+ // reset rounding mode to default (kRoundToNearest)
+ void ResetRoundingMode();
+
+ // These exist to provide portability between 32 and 64bit
+ void LoadP(Register dst, const MemOperand& mem, Register scratch = no_reg);
+ void StoreP(Register src, const MemOperand& mem, Register scratch = no_reg);
+
+ // ---------------------------------------------------------------------------
+ // JavaScript invokes
+
+ // Invoke the JavaScript function code by either calling or jumping.
+ void InvokeCode(Register code, const ParameterCount& expected,
+ const ParameterCount& actual, InvokeFlag flag,
+ const CallWrapper& call_wrapper);
+
+ // Invoke the JavaScript function in the given register. Changes the
+ // current context to the context in the function before invoking.
+ void InvokeFunction(Register function, const ParameterCount& actual,
+ InvokeFlag flag, const CallWrapper& call_wrapper);
+
+ void InvokeFunction(Register function, const ParameterCount& expected,
+ const ParameterCount& actual, InvokeFlag flag,
+ const CallWrapper& call_wrapper);
+
+ void InvokeFunction(Handle<JSFunction> function,
+ const ParameterCount& expected,
+ const ParameterCount& actual, InvokeFlag flag,
+ const CallWrapper& call_wrapper);
+
+ void IsObjectJSObjectType(Register heap_object, Register map,
+ Register scratch, Label* fail);
+
+ void IsInstanceJSObjectType(Register map, Register scratch, Label* fail);
+
+ void IsObjectJSStringType(Register object, Register scratch, Label* fail);
+
+ void IsObjectNameType(Register object, Register scratch, Label* fail);
+
+ // ---------------------------------------------------------------------------
+ // Debugger Support
+
+ void DebugBreak();
+
+ // ---------------------------------------------------------------------------
+ // Exception handling
+
+ // Push a new try handler and link into try handler chain.
+ void PushTryHandler(StackHandler::Kind kind, int handler_index);
+
+ // Unlink the stack handler on top of the stack from the try handler chain.
+ // Must preserve the result register.
+ void PopTryHandler();
+
+ // Passes thrown value to the handler of top of the try handler chain.
+ void Throw(Register value);
+
+ // Propagates an uncatchable exception to the top of the current JS stack's
+ // handler chain.
+ void ThrowUncatchable(Register value);
+
+ // ---------------------------------------------------------------------------
+ // Inline caching support
+
+ // Generate code for checking access rights - used for security checks
+ // on access to global objects across environments. The holder register
+ // is left untouched, whereas both scratch registers are clobbered.
+ void CheckAccessGlobalProxy(Register holder_reg, Register scratch,
+ Label* miss);
+
+ void GetNumberHash(Register t0, Register scratch);
+
+ void LoadFromNumberDictionary(Label* miss, Register elements, Register key,
+ Register result, Register t0, Register t1,
+ Register t2);
+
+
+ inline void MarkCode(NopMarkerTypes type) { nop(type); }
+
+ // Check if the given instruction is a 'type' marker.
+ // i.e. check if is is a mov r<type>, r<type> (referenced as nop(type))
+ // These instructions are generated to mark special location in the code,
+ // like some special IC code.
+ static inline bool IsMarkedCode(Instr instr, int type) {
+ DCHECK((FIRST_IC_MARKER <= type) && (type < LAST_CODE_MARKER));
+ return IsNop(instr, type);
+ }
+
+
+ static inline int GetCodeMarker(Instr instr) {
+ int dst_reg_offset = 12;
+ int dst_mask = 0xf << dst_reg_offset;
+ int src_mask = 0xf;
+ int dst_reg = (instr & dst_mask) >> dst_reg_offset;
+ int src_reg = instr & src_mask;
+ uint32_t non_register_mask = ~(dst_mask | src_mask);
+ uint32_t mov_mask = al | 13 << 21;
+
+ // Return <n> if we have a mov rn rn, else return -1.
+ int type = ((instr & non_register_mask) == mov_mask) &&
+ (dst_reg == src_reg) && (FIRST_IC_MARKER <= dst_reg) &&
+ (dst_reg < LAST_CODE_MARKER)
+ ? src_reg
+ : -1;
+ DCHECK((type == -1) ||
+ ((FIRST_IC_MARKER <= type) && (type < LAST_CODE_MARKER)));
+ return type;
+ }
+
+
+ // ---------------------------------------------------------------------------
+ // Allocation support
+
+ // Allocate an object in new space or old pointer space. The object_size is
+ // specified either in bytes or in words if the allocation flag SIZE_IN_WORDS
+ // is passed. If the space is exhausted control continues at the gc_required
+ // label. The allocated object is returned in result. If the flag
+ // tag_allocated_object is true the result is tagged as as a heap object.
+ // All registers are clobbered also when control continues at the gc_required
+ // label.
+ void Allocate(int object_size, Register result, Register scratch1,
+ Register scratch2, Label* gc_required, AllocationFlags flags);
+
+ void Allocate(Register object_size, Register result, Register scratch1,
+ Register scratch2, Label* gc_required, AllocationFlags flags);
+
+ // Undo allocation in new space. The object passed and objects allocated after
+ // it will no longer be allocated. The caller must make sure that no pointers
+ // are left to the object(s) no longer allocated as they would be invalid when
+ // allocation is undone.
+ void UndoAllocationInNewSpace(Register object, Register scratch);
+
+
+ void AllocateTwoByteString(Register result, Register length,
+ Register scratch1, Register scratch2,
+ Register scratch3, Label* gc_required);
+ void AllocateOneByteString(Register result, Register length,
+ Register scratch1, Register scratch2,
+ Register scratch3, Label* gc_required);
+ void AllocateTwoByteConsString(Register result, Register length,
+ Register scratch1, Register scratch2,
+ Label* gc_required);
+ void AllocateOneByteConsString(Register result, Register length,
+ Register scratch1, Register scratch2,
+ Label* gc_required);
+ void AllocateTwoByteSlicedString(Register result, Register length,
+ Register scratch1, Register scratch2,
+ Label* gc_required);
+ void AllocateOneByteSlicedString(Register result, Register length,
+ Register scratch1, Register scratch2,
+ Label* gc_required);
+
+ // Allocates a heap number or jumps to the gc_required label if the young
+ // space is full and a scavenge is needed. All registers are clobbered also
+ // when control continues at the gc_required label.
+ void AllocateHeapNumber(Register result, Register scratch1, Register scratch2,
+ Register heap_number_map, Label* gc_required,
+ TaggingMode tagging_mode = TAG_RESULT,
+ MutableMode mode = IMMUTABLE);
+ void AllocateHeapNumberWithValue(Register result, DoubleRegister value,
+ Register scratch1, Register scratch2,
+ Register heap_number_map,
+ Label* gc_required);
+
+ // Copies a fixed number of fields of heap objects from src to dst.
+ void CopyFields(Register dst, Register src, RegList temps, int field_count);
+
+ // Copies a number of bytes from src to dst. All registers are clobbered. On
+ // exit src and dst will point to the place just after where the last byte was
+ // read or written and length will be zero.
+ void CopyBytes(Register src, Register dst, Register length, Register scratch);
+
+ // Initialize fields with filler values. |count| fields starting at
+ // |start_offset| are overwritten with the value in |filler|. At the end the
+ // loop, |start_offset| points at the next uninitialized field. |count| is
+ // assumed to be non-zero.
+ void InitializeNFieldsWithFiller(Register start_offset, Register count,
+ Register filler);
+
+ // Initialize fields with filler values. Fields starting at |start_offset|
+ // not including end_offset are overwritten with the value in |filler|. At
+ // the end the loop, |start_offset| takes the value of |end_offset|.
+ void InitializeFieldsWithFiller(Register start_offset, Register end_offset,
+ Register filler);
+
+ // ---------------------------------------------------------------------------
+ // Support functions.
+
+ // Try to get function prototype of a function and puts the value in
+ // the result register. Checks that the function really is a
+ // function and jumps to the miss label if the fast checks fail. The
+ // function register will be untouched; the other registers may be
+ // clobbered.
+ void TryGetFunctionPrototype(Register function, Register result,
+ Register scratch, Label* miss,
+ bool miss_on_bound_function = false);
+
+ // Compare object type for heap object. heap_object contains a non-Smi
+ // whose object type should be compared with the given type. This both
+ // sets the flags and leaves the object type in the type_reg register.
+ // It leaves the map in the map register (unless the type_reg and map register
+ // are the same register). It leaves the heap object in the heap_object
+ // register unless the heap_object register is the same register as one of the
+ // other registers.
+ // Type_reg can be no_reg. In that case ip is used.
+ void CompareObjectType(Register heap_object, Register map, Register type_reg,
+ InstanceType type);
+
+ // Compare object type for heap object. Branch to false_label if type
+ // is lower than min_type or greater than max_type.
+ // Load map into the register map.
+ void CheckObjectTypeRange(Register heap_object, Register map,
+ InstanceType min_type, InstanceType max_type,
+ Label* false_label);
+
+ // Compare instance type in a map. map contains a valid map object whose
+ // object type should be compared with the given type. This both
+ // sets the flags and leaves the object type in the type_reg register.
+ void CompareInstanceType(Register map, Register type_reg, InstanceType type);
+
+
+ // Check if a map for a JSObject indicates that the object has fast elements.
+ // Jump to the specified label if it does not.
+ void CheckFastElements(Register map, Register scratch, Label* fail);
+
+ // Check if a map for a JSObject indicates that the object can have both smi
+ // and HeapObject elements. Jump to the specified label if it does not.
+ void CheckFastObjectElements(Register map, Register scratch, Label* fail);
+
+ // Check if a map for a JSObject indicates that the object has fast smi only
+ // elements. Jump to the specified label if it does not.
+ void CheckFastSmiElements(Register map, Register scratch, Label* fail);
+
+ // Check to see if maybe_number can be stored as a double in
+ // FastDoubleElements. If it can, store it at the index specified by key in
+ // the FastDoubleElements array elements. Otherwise jump to fail.
+ void StoreNumberToDoubleElements(Register value_reg, Register key_reg,
+ Register elements_reg, Register scratch1,
+ DoubleRegister double_scratch, Label* fail,
+ int elements_offset = 0);
+
+ // Compare an object's map with the specified map and its transitioned
+ // elements maps if mode is ALLOW_ELEMENT_TRANSITION_MAPS. Condition flags are
+ // set with result of map compare. If multiple map compares are required, the
+ // compare sequences branches to early_success.
+ void CompareMap(Register obj, Register scratch, Handle<Map> map,
+ Label* early_success);
+
+ // As above, but the map of the object is already loaded into the register
+ // which is preserved by the code generated.
+ void CompareMap(Register obj_map, Handle<Map> map, Label* early_success);
+
+ // Check if the map of an object is equal to a specified map and branch to
+ // label if not. Skip the smi check if not required (object is known to be a
+ // heap object). If mode is ALLOW_ELEMENT_TRANSITION_MAPS, then also match
+ // against maps that are ElementsKind transition maps of the specified map.
+ void CheckMap(Register obj, Register scratch, Handle<Map> map, Label* fail,
+ SmiCheckType smi_check_type);
+
+
+ void CheckMap(Register obj, Register scratch, Heap::RootListIndex index,
+ Label* fail, SmiCheckType smi_check_type);
+
+
+ // Check if the map of an object is equal to a specified map and branch to a
+ // specified target if equal. Skip the smi check if not required (object is
+ // known to be a heap object)
+ void DispatchMap(Register obj, Register scratch, Handle<Map> map,
+ Handle<Code> success, SmiCheckType smi_check_type);
+
+
+ // Compare the object in a register to a value from the root list.
+ // Uses the ip register as scratch.
+ void CompareRoot(Register obj, Heap::RootListIndex index);
+
+
+ // Load and check the instance type of an object for being a string.
+ // Loads the type into the second argument register.
+ // Returns a condition that will be enabled if the object was a string.
+ Condition IsObjectStringType(Register obj, Register type) {
+ LoadP(type, FieldMemOperand(obj, HeapObject::kMapOffset));
+ lbz(type, FieldMemOperand(type, Map::kInstanceTypeOffset));
+ andi(r0, type, Operand(kIsNotStringMask));
+ DCHECK_EQ(0, kStringTag);
+ return eq;
+ }
+
+
+ // Picks out an array index from the hash field.
+ // Register use:
+ // hash - holds the index's hash. Clobbered.
+ // index - holds the overwritten index on exit.
+ void IndexFromHash(Register hash, Register index);
+
+ // Get the number of least significant bits from a register
+ void GetLeastBitsFromSmi(Register dst, Register src, int num_least_bits);
+ void GetLeastBitsFromInt32(Register dst, Register src, int mun_least_bits);
+
+ // Load the value of a smi object into a double register.
+ void SmiToDouble(DoubleRegister value, Register smi);
+
+ // Check if a double can be exactly represented as a signed 32-bit integer.
+ // CR_EQ in cr7 is set if true.
+ void TestDoubleIsInt32(DoubleRegister double_input, Register scratch1,
+ Register scratch2, DoubleRegister double_scratch);
+
+ // Try to convert a double to a signed 32-bit integer.
+ // CR_EQ in cr7 is set and result assigned if the conversion is exact.
+ void TryDoubleToInt32Exact(Register result, DoubleRegister double_input,
+ Register scratch, DoubleRegister double_scratch);
+
+ // Floor a double and writes the value to the result register.
+ // Go to exact if the conversion is exact (to be able to test -0),
+ // fall through calling code if an overflow occurred, else go to done.
+ // In return, input_high is loaded with high bits of input.
+ void TryInt32Floor(Register result, DoubleRegister double_input,
+ Register input_high, Register scratch,
+ DoubleRegister double_scratch, Label* done, Label* exact);
+
+ // Performs a truncating conversion of a floating point number as used by
+ // the JS bitwise operations. See ECMA-262 9.5: ToInt32. Goes to 'done' if it
+ // succeeds, otherwise falls through if result is saturated. On return
+ // 'result' either holds answer, or is clobbered on fall through.
+ //
+ // Only public for the test code in test-code-stubs-arm.cc.
+ void TryInlineTruncateDoubleToI(Register result, DoubleRegister input,
+ Label* done);
+
+ // Performs a truncating conversion of a floating point number as used by
+ // the JS bitwise operations. See ECMA-262 9.5: ToInt32.
+ // Exits with 'result' holding the answer.
+ void TruncateDoubleToI(Register result, DoubleRegister double_input);
+
+ // Performs a truncating conversion of a heap number as used by
+ // the JS bitwise operations. See ECMA-262 9.5: ToInt32. 'result' and 'input'
+ // must be different registers. Exits with 'result' holding the answer.
+ void TruncateHeapNumberToI(Register result, Register object);
+
+ // Converts the smi or heap number in object to an int32 using the rules
+ // for ToInt32 as described in ECMAScript 9.5.: the value is truncated
+ // and brought into the range -2^31 .. +2^31 - 1. 'result' and 'input' must be
+ // different registers.
+ void TruncateNumberToI(Register object, Register result,
+ Register heap_number_map, Register scratch1,
+ Label* not_int32);
+
+ // Overflow handling functions.
+ // Usage: call the appropriate arithmetic function and then call one of the
+ // flow control functions with the corresponding label.
+
+ // Compute dst = left + right, setting condition codes. dst may be same as
+ // either left or right (or a unique register). left and right must not be
+ // the same register.
+ void AddAndCheckForOverflow(Register dst, Register left, Register right,
+ Register overflow_dst, Register scratch = r0);
+ void AddAndCheckForOverflow(Register dst, Register left, intptr_t right,
+ Register overflow_dst, Register scratch = r0);
+
+ // Compute dst = left - right, setting condition codes. dst may be same as
+ // either left or right (or a unique register). left and right must not be
+ // the same register.
+ void SubAndCheckForOverflow(Register dst, Register left, Register right,
+ Register overflow_dst, Register scratch = r0);
+
+ void BranchOnOverflow(Label* label) { blt(label, cr0); }
+
+ void BranchOnNoOverflow(Label* label) { bge(label, cr0); }
+
+ void RetOnOverflow(void) {
+ Label label;
+
+ blt(&label, cr0);
+ Ret();
+ bind(&label);
+ }
+
+ void RetOnNoOverflow(void) {
+ Label label;
+
+ bge(&label, cr0);
+ Ret();
+ bind(&label);
+ }
+
+ // Pushes <count> double values to <location>, starting from d<first>.
+ void SaveFPRegs(Register location, int first, int count);
+
+ // Pops <count> double values from <location>, starting from d<first>.
+ void RestoreFPRegs(Register location, int first, int count);
+
+ // ---------------------------------------------------------------------------
+ // Runtime calls
+
+ // Call a code stub.
+ void CallStub(CodeStub* stub, TypeFeedbackId ast_id = TypeFeedbackId::None(),
+ Condition cond = al);
+
+ // Call a code stub.
+ void TailCallStub(CodeStub* stub, Condition cond = al);
+
+ // Call a runtime routine.
+ void CallRuntime(const Runtime::Function* f, int num_arguments,
+ SaveFPRegsMode save_doubles = kDontSaveFPRegs);
+ void CallRuntimeSaveDoubles(Runtime::FunctionId id) {
+ const Runtime::Function* function = Runtime::FunctionForId(id);
+ CallRuntime(function, function->nargs, kSaveFPRegs);
+ }
+
+ // Convenience function: Same as above, but takes the fid instead.
+ void CallRuntime(Runtime::FunctionId id, int num_arguments,
+ SaveFPRegsMode save_doubles = kDontSaveFPRegs) {
+ CallRuntime(Runtime::FunctionForId(id), num_arguments, save_doubles);
+ }
+
+ // Convenience function: call an external reference.
+ void CallExternalReference(const ExternalReference& ext, int num_arguments);
+
+ // Tail call of a runtime routine (jump).
+ // Like JumpToExternalReference, but also takes care of passing the number
+ // of parameters.
+ void TailCallExternalReference(const ExternalReference& ext,
+ int num_arguments, int result_size);
+
+ // Convenience function: tail call a runtime routine (jump).
+ void TailCallRuntime(Runtime::FunctionId fid, int num_arguments,
+ int result_size);
+
+ int CalculateStackPassedWords(int num_reg_arguments,
+ int num_double_arguments);
+
+ // Before calling a C-function from generated code, align arguments on stack.
+ // After aligning the frame, non-register arguments must be stored in
+ // sp[0], sp[4], etc., not pushed. The argument count assumes all arguments
+ // are word sized. If double arguments are used, this function assumes that
+ // all double arguments are stored before core registers; otherwise the
+ // correct alignment of the double values is not guaranteed.
+ // Some compilers/platforms require the stack to be aligned when calling
+ // C++ code.
+ // Needs a scratch register to do some arithmetic. This register will be
+ // trashed.
+ void PrepareCallCFunction(int num_reg_arguments, int num_double_registers,
+ Register scratch);
+ void PrepareCallCFunction(int num_reg_arguments, Register scratch);
+
+ // There are two ways of passing double arguments on ARM, depending on
+ // whether soft or hard floating point ABI is used. These functions
+ // abstract parameter passing for the three different ways we call
+ // C functions from generated code.
+ void MovToFloatParameter(DoubleRegister src);
+ void MovToFloatParameters(DoubleRegister src1, DoubleRegister src2);
+ void MovToFloatResult(DoubleRegister src);
+
+ // Calls a C function and cleans up the space for arguments allocated
+ // by PrepareCallCFunction. The called function is not allowed to trigger a
+ // garbage collection, since that might move the code and invalidate the
+ // return address (unless this is somehow accounted for by the called
+ // function).
+ void CallCFunction(ExternalReference function, int num_arguments);
+ void CallCFunction(Register function, int num_arguments);
+ void CallCFunction(ExternalReference function, int num_reg_arguments,
+ int num_double_arguments);
+ void CallCFunction(Register function, int num_reg_arguments,
+ int num_double_arguments);
+
+ void MovFromFloatParameter(DoubleRegister dst);
+ void MovFromFloatResult(DoubleRegister dst);
+
+ // Calls an API function. Allocates HandleScope, extracts returned value
+ // from handle and propagates exceptions. Restores context. stack_space
+ // - space to be unwound on exit (includes the call JS arguments space and
+ // the additional space allocated for the fast call).
+ void CallApiFunctionAndReturn(Register function_address,
+ ExternalReference thunk_ref, int stack_space,
+ MemOperand return_value_operand,
+ MemOperand* context_restore_operand);
+
+ // Jump to a runtime routine.
+ void JumpToExternalReference(const ExternalReference& builtin);
+
+ // Invoke specified builtin JavaScript function. Adds an entry to
+ // the unresolved list if the name does not resolve.
+ void InvokeBuiltin(Builtins::JavaScript id, InvokeFlag flag,
+ const CallWrapper& call_wrapper = NullCallWrapper());
+
+ // Store the code object for the given builtin in the target register and
+ // setup the function in r1.
+ void GetBuiltinEntry(Register target, Builtins::JavaScript id);
+
+ // Store the function for the given builtin in the target register.
+ void GetBuiltinFunction(Register target, Builtins::JavaScript id);
+
+ Handle<Object> CodeObject() {
+ DCHECK(!code_object_.is_null());
+ return code_object_;
+ }
+
+
+ // Emit code for a truncating division by a constant. The dividend register is
+ // unchanged and ip gets clobbered. Dividend and result must be different.
+ void TruncatingDiv(Register result, Register dividend, int32_t divisor);
+
+ // ---------------------------------------------------------------------------
+ // StatsCounter support
+
+ void SetCounter(StatsCounter* counter, int value, Register scratch1,
+ Register scratch2);
+ void IncrementCounter(StatsCounter* counter, int value, Register scratch1,
+ Register scratch2);
+ void DecrementCounter(StatsCounter* counter, int value, Register scratch1,
+ Register scratch2);
+
+
+ // ---------------------------------------------------------------------------
+ // Debugging
+
+ // Calls Abort(msg) if the condition cond is not satisfied.
+ // Use --debug_code to enable.
+ void Assert(Condition cond, BailoutReason reason, CRegister cr = cr7);
+ void AssertFastElements(Register elements);
+
+ // Like Assert(), but always enabled.
+ void Check(Condition cond, BailoutReason reason, CRegister cr = cr7);
+
+ // Print a message to stdout and abort execution.
+ void Abort(BailoutReason reason);
+
+ // Verify restrictions about code generated in stubs.
+ void set_generating_stub(bool value) { generating_stub_ = value; }
+ bool generating_stub() { return generating_stub_; }
+ void set_has_frame(bool value) { has_frame_ = value; }
+ bool has_frame() { return has_frame_; }
+ inline bool AllowThisStubCall(CodeStub* stub);
+
+ // ---------------------------------------------------------------------------
+ // Number utilities
+
+ // Check whether the value of reg is a power of two and not zero. If not
+ // control continues at the label not_power_of_two. If reg is a power of two
+ // the register scratch contains the value of (reg - 1) when control falls
+ // through.
+ void JumpIfNotPowerOfTwoOrZero(Register reg, Register scratch,
+ Label* not_power_of_two_or_zero);
+ // Check whether the value of reg is a power of two and not zero.
+ // Control falls through if it is, with scratch containing the mask
+ // value (reg - 1).
+ // Otherwise control jumps to the 'zero_and_neg' label if the value of reg is
+ // zero or negative, or jumps to the 'not_power_of_two' label if the value is
+ // strictly positive but not a power of two.
+ void JumpIfNotPowerOfTwoOrZeroAndNeg(Register reg, Register scratch,
+ Label* zero_and_neg,
+ Label* not_power_of_two);
+
+ // ---------------------------------------------------------------------------
+ // Bit testing/extraction
+ //
+ // Bit numbering is such that the least significant bit is bit 0
+ // (for consistency between 32/64-bit).
+
+ // Extract consecutive bits (defined by rangeStart - rangeEnd) from src
+ // and place them into the least significant bits of dst.
+ inline void ExtractBitRange(Register dst, Register src, int rangeStart,
+ int rangeEnd, RCBit rc = LeaveRC) {
+ DCHECK(rangeStart >= rangeEnd && rangeStart < kBitsPerPointer);
+ int rotate = (rangeEnd == 0) ? 0 : kBitsPerPointer - rangeEnd;
+ int width = rangeStart - rangeEnd + 1;
+#if V8_TARGET_ARCH_PPC64
+ rldicl(dst, src, rotate, kBitsPerPointer - width, rc);
+#else
+ rlwinm(dst, src, rotate, kBitsPerPointer - width, kBitsPerPointer - 1, rc);
+#endif
+ }
+
+ inline void ExtractBit(Register dst, Register src, uint32_t bitNumber,
+ RCBit rc = LeaveRC) {
+ ExtractBitRange(dst, src, bitNumber, bitNumber, rc);
+ }
+
+ // Extract consecutive bits (defined by mask) from src and place them
+ // into the least significant bits of dst.
+ inline void ExtractBitMask(Register dst, Register src, uintptr_t mask,
+ RCBit rc = LeaveRC) {
+ int start = kBitsPerPointer - 1;
+ int end;
+ uintptr_t bit = (1L << start);
+
+ while (bit && (mask & bit) == 0) {
+ start--;
+ bit >>= 1;
+ }
+ end = start;
+ bit >>= 1;
+
+ while (bit && (mask & bit)) {
+ end--;
+ bit >>= 1;
+ }
+
+ // 1-bits in mask must be contiguous
+ DCHECK(bit == 0 || (mask & ((bit << 1) - 1)) == 0);
+
+ ExtractBitRange(dst, src, start, end, rc);
+ }
+
+ // Test single bit in value.
+ inline void TestBit(Register value, int bitNumber, Register scratch = r0) {
+ ExtractBitRange(scratch, value, bitNumber, bitNumber, SetRC);
+ }
+
+ // Test consecutive bit range in value. Range is defined by
+ // rangeStart - rangeEnd.
+ inline void TestBitRange(Register value, int rangeStart, int rangeEnd,
+ Register scratch = r0) {
+ ExtractBitRange(scratch, value, rangeStart, rangeEnd, SetRC);
+ }
+
+ // Test consecutive bit range in value. Range is defined by mask.
+ inline void TestBitMask(Register value, uintptr_t mask,
+ Register scratch = r0) {
+ ExtractBitMask(scratch, value, mask, SetRC);
+ }
+
+
+ // ---------------------------------------------------------------------------
+ // Smi utilities
+
+ // Shift left by 1
+ void SmiTag(Register reg, RCBit rc = LeaveRC) { SmiTag(reg, reg, rc); }
+ void SmiTag(Register dst, Register src, RCBit rc = LeaveRC) {
+ ShiftLeftImm(dst, src, Operand(kSmiShift), rc);
+ }
+
+#if !V8_TARGET_ARCH_PPC64
+ // Test for overflow < 0: use BranchOnOverflow() or BranchOnNoOverflow().
+ void SmiTagCheckOverflow(Register reg, Register overflow);
+ void SmiTagCheckOverflow(Register dst, Register src, Register overflow);
+
+ inline void JumpIfNotSmiCandidate(Register value, Register scratch,
+ Label* not_smi_label) {
+ // High bits must be identical to fit into an Smi
+ addis(scratch, value, Operand(0x40000000u >> 16));
+ cmpi(scratch, Operand::Zero());
+ blt(not_smi_label);
+ }
+#endif
+ inline void TestUnsignedSmiCandidate(Register value, Register scratch) {
+ // The test is different for unsigned int values. Since we need
+ // the value to be in the range of a positive smi, we can't
+ // handle any of the high bits being set in the value.
+ TestBitRange(value, kBitsPerPointer - 1, kBitsPerPointer - 1 - kSmiShift,
+ scratch);
+ }
+ inline void JumpIfNotUnsignedSmiCandidate(Register value, Register scratch,
+ Label* not_smi_label) {
+ TestUnsignedSmiCandidate(value, scratch);
+ bne(not_smi_label, cr0);
+ }
+
+ void SmiUntag(Register reg, RCBit rc = LeaveRC) { SmiUntag(reg, reg, rc); }
+
+ void SmiUntag(Register dst, Register src, RCBit rc = LeaveRC) {
+ ShiftRightArithImm(dst, src, kSmiShift, rc);
+ }
+
+ void SmiToPtrArrayOffset(Register dst, Register src) {
+#if V8_TARGET_ARCH_PPC64
+ STATIC_ASSERT(kSmiTag == 0 && kSmiShift > kPointerSizeLog2);
+ ShiftRightArithImm(dst, src, kSmiShift - kPointerSizeLog2);
+#else
+ STATIC_ASSERT(kSmiTag == 0 && kSmiShift < kPointerSizeLog2);
+ ShiftLeftImm(dst, src, Operand(kPointerSizeLog2 - kSmiShift));
+#endif
+ }
+
+ void SmiToByteArrayOffset(Register dst, Register src) { SmiUntag(dst, src); }
+
+ void SmiToShortArrayOffset(Register dst, Register src) {
+#if V8_TARGET_ARCH_PPC64
+ STATIC_ASSERT(kSmiTag == 0 && kSmiShift > 1);
+ ShiftRightArithImm(dst, src, kSmiShift - 1);
+#else
+ STATIC_ASSERT(kSmiTag == 0 && kSmiShift == 1);
+ if (!dst.is(src)) {
+ mr(dst, src);
+ }
+#endif
+ }
+
+ void SmiToIntArrayOffset(Register dst, Register src) {
+#if V8_TARGET_ARCH_PPC64
+ STATIC_ASSERT(kSmiTag == 0 && kSmiShift > 2);
+ ShiftRightArithImm(dst, src, kSmiShift - 2);
+#else
+ STATIC_ASSERT(kSmiTag == 0 && kSmiShift < 2);
+ ShiftLeftImm(dst, src, Operand(2 - kSmiShift));
+#endif
+ }
+
+#define SmiToFloatArrayOffset SmiToIntArrayOffset
+
+ void SmiToDoubleArrayOffset(Register dst, Register src) {
+#if V8_TARGET_ARCH_PPC64
+ STATIC_ASSERT(kSmiTag == 0 && kSmiShift > kDoubleSizeLog2);
+ ShiftRightArithImm(dst, src, kSmiShift - kDoubleSizeLog2);
+#else
+ STATIC_ASSERT(kSmiTag == 0 && kSmiShift < kDoubleSizeLog2);
+ ShiftLeftImm(dst, src, Operand(kDoubleSizeLog2 - kSmiShift));
+#endif
+ }
+
+ void SmiToArrayOffset(Register dst, Register src, int elementSizeLog2) {
+ if (kSmiShift < elementSizeLog2) {
+ ShiftLeftImm(dst, src, Operand(elementSizeLog2 - kSmiShift));
+ } else if (kSmiShift > elementSizeLog2) {
+ ShiftRightArithImm(dst, src, kSmiShift - elementSizeLog2);
+ } else if (!dst.is(src)) {
+ mr(dst, src);
+ }
+ }
+
+ void IndexToArrayOffset(Register dst, Register src, int elementSizeLog2,
+ bool isSmi) {
+ if (isSmi) {
+ SmiToArrayOffset(dst, src, elementSizeLog2);
+ } else {
+ ShiftLeftImm(dst, src, Operand(elementSizeLog2));
+ }
+ }
+
+ // Untag the source value into destination and jump if source is a smi.
+ // Souce and destination can be the same register.
+ void UntagAndJumpIfSmi(Register dst, Register src, Label* smi_case);
+
+ // Untag the source value into destination and jump if source is not a smi.
+ // Souce and destination can be the same register.
+ void UntagAndJumpIfNotSmi(Register dst, Register src, Label* non_smi_case);
+
+ inline void TestIfSmi(Register value, Register scratch) {
+ TestBit(value, 0, scratch); // tst(value, Operand(kSmiTagMask));
+ }
+
+ inline void TestIfPositiveSmi(Register value, Register scratch) {
+ STATIC_ASSERT((kSmiTagMask | kSmiSignMask) ==
+ (intptr_t)(1UL << (kBitsPerPointer - 1) | 1));
+#if V8_TARGET_ARCH_PPC64
+ rldicl(scratch, value, 1, kBitsPerPointer - 2, SetRC);
+#else
+ rlwinm(scratch, value, 1, kBitsPerPointer - 2, kBitsPerPointer - 1, SetRC);
+#endif
+ }
+
+ // Jump the register contains a smi.
+ inline void JumpIfSmi(Register value, Label* smi_label) {
+ TestIfSmi(value, r0);
+ beq(smi_label, cr0); // branch if SMI
+ }
+ // Jump if either of the registers contain a non-smi.
+ inline void JumpIfNotSmi(Register value, Label* not_smi_label) {
+ TestIfSmi(value, r0);
+ bne(not_smi_label, cr0);
+ }
+ // Jump if either of the registers contain a non-smi.
+ void JumpIfNotBothSmi(Register reg1, Register reg2, Label* on_not_both_smi);
+ // Jump if either of the registers contain a smi.
+ void JumpIfEitherSmi(Register reg1, Register reg2, Label* on_either_smi);
+
+ // Abort execution if argument is a smi, enabled via --debug-code.
+ void AssertNotSmi(Register object);
+ void AssertSmi(Register object);
+
+
+#if V8_TARGET_ARCH_PPC64
+ inline void TestIfInt32(Register value, Register scratch1, Register scratch2,
+ CRegister cr = cr7) {
+ // High bits must be identical to fit into an 32-bit integer
+ srawi(scratch1, value, 31);
+ sradi(scratch2, value, 32);
+ cmp(scratch1, scratch2, cr);
+ }
+#else
+ inline void TestIfInt32(Register hi_word, Register lo_word, Register scratch,
+ CRegister cr = cr7) {
+ // High bits must be identical to fit into an 32-bit integer
+ srawi(scratch, lo_word, 31);
+ cmp(scratch, hi_word, cr);
+ }
+#endif
+
+ // Abort execution if argument is not a string, enabled via --debug-code.
+ void AssertString(Register object);
+
+ // Abort execution if argument is not a name, enabled via --debug-code.
+ void AssertName(Register object);
+
+ // Abort execution if argument is not undefined or an AllocationSite, enabled
+ // via --debug-code.
+ void AssertUndefinedOrAllocationSite(Register object, Register scratch);
+
+ // Abort execution if reg is not the root value with the given index,
+ // enabled via --debug-code.
+ void AssertIsRoot(Register reg, Heap::RootListIndex index);
+
+ // ---------------------------------------------------------------------------
+ // HeapNumber utilities
+
+ void JumpIfNotHeapNumber(Register object, Register heap_number_map,
+ Register scratch, Label* on_not_heap_number);
+
+ // ---------------------------------------------------------------------------
+ // String utilities
+
+ // Generate code to do a lookup in the number string cache. If the number in
+ // the register object is found in the cache the generated code falls through
+ // with the result in the result register. The object and the result register
+ // can be the same. If the number is not found in the cache the code jumps to
+ // the label not_found with only the content of register object unchanged.
+ void LookupNumberStringCache(Register object, Register result,
+ Register scratch1, Register scratch2,
+ Register scratch3, Label* not_found);
+
+ // Checks if both objects are sequential one-byte strings and jumps to label
+ // if either is not. Assumes that neither object is a smi.
+ void JumpIfNonSmisNotBothSequentialOneByteStrings(Register object1,
+ Register object2,
+ Register scratch1,
+ Register scratch2,
+ Label* failure);
+
+ // Checks if both objects are sequential one-byte strings and jumps to label
+ // if either is not.
+ void JumpIfNotBothSequentialOneByteStrings(Register first, Register second,
+ Register scratch1,
+ Register scratch2,
+ Label* not_flat_one_byte_strings);
+
+ // Checks if both instance types are sequential one-byte strings and jumps to
+ // label if either is not.
+ void JumpIfBothInstanceTypesAreNotSequentialOneByte(
+ Register first_object_instance_type, Register second_object_instance_type,
+ Register scratch1, Register scratch2, Label* failure);
+
+ // Check if instance type is sequential one-byte string and jump to label if
+ // it is not.
+ void JumpIfInstanceTypeIsNotSequentialOneByte(Register type, Register scratch,
+ Label* failure);
+
+ void JumpIfNotUniqueNameInstanceType(Register reg, Label* not_unique_name);
+
+ void EmitSeqStringSetCharCheck(Register string, Register index,
+ Register value, uint32_t encoding_mask);
+
+ // ---------------------------------------------------------------------------
+ // Patching helpers.
+
+ // Retrieve/patch the relocated value (lis/ori pair or constant pool load).
+ void GetRelocatedValue(Register location, Register result, Register scratch);
+ void SetRelocatedValue(Register location, Register scratch,
+ Register new_value);
+
+ void ClampUint8(Register output_reg, Register input_reg);
+
+ // Saturate a value into 8-bit unsigned integer
+ // if input_value < 0, output_value is 0
+ // if input_value > 255, output_value is 255
+ // otherwise output_value is the (int)input_value (round to nearest)
+ void ClampDoubleToUint8(Register result_reg, DoubleRegister input_reg,
+ DoubleRegister temp_double_reg);
+
+
+ void LoadInstanceDescriptors(Register map, Register descriptors);
+ void EnumLength(Register dst, Register map);
+ void NumberOfOwnDescriptors(Register dst, Register map);
+
+ template <typename Field>
+ void DecodeField(Register dst, Register src) {
+ ExtractBitRange(dst, src, Field::kShift + Field::kSize - 1, Field::kShift);
+ }
+
+ template <typename Field>
+ void DecodeField(Register reg) {
+ DecodeField<Field>(reg, reg);
+ }
+
+ template <typename Field>
+ void DecodeFieldToSmi(Register dst, Register src) {
+#if V8_TARGET_ARCH_PPC64
+ DecodeField<Field>(dst, src);
+ SmiTag(dst);
+#else
+ // 32-bit can do this in one instruction:
+ int start = Field::kSize + kSmiShift - 1;
+ int end = kSmiShift;
+ int rotate = kSmiShift - Field::kShift;
+ if (rotate < 0) {
+ rotate += kBitsPerPointer;
+ }
+ rlwinm(dst, src, rotate, kBitsPerPointer - start - 1,
+ kBitsPerPointer - end - 1);
+#endif
+ }
+
+ template <typename Field>
+ void DecodeFieldToSmi(Register reg) {
+ DecodeFieldToSmi<Field>(reg, reg);
+ }
+
+ // Activation support.
+ void EnterFrame(StackFrame::Type type,
+ bool load_constant_pool_pointer_reg = false);
+ // Returns the pc offset at which the frame ends.
+ int LeaveFrame(StackFrame::Type type, int stack_adjustment = 0);
+
+ // Expects object in r0 and returns map with validated enum cache
+ // in r0. Assumes that any other register can be used as a scratch.
+ void CheckEnumCache(Register null_value, Label* call_runtime);
+
+ // AllocationMemento support. Arrays may have an associated
+ // AllocationMemento object that can be checked for in order to pretransition
+ // to another type.
+ // On entry, receiver_reg should point to the array object.
+ // scratch_reg gets clobbered.
+ // If allocation info is present, condition flags are set to eq.
+ void TestJSArrayForAllocationMemento(Register receiver_reg,
+ Register scratch_reg,
+ Label* no_memento_found);
+
+ void JumpIfJSArrayHasAllocationMemento(Register receiver_reg,
+ Register scratch_reg,
+ Label* memento_found) {
+ Label no_memento_found;
+ TestJSArrayForAllocationMemento(receiver_reg, scratch_reg,
+ &no_memento_found);
+ beq(memento_found);
+ bind(&no_memento_found);
+ }
+
+ // Jumps to found label if a prototype map has dictionary elements.
+ void JumpIfDictionaryInPrototypeChain(Register object, Register scratch0,
+ Register scratch1, Label* found);
+
+ private:
+ static const int kSmiShift = kSmiTagSize + kSmiShiftSize;
+
+ void CallCFunctionHelper(Register function, int num_reg_arguments,
+ int num_double_arguments);
+
+ void Jump(intptr_t target, RelocInfo::Mode rmode, Condition cond = al,
+ CRegister cr = cr7);
+
+ // Helper functions for generating invokes.
+ void InvokePrologue(const ParameterCount& expected,
+ const ParameterCount& actual, Handle<Code> code_constant,
+ Register code_reg, Label* done,
+ bool* definitely_mismatches, InvokeFlag flag,
+ const CallWrapper& call_wrapper);
+
+ void InitializeNewString(Register string, Register length,
+ Heap::RootListIndex map_index, Register scratch1,
+ Register scratch2);
+
+ // Helper for implementing JumpIfNotInNewSpace and JumpIfInNewSpace.
+ void InNewSpace(Register object, Register scratch,
+ Condition cond, // eq for new space, ne otherwise.
+ Label* branch);
+
+ // Helper for finding the mark bits for an address. Afterwards, the
+ // bitmap register points at the word with the mark bits and the mask
+ // the position of the first bit. Leaves addr_reg unchanged.
+ inline void GetMarkBits(Register addr_reg, Register bitmap_reg,
+ Register mask_reg);
+
+ // Helper for throwing exceptions. Compute a handler address and jump to
+ // it. See the implementation for register usage.
+ void JumpToHandlerEntry();
+
+ // Compute memory operands for safepoint stack slots.
+ static int SafepointRegisterStackIndex(int reg_code);
+ MemOperand SafepointRegisterSlot(Register reg);
+ MemOperand SafepointRegistersAndDoublesSlot(Register reg);
+
+#if V8_OOL_CONSTANT_POOL
+ // Loads the constant pool pointer (kConstantPoolRegister).
+ enum CodeObjectAccessMethod { CAN_USE_IP, CONSTRUCT_INTERNAL_REFERENCE };
+ void LoadConstantPoolPointerRegister(CodeObjectAccessMethod access_method,
+ int ip_code_entry_delta = 0);
+#endif
+
+ bool generating_stub_;
+ bool has_frame_;
+ // This handle will be patched with the code object on installation.
+ Handle<Object> code_object_;
+
+ // Needs access to SafepointRegisterStackIndex for compiled frame
+ // traversal.
+ friend class StandardFrame;
+};
+
+
+// The code patcher is used to patch (typically) small parts of code e.g. for
+// debugging and other types of instrumentation. When using the code patcher
+// the exact number of bytes specified must be emitted. It is not legal to emit
+// relocation information. If any of these constraints are violated it causes
+// an assertion to fail.
+class CodePatcher {
+ public:
+ enum FlushICache { FLUSH, DONT_FLUSH };
+
+ CodePatcher(byte* address, int instructions, FlushICache flush_cache = FLUSH);
+ virtual ~CodePatcher();
+
+ // Macro assembler to emit code.
+ MacroAssembler* masm() { return &masm_; }
+
+ // Emit an instruction directly.
+ void Emit(Instr instr);
+
+ // Emit the condition part of an instruction leaving the rest of the current
+ // instruction unchanged.
+ void EmitCondition(Condition cond);
+
+ private:
+ byte* address_; // The address of the code being patched.
+ int size_; // Number of bytes of the expected patch size.
+ MacroAssembler masm_; // Macro assembler used to generate the code.
+ FlushICache flush_cache_; // Whether to flush the I cache after patching.
+};
+
+
+// -----------------------------------------------------------------------------
+// Static helper functions.
+
+inline MemOperand ContextOperand(Register context, int index) {
+ return MemOperand(context, Context::SlotOffset(index));
+}
+
+
+inline MemOperand GlobalObjectOperand() {
+ return ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX);
+}
+
+
+#ifdef GENERATED_CODE_COVERAGE
+#define CODE_COVERAGE_STRINGIFY(x) #x
+#define CODE_COVERAGE_TOSTRING(x) CODE_COVERAGE_STRINGIFY(x)
+#define __FILE_LINE__ __FILE__ ":" CODE_COVERAGE_TOSTRING(__LINE__)
+#define ACCESS_MASM(masm) \
+ masm->stop(__FILE_LINE__); \
+ masm->
+#else
+#define ACCESS_MASM(masm) masm->
+#endif
+}
+} // namespace v8::internal
+
+#endif // V8_PPC_MACRO_ASSEMBLER_PPC_H_
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/base/bits.h"
+#include "src/code-stubs.h"
+#include "src/cpu-profiler.h"
+#include "src/log.h"
+#include "src/macro-assembler.h"
+#include "src/regexp-macro-assembler.h"
+#include "src/regexp-stack.h"
+#include "src/unicode.h"
+
+#include "src/ppc/regexp-macro-assembler-ppc.h"
+
+namespace v8 {
+namespace internal {
+
+#ifndef V8_INTERPRETED_REGEXP
+/*
+ * This assembler uses the following register assignment convention
+ * - r25: Temporarily stores the index of capture start after a matching pass
+ * for a global regexp.
+ * - r26: Pointer to current code object (Code*) including heap object tag.
+ * - r27: Current position in input, as negative offset from end of string.
+ * Please notice that this is the byte offset, not the character offset!
+ * - r28: Currently loaded character. Must be loaded using
+ * LoadCurrentCharacter before using any of the dispatch methods.
+ * - r29: Points to tip of backtrack stack
+ * - r30: End of input (points to byte after last character in input).
+ * - r31: Frame pointer. Used to access arguments, local variables and
+ * RegExp registers.
+ * - r12: IP register, used by assembler. Very volatile.
+ * - r1/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[44] Isolate* isolate (address of the current isolate)
+ * - fp[40] secondary link/return address used by native call.
+ * - fp[36] lr save area (currently unused)
+ * - fp[32] backchain (currently unused)
+ * --- sp when called ---
+ * - fp[28] return address (lr).
+ * - fp[24] old frame pointer (r31).
+ * - fp[0..20] backup of registers r25..r30
+ * --- frame pointer ----
+ * - fp[-4] direct_call (if 1, direct call from JavaScript code,
+ * if 0, call through the runtime system).
+ * - fp[-8] stack_area_base (high end of the memory area to use as
+ * backtracking stack).
+ * - fp[-12] capture array size (may fit multiple sets of matches)
+ * - fp[-16] int* capture_array (int[num_saved_registers_], for output).
+ * - fp[-20] end of input (address of end of string).
+ * - fp[-24] start of input (address of first character in string).
+ * - fp[-28] start index (character index of start).
+ * - fp[-32] void* input_string (location of a handle containing the string).
+ * - fp[-36] success counter (only for global regexps to count matches).
+ * - fp[-40] Offset of location before start of input (effectively character
+ * position -1). Used to initialize capture registers to a
+ * non-position.
+ * - fp[-44] At start (if 1, we are starting at the start of the
+ * string, otherwise 0)
+ * - fp[-48] register 0 (Only positions must be stored in the first
+ * - register 1 num_saved_registers_ registers)
+ * - ...
+ * - register num_registers-1
+ * --- sp ---
+ *
+ * The first num_saved_registers_ registers are initialized to point to
+ * "character -1" in the string (i.e., char_size() bytes before the first
+ * character of the string). The remaining registers start out as garbage.
+ *
+ * The data up to the return address must be placed there by the calling
+ * code and the remaining arguments are passed in registers, e.g. by calling the
+ * code entry as cast to a function with the signature:
+ * int (*match)(String* input_string,
+ * int start_index,
+ * Address start,
+ * Address end,
+ * int* capture_output_array,
+ * byte* stack_area_base,
+ * Address secondary_return_address, // Only used by native call.
+ * bool direct_call = false)
+ * The call is performed by NativeRegExpMacroAssembler::Execute()
+ * (in regexp-macro-assembler.cc) via the CALL_GENERATED_REGEXP_CODE macro
+ * in ppc/simulator-ppc.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
+ * the calling code, as in a normal exit frame.
+ */
+
+#define __ ACCESS_MASM(masm_)
+
+RegExpMacroAssemblerPPC::RegExpMacroAssemblerPPC(Mode mode,
+ int registers_to_save,
+ Zone* zone)
+ : NativeRegExpMacroAssembler(zone),
+ masm_(new MacroAssembler(zone->isolate(), NULL, kRegExpCodeSize)),
+ mode_(mode),
+ num_registers_(registers_to_save),
+ num_saved_registers_(registers_to_save),
+ entry_label_(),
+ start_label_(),
+ success_label_(),
+ backtrack_label_(),
+ exit_label_(),
+ internal_failure_label_() {
+ DCHECK_EQ(0, registers_to_save % 2);
+
+// Called from C
+#if ABI_USES_FUNCTION_DESCRIPTORS
+ __ function_descriptor();
+#endif
+
+ __ b(&entry_label_); // We'll write the entry code later.
+ // If the code gets too big or corrupted, an internal exception will be
+ // raised, and we will exit right away.
+ __ bind(&internal_failure_label_);
+ __ li(r3, Operand(FAILURE));
+ __ Ret();
+ __ bind(&start_label_); // And then continue from here.
+}
+
+
+RegExpMacroAssemblerPPC::~RegExpMacroAssemblerPPC() {
+ delete masm_;
+ // Unuse labels in case we throw away the assembler without calling GetCode.
+ entry_label_.Unuse();
+ start_label_.Unuse();
+ success_label_.Unuse();
+ backtrack_label_.Unuse();
+ exit_label_.Unuse();
+ check_preempt_label_.Unuse();
+ stack_overflow_label_.Unuse();
+ internal_failure_label_.Unuse();
+}
+
+
+int RegExpMacroAssemblerPPC::stack_limit_slack() {
+ return RegExpStack::kStackLimitSlack;
+}
+
+
+void RegExpMacroAssemblerPPC::AdvanceCurrentPosition(int by) {
+ if (by != 0) {
+ __ addi(current_input_offset(), current_input_offset(),
+ Operand(by * char_size()));
+ }
+}
+
+
+void RegExpMacroAssemblerPPC::AdvanceRegister(int reg, int by) {
+ DCHECK(reg >= 0);
+ DCHECK(reg < num_registers_);
+ if (by != 0) {
+ __ LoadP(r3, register_location(reg), r0);
+ __ mov(r0, Operand(by));
+ __ add(r3, r3, r0);
+ __ StoreP(r3, register_location(reg), r0);
+ }
+}
+
+
+void RegExpMacroAssemblerPPC::Backtrack() {
+ CheckPreemption();
+ // Pop Code* offset from backtrack stack, add Code* and jump to location.
+ Pop(r3);
+ __ add(r3, r3, code_pointer());
+ __ mtctr(r3);
+ __ bctr();
+}
+
+
+void RegExpMacroAssemblerPPC::Bind(Label* label) { __ bind(label); }
+
+
+void RegExpMacroAssemblerPPC::CheckCharacter(uint32_t c, Label* on_equal) {
+ __ Cmpli(current_character(), Operand(c), r0);
+ BranchOrBacktrack(eq, on_equal);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckCharacterGT(uc16 limit, Label* on_greater) {
+ __ Cmpli(current_character(), Operand(limit), r0);
+ BranchOrBacktrack(gt, on_greater);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckAtStart(Label* on_at_start) {
+ Label not_at_start;
+ // Did we start the match at the start of the string at all?
+ __ LoadP(r3, MemOperand(frame_pointer(), kStartIndex));
+ __ cmpi(r3, Operand::Zero());
+ BranchOrBacktrack(ne, ¬_at_start);
+
+ // If we did, are we still at the start of the input?
+ __ LoadP(r4, MemOperand(frame_pointer(), kInputStart));
+ __ mr(r0, current_input_offset());
+ __ add(r3, end_of_input_address(), r0);
+ __ cmp(r4, r3);
+ BranchOrBacktrack(eq, on_at_start);
+ __ bind(¬_at_start);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckNotAtStart(Label* on_not_at_start) {
+ // Did we start the match at the start of the string at all?
+ __ LoadP(r3, MemOperand(frame_pointer(), kStartIndex));
+ __ cmpi(r3, Operand::Zero());
+ BranchOrBacktrack(ne, on_not_at_start);
+ // If we did, are we still at the start of the input?
+ __ LoadP(r4, MemOperand(frame_pointer(), kInputStart));
+ __ add(r3, end_of_input_address(), current_input_offset());
+ __ cmp(r3, r4);
+ BranchOrBacktrack(ne, on_not_at_start);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckCharacterLT(uc16 limit, Label* on_less) {
+ __ Cmpli(current_character(), Operand(limit), r0);
+ BranchOrBacktrack(lt, on_less);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckGreedyLoop(Label* on_equal) {
+ Label backtrack_non_equal;
+ __ LoadP(r3, MemOperand(backtrack_stackpointer(), 0));
+ __ cmp(current_input_offset(), r3);
+ __ bne(&backtrack_non_equal);
+ __ addi(backtrack_stackpointer(), backtrack_stackpointer(),
+ Operand(kPointerSize));
+
+ __ bind(&backtrack_non_equal);
+ BranchOrBacktrack(eq, on_equal);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckNotBackReferenceIgnoreCase(
+ int start_reg, Label* on_no_match) {
+ Label fallthrough;
+ __ LoadP(r3, register_location(start_reg), r0); // Index of start of capture
+ __ LoadP(r4, register_location(start_reg + 1), r0); // Index of end
+ __ sub(r4, r4, r3, LeaveOE, SetRC); // Length of capture.
+
+ // If length is zero, either the capture is empty or it is not participating.
+ // In either case succeed immediately.
+ __ beq(&fallthrough, cr0);
+
+ // Check that there are enough characters left in the input.
+ __ add(r0, r4, current_input_offset(), LeaveOE, SetRC);
+ // __ cmn(r1, Operand(current_input_offset()));
+ BranchOrBacktrack(gt, on_no_match, cr0);
+
+ if (mode_ == LATIN1) {
+ Label success;
+ Label fail;
+ Label loop_check;
+
+ // r3 - offset of start of capture
+ // r4 - length of capture
+ __ add(r3, r3, end_of_input_address());
+ __ add(r5, end_of_input_address(), current_input_offset());
+ __ add(r4, r3, r4);
+
+ // r3 - Address of start of capture.
+ // r4 - Address of end of capture
+ // r5 - Address of current input position.
+
+ Label loop;
+ __ bind(&loop);
+ __ lbz(r6, MemOperand(r3));
+ __ addi(r3, r3, Operand(char_size()));
+ __ lbz(r25, MemOperand(r5));
+ __ addi(r5, r5, Operand(char_size()));
+ __ cmp(r25, r6);
+ __ beq(&loop_check);
+
+ // Mismatch, try case-insensitive match (converting letters to lower-case).
+ __ ori(r6, r6, Operand(0x20)); // Convert capture character to lower-case.
+ __ ori(r25, r25, Operand(0x20)); // Also convert input character.
+ __ cmp(r25, r6);
+ __ bne(&fail);
+ __ subi(r6, r6, Operand('a'));
+ __ cmpli(r6, Operand('z' - 'a')); // Is r6 a lowercase letter?
+ __ ble(&loop_check); // In range 'a'-'z'.
+ // Latin-1: Check for values in range [224,254] but not 247.
+ __ subi(r6, r6, Operand(224 - 'a'));
+ __ cmpli(r6, Operand(254 - 224));
+ __ bgt(&fail); // Weren't Latin-1 letters.
+ __ cmpi(r6, Operand(247 - 224)); // Check for 247.
+ __ beq(&fail);
+
+ __ bind(&loop_check);
+ __ cmp(r3, r4);
+ __ blt(&loop);
+ __ b(&success);
+
+ __ bind(&fail);
+ BranchOrBacktrack(al, on_no_match);
+
+ __ bind(&success);
+ // Compute new value of character position after the matched part.
+ __ sub(current_input_offset(), r5, end_of_input_address());
+ } else {
+ DCHECK(mode_ == UC16);
+ int argument_count = 4;
+ __ PrepareCallCFunction(argument_count, r5);
+
+ // r3 - offset of start of capture
+ // r4 - length of capture
+
+ // Put arguments into arguments registers.
+ // Parameters are
+ // r3: Address byte_offset1 - Address captured substring's start.
+ // r4: Address byte_offset2 - Address of current character position.
+ // r5: size_t byte_length - length of capture in bytes(!)
+ // r6: Isolate* isolate
+
+ // Address of start of capture.
+ __ add(r3, r3, end_of_input_address());
+ // Length of capture.
+ __ mr(r5, r4);
+ // Save length in callee-save register for use on return.
+ __ mr(r25, r4);
+ // Address of current input position.
+ __ add(r4, current_input_offset(), end_of_input_address());
+ // Isolate.
+ __ mov(r6, Operand(ExternalReference::isolate_address(isolate())));
+
+ {
+ AllowExternalCallThatCantCauseGC scope(masm_);
+ ExternalReference function =
+ ExternalReference::re_case_insensitive_compare_uc16(isolate());
+ __ CallCFunction(function, argument_count);
+ }
+
+ // Check if function returned non-zero for success or zero for failure.
+ __ cmpi(r3, Operand::Zero());
+ BranchOrBacktrack(eq, on_no_match);
+ // On success, increment position by length of capture.
+ __ add(current_input_offset(), current_input_offset(), r25);
+ }
+
+ __ bind(&fallthrough);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckNotBackReference(int start_reg,
+ Label* on_no_match) {
+ Label fallthrough;
+ Label success;
+
+ // Find length of back-referenced capture.
+ __ LoadP(r3, register_location(start_reg), r0);
+ __ LoadP(r4, register_location(start_reg + 1), r0);
+ __ sub(r4, r4, r3, LeaveOE, SetRC); // Length to check.
+ // Succeed on empty capture (including no capture).
+ __ beq(&fallthrough, cr0);
+
+ // Check that there are enough characters left in the input.
+ __ add(r0, r4, current_input_offset(), LeaveOE, SetRC);
+ BranchOrBacktrack(gt, on_no_match, cr0);
+
+ // Compute pointers to match string and capture string
+ __ add(r3, r3, end_of_input_address());
+ __ add(r5, end_of_input_address(), current_input_offset());
+ __ add(r4, r4, r3);
+
+ Label loop;
+ __ bind(&loop);
+ if (mode_ == LATIN1) {
+ __ lbz(r6, MemOperand(r3));
+ __ addi(r3, r3, Operand(char_size()));
+ __ lbz(r25, MemOperand(r5));
+ __ addi(r5, r5, Operand(char_size()));
+ } else {
+ DCHECK(mode_ == UC16);
+ __ lhz(r6, MemOperand(r3));
+ __ addi(r3, r3, Operand(char_size()));
+ __ lhz(r25, MemOperand(r5));
+ __ addi(r5, r5, Operand(char_size()));
+ }
+ __ cmp(r6, r25);
+ BranchOrBacktrack(ne, on_no_match);
+ __ cmp(r3, r4);
+ __ blt(&loop);
+
+ // Move current character position to position after match.
+ __ sub(current_input_offset(), r5, end_of_input_address());
+ __ bind(&fallthrough);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckNotCharacter(unsigned c,
+ Label* on_not_equal) {
+ __ Cmpli(current_character(), Operand(c), r0);
+ BranchOrBacktrack(ne, on_not_equal);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckCharacterAfterAnd(uint32_t c, uint32_t mask,
+ Label* on_equal) {
+ __ mov(r0, Operand(mask));
+ if (c == 0) {
+ __ and_(r3, current_character(), r0, SetRC);
+ } else {
+ __ and_(r3, current_character(), r0);
+ __ Cmpli(r3, Operand(c), r0, cr0);
+ }
+ BranchOrBacktrack(eq, on_equal, cr0);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckNotCharacterAfterAnd(unsigned c,
+ unsigned mask,
+ Label* on_not_equal) {
+ __ mov(r0, Operand(mask));
+ if (c == 0) {
+ __ and_(r3, current_character(), r0, SetRC);
+ } else {
+ __ and_(r3, current_character(), r0);
+ __ Cmpli(r3, Operand(c), r0, cr0);
+ }
+ BranchOrBacktrack(ne, on_not_equal, cr0);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckNotCharacterAfterMinusAnd(
+ uc16 c, uc16 minus, uc16 mask, Label* on_not_equal) {
+ DCHECK(minus < String::kMaxUtf16CodeUnit);
+ __ subi(r3, current_character(), Operand(minus));
+ __ mov(r0, Operand(mask));
+ __ and_(r3, r3, r0);
+ __ Cmpli(r3, Operand(c), r0);
+ BranchOrBacktrack(ne, on_not_equal);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckCharacterInRange(uc16 from, uc16 to,
+ Label* on_in_range) {
+ __ mov(r0, Operand(from));
+ __ sub(r3, current_character(), r0);
+ __ Cmpli(r3, Operand(to - from), r0);
+ BranchOrBacktrack(le, on_in_range); // Unsigned lower-or-same condition.
+}
+
+
+void RegExpMacroAssemblerPPC::CheckCharacterNotInRange(uc16 from, uc16 to,
+ Label* on_not_in_range) {
+ __ mov(r0, Operand(from));
+ __ sub(r3, current_character(), r0);
+ __ Cmpli(r3, Operand(to - from), r0);
+ BranchOrBacktrack(gt, on_not_in_range); // Unsigned higher condition.
+}
+
+
+void RegExpMacroAssemblerPPC::CheckBitInTable(Handle<ByteArray> table,
+ Label* on_bit_set) {
+ __ mov(r3, Operand(table));
+ if (mode_ != LATIN1 || kTableMask != String::kMaxOneByteCharCode) {
+ __ andi(r4, current_character(), Operand(kTableSize - 1));
+ __ addi(r4, r4, Operand(ByteArray::kHeaderSize - kHeapObjectTag));
+ } else {
+ __ addi(r4, current_character(),
+ Operand(ByteArray::kHeaderSize - kHeapObjectTag));
+ }
+ __ lbzx(r3, MemOperand(r3, r4));
+ __ cmpi(r3, Operand::Zero());
+ BranchOrBacktrack(ne, on_bit_set);
+}
+
+
+bool RegExpMacroAssemblerPPC::CheckSpecialCharacterClass(uc16 type,
+ Label* on_no_match) {
+ // Range checks (c in min..max) are generally implemented by an unsigned
+ // (c - min) <= (max - min) check
+ switch (type) {
+ case 's':
+ // Match space-characters
+ if (mode_ == LATIN1) {
+ // One byte space characters are '\t'..'\r', ' ' and \u00a0.
+ Label success;
+ __ cmpi(current_character(), Operand(' '));
+ __ beq(&success);
+ // Check range 0x09..0x0d
+ __ subi(r3, current_character(), Operand('\t'));
+ __ cmpli(r3, Operand('\r' - '\t'));
+ __ ble(&success);
+ // \u00a0 (NBSP).
+ __ cmpi(r3, Operand(0x00a0 - '\t'));
+ BranchOrBacktrack(ne, on_no_match);
+ __ bind(&success);
+ return true;
+ }
+ return false;
+ case 'S':
+ // The emitted code for generic character classes is good enough.
+ return false;
+ case 'd':
+ // Match ASCII digits ('0'..'9')
+ __ subi(r3, current_character(), Operand('0'));
+ __ cmpli(r3, Operand('9' - '0'));
+ BranchOrBacktrack(gt, on_no_match);
+ return true;
+ case 'D':
+ // Match non ASCII-digits
+ __ subi(r3, current_character(), Operand('0'));
+ __ cmpli(r3, Operand('9' - '0'));
+ BranchOrBacktrack(le, on_no_match);
+ return true;
+ case '.': {
+ // Match non-newlines (not 0x0a('\n'), 0x0d('\r'), 0x2028 and 0x2029)
+ __ xori(r3, current_character(), Operand(0x01));
+ // See if current character is '\n'^1 or '\r'^1, i.e., 0x0b or 0x0c
+ __ subi(r3, r3, Operand(0x0b));
+ __ cmpli(r3, Operand(0x0c - 0x0b));
+ BranchOrBacktrack(le, 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.
+ __ subi(r3, r3, Operand(0x2028 - 0x0b));
+ __ cmpli(r3, Operand(1));
+ BranchOrBacktrack(le, on_no_match);
+ }
+ return true;
+ }
+ case 'n': {
+ // Match newlines (0x0a('\n'), 0x0d('\r'), 0x2028 and 0x2029)
+ __ xori(r3, current_character(), Operand(0x01));
+ // See if current character is '\n'^1 or '\r'^1, i.e., 0x0b or 0x0c
+ __ subi(r3, r3, Operand(0x0b));
+ __ cmpli(r3, Operand(0x0c - 0x0b));
+ if (mode_ == LATIN1) {
+ BranchOrBacktrack(gt, on_no_match);
+ } else {
+ Label done;
+ __ ble(&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.
+ __ subi(r3, r3, Operand(0x2028 - 0x0b));
+ __ cmpli(r3, Operand(1));
+ BranchOrBacktrack(gt, on_no_match);
+ __ bind(&done);
+ }
+ return true;
+ }
+ case 'w': {
+ if (mode_ != LATIN1) {
+ // Table is 256 entries, so all Latin1 characters can be tested.
+ __ cmpi(current_character(), Operand('z'));
+ BranchOrBacktrack(gt, on_no_match);
+ }
+ ExternalReference map = ExternalReference::re_word_character_map();
+ __ mov(r3, Operand(map));
+ __ lbzx(r3, MemOperand(r3, current_character()));
+ __ cmpli(r3, Operand::Zero());
+ BranchOrBacktrack(eq, on_no_match);
+ return true;
+ }
+ case 'W': {
+ Label done;
+ if (mode_ != LATIN1) {
+ // Table is 256 entries, so all Latin1 characters can be tested.
+ __ cmpli(current_character(), Operand('z'));
+ __ bgt(&done);
+ }
+ ExternalReference map = ExternalReference::re_word_character_map();
+ __ mov(r3, Operand(map));
+ __ lbzx(r3, MemOperand(r3, current_character()));
+ __ cmpli(r3, Operand::Zero());
+ BranchOrBacktrack(ne, on_no_match);
+ if (mode_ != LATIN1) {
+ __ bind(&done);
+ }
+ return true;
+ }
+ case '*':
+ // Match any character.
+ return true;
+ // No custom implementation (yet): s(UC16), S(UC16).
+ default:
+ return false;
+ }
+}
+
+
+void RegExpMacroAssemblerPPC::Fail() {
+ __ li(r3, Operand(FAILURE));
+ __ b(&exit_label_);
+}
+
+
+Handle<HeapObject> RegExpMacroAssemblerPPC::GetCode(Handle<String> source) {
+ Label return_r3;
+
+ if (masm_->has_exception()) {
+ // If the code gets corrupted due to long regular expressions and lack of
+ // space on trampolines, an internal exception flag is set. If this case
+ // is detected, we will jump into exit sequence right away.
+ __ bind_to(&entry_label_, internal_failure_label_.pos());
+ } else {
+ // Finalize code - write the entry point code now we know how many
+ // registers we need.
+
+ // Entry code:
+ __ bind(&entry_label_);
+
+ // Tell the system that we have a stack frame. Because the type
+ // is MANUAL, no is generated.
+ FrameScope scope(masm_, StackFrame::MANUAL);
+
+ // Ensure register assigments are consistent with callee save mask
+ DCHECK(r25.bit() & kRegExpCalleeSaved);
+ DCHECK(code_pointer().bit() & kRegExpCalleeSaved);
+ DCHECK(current_input_offset().bit() & kRegExpCalleeSaved);
+ DCHECK(current_character().bit() & kRegExpCalleeSaved);
+ DCHECK(backtrack_stackpointer().bit() & kRegExpCalleeSaved);
+ DCHECK(end_of_input_address().bit() & kRegExpCalleeSaved);
+ DCHECK(frame_pointer().bit() & kRegExpCalleeSaved);
+
+ // Actually emit code to start a new stack frame.
+ // Push arguments
+ // Save callee-save registers.
+ // 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 = kRegExpCalleeSaved;
+ RegList argument_registers = r3.bit() | r4.bit() | r5.bit() | r6.bit() |
+ r7.bit() | r8.bit() | r9.bit() | r10.bit();
+ __ mflr(r0);
+ __ push(r0);
+ __ MultiPush(argument_registers | registers_to_retain);
+ // Set frame pointer in space for it if this is not a direct call
+ // from generated code.
+ __ addi(frame_pointer(), sp, Operand(8 * kPointerSize));
+ __ li(r3, Operand::Zero());
+ __ push(r3); // Make room for success counter and initialize it to 0.
+ __ push(r3); // Make room for "position - 1" constant (value is irrelevant)
+ // Check if we have space on the stack for registers.
+ Label stack_limit_hit;
+ Label stack_ok;
+
+ ExternalReference stack_limit =
+ ExternalReference::address_of_stack_limit(isolate());
+ __ mov(r3, Operand(stack_limit));
+ __ LoadP(r3, MemOperand(r3));
+ __ sub(r3, sp, r3, LeaveOE, SetRC);
+ // Handle it if the stack pointer is already below the stack limit.
+ __ ble(&stack_limit_hit, cr0);
+ // Check if there is room for the variable number of registers above
+ // the stack limit.
+ __ Cmpli(r3, Operand(num_registers_ * kPointerSize), r0);
+ __ bge(&stack_ok);
+ // Exit with OutOfMemory exception. There is not enough space on the stack
+ // for our working registers.
+ __ li(r3, Operand(EXCEPTION));
+ __ b(&return_r3);
+
+ __ bind(&stack_limit_hit);
+ CallCheckStackGuardState(r3);
+ __ cmpi(r3, Operand::Zero());
+ // If returned value is non-zero, we exit with the returned value as result.
+ __ bne(&return_r3);
+
+ __ bind(&stack_ok);
+
+ // Allocate space on stack for registers.
+ __ Add(sp, sp, -num_registers_ * kPointerSize, r0);
+ // Load string end.
+ __ LoadP(end_of_input_address(), MemOperand(frame_pointer(), kInputEnd));
+ // Load input start.
+ __ LoadP(r3, MemOperand(frame_pointer(), kInputStart));
+ // Find negative length (offset of start relative to end).
+ __ sub(current_input_offset(), r3, end_of_input_address());
+ // Set r3 to address of char before start of the input string
+ // (effectively string position -1).
+ __ LoadP(r4, MemOperand(frame_pointer(), kStartIndex));
+ __ subi(r3, current_input_offset(), Operand(char_size()));
+ if (mode_ == UC16) {
+ __ ShiftLeftImm(r0, r4, Operand(1));
+ __ sub(r3, r3, r0);
+ } else {
+ __ sub(r3, r3, r4);
+ }
+ // Store this value in a local variable, for use when clearing
+ // position registers.
+ __ StoreP(r3, MemOperand(frame_pointer(), kInputStartMinusOne));
+
+ // Initialize code pointer register
+ __ mov(code_pointer(), Operand(masm_->CodeObject()));
+
+ Label load_char_start_regexp, start_regexp;
+ // Load newline if index is at start, previous character otherwise.
+ __ cmpi(r4, Operand::Zero());
+ __ bne(&load_char_start_regexp);
+ __ li(current_character(), Operand('\n'));
+ __ b(&start_regexp);
+
+ // Global regexp restarts matching here.
+ __ bind(&load_char_start_regexp);
+ // Load previous char as initial value of current character register.
+ LoadCurrentCharacterUnchecked(-1, 1);
+ __ bind(&start_regexp);
+
+ // Initialize on-stack registers.
+ if (num_saved_registers_ > 0) { // Always is, if generated from a regexp.
+ // Fill saved registers with initial value = start offset - 1
+ if (num_saved_registers_ > 8) {
+ // One slot beyond address of register 0.
+ __ addi(r4, frame_pointer(), Operand(kRegisterZero + kPointerSize));
+ __ li(r5, Operand(num_saved_registers_));
+ __ mtctr(r5);
+ Label init_loop;
+ __ bind(&init_loop);
+ __ StorePU(r3, MemOperand(r4, -kPointerSize));
+ __ bdnz(&init_loop);
+ } else {
+ for (int i = 0; i < num_saved_registers_; i++) {
+ __ StoreP(r3, register_location(i), r0);
+ }
+ }
+ }
+
+ // Initialize backtrack stack pointer.
+ __ LoadP(backtrack_stackpointer(),
+ MemOperand(frame_pointer(), kStackHighEnd));
+
+ __ b(&start_label_);
+
+ // Exit code:
+ if (success_label_.is_linked()) {
+ // Save captures when successful.
+ __ bind(&success_label_);
+ if (num_saved_registers_ > 0) {
+ // copy captures to output
+ __ LoadP(r4, MemOperand(frame_pointer(), kInputStart));
+ __ LoadP(r3, MemOperand(frame_pointer(), kRegisterOutput));
+ __ LoadP(r5, MemOperand(frame_pointer(), kStartIndex));
+ __ sub(r4, end_of_input_address(), r4);
+ // r4 is length of input in bytes.
+ if (mode_ == UC16) {
+ __ ShiftRightImm(r4, r4, Operand(1));
+ }
+ // r4 is length of input in characters.
+ __ add(r4, r4, r5);
+ // r4 is length of string in characters.
+
+ DCHECK_EQ(0, num_saved_registers_ % 2);
+ // Always an even number of capture registers. This allows us to
+ // unroll the loop once to add an operation between a load of a register
+ // and the following use of that register.
+ for (int i = 0; i < num_saved_registers_; i += 2) {
+ __ LoadP(r5, register_location(i), r0);
+ __ LoadP(r6, register_location(i + 1), r0);
+ if (i == 0 && global_with_zero_length_check()) {
+ // Keep capture start in r25 for the zero-length check later.
+ __ mr(r25, r5);
+ }
+ if (mode_ == UC16) {
+ __ ShiftRightArithImm(r5, r5, 1);
+ __ add(r5, r4, r5);
+ __ ShiftRightArithImm(r6, r6, 1);
+ __ add(r6, r4, r6);
+ } else {
+ __ add(r5, r4, r5);
+ __ add(r6, r4, r6);
+ }
+ __ stw(r5, MemOperand(r3));
+ __ addi(r3, r3, Operand(kIntSize));
+ __ stw(r6, MemOperand(r3));
+ __ addi(r3, r3, Operand(kIntSize));
+ }
+ }
+
+ if (global()) {
+ // Restart matching if the regular expression is flagged as global.
+ __ LoadP(r3, MemOperand(frame_pointer(), kSuccessfulCaptures));
+ __ LoadP(r4, MemOperand(frame_pointer(), kNumOutputRegisters));
+ __ LoadP(r5, MemOperand(frame_pointer(), kRegisterOutput));
+ // Increment success counter.
+ __ addi(r3, r3, Operand(1));
+ __ StoreP(r3, MemOperand(frame_pointer(), kSuccessfulCaptures));
+ // Capture results have been stored, so the number of remaining global
+ // output registers is reduced by the number of stored captures.
+ __ subi(r4, r4, Operand(num_saved_registers_));
+ // Check whether we have enough room for another set of capture results.
+ __ cmpi(r4, Operand(num_saved_registers_));
+ __ blt(&return_r3);
+
+ __ StoreP(r4, MemOperand(frame_pointer(), kNumOutputRegisters));
+ // Advance the location for output.
+ __ addi(r5, r5, Operand(num_saved_registers_ * kIntSize));
+ __ StoreP(r5, MemOperand(frame_pointer(), kRegisterOutput));
+
+ // Prepare r3 to initialize registers with its value in the next run.
+ __ LoadP(r3, MemOperand(frame_pointer(), kInputStartMinusOne));
+
+ if (global_with_zero_length_check()) {
+ // Special case for zero-length matches.
+ // r25: capture start index
+ __ cmp(current_input_offset(), r25);
+ // Not a zero-length match, restart.
+ __ bne(&load_char_start_regexp);
+ // Offset from the end is zero if we already reached the end.
+ __ cmpi(current_input_offset(), Operand::Zero());
+ __ beq(&exit_label_);
+ // Advance current position after a zero-length match.
+ __ addi(current_input_offset(), current_input_offset(),
+ Operand((mode_ == UC16) ? 2 : 1));
+ }
+
+ __ b(&load_char_start_regexp);
+ } else {
+ __ li(r3, Operand(SUCCESS));
+ }
+ }
+
+ // Exit and return r3
+ __ bind(&exit_label_);
+ if (global()) {
+ __ LoadP(r3, MemOperand(frame_pointer(), kSuccessfulCaptures));
+ }
+
+ __ bind(&return_r3);
+ // Skip sp past regexp registers and local variables..
+ __ mr(sp, frame_pointer());
+ // Restore registers r25..r31 and return (restoring lr to pc).
+ __ MultiPop(registers_to_retain);
+ __ pop(r0);
+ __ mtctr(r0);
+ __ bctr();
+
+ // Backtrack code (branch target for conditional backtracks).
+ if (backtrack_label_.is_linked()) {
+ __ bind(&backtrack_label_);
+ Backtrack();
+ }
+
+ Label exit_with_exception;
+
+ // Preempt-code
+ if (check_preempt_label_.is_linked()) {
+ SafeCallTarget(&check_preempt_label_);
+
+ CallCheckStackGuardState(r3);
+ __ cmpi(r3, Operand::Zero());
+ // If returning non-zero, we should end execution with the given
+ // result as return value.
+ __ bne(&return_r3);
+
+ // String might have moved: Reload end of string from frame.
+ __ LoadP(end_of_input_address(), MemOperand(frame_pointer(), kInputEnd));
+ SafeReturn();
+ }
+
+ // Backtrack stack overflow code.
+ if (stack_overflow_label_.is_linked()) {
+ SafeCallTarget(&stack_overflow_label_);
+ // Reached if the backtrack-stack limit has been hit.
+ Label grow_failed;
+
+ // Call GrowStack(backtrack_stackpointer(), &stack_base)
+ static const int num_arguments = 3;
+ __ PrepareCallCFunction(num_arguments, r3);
+ __ mr(r3, backtrack_stackpointer());
+ __ addi(r4, frame_pointer(), Operand(kStackHighEnd));
+ __ mov(r5, Operand(ExternalReference::isolate_address(isolate())));
+ ExternalReference grow_stack =
+ ExternalReference::re_grow_stack(isolate());
+ __ CallCFunction(grow_stack, num_arguments);
+ // If return NULL, we have failed to grow the stack, and
+ // must exit with a stack-overflow exception.
+ __ cmpi(r3, Operand::Zero());
+ __ beq(&exit_with_exception);
+ // Otherwise use return value as new stack pointer.
+ __ mr(backtrack_stackpointer(), r3);
+ // Restore saved registers and continue.
+ SafeReturn();
+ }
+
+ if (exit_with_exception.is_linked()) {
+ // If any of the code above needed to exit with an exception.
+ __ bind(&exit_with_exception);
+ // Exit with Result EXCEPTION(-1) to signal thrown exception.
+ __ li(r3, Operand(EXCEPTION));
+ __ b(&return_r3);
+ }
+ }
+
+ CodeDesc code_desc;
+ masm_->GetCode(&code_desc);
+ Handle<Code> code = isolate()->factory()->NewCode(
+ code_desc, Code::ComputeFlags(Code::REGEXP), masm_->CodeObject());
+ PROFILE(masm_->isolate(), RegExpCodeCreateEvent(*code, *source));
+ return Handle<HeapObject>::cast(code);
+}
+
+
+void RegExpMacroAssemblerPPC::GoTo(Label* to) { BranchOrBacktrack(al, to); }
+
+
+void RegExpMacroAssemblerPPC::IfRegisterGE(int reg, int comparand,
+ Label* if_ge) {
+ __ LoadP(r3, register_location(reg), r0);
+ __ Cmpi(r3, Operand(comparand), r0);
+ BranchOrBacktrack(ge, if_ge);
+}
+
+
+void RegExpMacroAssemblerPPC::IfRegisterLT(int reg, int comparand,
+ Label* if_lt) {
+ __ LoadP(r3, register_location(reg), r0);
+ __ Cmpi(r3, Operand(comparand), r0);
+ BranchOrBacktrack(lt, if_lt);
+}
+
+
+void RegExpMacroAssemblerPPC::IfRegisterEqPos(int reg, Label* if_eq) {
+ __ LoadP(r3, register_location(reg), r0);
+ __ cmp(r3, current_input_offset());
+ BranchOrBacktrack(eq, if_eq);
+}
+
+
+RegExpMacroAssembler::IrregexpImplementation
+RegExpMacroAssemblerPPC::Implementation() {
+ return kPPCImplementation;
+}
+
+
+void RegExpMacroAssemblerPPC::LoadCurrentCharacter(int cp_offset,
+ Label* on_end_of_input,
+ bool check_bounds,
+ int characters) {
+ DCHECK(cp_offset >= -1); // ^ and \b can look behind one character.
+ DCHECK(cp_offset < (1 << 30)); // Be sane! (And ensure negation works)
+ if (check_bounds) {
+ CheckPosition(cp_offset + characters - 1, on_end_of_input);
+ }
+ LoadCurrentCharacterUnchecked(cp_offset, characters);
+}
+
+
+void RegExpMacroAssemblerPPC::PopCurrentPosition() {
+ Pop(current_input_offset());
+}
+
+
+void RegExpMacroAssemblerPPC::PopRegister(int register_index) {
+ Pop(r3);
+ __ StoreP(r3, register_location(register_index), r0);
+}
+
+
+void RegExpMacroAssemblerPPC::PushBacktrack(Label* label) {
+ __ mov_label_offset(r3, label);
+ Push(r3);
+ CheckStackLimit();
+}
+
+
+void RegExpMacroAssemblerPPC::PushCurrentPosition() {
+ Push(current_input_offset());
+}
+
+
+void RegExpMacroAssemblerPPC::PushRegister(int register_index,
+ StackCheckFlag check_stack_limit) {
+ __ LoadP(r3, register_location(register_index), r0);
+ Push(r3);
+ if (check_stack_limit) CheckStackLimit();
+}
+
+
+void RegExpMacroAssemblerPPC::ReadCurrentPositionFromRegister(int reg) {
+ __ LoadP(current_input_offset(), register_location(reg), r0);
+}
+
+
+void RegExpMacroAssemblerPPC::ReadStackPointerFromRegister(int reg) {
+ __ LoadP(backtrack_stackpointer(), register_location(reg), r0);
+ __ LoadP(r3, MemOperand(frame_pointer(), kStackHighEnd));
+ __ add(backtrack_stackpointer(), backtrack_stackpointer(), r3);
+}
+
+
+void RegExpMacroAssemblerPPC::SetCurrentPositionFromEnd(int by) {
+ Label after_position;
+ __ Cmpi(current_input_offset(), Operand(-by * char_size()), r0);
+ __ bge(&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.
+ // We have advanced the position, so it's safe to read backwards.
+ LoadCurrentCharacterUnchecked(-1, 1);
+ __ bind(&after_position);
+}
+
+
+void RegExpMacroAssemblerPPC::SetRegister(int register_index, int to) {
+ DCHECK(register_index >= num_saved_registers_); // Reserved for positions!
+ __ mov(r3, Operand(to));
+ __ StoreP(r3, register_location(register_index), r0);
+}
+
+
+bool RegExpMacroAssemblerPPC::Succeed() {
+ __ b(&success_label_);
+ return global();
+}
+
+
+void RegExpMacroAssemblerPPC::WriteCurrentPositionToRegister(int reg,
+ int cp_offset) {
+ if (cp_offset == 0) {
+ __ StoreP(current_input_offset(), register_location(reg), r0);
+ } else {
+ __ mov(r0, Operand(cp_offset * char_size()));
+ __ add(r3, current_input_offset(), r0);
+ __ StoreP(r3, register_location(reg), r0);
+ }
+}
+
+
+void RegExpMacroAssemblerPPC::ClearRegisters(int reg_from, int reg_to) {
+ DCHECK(reg_from <= reg_to);
+ __ LoadP(r3, MemOperand(frame_pointer(), kInputStartMinusOne));
+ for (int reg = reg_from; reg <= reg_to; reg++) {
+ __ StoreP(r3, register_location(reg), r0);
+ }
+}
+
+
+void RegExpMacroAssemblerPPC::WriteStackPointerToRegister(int reg) {
+ __ LoadP(r4, MemOperand(frame_pointer(), kStackHighEnd));
+ __ sub(r3, backtrack_stackpointer(), r4);
+ __ StoreP(r3, register_location(reg), r0);
+}
+
+
+// Private methods:
+
+void RegExpMacroAssemblerPPC::CallCheckStackGuardState(Register scratch) {
+ int frame_alignment = masm_->ActivationFrameAlignment();
+ int stack_space = kNumRequiredStackFrameSlots;
+ int stack_passed_arguments = 1; // space for return address pointer
+
+ // The following stack manipulation logic is similar to
+ // PrepareCallCFunction. However, we need an extra slot on the
+ // stack to house the return address parameter.
+ if (frame_alignment > kPointerSize) {
+ // Make stack end at alignment and make room for stack arguments
+ // -- preserving original value of sp.
+ __ mr(scratch, sp);
+ __ addi(sp, sp, Operand(-(stack_passed_arguments + 1) * kPointerSize));
+ DCHECK(base::bits::IsPowerOfTwo32(frame_alignment));
+ __ ClearRightImm(sp, sp, Operand(WhichPowerOf2(frame_alignment)));
+ __ StoreP(scratch, MemOperand(sp, stack_passed_arguments * kPointerSize));
+ } else {
+ // Make room for stack arguments
+ stack_space += stack_passed_arguments;
+ }
+
+ // Allocate frame with required slots to make ABI work.
+ __ li(r0, Operand::Zero());
+ __ StorePU(r0, MemOperand(sp, -stack_space * kPointerSize));
+
+ // RegExp code frame pointer.
+ __ mr(r5, frame_pointer());
+ // Code* of self.
+ __ mov(r4, Operand(masm_->CodeObject()));
+ // r3 will point to the return address, placed by DirectCEntry.
+ __ addi(r3, sp, Operand(kStackFrameExtraParamSlot * kPointerSize));
+
+ ExternalReference stack_guard_check =
+ ExternalReference::re_check_stack_guard_state(isolate());
+ __ mov(ip, Operand(stack_guard_check));
+ DirectCEntryStub stub(isolate());
+ stub.GenerateCall(masm_, ip);
+
+ // Restore the stack pointer
+ stack_space = kNumRequiredStackFrameSlots + stack_passed_arguments;
+ if (frame_alignment > kPointerSize) {
+ __ LoadP(sp, MemOperand(sp, stack_space * kPointerSize));
+ } else {
+ __ addi(sp, sp, Operand(stack_space * kPointerSize));
+ }
+
+ __ mov(code_pointer(), Operand(masm_->CodeObject()));
+}
+
+
+// Helper function for reading a value out of a stack frame.
+template <typename T>
+static T& frame_entry(Address re_frame, int frame_offset) {
+ return reinterpret_cast<T&>(Memory::int32_at(re_frame + frame_offset));
+}
+
+
+int RegExpMacroAssemblerPPC::CheckStackGuardState(Address* return_address,
+ Code* re_code,
+ Address re_frame) {
+ Isolate* isolate = frame_entry<Isolate*>(re_frame, kIsolate);
+ StackLimitCheck check(isolate);
+ if (check.JsHasOverflowed()) {
+ isolate->StackOverflow();
+ return EXCEPTION;
+ }
+
+ // If not real stack overflow the stack guard was used to interrupt
+ // execution for another purpose.
+
+ // If this is a direct call from JavaScript retry the RegExp forcing the call
+ // through the runtime system. Currently the direct call cannot handle a GC.
+ if (frame_entry<int>(re_frame, kDirectCall) == 1) {
+ return RETRY;
+ }
+
+ // Prepare for possible GC.
+ HandleScope handles(isolate);
+ Handle<Code> code_handle(re_code);
+
+ Handle<String> subject(frame_entry<String*>(re_frame, kInputString));
+
+ // Current string.
+ bool is_one_byte = subject->IsOneByteRepresentationUnderneath();
+
+ DCHECK(re_code->instruction_start() <= *return_address);
+ DCHECK(*return_address <=
+ re_code->instruction_start() + re_code->instruction_size());
+
+ Object* result = isolate->stack_guard()->HandleInterrupts();
+
+ if (*code_handle != re_code) { // Return address no longer valid
+ intptr_t delta = code_handle->address() - re_code->address();
+ // Overwrite the return address on the stack.
+ *return_address += delta;
+ }
+
+ if (result->IsException()) {
+ return EXCEPTION;
+ }
+
+ Handle<String> subject_tmp = subject;
+ int slice_offset = 0;
+
+ // Extract the underlying string and the slice offset.
+ if (StringShape(*subject_tmp).IsCons()) {
+ subject_tmp = Handle<String>(ConsString::cast(*subject_tmp)->first());
+ } else if (StringShape(*subject_tmp).IsSliced()) {
+ SlicedString* slice = SlicedString::cast(*subject_tmp);
+ subject_tmp = Handle<String>(slice->parent());
+ slice_offset = slice->offset();
+ }
+
+ // String might have changed.
+ if (subject_tmp->IsOneByteRepresentation() != is_one_byte) {
+ // If we changed between an Latin1 and an UC16 string, the specialized
+ // code cannot be used, and we need to restart regexp matching from
+ // scratch (including, potentially, compiling a new version of the code).
+ return RETRY;
+ }
+
+ // Otherwise, the content of the string might have moved. It must still
+ // be a sequential or external string with the same content.
+ // Update the start and end pointers in the stack frame to the current
+ // location (whether it has actually moved or not).
+ DCHECK(StringShape(*subject_tmp).IsSequential() ||
+ StringShape(*subject_tmp).IsExternal());
+
+ // The original start address of the characters to match.
+ const byte* start_address = frame_entry<const byte*>(re_frame, kInputStart);
+
+ // Find the current start address of the same character at the current string
+ // position.
+ int start_index = frame_entry<intptr_t>(re_frame, kStartIndex);
+ const byte* new_address =
+ StringCharacterPosition(*subject_tmp, start_index + slice_offset);
+
+ if (start_address != new_address) {
+ // If there is a difference, update the object pointer and start and end
+ // addresses in the RegExp stack frame to match the new value.
+ const byte* end_address = frame_entry<const byte*>(re_frame, kInputEnd);
+ int byte_length = static_cast<int>(end_address - start_address);
+ frame_entry<const String*>(re_frame, kInputString) = *subject;
+ frame_entry<const byte*>(re_frame, kInputStart) = new_address;
+ frame_entry<const byte*>(re_frame, kInputEnd) = new_address + byte_length;
+ } else if (frame_entry<const String*>(re_frame, kInputString) != *subject) {
+ // Subject string might have been a ConsString that underwent
+ // short-circuiting during GC. That will not change start_address but
+ // will change pointer inside the subject handle.
+ frame_entry<const String*>(re_frame, kInputString) = *subject;
+ }
+
+ return 0;
+}
+
+
+MemOperand RegExpMacroAssemblerPPC::register_location(int register_index) {
+ DCHECK(register_index < (1 << 30));
+ if (num_registers_ <= register_index) {
+ num_registers_ = register_index + 1;
+ }
+ return MemOperand(frame_pointer(),
+ kRegisterZero - register_index * kPointerSize);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckPosition(int cp_offset,
+ Label* on_outside_input) {
+ __ Cmpi(current_input_offset(), Operand(-cp_offset * char_size()), r0);
+ BranchOrBacktrack(ge, on_outside_input);
+}
+
+
+void RegExpMacroAssemblerPPC::BranchOrBacktrack(Condition condition, Label* to,
+ CRegister cr) {
+ if (condition == al) { // Unconditional.
+ if (to == NULL) {
+ Backtrack();
+ return;
+ }
+ __ b(to);
+ return;
+ }
+ if (to == NULL) {
+ __ b(condition, &backtrack_label_, cr);
+ return;
+ }
+ __ b(condition, to, cr);
+}
+
+
+void RegExpMacroAssemblerPPC::SafeCall(Label* to, Condition cond,
+ CRegister cr) {
+ __ b(cond, to, cr, SetLK);
+}
+
+
+void RegExpMacroAssemblerPPC::SafeReturn() {
+ __ pop(r0);
+ __ mov(ip, Operand(masm_->CodeObject()));
+ __ add(r0, r0, ip);
+ __ mtlr(r0);
+ __ blr();
+}
+
+
+void RegExpMacroAssemblerPPC::SafeCallTarget(Label* name) {
+ __ bind(name);
+ __ mflr(r0);
+ __ mov(ip, Operand(masm_->CodeObject()));
+ __ sub(r0, r0, ip);
+ __ push(r0);
+}
+
+
+void RegExpMacroAssemblerPPC::Push(Register source) {
+ DCHECK(!source.is(backtrack_stackpointer()));
+ __ StorePU(source, MemOperand(backtrack_stackpointer(), -kPointerSize));
+}
+
+
+void RegExpMacroAssemblerPPC::Pop(Register target) {
+ DCHECK(!target.is(backtrack_stackpointer()));
+ __ LoadP(target, MemOperand(backtrack_stackpointer()));
+ __ addi(backtrack_stackpointer(), backtrack_stackpointer(),
+ Operand(kPointerSize));
+}
+
+
+void RegExpMacroAssemblerPPC::CheckPreemption() {
+ // Check for preemption.
+ ExternalReference stack_limit =
+ ExternalReference::address_of_stack_limit(isolate());
+ __ mov(r3, Operand(stack_limit));
+ __ LoadP(r3, MemOperand(r3));
+ __ cmpl(sp, r3);
+ SafeCall(&check_preempt_label_, le);
+}
+
+
+void RegExpMacroAssemblerPPC::CheckStackLimit() {
+ ExternalReference stack_limit =
+ ExternalReference::address_of_regexp_stack_limit(isolate());
+ __ mov(r3, Operand(stack_limit));
+ __ LoadP(r3, MemOperand(r3));
+ __ cmpl(backtrack_stackpointer(), r3);
+ SafeCall(&stack_overflow_label_, le);
+}
+
+
+bool RegExpMacroAssemblerPPC::CanReadUnaligned() {
+ return CpuFeatures::IsSupported(UNALIGNED_ACCESSES) && !slow_safe();
+}
+
+
+void RegExpMacroAssemblerPPC::LoadCurrentCharacterUnchecked(int cp_offset,
+ int characters) {
+ Register offset = current_input_offset();
+ if (cp_offset != 0) {
+ // r25 is not being used to store the capture start index at this point.
+ __ addi(r25, current_input_offset(), Operand(cp_offset * char_size()));
+ offset = r25;
+ }
+ // The lwz, stw, lhz, sth instructions can do unaligned accesses, if the CPU
+ // and the operating system running on the target allow it.
+ // We assume we don't want to do unaligned loads on PPC, so this function
+ // must only be used to load a single character at a time.
+
+ DCHECK(characters == 1);
+ __ add(current_character(), end_of_input_address(), offset);
+ if (mode_ == LATIN1) {
+ __ lbz(current_character(), MemOperand(current_character()));
+ } else {
+ DCHECK(mode_ == UC16);
+ __ lhz(current_character(), MemOperand(current_character()));
+ }
+}
+
+
+#undef __
+
+#endif // V8_INTERPRETED_REGEXP
+}
+} // namespace v8::internal
+
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_PPC_REGEXP_MACRO_ASSEMBLER_PPC_H_
+#define V8_PPC_REGEXP_MACRO_ASSEMBLER_PPC_H_
+
+#include "src/macro-assembler.h"
+#include "src/ppc/assembler-ppc.h"
+#include "src/ppc/assembler-ppc-inl.h"
+
+namespace v8 {
+namespace internal {
+
+
+#ifndef V8_INTERPRETED_REGEXP
+class RegExpMacroAssemblerPPC : public NativeRegExpMacroAssembler {
+ public:
+ RegExpMacroAssemblerPPC(Mode mode, int registers_to_save, Zone* zone);
+ virtual ~RegExpMacroAssemblerPPC();
+ virtual int stack_limit_slack();
+ virtual void AdvanceCurrentPosition(int by);
+ virtual void AdvanceRegister(int reg, int by);
+ virtual void Backtrack();
+ virtual void Bind(Label* label);
+ virtual void CheckAtStart(Label* on_at_start);
+ virtual void CheckCharacter(unsigned c, Label* on_equal);
+ virtual void CheckCharacterAfterAnd(unsigned c, unsigned mask,
+ Label* on_equal);
+ virtual void CheckCharacterGT(uc16 limit, Label* on_greater);
+ virtual void CheckCharacterLT(uc16 limit, Label* on_less);
+ // A "greedy loop" is a loop that is both greedy and with a simple
+ // body. It has a particularly simple implementation.
+ virtual void CheckGreedyLoop(Label* on_tos_equals_current_position);
+ virtual void CheckNotAtStart(Label* on_not_at_start);
+ virtual void CheckNotBackReference(int start_reg, Label* on_no_match);
+ virtual void CheckNotBackReferenceIgnoreCase(int start_reg,
+ Label* on_no_match);
+ virtual void CheckNotCharacter(unsigned c, Label* on_not_equal);
+ virtual void CheckNotCharacterAfterAnd(unsigned c, unsigned mask,
+ Label* on_not_equal);
+ virtual void CheckNotCharacterAfterMinusAnd(uc16 c, uc16 minus, uc16 mask,
+ Label* on_not_equal);
+ virtual void CheckCharacterInRange(uc16 from, uc16 to, Label* on_in_range);
+ virtual void CheckCharacterNotInRange(uc16 from, uc16 to,
+ Label* on_not_in_range);
+ virtual void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set);
+
+ // Checks whether the given offset from the current position is before
+ // the end of the string.
+ virtual void CheckPosition(int cp_offset, Label* on_outside_input);
+ virtual bool CheckSpecialCharacterClass(uc16 type, Label* on_no_match);
+ virtual void Fail();
+ virtual Handle<HeapObject> GetCode(Handle<String> source);
+ virtual void GoTo(Label* label);
+ virtual void IfRegisterGE(int reg, int comparand, Label* if_ge);
+ virtual void IfRegisterLT(int reg, int comparand, Label* if_lt);
+ virtual void IfRegisterEqPos(int reg, Label* if_eq);
+ virtual IrregexpImplementation Implementation();
+ virtual void LoadCurrentCharacter(int cp_offset, Label* on_end_of_input,
+ bool check_bounds = true,
+ int characters = 1);
+ virtual void PopCurrentPosition();
+ virtual void PopRegister(int register_index);
+ virtual void PushBacktrack(Label* label);
+ virtual void PushCurrentPosition();
+ virtual void PushRegister(int register_index,
+ StackCheckFlag check_stack_limit);
+ virtual void ReadCurrentPositionFromRegister(int reg);
+ virtual void ReadStackPointerFromRegister(int reg);
+ virtual void SetCurrentPositionFromEnd(int by);
+ virtual void SetRegister(int register_index, int to);
+ virtual bool Succeed();
+ virtual void WriteCurrentPositionToRegister(int reg, int cp_offset);
+ virtual void ClearRegisters(int reg_from, int reg_to);
+ virtual void WriteStackPointerToRegister(int reg);
+ virtual bool CanReadUnaligned();
+
+ // Called from RegExp if the stack-guard is triggered.
+ // If the code object is relocated, the return address is fixed before
+ // returning.
+ static int CheckStackGuardState(Address* return_address, Code* re_code,
+ Address re_frame);
+
+ private:
+ // Offsets from frame_pointer() of function parameters and stored registers.
+ static const int kFramePointer = 0;
+
+ // Above the frame pointer - Stored registers and stack passed parameters.
+ // Register 25..31.
+ static const int kStoredRegisters = kFramePointer;
+ // Return address (stored from link register, read into pc on return).
+ static const int kReturnAddress = kStoredRegisters + 7 * kPointerSize;
+ static const int kCallerFrame = kReturnAddress + kPointerSize;
+ // Stack parameters placed by caller.
+ static const int kSecondaryReturnAddress =
+ kCallerFrame + kStackFrameExtraParamSlot * kPointerSize;
+ static const int kIsolate = kSecondaryReturnAddress + kPointerSize;
+
+ // Below the frame pointer.
+ // Register parameters stored by setup code.
+ static const int kDirectCall = kFramePointer - kPointerSize;
+ static const int kStackHighEnd = kDirectCall - kPointerSize;
+ static const int kNumOutputRegisters = kStackHighEnd - kPointerSize;
+ static const int kRegisterOutput = kNumOutputRegisters - kPointerSize;
+ static const int kInputEnd = kRegisterOutput - kPointerSize;
+ static const int kInputStart = kInputEnd - kPointerSize;
+ static const int kStartIndex = kInputStart - kPointerSize;
+ static const int kInputString = kStartIndex - kPointerSize;
+ // When adding local variables remember to push space for them in
+ // the frame in GetCode.
+ static const int kSuccessfulCaptures = kInputString - kPointerSize;
+ static const int kInputStartMinusOne = kSuccessfulCaptures - kPointerSize;
+ // First register address. Following registers are below it on the stack.
+ static const int kRegisterZero = kInputStartMinusOne - kPointerSize;
+
+ // Initial size of code buffer.
+ static const size_t kRegExpCodeSize = 1024;
+
+ // Load a number of characters at the given offset from the
+ // current position, into the current-character register.
+ void LoadCurrentCharacterUnchecked(int cp_offset, int character_count);
+
+ // Check whether preemption has been requested.
+ void CheckPreemption();
+
+ // Check whether we are exceeding the stack limit on the backtrack stack.
+ void CheckStackLimit();
+
+
+ // Generate a call to CheckStackGuardState.
+ void CallCheckStackGuardState(Register scratch);
+
+ // The ebp-relative location of a regexp register.
+ MemOperand register_location(int register_index);
+
+ // Register holding the current input position as negative offset from
+ // the end of the string.
+ inline Register current_input_offset() { return r27; }
+
+ // The register containing the current character after LoadCurrentCharacter.
+ inline Register current_character() { return r28; }
+
+ // Register holding address of the end of the input string.
+ inline Register end_of_input_address() { return r30; }
+
+ // Register holding the frame address. Local variables, parameters and
+ // regexp registers are addressed relative to this.
+ inline Register frame_pointer() { return fp; }
+
+ // The register containing the backtrack stack top. Provides a meaningful
+ // name to the register.
+ inline Register backtrack_stackpointer() { return r29; }
+
+ // Register holding pointer to the current code object.
+ inline Register code_pointer() { return r26; }
+
+ // Byte size of chars in the string to match (decided by the Mode argument)
+ inline int char_size() { return static_cast<int>(mode_); }
+
+ // Equivalent to a conditional branch to the label, unless the label
+ // is NULL, in which case it is a conditional Backtrack.
+ void BranchOrBacktrack(Condition condition, Label* to, CRegister cr = cr7);
+
+ // Call and return internally in the generated code in a way that
+ // is GC-safe (i.e., doesn't leave absolute code addresses on the stack)
+ inline void SafeCall(Label* to, Condition cond = al, CRegister cr = cr7);
+ inline void SafeReturn();
+ inline void SafeCallTarget(Label* name);
+
+ // Pushes the value of a register on the backtrack stack. Decrements the
+ // stack pointer by a word size and stores the register's value there.
+ inline void Push(Register source);
+
+ // Pops a value from the backtrack stack. Reads the word at the stack pointer
+ // and increments it by a word size.
+ inline void Pop(Register target);
+
+ Isolate* isolate() const { return masm_->isolate(); }
+
+ MacroAssembler* masm_;
+
+ // Which mode to generate code for (Latin1 or UC16).
+ Mode mode_;
+
+ // One greater than maximal register index actually used.
+ int num_registers_;
+
+ // Number of registers to output at the end (the saved registers
+ // are always 0..num_saved_registers_-1)
+ int num_saved_registers_;
+
+ // Labels used internally.
+ Label entry_label_;
+ Label start_label_;
+ Label success_label_;
+ Label backtrack_label_;
+ Label exit_label_;
+ Label check_preempt_label_;
+ Label stack_overflow_label_;
+ Label internal_failure_label_;
+};
+
+// Set of non-volatile registers saved/restored by generated regexp code.
+const RegList kRegExpCalleeSaved =
+ 1 << 25 | 1 << 26 | 1 << 27 | 1 << 28 | 1 << 29 | 1 << 30 | 1 << 31;
+
+#endif // V8_INTERPRETED_REGEXP
+}
+} // namespace v8::internal
+
+#endif // V8_PPC_REGEXP_MACRO_ASSEMBLER_PPC_H_
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <cmath>
+
+#include "src/v8.h"
+
+#if V8_TARGET_ARCH_PPC
+
+#include "src/assembler.h"
+#include "src/codegen.h"
+#include "src/disasm.h"
+#include "src/ppc/constants-ppc.h"
+#include "src/ppc/frames-ppc.h"
+#include "src/ppc/simulator-ppc.h"
+
+#if defined(USE_SIMULATOR)
+
+// Only build the simulator if not compiling for real PPC hardware.
+namespace v8 {
+namespace internal {
+
+// This macro provides a platform independent use of sscanf. The reason for
+// SScanF not being implemented in a platform independent way through
+// ::v8::internal::OS in the same way as SNPrintF is that the
+// Windows C Run-Time Library does not provide vsscanf.
+#define SScanF sscanf // NOLINT
+
+// The PPCDebugger class is used by the simulator while debugging simulated
+// PowerPC code.
+class PPCDebugger {
+ public:
+ explicit PPCDebugger(Simulator* sim) : sim_(sim) {}
+ ~PPCDebugger();
+
+ void Stop(Instruction* instr);
+ void Info(Instruction* instr);
+ void Debug();
+
+ private:
+ static const Instr kBreakpointInstr = (TWI | 0x1f * B21);
+ static const Instr kNopInstr = (ORI); // ori, 0,0,0
+
+ Simulator* sim_;
+
+ intptr_t GetRegisterValue(int regnum);
+ double GetRegisterPairDoubleValue(int regnum);
+ double GetFPDoubleRegisterValue(int regnum);
+ bool GetValue(const char* desc, intptr_t* value);
+ bool GetFPDoubleValue(const char* desc, double* value);
+
+ // Set or delete a breakpoint. Returns true if successful.
+ bool SetBreakpoint(Instruction* break_pc);
+ bool DeleteBreakpoint(Instruction* break_pc);
+
+ // Undo and redo all breakpoints. This is needed to bracket disassembly and
+ // execution to skip past breakpoints when run from the debugger.
+ void UndoBreakpoints();
+ void RedoBreakpoints();
+};
+
+
+PPCDebugger::~PPCDebugger() {}
+
+
+#ifdef GENERATED_CODE_COVERAGE
+static FILE* coverage_log = NULL;
+
+
+static void InitializeCoverage() {
+ char* file_name = getenv("V8_GENERATED_CODE_COVERAGE_LOG");
+ if (file_name != NULL) {
+ coverage_log = fopen(file_name, "aw+");
+ }
+}
+
+
+void PPCDebugger::Stop(Instruction* instr) {
+ // Get the stop code.
+ uint32_t code = instr->SvcValue() & kStopCodeMask;
+ // Retrieve the encoded address, which comes just after this stop.
+ char** msg_address =
+ reinterpret_cast<char**>(sim_->get_pc() + Instruction::kInstrSize);
+ char* msg = *msg_address;
+ DCHECK(msg != NULL);
+
+ // Update this stop description.
+ if (isWatchedStop(code) && !watched_stops_[code].desc) {
+ watched_stops_[code].desc = msg;
+ }
+
+ if (strlen(msg) > 0) {
+ if (coverage_log != NULL) {
+ fprintf(coverage_log, "%s\n", msg);
+ fflush(coverage_log);
+ }
+ // Overwrite the instruction and address with nops.
+ instr->SetInstructionBits(kNopInstr);
+ reinterpret_cast<Instruction*>(msg_address)->SetInstructionBits(kNopInstr);
+ }
+ sim_->set_pc(sim_->get_pc() + Instruction::kInstrSize + kPointerSize);
+}
+
+#else // ndef GENERATED_CODE_COVERAGE
+
+static void InitializeCoverage() {}
+
+
+void PPCDebugger::Stop(Instruction* instr) {
+ // Get the stop code.
+ // use of kStopCodeMask not right on PowerPC
+ uint32_t code = instr->SvcValue() & kStopCodeMask;
+ // Retrieve the encoded address, which comes just after this stop.
+ char* msg =
+ *reinterpret_cast<char**>(sim_->get_pc() + Instruction::kInstrSize);
+ // Update this stop description.
+ if (sim_->isWatchedStop(code) && !sim_->watched_stops_[code].desc) {
+ sim_->watched_stops_[code].desc = msg;
+ }
+ // Print the stop message and code if it is not the default code.
+ if (code != kMaxStopCode) {
+ PrintF("Simulator hit stop %u: %s\n", code, msg);
+ } else {
+ PrintF("Simulator hit %s\n", msg);
+ }
+ sim_->set_pc(sim_->get_pc() + Instruction::kInstrSize + kPointerSize);
+ Debug();
+}
+#endif
+
+
+void PPCDebugger::Info(Instruction* instr) {
+ // Retrieve the encoded address immediately following the Info breakpoint.
+ char* msg =
+ *reinterpret_cast<char**>(sim_->get_pc() + Instruction::kInstrSize);
+ PrintF("Simulator info %s\n", msg);
+ sim_->set_pc(sim_->get_pc() + Instruction::kInstrSize + kPointerSize);
+}
+
+
+intptr_t PPCDebugger::GetRegisterValue(int regnum) {
+ return sim_->get_register(regnum);
+}
+
+
+double PPCDebugger::GetRegisterPairDoubleValue(int regnum) {
+ return sim_->get_double_from_register_pair(regnum);
+}
+
+
+double PPCDebugger::GetFPDoubleRegisterValue(int regnum) {
+ return sim_->get_double_from_d_register(regnum);
+}
+
+
+bool PPCDebugger::GetValue(const char* desc, intptr_t* value) {
+ int regnum = Registers::Number(desc);
+ if (regnum != kNoRegister) {
+ *value = GetRegisterValue(regnum);
+ return true;
+ } else {
+ if (strncmp(desc, "0x", 2) == 0) {
+ return SScanF(desc + 2, "%" V8PRIxPTR,
+ reinterpret_cast<uintptr_t*>(value)) == 1;
+ } else {
+ return SScanF(desc, "%" V8PRIuPTR, reinterpret_cast<uintptr_t*>(value)) ==
+ 1;
+ }
+ }
+ return false;
+}
+
+
+bool PPCDebugger::GetFPDoubleValue(const char* desc, double* value) {
+ int regnum = FPRegisters::Number(desc);
+ if (regnum != kNoRegister) {
+ *value = sim_->get_double_from_d_register(regnum);
+ return true;
+ }
+ return false;
+}
+
+
+bool PPCDebugger::SetBreakpoint(Instruction* break_pc) {
+ // Check if a breakpoint can be set. If not return without any side-effects.
+ if (sim_->break_pc_ != NULL) {
+ return false;
+ }
+
+ // Set the breakpoint.
+ sim_->break_pc_ = break_pc;
+ sim_->break_instr_ = break_pc->InstructionBits();
+ // Not setting the breakpoint instruction in the code itself. It will be set
+ // when the debugger shell continues.
+ return true;
+}
+
+
+bool PPCDebugger::DeleteBreakpoint(Instruction* break_pc) {
+ if (sim_->break_pc_ != NULL) {
+ sim_->break_pc_->SetInstructionBits(sim_->break_instr_);
+ }
+
+ sim_->break_pc_ = NULL;
+ sim_->break_instr_ = 0;
+ return true;
+}
+
+
+void PPCDebugger::UndoBreakpoints() {
+ if (sim_->break_pc_ != NULL) {
+ sim_->break_pc_->SetInstructionBits(sim_->break_instr_);
+ }
+}
+
+
+void PPCDebugger::RedoBreakpoints() {
+ if (sim_->break_pc_ != NULL) {
+ sim_->break_pc_->SetInstructionBits(kBreakpointInstr);
+ }
+}
+
+
+void PPCDebugger::Debug() {
+ intptr_t last_pc = -1;
+ bool done = false;
+
+#define COMMAND_SIZE 63
+#define ARG_SIZE 255
+
+#define STR(a) #a
+#define XSTR(a) STR(a)
+
+ char cmd[COMMAND_SIZE + 1];
+ char arg1[ARG_SIZE + 1];
+ char arg2[ARG_SIZE + 1];
+ char* argv[3] = {cmd, arg1, arg2};
+
+ // make sure to have a proper terminating character if reaching the limit
+ cmd[COMMAND_SIZE] = 0;
+ arg1[ARG_SIZE] = 0;
+ arg2[ARG_SIZE] = 0;
+
+ // Undo all set breakpoints while running in the debugger shell. This will
+ // make them invisible to all commands.
+ UndoBreakpoints();
+ // Disable tracing while simulating
+ bool trace = ::v8::internal::FLAG_trace_sim;
+ ::v8::internal::FLAG_trace_sim = false;
+
+ while (!done && !sim_->has_bad_pc()) {
+ if (last_pc != sim_->get_pc()) {
+ disasm::NameConverter converter;
+ disasm::Disassembler dasm(converter);
+ // use a reasonably large buffer
+ v8::internal::EmbeddedVector<char, 256> buffer;
+ dasm.InstructionDecode(buffer, reinterpret_cast<byte*>(sim_->get_pc()));
+ PrintF(" 0x%08" V8PRIxPTR " %s\n", sim_->get_pc(), buffer.start());
+ last_pc = sim_->get_pc();
+ }
+ char* line = ReadLine("sim> ");
+ if (line == NULL) {
+ break;
+ } else {
+ char* last_input = sim_->last_debugger_input();
+ if (strcmp(line, "\n") == 0 && last_input != NULL) {
+ line = last_input;
+ } else {
+ // Ownership is transferred to sim_;
+ sim_->set_last_debugger_input(line);
+ }
+ // Use sscanf to parse the individual parts of the command line. At the
+ // moment no command expects more than two parameters.
+ int argc = SScanF(line,
+ "%" XSTR(COMMAND_SIZE) "s "
+ "%" XSTR(ARG_SIZE) "s "
+ "%" XSTR(ARG_SIZE) "s",
+ cmd, arg1, arg2);
+ if ((strcmp(cmd, "si") == 0) || (strcmp(cmd, "stepi") == 0)) {
+ intptr_t value;
+
+ // If at a breakpoint, proceed past it.
+ if ((reinterpret_cast<Instruction*>(sim_->get_pc()))
+ ->InstructionBits() == 0x7d821008) {
+ sim_->set_pc(sim_->get_pc() + Instruction::kInstrSize);
+ } else {
+ sim_->ExecuteInstruction(
+ reinterpret_cast<Instruction*>(sim_->get_pc()));
+ }
+
+ if (argc == 2 && last_pc != sim_->get_pc() && GetValue(arg1, &value)) {
+ for (int i = 1; i < value; i++) {
+ disasm::NameConverter converter;
+ disasm::Disassembler dasm(converter);
+ // use a reasonably large buffer
+ v8::internal::EmbeddedVector<char, 256> buffer;
+ dasm.InstructionDecode(buffer,
+ reinterpret_cast<byte*>(sim_->get_pc()));
+ PrintF(" 0x%08" V8PRIxPTR " %s\n", sim_->get_pc(),
+ buffer.start());
+ sim_->ExecuteInstruction(
+ reinterpret_cast<Instruction*>(sim_->get_pc()));
+ }
+ }
+ } else if ((strcmp(cmd, "c") == 0) || (strcmp(cmd, "cont") == 0)) {
+ // If at a breakpoint, proceed past it.
+ if ((reinterpret_cast<Instruction*>(sim_->get_pc()))
+ ->InstructionBits() == 0x7d821008) {
+ sim_->set_pc(sim_->get_pc() + Instruction::kInstrSize);
+ } else {
+ // Execute the one instruction we broke at with breakpoints disabled.
+ sim_->ExecuteInstruction(
+ reinterpret_cast<Instruction*>(sim_->get_pc()));
+ }
+ // Leave the debugger shell.
+ done = true;
+ } else if ((strcmp(cmd, "p") == 0) || (strcmp(cmd, "print") == 0)) {
+ if (argc == 2 || (argc == 3 && strcmp(arg2, "fp") == 0)) {
+ intptr_t value;
+ double dvalue;
+ if (strcmp(arg1, "all") == 0) {
+ for (int i = 0; i < kNumRegisters; i++) {
+ value = GetRegisterValue(i);
+ PrintF(" %3s: %08" V8PRIxPTR, Registers::Name(i), value);
+ if ((argc == 3 && strcmp(arg2, "fp") == 0) && i < 8 &&
+ (i % 2) == 0) {
+ dvalue = GetRegisterPairDoubleValue(i);
+ PrintF(" (%f)\n", dvalue);
+ } else if (i != 0 && !((i + 1) & 3)) {
+ PrintF("\n");
+ }
+ }
+ PrintF(" pc: %08" V8PRIxPTR " lr: %08" V8PRIxPTR
+ " "
+ "ctr: %08" V8PRIxPTR " xer: %08x cr: %08x\n",
+ sim_->special_reg_pc_, sim_->special_reg_lr_,
+ sim_->special_reg_ctr_, sim_->special_reg_xer_,
+ sim_->condition_reg_);
+ } else if (strcmp(arg1, "alld") == 0) {
+ for (int i = 0; i < kNumRegisters; i++) {
+ value = GetRegisterValue(i);
+ PrintF(" %3s: %08" V8PRIxPTR " %11" V8PRIdPTR,
+ Registers::Name(i), value, value);
+ if ((argc == 3 && strcmp(arg2, "fp") == 0) && i < 8 &&
+ (i % 2) == 0) {
+ dvalue = GetRegisterPairDoubleValue(i);
+ PrintF(" (%f)\n", dvalue);
+ } else if (!((i + 1) % 2)) {
+ PrintF("\n");
+ }
+ }
+ PrintF(" pc: %08" V8PRIxPTR " lr: %08" V8PRIxPTR
+ " "
+ "ctr: %08" V8PRIxPTR " xer: %08x cr: %08x\n",
+ sim_->special_reg_pc_, sim_->special_reg_lr_,
+ sim_->special_reg_ctr_, sim_->special_reg_xer_,
+ sim_->condition_reg_);
+ } else if (strcmp(arg1, "allf") == 0) {
+ for (int i = 0; i < DoubleRegister::kNumRegisters; i++) {
+ dvalue = GetFPDoubleRegisterValue(i);
+ uint64_t as_words = bit_cast<uint64_t>(dvalue);
+ PrintF("%3s: %f 0x%08x %08x\n", FPRegisters::Name(i), dvalue,
+ static_cast<uint32_t>(as_words >> 32),
+ static_cast<uint32_t>(as_words & 0xffffffff));
+ }
+ } else if (arg1[0] == 'r' &&
+ (arg1[1] >= '0' && arg1[1] <= '9' &&
+ (arg1[2] == '\0' || (arg1[2] >= '0' && arg1[2] <= '9' &&
+ arg1[3] == '\0')))) {
+ int regnum = strtoul(&arg1[1], 0, 10);
+ if (regnum != kNoRegister) {
+ value = GetRegisterValue(regnum);
+ PrintF("%s: 0x%08" V8PRIxPTR " %" V8PRIdPTR "\n", arg1, value,
+ value);
+ } else {
+ PrintF("%s unrecognized\n", arg1);
+ }
+ } else {
+ if (GetValue(arg1, &value)) {
+ PrintF("%s: 0x%08" V8PRIxPTR " %" V8PRIdPTR "\n", arg1, value,
+ value);
+ } else if (GetFPDoubleValue(arg1, &dvalue)) {
+ uint64_t as_words = bit_cast<uint64_t>(dvalue);
+ PrintF("%s: %f 0x%08x %08x\n", arg1, dvalue,
+ static_cast<uint32_t>(as_words >> 32),
+ static_cast<uint32_t>(as_words & 0xffffffff));
+ } else {
+ PrintF("%s unrecognized\n", arg1);
+ }
+ }
+ } else {
+ PrintF("print <register>\n");
+ }
+ } else if ((strcmp(cmd, "po") == 0) ||
+ (strcmp(cmd, "printobject") == 0)) {
+ if (argc == 2) {
+ intptr_t value;
+ OFStream os(stdout);
+ if (GetValue(arg1, &value)) {
+ Object* obj = reinterpret_cast<Object*>(value);
+ os << arg1 << ": \n";
+#ifdef DEBUG
+ obj->Print(os);
+ os << "\n";
+#else
+ os << Brief(obj) << "\n";
+#endif
+ } else {
+ os << arg1 << " unrecognized\n";
+ }
+ } else {
+ PrintF("printobject <value>\n");
+ }
+ } else if (strcmp(cmd, "setpc") == 0) {
+ intptr_t value;
+
+ if (!GetValue(arg1, &value)) {
+ PrintF("%s unrecognized\n", arg1);
+ continue;
+ }
+ sim_->set_pc(value);
+ } else if (strcmp(cmd, "stack") == 0 || strcmp(cmd, "mem") == 0) {
+ intptr_t* cur = NULL;
+ intptr_t* end = NULL;
+ int next_arg = 1;
+
+ if (strcmp(cmd, "stack") == 0) {
+ cur = reinterpret_cast<intptr_t*>(sim_->get_register(Simulator::sp));
+ } else { // "mem"
+ intptr_t value;
+ if (!GetValue(arg1, &value)) {
+ PrintF("%s unrecognized\n", arg1);
+ continue;
+ }
+ cur = reinterpret_cast<intptr_t*>(value);
+ next_arg++;
+ }
+
+ intptr_t words; // likely inaccurate variable name for 64bit
+ if (argc == next_arg) {
+ words = 10;
+ } else {
+ if (!GetValue(argv[next_arg], &words)) {
+ words = 10;
+ }
+ }
+ end = cur + words;
+
+ while (cur < end) {
+ PrintF(" 0x%08" V8PRIxPTR ": 0x%08" V8PRIxPTR " %10" V8PRIdPTR,
+ reinterpret_cast<intptr_t>(cur), *cur, *cur);
+ HeapObject* obj = reinterpret_cast<HeapObject*>(*cur);
+ intptr_t value = *cur;
+ Heap* current_heap = v8::internal::Isolate::Current()->heap();
+ if (((value & 1) == 0) || current_heap->Contains(obj)) {
+ PrintF(" (");
+ if ((value & 1) == 0) {
+ PrintF("smi %d", PlatformSmiTagging::SmiToInt(obj));
+ } else {
+ obj->ShortPrint();
+ }
+ PrintF(")");
+ }
+ PrintF("\n");
+ cur++;
+ }
+ } else if (strcmp(cmd, "disasm") == 0 || strcmp(cmd, "di") == 0) {
+ disasm::NameConverter converter;
+ disasm::Disassembler dasm(converter);
+ // use a reasonably large buffer
+ v8::internal::EmbeddedVector<char, 256> buffer;
+
+ byte* prev = NULL;
+ byte* cur = NULL;
+ byte* end = NULL;
+
+ if (argc == 1) {
+ cur = reinterpret_cast<byte*>(sim_->get_pc());
+ end = cur + (10 * Instruction::kInstrSize);
+ } else if (argc == 2) {
+ int regnum = Registers::Number(arg1);
+ if (regnum != kNoRegister || strncmp(arg1, "0x", 2) == 0) {
+ // The argument is an address or a register name.
+ intptr_t value;
+ if (GetValue(arg1, &value)) {
+ cur = reinterpret_cast<byte*>(value);
+ // Disassemble 10 instructions at <arg1>.
+ end = cur + (10 * Instruction::kInstrSize);
+ }
+ } else {
+ // The argument is the number of instructions.
+ intptr_t value;
+ if (GetValue(arg1, &value)) {
+ cur = reinterpret_cast<byte*>(sim_->get_pc());
+ // Disassemble <arg1> instructions.
+ end = cur + (value * Instruction::kInstrSize);
+ }
+ }
+ } else {
+ intptr_t value1;
+ intptr_t value2;
+ if (GetValue(arg1, &value1) && GetValue(arg2, &value2)) {
+ cur = reinterpret_cast<byte*>(value1);
+ end = cur + (value2 * Instruction::kInstrSize);
+ }
+ }
+
+ while (cur < end) {
+ prev = cur;
+ cur += dasm.InstructionDecode(buffer, cur);
+ PrintF(" 0x%08" V8PRIxPTR " %s\n", reinterpret_cast<intptr_t>(prev),
+ buffer.start());
+ }
+ } else if (strcmp(cmd, "gdb") == 0) {
+ PrintF("relinquishing control to gdb\n");
+ v8::base::OS::DebugBreak();
+ PrintF("regaining control from gdb\n");
+ } else if (strcmp(cmd, "break") == 0) {
+ if (argc == 2) {
+ intptr_t value;
+ if (GetValue(arg1, &value)) {
+ if (!SetBreakpoint(reinterpret_cast<Instruction*>(value))) {
+ PrintF("setting breakpoint failed\n");
+ }
+ } else {
+ PrintF("%s unrecognized\n", arg1);
+ }
+ } else {
+ PrintF("break <address>\n");
+ }
+ } else if (strcmp(cmd, "del") == 0) {
+ if (!DeleteBreakpoint(NULL)) {
+ PrintF("deleting breakpoint failed\n");
+ }
+ } else if (strcmp(cmd, "cr") == 0) {
+ PrintF("Condition reg: %08x\n", sim_->condition_reg_);
+ } else if (strcmp(cmd, "lr") == 0) {
+ PrintF("Link reg: %08" V8PRIxPTR "\n", sim_->special_reg_lr_);
+ } else if (strcmp(cmd, "ctr") == 0) {
+ PrintF("Ctr reg: %08" V8PRIxPTR "\n", sim_->special_reg_ctr_);
+ } else if (strcmp(cmd, "xer") == 0) {
+ PrintF("XER: %08x\n", sim_->special_reg_xer_);
+ } else if (strcmp(cmd, "fpscr") == 0) {
+ PrintF("FPSCR: %08x\n", sim_->fp_condition_reg_);
+ } else if (strcmp(cmd, "stop") == 0) {
+ intptr_t value;
+ intptr_t stop_pc =
+ sim_->get_pc() - (Instruction::kInstrSize + kPointerSize);
+ Instruction* stop_instr = reinterpret_cast<Instruction*>(stop_pc);
+ Instruction* msg_address =
+ reinterpret_cast<Instruction*>(stop_pc + Instruction::kInstrSize);
+ if ((argc == 2) && (strcmp(arg1, "unstop") == 0)) {
+ // Remove the current stop.
+ if (sim_->isStopInstruction(stop_instr)) {
+ stop_instr->SetInstructionBits(kNopInstr);
+ msg_address->SetInstructionBits(kNopInstr);
+ } else {
+ PrintF("Not at debugger stop.\n");
+ }
+ } else if (argc == 3) {
+ // Print information about all/the specified breakpoint(s).
+ if (strcmp(arg1, "info") == 0) {
+ if (strcmp(arg2, "all") == 0) {
+ PrintF("Stop information:\n");
+ for (uint32_t i = 0; i < sim_->kNumOfWatchedStops; i++) {
+ sim_->PrintStopInfo(i);
+ }
+ } else if (GetValue(arg2, &value)) {
+ sim_->PrintStopInfo(value);
+ } else {
+ PrintF("Unrecognized argument.\n");
+ }
+ } else if (strcmp(arg1, "enable") == 0) {
+ // Enable all/the specified breakpoint(s).
+ if (strcmp(arg2, "all") == 0) {
+ for (uint32_t i = 0; i < sim_->kNumOfWatchedStops; i++) {
+ sim_->EnableStop(i);
+ }
+ } else if (GetValue(arg2, &value)) {
+ sim_->EnableStop(value);
+ } else {
+ PrintF("Unrecognized argument.\n");
+ }
+ } else if (strcmp(arg1, "disable") == 0) {
+ // Disable all/the specified breakpoint(s).
+ if (strcmp(arg2, "all") == 0) {
+ for (uint32_t i = 0; i < sim_->kNumOfWatchedStops; i++) {
+ sim_->DisableStop(i);
+ }
+ } else if (GetValue(arg2, &value)) {
+ sim_->DisableStop(value);
+ } else {
+ PrintF("Unrecognized argument.\n");
+ }
+ }
+ } else {
+ PrintF("Wrong usage. Use help command for more information.\n");
+ }
+ } else if ((strcmp(cmd, "t") == 0) || strcmp(cmd, "trace") == 0) {
+ ::v8::internal::FLAG_trace_sim = !::v8::internal::FLAG_trace_sim;
+ PrintF("Trace of executed instructions is %s\n",
+ ::v8::internal::FLAG_trace_sim ? "on" : "off");
+ } else if ((strcmp(cmd, "h") == 0) || (strcmp(cmd, "help") == 0)) {
+ PrintF("cont\n");
+ PrintF(" continue execution (alias 'c')\n");
+ PrintF("stepi [num instructions]\n");
+ PrintF(" step one/num instruction(s) (alias 'si')\n");
+ PrintF("print <register>\n");
+ PrintF(" print register content (alias 'p')\n");
+ PrintF(" use register name 'all' to display all integer registers\n");
+ PrintF(
+ " use register name 'alld' to display integer registers "
+ "with decimal values\n");
+ PrintF(" use register name 'rN' to display register number 'N'\n");
+ PrintF(" add argument 'fp' to print register pair double values\n");
+ PrintF(
+ " use register name 'allf' to display floating-point "
+ "registers\n");
+ PrintF("printobject <register>\n");
+ PrintF(" print an object from a register (alias 'po')\n");
+ PrintF("cr\n");
+ PrintF(" print condition register\n");
+ PrintF("lr\n");
+ PrintF(" print link register\n");
+ PrintF("ctr\n");
+ PrintF(" print ctr register\n");
+ PrintF("xer\n");
+ PrintF(" print XER\n");
+ PrintF("fpscr\n");
+ PrintF(" print FPSCR\n");
+ PrintF("stack [<num words>]\n");
+ PrintF(" dump stack content, default dump 10 words)\n");
+ PrintF("mem <address> [<num words>]\n");
+ PrintF(" dump memory content, default dump 10 words)\n");
+ PrintF("disasm [<instructions>]\n");
+ PrintF("disasm [<address/register>]\n");
+ PrintF("disasm [[<address/register>] <instructions>]\n");
+ PrintF(" disassemble code, default is 10 instructions\n");
+ PrintF(" from pc (alias 'di')\n");
+ PrintF("gdb\n");
+ PrintF(" enter gdb\n");
+ PrintF("break <address>\n");
+ PrintF(" set a break point on the address\n");
+ PrintF("del\n");
+ PrintF(" delete the breakpoint\n");
+ PrintF("trace (alias 't')\n");
+ PrintF(" toogle the tracing of all executed statements\n");
+ PrintF("stop feature:\n");
+ PrintF(" Description:\n");
+ PrintF(" Stops are debug instructions inserted by\n");
+ PrintF(" the Assembler::stop() function.\n");
+ PrintF(" When hitting a stop, the Simulator will\n");
+ PrintF(" stop and and give control to the PPCDebugger.\n");
+ PrintF(" The first %d stop codes are watched:\n",
+ Simulator::kNumOfWatchedStops);
+ PrintF(" - They can be enabled / disabled: the Simulator\n");
+ PrintF(" will / won't stop when hitting them.\n");
+ PrintF(" - The Simulator keeps track of how many times they \n");
+ PrintF(" are met. (See the info command.) Going over a\n");
+ PrintF(" disabled stop still increases its counter. \n");
+ PrintF(" Commands:\n");
+ PrintF(" stop info all/<code> : print infos about number <code>\n");
+ PrintF(" or all stop(s).\n");
+ PrintF(" stop enable/disable all/<code> : enables / disables\n");
+ PrintF(" all or number <code> stop(s)\n");
+ PrintF(" stop unstop\n");
+ PrintF(" ignore the stop instruction at the current location\n");
+ PrintF(" from now on\n");
+ } else {
+ PrintF("Unknown command: %s\n", cmd);
+ }
+ }
+ }
+
+ // Add all the breakpoints back to stop execution and enter the debugger
+ // shell when hit.
+ RedoBreakpoints();
+ // Restore tracing
+ ::v8::internal::FLAG_trace_sim = trace;
+
+#undef COMMAND_SIZE
+#undef ARG_SIZE
+
+#undef STR
+#undef XSTR
+}
+
+
+static bool ICacheMatch(void* one, void* two) {
+ DCHECK((reinterpret_cast<intptr_t>(one) & CachePage::kPageMask) == 0);
+ DCHECK((reinterpret_cast<intptr_t>(two) & CachePage::kPageMask) == 0);
+ return one == two;
+}
+
+
+static uint32_t ICacheHash(void* key) {
+ return static_cast<uint32_t>(reinterpret_cast<uintptr_t>(key)) >> 2;
+}
+
+
+static bool AllOnOnePage(uintptr_t start, int size) {
+ intptr_t start_page = (start & ~CachePage::kPageMask);
+ intptr_t end_page = ((start + size) & ~CachePage::kPageMask);
+ return start_page == end_page;
+}
+
+
+void Simulator::set_last_debugger_input(char* input) {
+ DeleteArray(last_debugger_input_);
+ last_debugger_input_ = input;
+}
+
+
+void Simulator::FlushICache(v8::internal::HashMap* i_cache, void* start_addr,
+ size_t size) {
+ intptr_t start = reinterpret_cast<intptr_t>(start_addr);
+ int intra_line = (start & CachePage::kLineMask);
+ start -= intra_line;
+ size += intra_line;
+ size = ((size - 1) | CachePage::kLineMask) + 1;
+ int offset = (start & CachePage::kPageMask);
+ while (!AllOnOnePage(start, size - 1)) {
+ int bytes_to_flush = CachePage::kPageSize - offset;
+ FlushOnePage(i_cache, start, bytes_to_flush);
+ start += bytes_to_flush;
+ size -= bytes_to_flush;
+ DCHECK_EQ(0, static_cast<int>(start & CachePage::kPageMask));
+ offset = 0;
+ }
+ if (size != 0) {
+ FlushOnePage(i_cache, start, size);
+ }
+}
+
+
+CachePage* Simulator::GetCachePage(v8::internal::HashMap* i_cache, void* page) {
+ v8::internal::HashMap::Entry* entry =
+ i_cache->Lookup(page, ICacheHash(page), true);
+ if (entry->value == NULL) {
+ CachePage* new_page = new CachePage();
+ entry->value = new_page;
+ }
+ return reinterpret_cast<CachePage*>(entry->value);
+}
+
+
+// Flush from start up to and not including start + size.
+void Simulator::FlushOnePage(v8::internal::HashMap* i_cache, intptr_t start,
+ int size) {
+ DCHECK(size <= CachePage::kPageSize);
+ DCHECK(AllOnOnePage(start, size - 1));
+ DCHECK((start & CachePage::kLineMask) == 0);
+ DCHECK((size & CachePage::kLineMask) == 0);
+ void* page = reinterpret_cast<void*>(start & (~CachePage::kPageMask));
+ int offset = (start & CachePage::kPageMask);
+ CachePage* cache_page = GetCachePage(i_cache, page);
+ char* valid_bytemap = cache_page->ValidityByte(offset);
+ memset(valid_bytemap, CachePage::LINE_INVALID, size >> CachePage::kLineShift);
+}
+
+
+void Simulator::CheckICache(v8::internal::HashMap* i_cache,
+ Instruction* instr) {
+ intptr_t address = reinterpret_cast<intptr_t>(instr);
+ void* page = reinterpret_cast<void*>(address & (~CachePage::kPageMask));
+ void* line = reinterpret_cast<void*>(address & (~CachePage::kLineMask));
+ int offset = (address & CachePage::kPageMask);
+ CachePage* cache_page = GetCachePage(i_cache, page);
+ char* cache_valid_byte = cache_page->ValidityByte(offset);
+ bool cache_hit = (*cache_valid_byte == CachePage::LINE_VALID);
+ char* cached_line = cache_page->CachedData(offset & ~CachePage::kLineMask);
+ if (cache_hit) {
+ // Check that the data in memory matches the contents of the I-cache.
+ CHECK_EQ(0,
+ memcmp(reinterpret_cast<void*>(instr),
+ cache_page->CachedData(offset), Instruction::kInstrSize));
+ } else {
+ // Cache miss. Load memory into the cache.
+ memcpy(cached_line, line, CachePage::kLineLength);
+ *cache_valid_byte = CachePage::LINE_VALID;
+ }
+}
+
+
+void Simulator::Initialize(Isolate* isolate) {
+ if (isolate->simulator_initialized()) return;
+ isolate->set_simulator_initialized(true);
+ ::v8::internal::ExternalReference::set_redirector(isolate,
+ &RedirectExternalReference);
+}
+
+
+Simulator::Simulator(Isolate* isolate) : isolate_(isolate) {
+ i_cache_ = isolate_->simulator_i_cache();
+ if (i_cache_ == NULL) {
+ i_cache_ = new v8::internal::HashMap(&ICacheMatch);
+ isolate_->set_simulator_i_cache(i_cache_);
+ }
+ Initialize(isolate);
+// Set up simulator support first. Some of this information is needed to
+// setup the architecture state.
+#if V8_TARGET_ARCH_PPC64
+ size_t stack_size = 2 * 1024 * 1024; // allocate 2MB for stack
+#else
+ size_t stack_size = 1 * 1024 * 1024; // allocate 1MB for stack
+#endif
+ stack_ = reinterpret_cast<char*>(malloc(stack_size));
+ pc_modified_ = false;
+ icount_ = 0;
+ break_pc_ = NULL;
+ break_instr_ = 0;
+
+ // Set up architecture state.
+ // All registers are initialized to zero to start with.
+ for (int i = 0; i < kNumGPRs; i++) {
+ registers_[i] = 0;
+ }
+ condition_reg_ = 0;
+ fp_condition_reg_ = 0;
+ special_reg_pc_ = 0;
+ special_reg_lr_ = 0;
+ special_reg_ctr_ = 0;
+
+ // Initializing FP registers.
+ for (int i = 0; i < kNumFPRs; i++) {
+ fp_registers_[i] = 0.0;
+ }
+
+ // The sp is initialized to point to the bottom (high address) of the
+ // allocated stack area. To be safe in potential stack underflows we leave
+ // some buffer below.
+ registers_[sp] = reinterpret_cast<intptr_t>(stack_) + stack_size - 64;
+ InitializeCoverage();
+
+ last_debugger_input_ = NULL;
+}
+
+
+Simulator::~Simulator() {}
+
+
+// When the generated code calls an external reference we need to catch that in
+// the simulator. The external reference will be a function compiled for the
+// host architecture. We need to call that function instead of trying to
+// execute it with the simulator. We do that by redirecting the external
+// reference to a svc (Supervisor Call) instruction that is handled by
+// the simulator. We write the original destination of the jump just at a known
+// offset from the svc instruction so the simulator knows what to call.
+class Redirection {
+ public:
+ Redirection(void* external_function, ExternalReference::Type type)
+ : external_function_(external_function),
+ swi_instruction_(rtCallRedirInstr | kCallRtRedirected),
+ type_(type),
+ next_(NULL) {
+ Isolate* isolate = Isolate::Current();
+ next_ = isolate->simulator_redirection();
+ Simulator::current(isolate)->FlushICache(
+ isolate->simulator_i_cache(),
+ reinterpret_cast<void*>(&swi_instruction_), Instruction::kInstrSize);
+ isolate->set_simulator_redirection(this);
+ }
+
+ void* address_of_swi_instruction() {
+ return reinterpret_cast<void*>(&swi_instruction_);
+ }
+
+ void* external_function() { return external_function_; }
+ ExternalReference::Type type() { return type_; }
+
+ static Redirection* Get(void* external_function,
+ ExternalReference::Type type) {
+ Isolate* isolate = Isolate::Current();
+ Redirection* current = isolate->simulator_redirection();
+ for (; current != NULL; current = current->next_) {
+ if (current->external_function_ == external_function) {
+ DCHECK_EQ(current->type(), type);
+ return current;
+ }
+ }
+ return new Redirection(external_function, type);
+ }
+
+ static Redirection* FromSwiInstruction(Instruction* swi_instruction) {
+ char* addr_of_swi = reinterpret_cast<char*>(swi_instruction);
+ char* addr_of_redirection =
+ addr_of_swi - OFFSET_OF(Redirection, swi_instruction_);
+ return reinterpret_cast<Redirection*>(addr_of_redirection);
+ }
+
+ static void* ReverseRedirection(intptr_t reg) {
+ Redirection* redirection = FromSwiInstruction(
+ reinterpret_cast<Instruction*>(reinterpret_cast<void*>(reg)));
+ return redirection->external_function();
+ }
+
+ private:
+ void* external_function_;
+ uint32_t swi_instruction_;
+ ExternalReference::Type type_;
+ Redirection* next_;
+};
+
+
+void* Simulator::RedirectExternalReference(void* external_function,
+ ExternalReference::Type type) {
+ Redirection* redirection = Redirection::Get(external_function, type);
+ return redirection->address_of_swi_instruction();
+}
+
+
+// Get the active Simulator for the current thread.
+Simulator* Simulator::current(Isolate* isolate) {
+ v8::internal::Isolate::PerIsolateThreadData* isolate_data =
+ isolate->FindOrAllocatePerThreadDataForThisThread();
+ DCHECK(isolate_data != NULL);
+
+ Simulator* sim = isolate_data->simulator();
+ if (sim == NULL) {
+ // TODO(146): delete the simulator object when a thread/isolate goes away.
+ sim = new Simulator(isolate);
+ isolate_data->set_simulator(sim);
+ }
+ return sim;
+}
+
+
+// Sets the register in the architecture state.
+void Simulator::set_register(int reg, intptr_t value) {
+ DCHECK((reg >= 0) && (reg < kNumGPRs));
+ registers_[reg] = value;
+}
+
+
+// Get the register from the architecture state.
+intptr_t Simulator::get_register(int reg) const {
+ DCHECK((reg >= 0) && (reg < kNumGPRs));
+ // Stupid code added to avoid bug in GCC.
+ // See: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43949
+ if (reg >= kNumGPRs) return 0;
+ // End stupid code.
+ return registers_[reg];
+}
+
+
+double Simulator::get_double_from_register_pair(int reg) {
+ DCHECK((reg >= 0) && (reg < kNumGPRs) && ((reg % 2) == 0));
+
+ double dm_val = 0.0;
+#if !V8_TARGET_ARCH_PPC64 // doesn't make sense in 64bit mode
+ // Read the bits from the unsigned integer register_[] array
+ // into the double precision floating point value and return it.
+ char buffer[sizeof(fp_registers_[0])];
+ memcpy(buffer, ®isters_[reg], 2 * sizeof(registers_[0]));
+ memcpy(&dm_val, buffer, 2 * sizeof(registers_[0]));
+#endif
+ return (dm_val);
+}
+
+
+// Raw access to the PC register.
+void Simulator::set_pc(intptr_t value) {
+ pc_modified_ = true;
+ special_reg_pc_ = value;
+}
+
+
+bool Simulator::has_bad_pc() const {
+ return ((special_reg_pc_ == bad_lr) || (special_reg_pc_ == end_sim_pc));
+}
+
+
+// Raw access to the PC register without the special adjustment when reading.
+intptr_t Simulator::get_pc() const { return special_reg_pc_; }
+
+
+// Runtime FP routines take:
+// - two double arguments
+// - one double argument and zero or one integer arguments.
+// All are consructed here from d1, d2 and r3.
+void Simulator::GetFpArgs(double* x, double* y, intptr_t* z) {
+ *x = get_double_from_d_register(1);
+ *y = get_double_from_d_register(2);
+ *z = get_register(3);
+}
+
+
+// The return value is in d1.
+void Simulator::SetFpResult(const double& result) { fp_registers_[1] = result; }
+
+
+void Simulator::TrashCallerSaveRegisters() {
+// We don't trash the registers with the return value.
+#if 0 // A good idea to trash volatile registers, needs to be done
+ registers_[2] = 0x50Bad4U;
+ registers_[3] = 0x50Bad4U;
+ registers_[12] = 0x50Bad4U;
+#endif
+}
+
+
+uint32_t Simulator::ReadWU(intptr_t addr, Instruction* instr) {
+ uint32_t* ptr = reinterpret_cast<uint32_t*>(addr);
+ return *ptr;
+}
+
+
+int32_t Simulator::ReadW(intptr_t addr, Instruction* instr) {
+ int32_t* ptr = reinterpret_cast<int32_t*>(addr);
+ return *ptr;
+}
+
+
+void Simulator::WriteW(intptr_t addr, uint32_t value, Instruction* instr) {
+ uint32_t* ptr = reinterpret_cast<uint32_t*>(addr);
+ *ptr = value;
+ return;
+}
+
+
+void Simulator::WriteW(intptr_t addr, int32_t value, Instruction* instr) {
+ int32_t* ptr = reinterpret_cast<int32_t*>(addr);
+ *ptr = value;
+ return;
+}
+
+
+uint16_t Simulator::ReadHU(intptr_t addr, Instruction* instr) {
+ uint16_t* ptr = reinterpret_cast<uint16_t*>(addr);
+ return *ptr;
+}
+
+
+int16_t Simulator::ReadH(intptr_t addr, Instruction* instr) {
+ int16_t* ptr = reinterpret_cast<int16_t*>(addr);
+ return *ptr;
+}
+
+
+void Simulator::WriteH(intptr_t addr, uint16_t value, Instruction* instr) {
+ uint16_t* ptr = reinterpret_cast<uint16_t*>(addr);
+ *ptr = value;
+ return;
+}
+
+
+void Simulator::WriteH(intptr_t addr, int16_t value, Instruction* instr) {
+ int16_t* ptr = reinterpret_cast<int16_t*>(addr);
+ *ptr = value;
+ return;
+}
+
+
+uint8_t Simulator::ReadBU(intptr_t addr) {
+ uint8_t* ptr = reinterpret_cast<uint8_t*>(addr);
+ return *ptr;
+}
+
+
+int8_t Simulator::ReadB(intptr_t addr) {
+ int8_t* ptr = reinterpret_cast<int8_t*>(addr);
+ return *ptr;
+}
+
+
+void Simulator::WriteB(intptr_t addr, uint8_t value) {
+ uint8_t* ptr = reinterpret_cast<uint8_t*>(addr);
+ *ptr = value;
+}
+
+
+void Simulator::WriteB(intptr_t addr, int8_t value) {
+ int8_t* ptr = reinterpret_cast<int8_t*>(addr);
+ *ptr = value;
+}
+
+
+intptr_t* Simulator::ReadDW(intptr_t addr) {
+ intptr_t* ptr = reinterpret_cast<intptr_t*>(addr);
+ return ptr;
+}
+
+
+void Simulator::WriteDW(intptr_t addr, int64_t value) {
+ int64_t* ptr = reinterpret_cast<int64_t*>(addr);
+ *ptr = value;
+ return;
+}
+
+
+// Returns the limit of the stack area to enable checking for stack overflows.
+uintptr_t Simulator::StackLimit() const {
+ // Leave a safety margin of 1024 bytes to prevent overrunning the stack when
+ // pushing values.
+ return reinterpret_cast<uintptr_t>(stack_) + 1024;
+}
+
+
+// Unsupported instructions use Format to print an error and stop execution.
+void Simulator::Format(Instruction* instr, const char* format) {
+ PrintF("Simulator found unsupported instruction:\n 0x%08" V8PRIxPTR ": %s\n",
+ reinterpret_cast<intptr_t>(instr), format);
+ UNIMPLEMENTED();
+}
+
+
+// Calculate C flag value for additions.
+bool Simulator::CarryFrom(int32_t left, int32_t right, int32_t carry) {
+ uint32_t uleft = static_cast<uint32_t>(left);
+ uint32_t uright = static_cast<uint32_t>(right);
+ uint32_t urest = 0xffffffffU - uleft;
+
+ return (uright > urest) ||
+ (carry && (((uright + 1) > urest) || (uright > (urest - 1))));
+}
+
+
+// Calculate C flag value for subtractions.
+bool Simulator::BorrowFrom(int32_t left, int32_t right) {
+ uint32_t uleft = static_cast<uint32_t>(left);
+ uint32_t uright = static_cast<uint32_t>(right);
+
+ return (uright > uleft);
+}
+
+
+// Calculate V flag value for additions and subtractions.
+bool Simulator::OverflowFrom(int32_t alu_out, int32_t left, int32_t right,
+ bool addition) {
+ bool overflow;
+ if (addition) {
+ // operands have the same sign
+ overflow = ((left >= 0 && right >= 0) || (left < 0 && right < 0))
+ // and operands and result have different sign
+ &&
+ ((left < 0 && alu_out >= 0) || (left >= 0 && alu_out < 0));
+ } else {
+ // operands have different signs
+ overflow = ((left < 0 && right >= 0) || (left >= 0 && right < 0))
+ // and first operand and result have different signs
+ &&
+ ((left < 0 && alu_out >= 0) || (left >= 0 && alu_out < 0));
+ }
+ return overflow;
+}
+
+
+#if !V8_TARGET_ARCH_PPC64
+// Calls into the V8 runtime are based on this very simple interface.
+// Note: To be able to return two values from some calls the code in runtime.cc
+// uses the ObjectPair which is essentially two 32-bit values stuffed into a
+// 64-bit value. With the code below we assume that all runtime calls return
+// 64 bits of result. If they don't, the r4 result register contains a bogus
+// value, which is fine because it is caller-saved.
+typedef int64_t (*SimulatorRuntimeCall)(intptr_t arg0, intptr_t arg1,
+ intptr_t arg2, intptr_t arg3,
+ intptr_t arg4, intptr_t arg5);
+#else
+// For 64-bit, we need to be more explicit.
+typedef intptr_t (*SimulatorRuntimeCall)(intptr_t arg0, intptr_t arg1,
+ intptr_t arg2, intptr_t arg3,
+ intptr_t arg4, intptr_t arg5);
+struct ObjectPair {
+ intptr_t x;
+ intptr_t y;
+};
+
+typedef struct ObjectPair (*SimulatorRuntimeObjectPairCall)(
+ intptr_t arg0, intptr_t arg1, intptr_t arg2, intptr_t arg3, intptr_t arg4,
+ intptr_t arg5);
+#endif
+
+// These prototypes handle the four types of FP calls.
+typedef int (*SimulatorRuntimeCompareCall)(double darg0, double darg1);
+typedef double (*SimulatorRuntimeFPFPCall)(double darg0, double darg1);
+typedef double (*SimulatorRuntimeFPCall)(double darg0);
+typedef double (*SimulatorRuntimeFPIntCall)(double darg0, intptr_t arg0);
+
+// This signature supports direct call in to API function native callback
+// (refer to InvocationCallback in v8.h).
+typedef void (*SimulatorRuntimeDirectApiCall)(intptr_t arg0);
+typedef void (*SimulatorRuntimeProfilingApiCall)(intptr_t arg0, void* arg1);
+
+// This signature supports direct call to accessor getter callback.
+typedef void (*SimulatorRuntimeDirectGetterCall)(intptr_t arg0, intptr_t arg1);
+typedef void (*SimulatorRuntimeProfilingGetterCall)(intptr_t arg0,
+ intptr_t arg1, void* arg2);
+
+// Software interrupt instructions are used by the simulator to call into the
+// C-based V8 runtime.
+void Simulator::SoftwareInterrupt(Instruction* instr) {
+ int svc = instr->SvcValue();
+ switch (svc) {
+ case kCallRtRedirected: {
+ // Check if stack is aligned. Error if not aligned is reported below to
+ // include information on the function called.
+ bool stack_aligned =
+ (get_register(sp) & (::v8::internal::FLAG_sim_stack_alignment - 1)) ==
+ 0;
+ Redirection* redirection = Redirection::FromSwiInstruction(instr);
+ const int kArgCount = 6;
+ int arg0_regnum = 3;
+#if V8_TARGET_ARCH_PPC64 && !ABI_RETURNS_OBJECT_PAIRS_IN_REGS
+ intptr_t result_buffer = 0;
+ if (redirection->type() == ExternalReference::BUILTIN_OBJECTPAIR_CALL) {
+ result_buffer = get_register(r3);
+ arg0_regnum++;
+ }
+#endif
+ intptr_t arg[kArgCount];
+ for (int i = 0; i < kArgCount; i++) {
+ arg[i] = get_register(arg0_regnum + i);
+ }
+ bool fp_call =
+ (redirection->type() == ExternalReference::BUILTIN_FP_FP_CALL) ||
+ (redirection->type() == ExternalReference::BUILTIN_COMPARE_CALL) ||
+ (redirection->type() == ExternalReference::BUILTIN_FP_CALL) ||
+ (redirection->type() == ExternalReference::BUILTIN_FP_INT_CALL);
+ // This is dodgy but it works because the C entry stubs are never moved.
+ // See comment in codegen-arm.cc and bug 1242173.
+ intptr_t saved_lr = special_reg_lr_;
+ intptr_t external =
+ reinterpret_cast<intptr_t>(redirection->external_function());
+ if (fp_call) {
+ double dval0, dval1; // one or two double parameters
+ intptr_t ival; // zero or one integer parameters
+ int iresult = 0; // integer return value
+ double dresult = 0; // double return value
+ GetFpArgs(&dval0, &dval1, &ival);
+ if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
+ SimulatorRuntimeCall generic_target =
+ reinterpret_cast<SimulatorRuntimeCall>(external);
+ switch (redirection->type()) {
+ case ExternalReference::BUILTIN_FP_FP_CALL:
+ case ExternalReference::BUILTIN_COMPARE_CALL:
+ PrintF("Call to host function at %p with args %f, %f",
+ FUNCTION_ADDR(generic_target), dval0, dval1);
+ break;
+ case ExternalReference::BUILTIN_FP_CALL:
+ PrintF("Call to host function at %p with arg %f",
+ FUNCTION_ADDR(generic_target), dval0);
+ break;
+ case ExternalReference::BUILTIN_FP_INT_CALL:
+ PrintF("Call to host function at %p with args %f, %" V8PRIdPTR,
+ FUNCTION_ADDR(generic_target), dval0, ival);
+ break;
+ default:
+ UNREACHABLE();
+ break;
+ }
+ if (!stack_aligned) {
+ PrintF(" with unaligned stack %08" V8PRIxPTR "\n",
+ get_register(sp));
+ }
+ PrintF("\n");
+ }
+ CHECK(stack_aligned);
+ switch (redirection->type()) {
+ case ExternalReference::BUILTIN_COMPARE_CALL: {
+ SimulatorRuntimeCompareCall target =
+ reinterpret_cast<SimulatorRuntimeCompareCall>(external);
+ iresult = target(dval0, dval1);
+ set_register(r3, iresult);
+ break;
+ }
+ case ExternalReference::BUILTIN_FP_FP_CALL: {
+ SimulatorRuntimeFPFPCall target =
+ reinterpret_cast<SimulatorRuntimeFPFPCall>(external);
+ dresult = target(dval0, dval1);
+ SetFpResult(dresult);
+ break;
+ }
+ case ExternalReference::BUILTIN_FP_CALL: {
+ SimulatorRuntimeFPCall target =
+ reinterpret_cast<SimulatorRuntimeFPCall>(external);
+ dresult = target(dval0);
+ SetFpResult(dresult);
+ break;
+ }
+ case ExternalReference::BUILTIN_FP_INT_CALL: {
+ SimulatorRuntimeFPIntCall target =
+ reinterpret_cast<SimulatorRuntimeFPIntCall>(external);
+ dresult = target(dval0, ival);
+ SetFpResult(dresult);
+ break;
+ }
+ default:
+ UNREACHABLE();
+ break;
+ }
+ if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
+ switch (redirection->type()) {
+ case ExternalReference::BUILTIN_COMPARE_CALL:
+ PrintF("Returned %08x\n", iresult);
+ break;
+ case ExternalReference::BUILTIN_FP_FP_CALL:
+ case ExternalReference::BUILTIN_FP_CALL:
+ case ExternalReference::BUILTIN_FP_INT_CALL:
+ PrintF("Returned %f\n", dresult);
+ break;
+ default:
+ UNREACHABLE();
+ break;
+ }
+ }
+ } else if (redirection->type() == ExternalReference::DIRECT_API_CALL) {
+ // See callers of MacroAssembler::CallApiFunctionAndReturn for
+ // explanation of register usage.
+ if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
+ PrintF("Call to host function at %p args %08" V8PRIxPTR,
+ reinterpret_cast<void*>(external), arg[0]);
+ if (!stack_aligned) {
+ PrintF(" with unaligned stack %08" V8PRIxPTR "\n",
+ get_register(sp));
+ }
+ PrintF("\n");
+ }
+ CHECK(stack_aligned);
+ SimulatorRuntimeDirectApiCall target =
+ reinterpret_cast<SimulatorRuntimeDirectApiCall>(external);
+ target(arg[0]);
+ } else if (redirection->type() == ExternalReference::PROFILING_API_CALL) {
+ // See callers of MacroAssembler::CallApiFunctionAndReturn for
+ // explanation of register usage.
+ if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
+ PrintF("Call to host function at %p args %08" V8PRIxPTR
+ " %08" V8PRIxPTR,
+ reinterpret_cast<void*>(external), arg[0], arg[1]);
+ if (!stack_aligned) {
+ PrintF(" with unaligned stack %08" V8PRIxPTR "\n",
+ get_register(sp));
+ }
+ PrintF("\n");
+ }
+ CHECK(stack_aligned);
+ SimulatorRuntimeProfilingApiCall target =
+ reinterpret_cast<SimulatorRuntimeProfilingApiCall>(external);
+ target(arg[0], Redirection::ReverseRedirection(arg[1]));
+ } else if (redirection->type() == ExternalReference::DIRECT_GETTER_CALL) {
+ // See callers of MacroAssembler::CallApiFunctionAndReturn for
+ // explanation of register usage.
+ if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
+ PrintF("Call to host function at %p args %08" V8PRIxPTR
+ " %08" V8PRIxPTR,
+ reinterpret_cast<void*>(external), arg[0], arg[1]);
+ if (!stack_aligned) {
+ PrintF(" with unaligned stack %08" V8PRIxPTR "\n",
+ get_register(sp));
+ }
+ PrintF("\n");
+ }
+ CHECK(stack_aligned);
+ SimulatorRuntimeDirectGetterCall target =
+ reinterpret_cast<SimulatorRuntimeDirectGetterCall>(external);
+#if !ABI_PASSES_HANDLES_IN_REGS
+ arg[0] = *(reinterpret_cast<intptr_t*>(arg[0]));
+#endif
+ target(arg[0], arg[1]);
+ } else if (redirection->type() ==
+ ExternalReference::PROFILING_GETTER_CALL) {
+ if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
+ PrintF("Call to host function at %p args %08" V8PRIxPTR
+ " %08" V8PRIxPTR " %08" V8PRIxPTR,
+ reinterpret_cast<void*>(external), arg[0], arg[1], arg[2]);
+ if (!stack_aligned) {
+ PrintF(" with unaligned stack %08" V8PRIxPTR "\n",
+ get_register(sp));
+ }
+ PrintF("\n");
+ }
+ CHECK(stack_aligned);
+ SimulatorRuntimeProfilingGetterCall target =
+ reinterpret_cast<SimulatorRuntimeProfilingGetterCall>(external);
+#if !ABI_PASSES_HANDLES_IN_REGS
+ arg[0] = *(reinterpret_cast<intptr_t*>(arg[0]));
+#endif
+ target(arg[0], arg[1], Redirection::ReverseRedirection(arg[2]));
+ } else {
+ // builtin call.
+ if (::v8::internal::FLAG_trace_sim || !stack_aligned) {
+ SimulatorRuntimeCall target =
+ reinterpret_cast<SimulatorRuntimeCall>(external);
+ PrintF(
+ "Call to host function at %p,\n"
+ "\t\t\t\targs %08" V8PRIxPTR ", %08" V8PRIxPTR ", %08" V8PRIxPTR
+ ", %08" V8PRIxPTR ", %08" V8PRIxPTR ", %08" V8PRIxPTR,
+ FUNCTION_ADDR(target), arg[0], arg[1], arg[2], arg[3], arg[4],
+ arg[5]);
+ if (!stack_aligned) {
+ PrintF(" with unaligned stack %08" V8PRIxPTR "\n",
+ get_register(sp));
+ }
+ PrintF("\n");
+ }
+ CHECK(stack_aligned);
+#if !V8_TARGET_ARCH_PPC64
+ DCHECK(redirection->type() == ExternalReference::BUILTIN_CALL);
+ SimulatorRuntimeCall target =
+ reinterpret_cast<SimulatorRuntimeCall>(external);
+ int64_t result = target(arg[0], arg[1], arg[2], arg[3], arg[4], arg[5]);
+ int32_t lo_res = static_cast<int32_t>(result);
+ int32_t hi_res = static_cast<int32_t>(result >> 32);
+#if V8_TARGET_BIG_ENDIAN
+ if (::v8::internal::FLAG_trace_sim) {
+ PrintF("Returned %08x\n", hi_res);
+ }
+ set_register(r3, hi_res);
+ set_register(r4, lo_res);
+#else
+ if (::v8::internal::FLAG_trace_sim) {
+ PrintF("Returned %08x\n", lo_res);
+ }
+ set_register(r3, lo_res);
+ set_register(r4, hi_res);
+#endif
+#else
+ if (redirection->type() == ExternalReference::BUILTIN_CALL) {
+ SimulatorRuntimeCall target =
+ reinterpret_cast<SimulatorRuntimeCall>(external);
+ intptr_t result =
+ target(arg[0], arg[1], arg[2], arg[3], arg[4], arg[5]);
+ if (::v8::internal::FLAG_trace_sim) {
+ PrintF("Returned %08" V8PRIxPTR "\n", result);
+ }
+ set_register(r3, result);
+ } else {
+ DCHECK(redirection->type() ==
+ ExternalReference::BUILTIN_OBJECTPAIR_CALL);
+ SimulatorRuntimeObjectPairCall target =
+ reinterpret_cast<SimulatorRuntimeObjectPairCall>(external);
+ struct ObjectPair result =
+ target(arg[0], arg[1], arg[2], arg[3], arg[4], arg[5]);
+ if (::v8::internal::FLAG_trace_sim) {
+ PrintF("Returned %08" V8PRIxPTR ", %08" V8PRIxPTR "\n", result.x,
+ result.y);
+ }
+#if ABI_RETURNS_OBJECT_PAIRS_IN_REGS
+ set_register(r3, result.x);
+ set_register(r4, result.y);
+#else
+ memcpy(reinterpret_cast<void*>(result_buffer), &result,
+ sizeof(struct ObjectPair));
+#endif
+ }
+#endif
+ }
+ set_pc(saved_lr);
+ break;
+ }
+ case kBreakpoint: {
+ PPCDebugger dbg(this);
+ dbg.Debug();
+ break;
+ }
+ case kInfo: {
+ PPCDebugger dbg(this);
+ dbg.Info(instr);
+ break;
+ }
+ // stop uses all codes greater than 1 << 23.
+ default: {
+ if (svc >= (1 << 23)) {
+ uint32_t code = svc & kStopCodeMask;
+ if (isWatchedStop(code)) {
+ IncreaseStopCounter(code);
+ }
+ // Stop if it is enabled, otherwise go on jumping over the stop
+ // and the message address.
+ if (isEnabledStop(code)) {
+ PPCDebugger dbg(this);
+ dbg.Stop(instr);
+ } else {
+ set_pc(get_pc() + Instruction::kInstrSize + kPointerSize);
+ }
+ } else {
+ // This is not a valid svc code.
+ UNREACHABLE();
+ break;
+ }
+ }
+ }
+}
+
+
+// Stop helper functions.
+bool Simulator::isStopInstruction(Instruction* instr) {
+ return (instr->Bits(27, 24) == 0xF) && (instr->SvcValue() >= kStopCode);
+}
+
+
+bool Simulator::isWatchedStop(uint32_t code) {
+ DCHECK(code <= kMaxStopCode);
+ return code < kNumOfWatchedStops;
+}
+
+
+bool Simulator::isEnabledStop(uint32_t code) {
+ DCHECK(code <= kMaxStopCode);
+ // Unwatched stops are always enabled.
+ return !isWatchedStop(code) ||
+ !(watched_stops_[code].count & kStopDisabledBit);
+}
+
+
+void Simulator::EnableStop(uint32_t code) {
+ DCHECK(isWatchedStop(code));
+ if (!isEnabledStop(code)) {
+ watched_stops_[code].count &= ~kStopDisabledBit;
+ }
+}
+
+
+void Simulator::DisableStop(uint32_t code) {
+ DCHECK(isWatchedStop(code));
+ if (isEnabledStop(code)) {
+ watched_stops_[code].count |= kStopDisabledBit;
+ }
+}
+
+
+void Simulator::IncreaseStopCounter(uint32_t code) {
+ DCHECK(code <= kMaxStopCode);
+ DCHECK(isWatchedStop(code));
+ if ((watched_stops_[code].count & ~(1 << 31)) == 0x7fffffff) {
+ PrintF(
+ "Stop counter for code %i has overflowed.\n"
+ "Enabling this code and reseting the counter to 0.\n",
+ code);
+ watched_stops_[code].count = 0;
+ EnableStop(code);
+ } else {
+ watched_stops_[code].count++;
+ }
+}
+
+
+// Print a stop status.
+void Simulator::PrintStopInfo(uint32_t code) {
+ DCHECK(code <= kMaxStopCode);
+ if (!isWatchedStop(code)) {
+ PrintF("Stop not watched.");
+ } else {
+ const char* state = isEnabledStop(code) ? "Enabled" : "Disabled";
+ int32_t count = watched_stops_[code].count & ~kStopDisabledBit;
+ // Don't print the state of unused breakpoints.
+ if (count != 0) {
+ if (watched_stops_[code].desc) {
+ PrintF("stop %i - 0x%x: \t%s, \tcounter = %i, \t%s\n", code, code,
+ state, count, watched_stops_[code].desc);
+ } else {
+ PrintF("stop %i - 0x%x: \t%s, \tcounter = %i\n", code, code, state,
+ count);
+ }
+ }
+ }
+}
+
+
+void Simulator::SetCR0(intptr_t result, bool setSO) {
+ int bf = 0;
+ if (result < 0) {
+ bf |= 0x80000000;
+ }
+ if (result > 0) {
+ bf |= 0x40000000;
+ }
+ if (result == 0) {
+ bf |= 0x20000000;
+ }
+ if (setSO) {
+ bf |= 0x10000000;
+ }
+ condition_reg_ = (condition_reg_ & ~0xF0000000) | bf;
+}
+
+
+void Simulator::ExecuteBranchConditional(Instruction* instr) {
+ int bo = instr->Bits(25, 21) << 21;
+ int offset = (instr->Bits(15, 2) << 18) >> 16;
+ int condition_bit = instr->Bits(20, 16);
+ int condition_mask = 0x80000000 >> condition_bit;
+ switch (bo) {
+ case DCBNZF: // Decrement CTR; branch if CTR != 0 and condition false
+ case DCBEZF: // Decrement CTR; branch if CTR == 0 and condition false
+ UNIMPLEMENTED();
+ case BF: { // Branch if condition false
+ if (!(condition_reg_ & condition_mask)) {
+ if (instr->Bit(0) == 1) { // LK flag set
+ special_reg_lr_ = get_pc() + 4;
+ }
+ set_pc(get_pc() + offset);
+ }
+ break;
+ }
+ case DCBNZT: // Decrement CTR; branch if CTR != 0 and condition true
+ case DCBEZT: // Decrement CTR; branch if CTR == 0 and condition true
+ UNIMPLEMENTED();
+ case BT: { // Branch if condition true
+ if (condition_reg_ & condition_mask) {
+ if (instr->Bit(0) == 1) { // LK flag set
+ special_reg_lr_ = get_pc() + 4;
+ }
+ set_pc(get_pc() + offset);
+ }
+ break;
+ }
+ case DCBNZ: // Decrement CTR; branch if CTR != 0
+ case DCBEZ: // Decrement CTR; branch if CTR == 0
+ special_reg_ctr_ -= 1;
+ if ((special_reg_ctr_ == 0) == (bo == DCBEZ)) {
+ if (instr->Bit(0) == 1) { // LK flag set
+ special_reg_lr_ = get_pc() + 4;
+ }
+ set_pc(get_pc() + offset);
+ }
+ break;
+ case BA: { // Branch always
+ if (instr->Bit(0) == 1) { // LK flag set
+ special_reg_lr_ = get_pc() + 4;
+ }
+ set_pc(get_pc() + offset);
+ break;
+ }
+ default:
+ UNIMPLEMENTED(); // Invalid encoding
+ }
+}
+
+
+// Handle execution based on instruction types.
+void Simulator::ExecuteExt1(Instruction* instr) {
+ switch (instr->Bits(10, 1) << 1) {
+ case MCRF:
+ UNIMPLEMENTED(); // Not used by V8.
+ case BCLRX: {
+ // need to check BO flag
+ intptr_t old_pc = get_pc();
+ set_pc(special_reg_lr_);
+ if (instr->Bit(0) == 1) { // LK flag set
+ special_reg_lr_ = old_pc + 4;
+ }
+ break;
+ }
+ case BCCTRX: {
+ // need to check BO flag
+ intptr_t old_pc = get_pc();
+ set_pc(special_reg_ctr_);
+ if (instr->Bit(0) == 1) { // LK flag set
+ special_reg_lr_ = old_pc + 4;
+ }
+ break;
+ }
+ case CRNOR:
+ case RFI:
+ case CRANDC:
+ UNIMPLEMENTED();
+ case ISYNC: {
+ // todo - simulate isync
+ break;
+ }
+ case CRXOR: {
+ int bt = instr->Bits(25, 21);
+ int ba = instr->Bits(20, 16);
+ int bb = instr->Bits(15, 11);
+ int ba_val = ((0x80000000 >> ba) & condition_reg_) == 0 ? 0 : 1;
+ int bb_val = ((0x80000000 >> bb) & condition_reg_) == 0 ? 0 : 1;
+ int bt_val = ba_val ^ bb_val;
+ bt_val = bt_val << (31 - bt); // shift bit to correct destination
+ condition_reg_ &= ~(0x80000000 >> bt);
+ condition_reg_ |= bt_val;
+ break;
+ }
+ case CREQV: {
+ int bt = instr->Bits(25, 21);
+ int ba = instr->Bits(20, 16);
+ int bb = instr->Bits(15, 11);
+ int ba_val = ((0x80000000 >> ba) & condition_reg_) == 0 ? 0 : 1;
+ int bb_val = ((0x80000000 >> bb) & condition_reg_) == 0 ? 0 : 1;
+ int bt_val = 1 - (ba_val ^ bb_val);
+ bt_val = bt_val << (31 - bt); // shift bit to correct destination
+ condition_reg_ &= ~(0x80000000 >> bt);
+ condition_reg_ |= bt_val;
+ break;
+ }
+ case CRNAND:
+ case CRAND:
+ case CRORC:
+ case CROR:
+ default: {
+ UNIMPLEMENTED(); // Not used by V8.
+ }
+ }
+}
+
+
+bool Simulator::ExecuteExt2_10bit(Instruction* instr) {
+ bool found = true;
+
+ int opcode = instr->Bits(10, 1) << 1;
+ switch (opcode) {
+ case SRWX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ uint32_t rs_val = get_register(rs);
+ uintptr_t rb_val = get_register(rb);
+ intptr_t result = rs_val >> (rb_val & 0x3f);
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case SRDX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ uintptr_t rs_val = get_register(rs);
+ uintptr_t rb_val = get_register(rb);
+ intptr_t result = rs_val >> (rb_val & 0x7f);
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ break;
+ }
+#endif
+ case SRAW: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ int32_t rs_val = get_register(rs);
+ intptr_t rb_val = get_register(rb);
+ intptr_t result = rs_val >> (rb_val & 0x3f);
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case SRAD: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t rs_val = get_register(rs);
+ intptr_t rb_val = get_register(rb);
+ intptr_t result = rs_val >> (rb_val & 0x7f);
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ break;
+ }
+#endif
+ case SRAWIX: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ int sh = instr->Bits(15, 11);
+ int32_t rs_val = get_register(rs);
+ intptr_t result = rs_val >> sh;
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case EXTSW: {
+ const int shift = kBitsPerPointer - 32;
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ intptr_t rs_val = get_register(rs);
+ intptr_t ra_val = (rs_val << shift) >> shift;
+ set_register(ra, ra_val);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(ra_val);
+ }
+ break;
+ }
+#endif
+ case EXTSH: {
+ const int shift = kBitsPerPointer - 16;
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ intptr_t rs_val = get_register(rs);
+ intptr_t ra_val = (rs_val << shift) >> shift;
+ set_register(ra, ra_val);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(ra_val);
+ }
+ break;
+ }
+ case EXTSB: {
+ const int shift = kBitsPerPointer - 8;
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ intptr_t rs_val = get_register(rs);
+ intptr_t ra_val = (rs_val << shift) >> shift;
+ set_register(ra, ra_val);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(ra_val);
+ }
+ break;
+ }
+ case LFSUX:
+ case LFSX: {
+ int frt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ intptr_t rb_val = get_register(rb);
+ int32_t val = ReadW(ra_val + rb_val, instr);
+ float* fptr = reinterpret_cast<float*>(&val);
+ set_d_register_from_double(frt, static_cast<double>(*fptr));
+ if (opcode == LFSUX) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + rb_val);
+ }
+ break;
+ }
+ case LFDUX:
+ case LFDX: {
+ int frt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ intptr_t rb_val = get_register(rb);
+ double* dptr = reinterpret_cast<double*>(ReadDW(ra_val + rb_val));
+ set_d_register_from_double(frt, *dptr);
+ if (opcode == LFDUX) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + rb_val);
+ }
+ break;
+ }
+ case STFSUX: {
+ case STFSX:
+ int frs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ intptr_t rb_val = get_register(rb);
+ float frs_val = static_cast<float>(get_double_from_d_register(frs));
+ int32_t* p = reinterpret_cast<int32_t*>(&frs_val);
+ WriteW(ra_val + rb_val, *p, instr);
+ if (opcode == STFSUX) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + rb_val);
+ }
+ break;
+ }
+ case STFDUX: {
+ case STFDX:
+ int frs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ intptr_t rb_val = get_register(rb);
+ double frs_val = get_double_from_d_register(frs);
+ int64_t* p = reinterpret_cast<int64_t*>(&frs_val);
+ WriteDW(ra_val + rb_val, *p);
+ if (opcode == STFDUX) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + rb_val);
+ }
+ break;
+ }
+ case SYNC: {
+ // todo - simulate sync
+ break;
+ }
+ case ICBI: {
+ // todo - simulate icbi
+ break;
+ }
+ default: {
+ found = false;
+ break;
+ }
+ }
+
+ if (found) return found;
+
+ found = true;
+ opcode = instr->Bits(10, 2) << 2;
+ switch (opcode) {
+ case SRADIX: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ int sh = (instr->Bits(15, 11) | (instr->Bit(1) << 5));
+ intptr_t rs_val = get_register(rs);
+ intptr_t result = rs_val >> sh;
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ break;
+ }
+ default: {
+ found = false;
+ break;
+ }
+ }
+
+ return found;
+}
+
+
+bool Simulator::ExecuteExt2_9bit_part1(Instruction* instr) {
+ bool found = true;
+
+ int opcode = instr->Bits(9, 1) << 1;
+ switch (opcode) {
+ case TW: {
+ // used for call redirection in simulation mode
+ SoftwareInterrupt(instr);
+ break;
+ }
+ case CMP: {
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ int cr = instr->Bits(25, 23);
+ uint32_t bf = 0;
+#if V8_TARGET_ARCH_PPC64
+ int L = instr->Bit(21);
+ if (L) {
+#endif
+ intptr_t ra_val = get_register(ra);
+ intptr_t rb_val = get_register(rb);
+ if (ra_val < rb_val) {
+ bf |= 0x80000000;
+ }
+ if (ra_val > rb_val) {
+ bf |= 0x40000000;
+ }
+ if (ra_val == rb_val) {
+ bf |= 0x20000000;
+ }
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ int32_t ra_val = get_register(ra);
+ int32_t rb_val = get_register(rb);
+ if (ra_val < rb_val) {
+ bf |= 0x80000000;
+ }
+ if (ra_val > rb_val) {
+ bf |= 0x40000000;
+ }
+ if (ra_val == rb_val) {
+ bf |= 0x20000000;
+ }
+ }
+#endif
+ uint32_t condition_mask = 0xF0000000U >> (cr * 4);
+ uint32_t condition = bf >> (cr * 4);
+ condition_reg_ = (condition_reg_ & ~condition_mask) | condition;
+ break;
+ }
+ case SUBFCX: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ // int oe = instr->Bit(10);
+ uintptr_t ra_val = get_register(ra);
+ uintptr_t rb_val = get_register(rb);
+ uintptr_t alu_out = ~ra_val + rb_val + 1;
+ set_register(rt, alu_out);
+ // If the sign of rb and alu_out don't match, carry = 0
+ if ((alu_out ^ rb_val) & 0x80000000) {
+ special_reg_xer_ &= ~0xF0000000;
+ } else {
+ special_reg_xer_ = (special_reg_xer_ & ~0xF0000000) | 0x20000000;
+ }
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(alu_out);
+ }
+ // todo - handle OE bit
+ break;
+ }
+ case ADDCX: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ // int oe = instr->Bit(10);
+ uintptr_t ra_val = get_register(ra);
+ uintptr_t rb_val = get_register(rb);
+ uintptr_t alu_out = ra_val + rb_val;
+ // Check overflow
+ if (~ra_val < rb_val) {
+ special_reg_xer_ = (special_reg_xer_ & ~0xF0000000) | 0x20000000;
+ } else {
+ special_reg_xer_ &= ~0xF0000000;
+ }
+ set_register(rt, alu_out);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(static_cast<intptr_t>(alu_out));
+ }
+ // todo - handle OE bit
+ break;
+ }
+ case MULHWX: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ int32_t ra_val = (get_register(ra) & 0xFFFFFFFF);
+ int32_t rb_val = (get_register(rb) & 0xFFFFFFFF);
+ int64_t alu_out = (int64_t)ra_val * (int64_t)rb_val;
+ alu_out >>= 32;
+ set_register(rt, alu_out);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(static_cast<intptr_t>(alu_out));
+ }
+ // todo - handle OE bit
+ break;
+ }
+ case NEGX: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ intptr_t ra_val = get_register(ra);
+ intptr_t alu_out = 1 + ~ra_val;
+#if V8_TARGET_ARCH_PPC64
+ intptr_t one = 1; // work-around gcc
+ intptr_t kOverflowVal = (one << 63);
+#else
+ intptr_t kOverflowVal = kMinInt;
+#endif
+ set_register(rt, alu_out);
+ if (instr->Bit(10)) { // OE bit set
+ if (ra_val == kOverflowVal) {
+ special_reg_xer_ |= 0xC0000000; // set SO,OV
+ } else {
+ special_reg_xer_ &= ~0x40000000; // clear OV
+ }
+ }
+ if (instr->Bit(0)) { // RC bit set
+ bool setSO = (special_reg_xer_ & 0x80000000);
+ SetCR0(alu_out, setSO);
+ }
+ break;
+ }
+ case SLWX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ uint32_t rs_val = get_register(rs);
+ uintptr_t rb_val = get_register(rb);
+ uint32_t result = rs_val << (rb_val & 0x3f);
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case SLDX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ uintptr_t rs_val = get_register(rs);
+ uintptr_t rb_val = get_register(rb);
+ uintptr_t result = rs_val << (rb_val & 0x7f);
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ break;
+ }
+ case MFVSRD: {
+ DCHECK(!instr->Bit(0));
+ int frt = instr->RTValue();
+ int ra = instr->RAValue();
+ double frt_val = get_double_from_d_register(frt);
+ int64_t* p = reinterpret_cast<int64_t*>(&frt_val);
+ set_register(ra, *p);
+ break;
+ }
+ case MFVSRWZ: {
+ DCHECK(!instr->Bit(0));
+ int frt = instr->RTValue();
+ int ra = instr->RAValue();
+ double frt_val = get_double_from_d_register(frt);
+ int64_t* p = reinterpret_cast<int64_t*>(&frt_val);
+ set_register(ra, static_cast<uint32_t>(*p));
+ break;
+ }
+ case MTVSRD: {
+ DCHECK(!instr->Bit(0));
+ int frt = instr->RTValue();
+ int ra = instr->RAValue();
+ int64_t ra_val = get_register(ra);
+ double* p = reinterpret_cast<double*>(&ra_val);
+ set_d_register_from_double(frt, *p);
+ break;
+ }
+ case MTVSRWA: {
+ DCHECK(!instr->Bit(0));
+ int frt = instr->RTValue();
+ int ra = instr->RAValue();
+ int64_t ra_val = static_cast<int32_t>(get_register(ra));
+ double* p = reinterpret_cast<double*>(&ra_val);
+ set_d_register_from_double(frt, *p);
+ break;
+ }
+ case MTVSRWZ: {
+ DCHECK(!instr->Bit(0));
+ int frt = instr->RTValue();
+ int ra = instr->RAValue();
+ uint64_t ra_val = static_cast<uint32_t>(get_register(ra));
+ double* p = reinterpret_cast<double*>(&ra_val);
+ set_d_register_from_double(frt, *p);
+ break;
+ }
+#endif
+ default: {
+ found = false;
+ break;
+ }
+ }
+
+ return found;
+}
+
+
+void Simulator::ExecuteExt2_9bit_part2(Instruction* instr) {
+ int opcode = instr->Bits(9, 1) << 1;
+ switch (opcode) {
+ case CNTLZWX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ uintptr_t rs_val = get_register(rs);
+ uintptr_t count = 0;
+ int n = 0;
+ uintptr_t bit = 0x80000000;
+ for (; n < 32; n++) {
+ if (bit & rs_val) break;
+ count++;
+ bit >>= 1;
+ }
+ set_register(ra, count);
+ if (instr->Bit(0)) { // RC Bit set
+ int bf = 0;
+ if (count > 0) {
+ bf |= 0x40000000;
+ }
+ if (count == 0) {
+ bf |= 0x20000000;
+ }
+ condition_reg_ = (condition_reg_ & ~0xF0000000) | bf;
+ }
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case CNTLZDX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ uintptr_t rs_val = get_register(rs);
+ uintptr_t count = 0;
+ int n = 0;
+ uintptr_t bit = 0x8000000000000000UL;
+ for (; n < 64; n++) {
+ if (bit & rs_val) break;
+ count++;
+ bit >>= 1;
+ }
+ set_register(ra, count);
+ if (instr->Bit(0)) { // RC Bit set
+ int bf = 0;
+ if (count > 0) {
+ bf |= 0x40000000;
+ }
+ if (count == 0) {
+ bf |= 0x20000000;
+ }
+ condition_reg_ = (condition_reg_ & ~0xF0000000) | bf;
+ }
+ break;
+ }
+#endif
+ case ANDX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t rs_val = get_register(rs);
+ intptr_t rb_val = get_register(rb);
+ intptr_t alu_out = rs_val & rb_val;
+ set_register(ra, alu_out);
+ if (instr->Bit(0)) { // RC Bit set
+ SetCR0(alu_out);
+ }
+ break;
+ }
+ case ANDCX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t rs_val = get_register(rs);
+ intptr_t rb_val = get_register(rb);
+ intptr_t alu_out = rs_val & ~rb_val;
+ set_register(ra, alu_out);
+ if (instr->Bit(0)) { // RC Bit set
+ SetCR0(alu_out);
+ }
+ break;
+ }
+ case CMPL: {
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ int cr = instr->Bits(25, 23);
+ uint32_t bf = 0;
+#if V8_TARGET_ARCH_PPC64
+ int L = instr->Bit(21);
+ if (L) {
+#endif
+ uintptr_t ra_val = get_register(ra);
+ uintptr_t rb_val = get_register(rb);
+ if (ra_val < rb_val) {
+ bf |= 0x80000000;
+ }
+ if (ra_val > rb_val) {
+ bf |= 0x40000000;
+ }
+ if (ra_val == rb_val) {
+ bf |= 0x20000000;
+ }
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ uint32_t ra_val = get_register(ra);
+ uint32_t rb_val = get_register(rb);
+ if (ra_val < rb_val) {
+ bf |= 0x80000000;
+ }
+ if (ra_val > rb_val) {
+ bf |= 0x40000000;
+ }
+ if (ra_val == rb_val) {
+ bf |= 0x20000000;
+ }
+ }
+#endif
+ uint32_t condition_mask = 0xF0000000U >> (cr * 4);
+ uint32_t condition = bf >> (cr * 4);
+ condition_reg_ = (condition_reg_ & ~condition_mask) | condition;
+ break;
+ }
+ case SUBFX: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ // int oe = instr->Bit(10);
+ intptr_t ra_val = get_register(ra);
+ intptr_t rb_val = get_register(rb);
+ intptr_t alu_out = rb_val - ra_val;
+ // todo - figure out underflow
+ set_register(rt, alu_out);
+ if (instr->Bit(0)) { // RC Bit set
+ SetCR0(alu_out);
+ }
+ // todo - handle OE bit
+ break;
+ }
+ case ADDZEX: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ intptr_t ra_val = get_register(ra);
+ if (special_reg_xer_ & 0x20000000) {
+ ra_val += 1;
+ }
+ set_register(rt, ra_val);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(ra_val);
+ }
+ // todo - handle OE bit
+ break;
+ }
+ case NORX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t rs_val = get_register(rs);
+ intptr_t rb_val = get_register(rb);
+ intptr_t alu_out = ~(rs_val | rb_val);
+ set_register(ra, alu_out);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(alu_out);
+ }
+ break;
+ }
+ case MULLW: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ int32_t ra_val = (get_register(ra) & 0xFFFFFFFF);
+ int32_t rb_val = (get_register(rb) & 0xFFFFFFFF);
+ int32_t alu_out = ra_val * rb_val;
+ set_register(rt, alu_out);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(alu_out);
+ }
+ // todo - handle OE bit
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case MULLD: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ int64_t ra_val = get_register(ra);
+ int64_t rb_val = get_register(rb);
+ int64_t alu_out = ra_val * rb_val;
+ set_register(rt, alu_out);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(alu_out);
+ }
+ // todo - handle OE bit
+ break;
+ }
+#endif
+ case DIVW: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ int32_t ra_val = get_register(ra);
+ int32_t rb_val = get_register(rb);
+ bool overflow = (ra_val == kMinInt && rb_val == -1);
+ // result is undefined if divisor is zero or if operation
+ // is 0x80000000 / -1.
+ int32_t alu_out = (rb_val == 0 || overflow) ? -1 : ra_val / rb_val;
+ set_register(rt, alu_out);
+ if (instr->Bit(10)) { // OE bit set
+ if (overflow) {
+ special_reg_xer_ |= 0xC0000000; // set SO,OV
+ } else {
+ special_reg_xer_ &= ~0x40000000; // clear OV
+ }
+ }
+ if (instr->Bit(0)) { // RC bit set
+ bool setSO = (special_reg_xer_ & 0x80000000);
+ SetCR0(alu_out, setSO);
+ }
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case DIVD: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ int64_t ra_val = get_register(ra);
+ int64_t rb_val = get_register(rb);
+ int64_t one = 1; // work-around gcc
+ int64_t kMinLongLong = (one << 63);
+ // result is undefined if divisor is zero or if operation
+ // is 0x80000000_00000000 / -1.
+ int64_t alu_out =
+ (rb_val == 0 || (ra_val == kMinLongLong && rb_val == -1))
+ ? -1
+ : ra_val / rb_val;
+ set_register(rt, alu_out);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(alu_out);
+ }
+ // todo - handle OE bit
+ break;
+ }
+#endif
+ case ADDX: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ // int oe = instr->Bit(10);
+ intptr_t ra_val = get_register(ra);
+ intptr_t rb_val = get_register(rb);
+ intptr_t alu_out = ra_val + rb_val;
+ set_register(rt, alu_out);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(alu_out);
+ }
+ // todo - handle OE bit
+ break;
+ }
+ case XORX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t rs_val = get_register(rs);
+ intptr_t rb_val = get_register(rb);
+ intptr_t alu_out = rs_val ^ rb_val;
+ set_register(ra, alu_out);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(alu_out);
+ }
+ break;
+ }
+ case ORX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t rs_val = get_register(rs);
+ intptr_t rb_val = get_register(rb);
+ intptr_t alu_out = rs_val | rb_val;
+ set_register(ra, alu_out);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(alu_out);
+ }
+ break;
+ }
+ case MFSPR: {
+ int rt = instr->RTValue();
+ int spr = instr->Bits(20, 11);
+ if (spr != 256) {
+ UNIMPLEMENTED(); // Only LRLR supported
+ }
+ set_register(rt, special_reg_lr_);
+ break;
+ }
+ case MTSPR: {
+ int rt = instr->RTValue();
+ intptr_t rt_val = get_register(rt);
+ int spr = instr->Bits(20, 11);
+ if (spr == 256) {
+ special_reg_lr_ = rt_val;
+ } else if (spr == 288) {
+ special_reg_ctr_ = rt_val;
+ } else if (spr == 32) {
+ special_reg_xer_ = rt_val;
+ } else {
+ UNIMPLEMENTED(); // Only LR supported
+ }
+ break;
+ }
+ case MFCR: {
+ int rt = instr->RTValue();
+ set_register(rt, condition_reg_);
+ break;
+ }
+ case STWUX:
+ case STWX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ int32_t rs_val = get_register(rs);
+ intptr_t rb_val = get_register(rb);
+ WriteW(ra_val + rb_val, rs_val, instr);
+ if (opcode == STWUX) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + rb_val);
+ }
+ break;
+ }
+ case STBUX:
+ case STBX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ int8_t rs_val = get_register(rs);
+ intptr_t rb_val = get_register(rb);
+ WriteB(ra_val + rb_val, rs_val);
+ if (opcode == STBUX) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + rb_val);
+ }
+ break;
+ }
+ case STHUX:
+ case STHX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ int16_t rs_val = get_register(rs);
+ intptr_t rb_val = get_register(rb);
+ WriteH(ra_val + rb_val, rs_val, instr);
+ if (opcode == STHUX) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + rb_val);
+ }
+ break;
+ }
+ case LWZX:
+ case LWZUX: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ intptr_t rb_val = get_register(rb);
+ set_register(rt, ReadWU(ra_val + rb_val, instr));
+ if (opcode == LWZUX) {
+ DCHECK(ra != 0 && ra != rt);
+ set_register(ra, ra_val + rb_val);
+ }
+ break;
+ }
+#if V8_TARGET_ARCH_PPC64
+ case LDX:
+ case LDUX: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ intptr_t rb_val = get_register(rb);
+ intptr_t* result = ReadDW(ra_val + rb_val);
+ set_register(rt, *result);
+ if (opcode == LDUX) {
+ DCHECK(ra != 0 && ra != rt);
+ set_register(ra, ra_val + rb_val);
+ }
+ break;
+ }
+ case STDX:
+ case STDUX: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ intptr_t rs_val = get_register(rs);
+ intptr_t rb_val = get_register(rb);
+ WriteDW(ra_val + rb_val, rs_val);
+ if (opcode == STDUX) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + rb_val);
+ }
+ break;
+ }
+#endif
+ case LBZX:
+ case LBZUX: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ intptr_t rb_val = get_register(rb);
+ set_register(rt, ReadBU(ra_val + rb_val) & 0xFF);
+ if (opcode == LBZUX) {
+ DCHECK(ra != 0 && ra != rt);
+ set_register(ra, ra_val + rb_val);
+ }
+ break;
+ }
+ case LHZX:
+ case LHZUX: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int rb = instr->RBValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ intptr_t rb_val = get_register(rb);
+ set_register(rt, ReadHU(ra_val + rb_val, instr) & 0xFFFF);
+ if (opcode == LHZUX) {
+ DCHECK(ra != 0 && ra != rt);
+ set_register(ra, ra_val + rb_val);
+ }
+ break;
+ }
+ case DCBF: {
+ // todo - simulate dcbf
+ break;
+ }
+ default: {
+ PrintF("Unimplemented: %08x\n", instr->InstructionBits());
+ UNIMPLEMENTED(); // Not used by V8.
+ }
+ }
+}
+
+
+void Simulator::ExecuteExt2(Instruction* instr) {
+ // Check first the 10-1 bit versions
+ if (ExecuteExt2_10bit(instr)) return;
+ // Now look at the lesser encodings
+ if (ExecuteExt2_9bit_part1(instr)) return;
+ ExecuteExt2_9bit_part2(instr);
+}
+
+
+void Simulator::ExecuteExt4(Instruction* instr) {
+ switch (instr->Bits(5, 1) << 1) {
+ case FDIV: {
+ int frt = instr->RTValue();
+ int fra = instr->RAValue();
+ int frb = instr->RBValue();
+ double fra_val = get_double_from_d_register(fra);
+ double frb_val = get_double_from_d_register(frb);
+ double frt_val = fra_val / frb_val;
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ case FSUB: {
+ int frt = instr->RTValue();
+ int fra = instr->RAValue();
+ int frb = instr->RBValue();
+ double fra_val = get_double_from_d_register(fra);
+ double frb_val = get_double_from_d_register(frb);
+ double frt_val = fra_val - frb_val;
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ case FADD: {
+ int frt = instr->RTValue();
+ int fra = instr->RAValue();
+ int frb = instr->RBValue();
+ double fra_val = get_double_from_d_register(fra);
+ double frb_val = get_double_from_d_register(frb);
+ double frt_val = fra_val + frb_val;
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ case FSQRT: {
+ int frt = instr->RTValue();
+ int frb = instr->RBValue();
+ double frb_val = get_double_from_d_register(frb);
+ double frt_val = std::sqrt(frb_val);
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ case FSEL: {
+ int frt = instr->RTValue();
+ int fra = instr->RAValue();
+ int frb = instr->RBValue();
+ int frc = instr->RCValue();
+ double fra_val = get_double_from_d_register(fra);
+ double frb_val = get_double_from_d_register(frb);
+ double frc_val = get_double_from_d_register(frc);
+ double frt_val = ((fra_val >= 0.0) ? frc_val : frb_val);
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ case FMUL: {
+ int frt = instr->RTValue();
+ int fra = instr->RAValue();
+ int frc = instr->RCValue();
+ double fra_val = get_double_from_d_register(fra);
+ double frc_val = get_double_from_d_register(frc);
+ double frt_val = fra_val * frc_val;
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ case FMSUB: {
+ int frt = instr->RTValue();
+ int fra = instr->RAValue();
+ int frb = instr->RBValue();
+ int frc = instr->RCValue();
+ double fra_val = get_double_from_d_register(fra);
+ double frb_val = get_double_from_d_register(frb);
+ double frc_val = get_double_from_d_register(frc);
+ double frt_val = (fra_val * frc_val) - frb_val;
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ case FMADD: {
+ int frt = instr->RTValue();
+ int fra = instr->RAValue();
+ int frb = instr->RBValue();
+ int frc = instr->RCValue();
+ double fra_val = get_double_from_d_register(fra);
+ double frb_val = get_double_from_d_register(frb);
+ double frc_val = get_double_from_d_register(frc);
+ double frt_val = (fra_val * frc_val) + frb_val;
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ }
+ int opcode = instr->Bits(10, 1) << 1;
+ switch (opcode) {
+ case FCMPU: {
+ int fra = instr->RAValue();
+ int frb = instr->RBValue();
+ double fra_val = get_double_from_d_register(fra);
+ double frb_val = get_double_from_d_register(frb);
+ int cr = instr->Bits(25, 23);
+ int bf = 0;
+ if (fra_val < frb_val) {
+ bf |= 0x80000000;
+ }
+ if (fra_val > frb_val) {
+ bf |= 0x40000000;
+ }
+ if (fra_val == frb_val) {
+ bf |= 0x20000000;
+ }
+ if (std::isunordered(fra_val, frb_val)) {
+ bf |= 0x10000000;
+ }
+ int condition_mask = 0xF0000000 >> (cr * 4);
+ int condition = bf >> (cr * 4);
+ condition_reg_ = (condition_reg_ & ~condition_mask) | condition;
+ return;
+ }
+ case FRSP: {
+ int frt = instr->RTValue();
+ int frb = instr->RBValue();
+ double frb_val = get_double_from_d_register(frb);
+ // frsp round 8-byte double-precision value to 8-byte
+ // single-precision value, ignore the round here
+ set_d_register_from_double(frt, frb_val);
+ if (instr->Bit(0)) { // RC bit set
+ // UNIMPLEMENTED();
+ }
+ return;
+ }
+ case FCFID: {
+ int frt = instr->RTValue();
+ int frb = instr->RBValue();
+ double t_val = get_double_from_d_register(frb);
+ int64_t* frb_val_p = reinterpret_cast<int64_t*>(&t_val);
+ double frt_val = static_cast<double>(*frb_val_p);
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ case FCTID: {
+ int frt = instr->RTValue();
+ int frb = instr->RBValue();
+ double frb_val = get_double_from_d_register(frb);
+ int64_t frt_val;
+ int64_t one = 1; // work-around gcc
+ int64_t kMinLongLong = (one << 63);
+ int64_t kMaxLongLong = kMinLongLong - 1;
+
+ if (frb_val > kMaxLongLong) {
+ frt_val = kMaxLongLong;
+ } else if (frb_val < kMinLongLong) {
+ frt_val = kMinLongLong;
+ } else {
+ switch (fp_condition_reg_ & kFPRoundingModeMask) {
+ case kRoundToZero:
+ frt_val = (int64_t)frb_val;
+ break;
+ case kRoundToPlusInf:
+ frt_val = (int64_t)std::ceil(frb_val);
+ break;
+ case kRoundToMinusInf:
+ frt_val = (int64_t)std::floor(frb_val);
+ break;
+ default:
+ frt_val = (int64_t)frb_val;
+ UNIMPLEMENTED(); // Not used by V8.
+ break;
+ }
+ }
+ double* p = reinterpret_cast<double*>(&frt_val);
+ set_d_register_from_double(frt, *p);
+ return;
+ }
+ case FCTIDZ: {
+ int frt = instr->RTValue();
+ int frb = instr->RBValue();
+ double frb_val = get_double_from_d_register(frb);
+ int64_t frt_val;
+ int64_t one = 1; // work-around gcc
+ int64_t kMinLongLong = (one << 63);
+ int64_t kMaxLongLong = kMinLongLong - 1;
+
+ if (frb_val > kMaxLongLong) {
+ frt_val = kMaxLongLong;
+ } else if (frb_val < kMinLongLong) {
+ frt_val = kMinLongLong;
+ } else {
+ frt_val = (int64_t)frb_val;
+ }
+ double* p = reinterpret_cast<double*>(&frt_val);
+ set_d_register_from_double(frt, *p);
+ return;
+ }
+ case FCTIW:
+ case FCTIWZ: {
+ int frt = instr->RTValue();
+ int frb = instr->RBValue();
+ double frb_val = get_double_from_d_register(frb);
+ int64_t frt_val;
+ if (frb_val > kMaxInt) {
+ frt_val = kMaxInt;
+ } else if (frb_val < kMinInt) {
+ frt_val = kMinInt;
+ } else {
+ if (opcode == FCTIWZ) {
+ frt_val = (int64_t)frb_val;
+ } else {
+ switch (fp_condition_reg_ & kFPRoundingModeMask) {
+ case kRoundToZero:
+ frt_val = (int64_t)frb_val;
+ break;
+ case kRoundToPlusInf:
+ frt_val = (int64_t)std::ceil(frb_val);
+ break;
+ case kRoundToMinusInf:
+ frt_val = (int64_t)std::floor(frb_val);
+ break;
+ case kRoundToNearest:
+ frt_val = (int64_t)lround(frb_val);
+
+ // Round to even if exactly halfway. (lround rounds up)
+ if (std::fabs(static_cast<double>(frt_val) - frb_val) == 0.5 &&
+ (frt_val % 2)) {
+ frt_val += ((frt_val > 0) ? -1 : 1);
+ }
+
+ break;
+ default:
+ DCHECK(false);
+ frt_val = (int64_t)frb_val;
+ break;
+ }
+ }
+ }
+ double* p = reinterpret_cast<double*>(&frt_val);
+ set_d_register_from_double(frt, *p);
+ return;
+ }
+ case FNEG: {
+ int frt = instr->RTValue();
+ int frb = instr->RBValue();
+ double frb_val = get_double_from_d_register(frb);
+ double frt_val = -frb_val;
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ case FMR: {
+ int frt = instr->RTValue();
+ int frb = instr->RBValue();
+ double frb_val = get_double_from_d_register(frb);
+ double frt_val = frb_val;
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ case MTFSFI: {
+ int bf = instr->Bits(25, 23);
+ int imm = instr->Bits(15, 12);
+ int fp_condition_mask = 0xF0000000 >> (bf * 4);
+ fp_condition_reg_ &= ~fp_condition_mask;
+ fp_condition_reg_ |= (imm << (28 - (bf * 4)));
+ if (instr->Bit(0)) { // RC bit set
+ condition_reg_ &= 0xF0FFFFFF;
+ condition_reg_ |= (imm << 23);
+ }
+ return;
+ }
+ case MTFSF: {
+ int frb = instr->RBValue();
+ double frb_dval = get_double_from_d_register(frb);
+ int64_t* p = reinterpret_cast<int64_t*>(&frb_dval);
+ int32_t frb_ival = static_cast<int32_t>((*p) & 0xffffffff);
+ int l = instr->Bits(25, 25);
+ if (l == 1) {
+ fp_condition_reg_ = frb_ival;
+ } else {
+ UNIMPLEMENTED();
+ }
+ if (instr->Bit(0)) { // RC bit set
+ UNIMPLEMENTED();
+ // int w = instr->Bits(16, 16);
+ // int flm = instr->Bits(24, 17);
+ }
+ return;
+ }
+ case MFFS: {
+ int frt = instr->RTValue();
+ int64_t lval = static_cast<int64_t>(fp_condition_reg_);
+ double* p = reinterpret_cast<double*>(&lval);
+ set_d_register_from_double(frt, *p);
+ return;
+ }
+ case FABS: {
+ int frt = instr->RTValue();
+ int frb = instr->RBValue();
+ double frb_val = get_double_from_d_register(frb);
+ double frt_val = std::fabs(frb_val);
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ case FRIM: {
+ int frt = instr->RTValue();
+ int frb = instr->RBValue();
+ double frb_val = get_double_from_d_register(frb);
+ int64_t floor_val = (int64_t)frb_val;
+ if (floor_val > frb_val) floor_val--;
+ double frt_val = static_cast<double>(floor_val);
+ set_d_register_from_double(frt, frt_val);
+ return;
+ }
+ }
+ UNIMPLEMENTED(); // Not used by V8.
+}
+
+#if V8_TARGET_ARCH_PPC64
+void Simulator::ExecuteExt5(Instruction* instr) {
+ switch (instr->Bits(4, 2) << 2) {
+ case RLDICL: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ uintptr_t rs_val = get_register(rs);
+ int sh = (instr->Bits(15, 11) | (instr->Bit(1) << 5));
+ int mb = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
+ DCHECK(sh >= 0 && sh <= 63);
+ DCHECK(mb >= 0 && mb <= 63);
+ // rotate left
+ uintptr_t result = (rs_val << sh) | (rs_val >> (64 - sh));
+ uintptr_t mask = 0xffffffffffffffff >> mb;
+ result &= mask;
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ return;
+ }
+ case RLDICR: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ uintptr_t rs_val = get_register(rs);
+ int sh = (instr->Bits(15, 11) | (instr->Bit(1) << 5));
+ int me = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
+ DCHECK(sh >= 0 && sh <= 63);
+ DCHECK(me >= 0 && me <= 63);
+ // rotate left
+ uintptr_t result = (rs_val << sh) | (rs_val >> (64 - sh));
+ uintptr_t mask = 0xffffffffffffffff << (63 - me);
+ result &= mask;
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ return;
+ }
+ case RLDIC: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ uintptr_t rs_val = get_register(rs);
+ int sh = (instr->Bits(15, 11) | (instr->Bit(1) << 5));
+ int mb = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
+ DCHECK(sh >= 0 && sh <= 63);
+ DCHECK(mb >= 0 && mb <= 63);
+ // rotate left
+ uintptr_t result = (rs_val << sh) | (rs_val >> (64 - sh));
+ uintptr_t mask = (0xffffffffffffffff >> mb) & (0xffffffffffffffff << sh);
+ result &= mask;
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ return;
+ }
+ case RLDIMI: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ uintptr_t rs_val = get_register(rs);
+ intptr_t ra_val = get_register(ra);
+ int sh = (instr->Bits(15, 11) | (instr->Bit(1) << 5));
+ int mb = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
+ int me = 63 - sh;
+ // rotate left
+ uintptr_t result = (rs_val << sh) | (rs_val >> (64 - sh));
+ uintptr_t mask = 0;
+ if (mb < me + 1) {
+ uintptr_t bit = 0x8000000000000000 >> mb;
+ for (; mb <= me; mb++) {
+ mask |= bit;
+ bit >>= 1;
+ }
+ } else if (mb == me + 1) {
+ mask = 0xffffffffffffffff;
+ } else { // mb > me+1
+ uintptr_t bit = 0x8000000000000000 >> (me + 1); // needs to be tested
+ mask = 0xffffffffffffffff;
+ for (; me < mb; me++) {
+ mask ^= bit;
+ bit >>= 1;
+ }
+ }
+ result &= mask;
+ ra_val &= ~mask;
+ result |= ra_val;
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ return;
+ }
+ }
+ switch (instr->Bits(4, 1) << 1) {
+ case RLDCL: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ int rb = instr->RBValue();
+ uintptr_t rs_val = get_register(rs);
+ uintptr_t rb_val = get_register(rb);
+ int sh = (rb_val & 0x3f);
+ int mb = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
+ DCHECK(sh >= 0 && sh <= 63);
+ DCHECK(mb >= 0 && mb <= 63);
+ // rotate left
+ uintptr_t result = (rs_val << sh) | (rs_val >> (64 - sh));
+ uintptr_t mask = 0xffffffffffffffff >> mb;
+ result &= mask;
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ return;
+ }
+ }
+ UNIMPLEMENTED(); // Not used by V8.
+}
+#endif
+
+
+void Simulator::ExecuteGeneric(Instruction* instr) {
+ int opcode = instr->OpcodeValue() << 26;
+ switch (opcode) {
+ case SUBFIC: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ intptr_t ra_val = get_register(ra);
+ int32_t im_val = instr->Bits(15, 0);
+ im_val = SIGN_EXT_IMM16(im_val);
+ intptr_t alu_out = im_val - ra_val;
+ set_register(rt, alu_out);
+ // todo - handle RC bit
+ break;
+ }
+ case CMPLI: {
+ int ra = instr->RAValue();
+ uint32_t im_val = instr->Bits(15, 0);
+ int cr = instr->Bits(25, 23);
+ uint32_t bf = 0;
+#if V8_TARGET_ARCH_PPC64
+ int L = instr->Bit(21);
+ if (L) {
+#endif
+ uintptr_t ra_val = get_register(ra);
+ if (ra_val < im_val) {
+ bf |= 0x80000000;
+ }
+ if (ra_val > im_val) {
+ bf |= 0x40000000;
+ }
+ if (ra_val == im_val) {
+ bf |= 0x20000000;
+ }
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ uint32_t ra_val = get_register(ra);
+ if (ra_val < im_val) {
+ bf |= 0x80000000;
+ }
+ if (ra_val > im_val) {
+ bf |= 0x40000000;
+ }
+ if (ra_val == im_val) {
+ bf |= 0x20000000;
+ }
+ }
+#endif
+ uint32_t condition_mask = 0xF0000000U >> (cr * 4);
+ uint32_t condition = bf >> (cr * 4);
+ condition_reg_ = (condition_reg_ & ~condition_mask) | condition;
+ break;
+ }
+ case CMPI: {
+ int ra = instr->RAValue();
+ int32_t im_val = instr->Bits(15, 0);
+ im_val = SIGN_EXT_IMM16(im_val);
+ int cr = instr->Bits(25, 23);
+ uint32_t bf = 0;
+#if V8_TARGET_ARCH_PPC64
+ int L = instr->Bit(21);
+ if (L) {
+#endif
+ intptr_t ra_val = get_register(ra);
+ if (ra_val < im_val) {
+ bf |= 0x80000000;
+ }
+ if (ra_val > im_val) {
+ bf |= 0x40000000;
+ }
+ if (ra_val == im_val) {
+ bf |= 0x20000000;
+ }
+#if V8_TARGET_ARCH_PPC64
+ } else {
+ int32_t ra_val = get_register(ra);
+ if (ra_val < im_val) {
+ bf |= 0x80000000;
+ }
+ if (ra_val > im_val) {
+ bf |= 0x40000000;
+ }
+ if (ra_val == im_val) {
+ bf |= 0x20000000;
+ }
+ }
+#endif
+ uint32_t condition_mask = 0xF0000000U >> (cr * 4);
+ uint32_t condition = bf >> (cr * 4);
+ condition_reg_ = (condition_reg_ & ~condition_mask) | condition;
+ break;
+ }
+ case ADDIC: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ uintptr_t ra_val = get_register(ra);
+ uintptr_t im_val = SIGN_EXT_IMM16(instr->Bits(15, 0));
+ uintptr_t alu_out = ra_val + im_val;
+ // Check overflow
+ if (~ra_val < im_val) {
+ special_reg_xer_ = (special_reg_xer_ & ~0xF0000000) | 0x20000000;
+ } else {
+ special_reg_xer_ &= ~0xF0000000;
+ }
+ set_register(rt, alu_out);
+ break;
+ }
+ case ADDI: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int32_t im_val = SIGN_EXT_IMM16(instr->Bits(15, 0));
+ intptr_t alu_out;
+ if (ra == 0) {
+ alu_out = im_val;
+ } else {
+ intptr_t ra_val = get_register(ra);
+ alu_out = ra_val + im_val;
+ }
+ set_register(rt, alu_out);
+ // todo - handle RC bit
+ break;
+ }
+ case ADDIS: {
+ int rt = instr->RTValue();
+ int ra = instr->RAValue();
+ int32_t im_val = (instr->Bits(15, 0) << 16);
+ intptr_t alu_out;
+ if (ra == 0) { // treat r0 as zero
+ alu_out = im_val;
+ } else {
+ intptr_t ra_val = get_register(ra);
+ alu_out = ra_val + im_val;
+ }
+ set_register(rt, alu_out);
+ break;
+ }
+ case BCX: {
+ ExecuteBranchConditional(instr);
+ break;
+ }
+ case BX: {
+ int offset = (instr->Bits(25, 2) << 8) >> 6;
+ if (instr->Bit(0) == 1) { // LK flag set
+ special_reg_lr_ = get_pc() + 4;
+ }
+ set_pc(get_pc() + offset);
+ // todo - AA flag
+ break;
+ }
+ case EXT1: {
+ ExecuteExt1(instr);
+ break;
+ }
+ case RLWIMIX: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ uint32_t rs_val = get_register(rs);
+ int32_t ra_val = get_register(ra);
+ int sh = instr->Bits(15, 11);
+ int mb = instr->Bits(10, 6);
+ int me = instr->Bits(5, 1);
+ // rotate left
+ uint32_t result = (rs_val << sh) | (rs_val >> (32 - sh));
+ int mask = 0;
+ if (mb < me + 1) {
+ int bit = 0x80000000 >> mb;
+ for (; mb <= me; mb++) {
+ mask |= bit;
+ bit >>= 1;
+ }
+ } else if (mb == me + 1) {
+ mask = 0xffffffff;
+ } else { // mb > me+1
+ int bit = 0x80000000 >> (me + 1); // needs to be tested
+ mask = 0xffffffff;
+ for (; me < mb; me++) {
+ mask ^= bit;
+ bit >>= 1;
+ }
+ }
+ result &= mask;
+ ra_val &= ~mask;
+ result |= ra_val;
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ break;
+ }
+ case RLWINMX:
+ case RLWNMX: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ uint32_t rs_val = get_register(rs);
+ int sh = 0;
+ if (opcode == RLWINMX) {
+ sh = instr->Bits(15, 11);
+ } else {
+ int rb = instr->RBValue();
+ uint32_t rb_val = get_register(rb);
+ sh = (rb_val & 0x1f);
+ }
+ int mb = instr->Bits(10, 6);
+ int me = instr->Bits(5, 1);
+ // rotate left
+ uint32_t result = (rs_val << sh) | (rs_val >> (32 - sh));
+ int mask = 0;
+ if (mb < me + 1) {
+ int bit = 0x80000000 >> mb;
+ for (; mb <= me; mb++) {
+ mask |= bit;
+ bit >>= 1;
+ }
+ } else if (mb == me + 1) {
+ mask = 0xffffffff;
+ } else { // mb > me+1
+ int bit = 0x80000000 >> (me + 1); // needs to be tested
+ mask = 0xffffffff;
+ for (; me < mb; me++) {
+ mask ^= bit;
+ bit >>= 1;
+ }
+ }
+ result &= mask;
+ set_register(ra, result);
+ if (instr->Bit(0)) { // RC bit set
+ SetCR0(result);
+ }
+ break;
+ }
+ case ORI: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ intptr_t rs_val = get_register(rs);
+ uint32_t im_val = instr->Bits(15, 0);
+ intptr_t alu_out = rs_val | im_val;
+ set_register(ra, alu_out);
+ break;
+ }
+ case ORIS: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ intptr_t rs_val = get_register(rs);
+ uint32_t im_val = instr->Bits(15, 0);
+ intptr_t alu_out = rs_val | (im_val << 16);
+ set_register(ra, alu_out);
+ break;
+ }
+ case XORI: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ intptr_t rs_val = get_register(rs);
+ uint32_t im_val = instr->Bits(15, 0);
+ intptr_t alu_out = rs_val ^ im_val;
+ set_register(ra, alu_out);
+ // todo - set condition based SO bit
+ break;
+ }
+ case XORIS: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ intptr_t rs_val = get_register(rs);
+ uint32_t im_val = instr->Bits(15, 0);
+ intptr_t alu_out = rs_val ^ (im_val << 16);
+ set_register(ra, alu_out);
+ break;
+ }
+ case ANDIx: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ intptr_t rs_val = get_register(rs);
+ uint32_t im_val = instr->Bits(15, 0);
+ intptr_t alu_out = rs_val & im_val;
+ set_register(ra, alu_out);
+ SetCR0(alu_out);
+ break;
+ }
+ case ANDISx: {
+ int rs = instr->RSValue();
+ int ra = instr->RAValue();
+ intptr_t rs_val = get_register(rs);
+ uint32_t im_val = instr->Bits(15, 0);
+ intptr_t alu_out = rs_val & (im_val << 16);
+ set_register(ra, alu_out);
+ SetCR0(alu_out);
+ break;
+ }
+ case EXT2: {
+ ExecuteExt2(instr);
+ break;
+ }
+
+ case LWZU:
+ case LWZ: {
+ int ra = instr->RAValue();
+ int rt = instr->RTValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ int offset = SIGN_EXT_IMM16(instr->Bits(15, 0));
+ set_register(rt, ReadWU(ra_val + offset, instr));
+ if (opcode == LWZU) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + offset);
+ }
+ break;
+ }
+
+ case LBZU:
+ case LBZ: {
+ int ra = instr->RAValue();
+ int rt = instr->RTValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ int offset = SIGN_EXT_IMM16(instr->Bits(15, 0));
+ set_register(rt, ReadB(ra_val + offset) & 0xFF);
+ if (opcode == LBZU) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + offset);
+ }
+ break;
+ }
+
+ case STWU:
+ case STW: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ int32_t rs_val = get_register(rs);
+ int offset = SIGN_EXT_IMM16(instr->Bits(15, 0));
+ WriteW(ra_val + offset, rs_val, instr);
+ if (opcode == STWU) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + offset);
+ }
+ // printf("r%d %08x -> %08x\n", rs, rs_val, offset); // 0xdead
+ break;
+ }
+
+ case STBU:
+ case STB: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ int8_t rs_val = get_register(rs);
+ int offset = SIGN_EXT_IMM16(instr->Bits(15, 0));
+ WriteB(ra_val + offset, rs_val);
+ if (opcode == STBU) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + offset);
+ }
+ break;
+ }
+
+ case LHZU:
+ case LHZ: {
+ int ra = instr->RAValue();
+ int rt = instr->RTValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ int offset = SIGN_EXT_IMM16(instr->Bits(15, 0));
+ uintptr_t result = ReadHU(ra_val + offset, instr) & 0xffff;
+ set_register(rt, result);
+ if (opcode == LHZU) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + offset);
+ }
+ break;
+ }
+
+ case LHA:
+ case LHAU: {
+ UNIMPLEMENTED();
+ break;
+ }
+
+ case STHU:
+ case STH: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ int16_t rs_val = get_register(rs);
+ int offset = SIGN_EXT_IMM16(instr->Bits(15, 0));
+ WriteH(ra_val + offset, rs_val, instr);
+ if (opcode == STHU) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + offset);
+ }
+ break;
+ }
+
+ case LMW:
+ case STMW: {
+ UNIMPLEMENTED();
+ break;
+ }
+
+ case LFSU:
+ case LFS: {
+ int frt = instr->RTValue();
+ int ra = instr->RAValue();
+ int32_t offset = SIGN_EXT_IMM16(instr->Bits(15, 0));
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ int32_t val = ReadW(ra_val + offset, instr);
+ float* fptr = reinterpret_cast<float*>(&val);
+ set_d_register_from_double(frt, static_cast<double>(*fptr));
+ if (opcode == LFSU) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + offset);
+ }
+ break;
+ }
+
+ case LFDU:
+ case LFD: {
+ int frt = instr->RTValue();
+ int ra = instr->RAValue();
+ int32_t offset = SIGN_EXT_IMM16(instr->Bits(15, 0));
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ double* dptr = reinterpret_cast<double*>(ReadDW(ra_val + offset));
+ set_d_register_from_double(frt, *dptr);
+ if (opcode == LFDU) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + offset);
+ }
+ break;
+ }
+
+ case STFSU: {
+ case STFS:
+ int frs = instr->RSValue();
+ int ra = instr->RAValue();
+ int32_t offset = SIGN_EXT_IMM16(instr->Bits(15, 0));
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ float frs_val = static_cast<float>(get_double_from_d_register(frs));
+ int32_t* p = reinterpret_cast<int32_t*>(&frs_val);
+ WriteW(ra_val + offset, *p, instr);
+ if (opcode == STFSU) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + offset);
+ }
+ break;
+ }
+
+ case STFDU:
+ case STFD: {
+ int frs = instr->RSValue();
+ int ra = instr->RAValue();
+ int32_t offset = SIGN_EXT_IMM16(instr->Bits(15, 0));
+ intptr_t ra_val = ra == 0 ? 0 : get_register(ra);
+ double frs_val = get_double_from_d_register(frs);
+ int64_t* p = reinterpret_cast<int64_t*>(&frs_val);
+ WriteDW(ra_val + offset, *p);
+ if (opcode == STFDU) {
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + offset);
+ }
+ break;
+ }
+
+ case EXT3:
+ UNIMPLEMENTED();
+ case EXT4: {
+ ExecuteExt4(instr);
+ break;
+ }
+
+#if V8_TARGET_ARCH_PPC64
+ case EXT5: {
+ ExecuteExt5(instr);
+ break;
+ }
+ case LD: {
+ int ra = instr->RAValue();
+ int rt = instr->RTValue();
+ int64_t ra_val = ra == 0 ? 0 : get_register(ra);
+ int offset = SIGN_EXT_IMM16(instr->Bits(15, 0) & ~3);
+ switch (instr->Bits(1, 0)) {
+ case 0: { // ld
+ intptr_t* result = ReadDW(ra_val + offset);
+ set_register(rt, *result);
+ break;
+ }
+ case 1: { // ldu
+ intptr_t* result = ReadDW(ra_val + offset);
+ set_register(rt, *result);
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + offset);
+ break;
+ }
+ case 2: { // lwa
+ intptr_t result = ReadW(ra_val + offset, instr);
+ set_register(rt, result);
+ break;
+ }
+ }
+ break;
+ }
+
+ case STD: {
+ int ra = instr->RAValue();
+ int rs = instr->RSValue();
+ int64_t ra_val = ra == 0 ? 0 : get_register(ra);
+ int64_t rs_val = get_register(rs);
+ int offset = SIGN_EXT_IMM16(instr->Bits(15, 0) & ~3);
+ WriteDW(ra_val + offset, rs_val);
+ if (instr->Bit(0) == 1) { // This is the STDU form
+ DCHECK(ra != 0);
+ set_register(ra, ra_val + offset);
+ }
+ break;
+ }
+#endif
+
+ case FAKE_OPCODE: {
+ if (instr->Bits(MARKER_SUBOPCODE_BIT, MARKER_SUBOPCODE_BIT) == 1) {
+ int marker_code = instr->Bits(STUB_MARKER_HIGH_BIT, 0);
+ DCHECK(marker_code < F_NEXT_AVAILABLE_STUB_MARKER);
+ PrintF("Hit stub-marker: %d (EMIT_STUB_MARKER)\n", marker_code);
+ } else {
+ int fake_opcode = instr->Bits(FAKE_OPCODE_HIGH_BIT, 0);
+ if (fake_opcode == fBKPT) {
+ PPCDebugger dbg(this);
+ PrintF("Simulator hit BKPT.\n");
+ dbg.Debug();
+ } else {
+ DCHECK(fake_opcode < fLastFaker);
+ PrintF("Hit ARM opcode: %d(FAKE_OPCODE defined in constant-ppc.h)\n",
+ fake_opcode);
+ UNIMPLEMENTED();
+ }
+ }
+ break;
+ }
+
+ default: {
+ UNIMPLEMENTED();
+ break;
+ }
+ }
+} // NOLINT
+
+
+void Simulator::Trace(Instruction* instr) {
+ disasm::NameConverter converter;
+ disasm::Disassembler dasm(converter);
+ // use a reasonably large buffer
+ v8::internal::EmbeddedVector<char, 256> buffer;
+ dasm.InstructionDecode(buffer, reinterpret_cast<byte*>(instr));
+ PrintF("%05d %08" V8PRIxPTR " %s\n", icount_,
+ reinterpret_cast<intptr_t>(instr), buffer.start());
+}
+
+
+// Executes the current instruction.
+void Simulator::ExecuteInstruction(Instruction* instr) {
+ if (v8::internal::FLAG_check_icache) {
+ CheckICache(isolate_->simulator_i_cache(), instr);
+ }
+ pc_modified_ = false;
+ if (::v8::internal::FLAG_trace_sim) {
+ Trace(instr);
+ }
+ int opcode = instr->OpcodeValue() << 26;
+ if (opcode == TWI) {
+ SoftwareInterrupt(instr);
+ } else {
+ ExecuteGeneric(instr);
+ }
+ if (!pc_modified_) {
+ set_pc(reinterpret_cast<intptr_t>(instr) + Instruction::kInstrSize);
+ }
+}
+
+
+void Simulator::Execute() {
+ // Get the PC to simulate. Cannot use the accessor here as we need the
+ // raw PC value and not the one used as input to arithmetic instructions.
+ intptr_t program_counter = get_pc();
+
+ if (::v8::internal::FLAG_stop_sim_at == 0) {
+ // Fast version of the dispatch loop without checking whether the simulator
+ // should be stopping at a particular executed instruction.
+ while (program_counter != end_sim_pc) {
+ Instruction* instr = reinterpret_cast<Instruction*>(program_counter);
+ icount_++;
+ ExecuteInstruction(instr);
+ program_counter = get_pc();
+ }
+ } else {
+ // FLAG_stop_sim_at is at the non-default value. Stop in the debugger when
+ // we reach the particular instuction count.
+ while (program_counter != end_sim_pc) {
+ Instruction* instr = reinterpret_cast<Instruction*>(program_counter);
+ icount_++;
+ if (icount_ == ::v8::internal::FLAG_stop_sim_at) {
+ PPCDebugger dbg(this);
+ dbg.Debug();
+ } else {
+ ExecuteInstruction(instr);
+ }
+ program_counter = get_pc();
+ }
+ }
+}
+
+
+void Simulator::CallInternal(byte* entry) {
+// Prepare to execute the code at entry
+#if ABI_USES_FUNCTION_DESCRIPTORS
+ // entry is the function descriptor
+ set_pc(*(reinterpret_cast<intptr_t*>(entry)));
+#else
+ // entry is the instruction address
+ set_pc(reinterpret_cast<intptr_t>(entry));
+#endif
+
+ // Put down marker for end of simulation. The simulator will stop simulation
+ // when the PC reaches this value. By saving the "end simulation" value into
+ // the LR the simulation stops when returning to this call point.
+ special_reg_lr_ = end_sim_pc;
+
+ // Remember the values of non-volatile registers.
+ intptr_t r2_val = get_register(r2);
+ intptr_t r13_val = get_register(r13);
+ intptr_t r14_val = get_register(r14);
+ intptr_t r15_val = get_register(r15);
+ intptr_t r16_val = get_register(r16);
+ intptr_t r17_val = get_register(r17);
+ intptr_t r18_val = get_register(r18);
+ intptr_t r19_val = get_register(r19);
+ intptr_t r20_val = get_register(r20);
+ intptr_t r21_val = get_register(r21);
+ intptr_t r22_val = get_register(r22);
+ intptr_t r23_val = get_register(r23);
+ intptr_t r24_val = get_register(r24);
+ intptr_t r25_val = get_register(r25);
+ intptr_t r26_val = get_register(r26);
+ intptr_t r27_val = get_register(r27);
+ intptr_t r28_val = get_register(r28);
+ intptr_t r29_val = get_register(r29);
+ intptr_t r30_val = get_register(r30);
+ intptr_t r31_val = get_register(fp);
+
+ // Set up the non-volatile registers with a known value. To be able to check
+ // that they are preserved properly across JS execution.
+ intptr_t callee_saved_value = icount_;
+ set_register(r2, callee_saved_value);
+ set_register(r13, callee_saved_value);
+ set_register(r14, callee_saved_value);
+ set_register(r15, callee_saved_value);
+ set_register(r16, callee_saved_value);
+ set_register(r17, callee_saved_value);
+ set_register(r18, callee_saved_value);
+ set_register(r19, callee_saved_value);
+ set_register(r20, callee_saved_value);
+ set_register(r21, callee_saved_value);
+ set_register(r22, callee_saved_value);
+ set_register(r23, callee_saved_value);
+ set_register(r24, callee_saved_value);
+ set_register(r25, callee_saved_value);
+ set_register(r26, callee_saved_value);
+ set_register(r27, callee_saved_value);
+ set_register(r28, callee_saved_value);
+ set_register(r29, callee_saved_value);
+ set_register(r30, callee_saved_value);
+ set_register(fp, callee_saved_value);
+
+ // Start the simulation
+ Execute();
+
+ // Check that the non-volatile registers have been preserved.
+ CHECK_EQ(callee_saved_value, get_register(r2));
+ CHECK_EQ(callee_saved_value, get_register(r13));
+ CHECK_EQ(callee_saved_value, get_register(r14));
+ CHECK_EQ(callee_saved_value, get_register(r15));
+ CHECK_EQ(callee_saved_value, get_register(r16));
+ CHECK_EQ(callee_saved_value, get_register(r17));
+ CHECK_EQ(callee_saved_value, get_register(r18));
+ CHECK_EQ(callee_saved_value, get_register(r19));
+ CHECK_EQ(callee_saved_value, get_register(r20));
+ CHECK_EQ(callee_saved_value, get_register(r21));
+ CHECK_EQ(callee_saved_value, get_register(r22));
+ CHECK_EQ(callee_saved_value, get_register(r23));
+ CHECK_EQ(callee_saved_value, get_register(r24));
+ CHECK_EQ(callee_saved_value, get_register(r25));
+ CHECK_EQ(callee_saved_value, get_register(r26));
+ CHECK_EQ(callee_saved_value, get_register(r27));
+ CHECK_EQ(callee_saved_value, get_register(r28));
+ CHECK_EQ(callee_saved_value, get_register(r29));
+ CHECK_EQ(callee_saved_value, get_register(r30));
+ CHECK_EQ(callee_saved_value, get_register(fp));
+
+ // Restore non-volatile registers with the original value.
+ set_register(r2, r2_val);
+ set_register(r13, r13_val);
+ set_register(r14, r14_val);
+ set_register(r15, r15_val);
+ set_register(r16, r16_val);
+ set_register(r17, r17_val);
+ set_register(r18, r18_val);
+ set_register(r19, r19_val);
+ set_register(r20, r20_val);
+ set_register(r21, r21_val);
+ set_register(r22, r22_val);
+ set_register(r23, r23_val);
+ set_register(r24, r24_val);
+ set_register(r25, r25_val);
+ set_register(r26, r26_val);
+ set_register(r27, r27_val);
+ set_register(r28, r28_val);
+ set_register(r29, r29_val);
+ set_register(r30, r30_val);
+ set_register(fp, r31_val);
+}
+
+
+intptr_t Simulator::Call(byte* entry, int argument_count, ...) {
+ va_list parameters;
+ va_start(parameters, argument_count);
+ // Set up arguments
+
+ // First eight arguments passed in registers r3-r10.
+ int reg_arg_count = (argument_count > 8) ? 8 : argument_count;
+ int stack_arg_count = argument_count - reg_arg_count;
+ for (int i = 0; i < reg_arg_count; i++) {
+ set_register(i + 3, va_arg(parameters, intptr_t));
+ }
+
+ // Remaining arguments passed on stack.
+ intptr_t original_stack = get_register(sp);
+ // Compute position of stack on entry to generated code.
+ intptr_t entry_stack =
+ (original_stack -
+ (kNumRequiredStackFrameSlots + stack_arg_count) * sizeof(intptr_t));
+ if (base::OS::ActivationFrameAlignment() != 0) {
+ entry_stack &= -base::OS::ActivationFrameAlignment();
+ }
+ // Store remaining arguments on stack, from low to high memory.
+ // +2 is a hack for the LR slot + old SP on PPC
+ intptr_t* stack_argument =
+ reinterpret_cast<intptr_t*>(entry_stack) + kStackFrameExtraParamSlot;
+ for (int i = 0; i < stack_arg_count; i++) {
+ stack_argument[i] = va_arg(parameters, intptr_t);
+ }
+ va_end(parameters);
+ set_register(sp, entry_stack);
+
+ CallInternal(entry);
+
+ // Pop stack passed arguments.
+ CHECK_EQ(entry_stack, get_register(sp));
+ set_register(sp, original_stack);
+
+ intptr_t result = get_register(r3);
+ return result;
+}
+
+
+void Simulator::CallFP(byte* entry, double d0, double d1) {
+ set_d_register_from_double(1, d0);
+ set_d_register_from_double(2, d1);
+ CallInternal(entry);
+}
+
+
+int32_t Simulator::CallFPReturnsInt(byte* entry, double d0, double d1) {
+ CallFP(entry, d0, d1);
+ int32_t result = get_register(r3);
+ return result;
+}
+
+
+double Simulator::CallFPReturnsDouble(byte* entry, double d0, double d1) {
+ CallFP(entry, d0, d1);
+ return get_double_from_d_register(1);
+}
+
+
+uintptr_t Simulator::PushAddress(uintptr_t address) {
+ uintptr_t new_sp = get_register(sp) - sizeof(uintptr_t);
+ uintptr_t* stack_slot = reinterpret_cast<uintptr_t*>(new_sp);
+ *stack_slot = address;
+ set_register(sp, new_sp);
+ return new_sp;
+}
+
+
+uintptr_t Simulator::PopAddress() {
+ uintptr_t current_sp = get_register(sp);
+ uintptr_t* stack_slot = reinterpret_cast<uintptr_t*>(current_sp);
+ uintptr_t address = *stack_slot;
+ set_register(sp, current_sp + sizeof(uintptr_t));
+ return address;
+}
+}
+} // namespace v8::internal
+
+#endif // USE_SIMULATOR
+#endif // V8_TARGET_ARCH_PPC
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+
+// Declares a Simulator for PPC instructions if we are not generating a native
+// PPC binary. This Simulator allows us to run and debug PPC code generation on
+// regular desktop machines.
+// V8 calls into generated code by "calling" the CALL_GENERATED_CODE macro,
+// which will start execution in the Simulator or forwards to the real entry
+// on a PPC HW platform.
+
+#ifndef V8_PPC_SIMULATOR_PPC_H_
+#define V8_PPC_SIMULATOR_PPC_H_
+
+#include "src/allocation.h"
+
+#if !defined(USE_SIMULATOR)
+// Running without a simulator on a native ppc platform.
+
+namespace v8 {
+namespace internal {
+
+// When running without a simulator we call the entry directly.
+#define CALL_GENERATED_CODE(entry, p0, p1, p2, p3, p4) \
+ (entry(p0, p1, p2, p3, p4))
+
+typedef int (*ppc_regexp_matcher)(String*, int, const byte*, const byte*, int*,
+ int, Address, int, void*, Isolate*);
+
+
+// Call the generated regexp code directly. The code at the entry address
+// should act as a function matching the type ppc_regexp_matcher.
+// The ninth argument is a dummy that reserves the space used for
+// the return address added by the ExitFrame in native calls.
+#define CALL_GENERATED_REGEXP_CODE(entry, p0, p1, p2, p3, p4, p5, p6, p7, p8) \
+ (FUNCTION_CAST<ppc_regexp_matcher>(entry)(p0, p1, p2, p3, p4, p5, p6, p7, \
+ NULL, p8))
+
+// The stack limit beyond which we will throw stack overflow errors in
+// generated code. Because generated code on ppc uses the C stack, we
+// just use the C stack limit.
+class SimulatorStack : public v8::internal::AllStatic {
+ public:
+ static inline uintptr_t JsLimitFromCLimit(v8::internal::Isolate* isolate,
+ uintptr_t c_limit) {
+ USE(isolate);
+ return c_limit;
+ }
+
+ static inline uintptr_t RegisterCTryCatch(uintptr_t try_catch_address) {
+ return try_catch_address;
+ }
+
+ static inline void UnregisterCTryCatch() {}
+};
+}
+} // namespace v8::internal
+
+#else // !defined(USE_SIMULATOR)
+// Running with a simulator.
+
+#include "src/assembler.h"
+#include "src/hashmap.h"
+#include "src/ppc/constants-ppc.h"
+
+namespace v8 {
+namespace internal {
+
+class CachePage {
+ public:
+ static const int LINE_VALID = 0;
+ static const int LINE_INVALID = 1;
+
+ static const int kPageShift = 12;
+ static const int kPageSize = 1 << kPageShift;
+ static const int kPageMask = kPageSize - 1;
+ static const int kLineShift = 2; // The cache line is only 4 bytes right now.
+ static const int kLineLength = 1 << kLineShift;
+ static const int kLineMask = kLineLength - 1;
+
+ CachePage() { memset(&validity_map_, LINE_INVALID, sizeof(validity_map_)); }
+
+ char* ValidityByte(int offset) {
+ return &validity_map_[offset >> kLineShift];
+ }
+
+ char* CachedData(int offset) { return &data_[offset]; }
+
+ private:
+ char data_[kPageSize]; // The cached data.
+ static const int kValidityMapSize = kPageSize >> kLineShift;
+ char validity_map_[kValidityMapSize]; // One byte per line.
+};
+
+
+class Simulator {
+ public:
+ friend class PPCDebugger;
+ enum Register {
+ no_reg = -1,
+ r0 = 0,
+ sp,
+ r2,
+ r3,
+ r4,
+ r5,
+ r6,
+ r7,
+ r8,
+ r9,
+ r10,
+ r11,
+ r12,
+ r13,
+ r14,
+ r15,
+ r16,
+ r17,
+ r18,
+ r19,
+ r20,
+ r21,
+ r22,
+ r23,
+ r24,
+ r25,
+ r26,
+ r27,
+ r28,
+ r29,
+ r30,
+ fp,
+ kNumGPRs = 32,
+ d0 = 0,
+ d1,
+ d2,
+ d3,
+ d4,
+ d5,
+ d6,
+ d7,
+ d8,
+ d9,
+ d10,
+ d11,
+ d12,
+ d13,
+ d14,
+ d15,
+ d16,
+ d17,
+ d18,
+ d19,
+ d20,
+ d21,
+ d22,
+ d23,
+ d24,
+ d25,
+ d26,
+ d27,
+ d28,
+ d29,
+ d30,
+ d31,
+ kNumFPRs = 32
+ };
+
+ explicit Simulator(Isolate* isolate);
+ ~Simulator();
+
+ // The currently executing Simulator instance. Potentially there can be one
+ // for each native thread.
+ static Simulator* current(v8::internal::Isolate* isolate);
+
+ // Accessors for register state.
+ void set_register(int reg, intptr_t value);
+ intptr_t get_register(int reg) const;
+ double get_double_from_register_pair(int reg);
+ void set_d_register_from_double(int dreg, const double dbl) {
+ DCHECK(dreg >= 0 && dreg < kNumFPRs);
+ fp_registers_[dreg] = dbl;
+ }
+ double get_double_from_d_register(int dreg) { return fp_registers_[dreg]; }
+
+ // Special case of set_register and get_register to access the raw PC value.
+ void set_pc(intptr_t value);
+ intptr_t get_pc() const;
+
+ Address get_sp() {
+ return reinterpret_cast<Address>(static_cast<intptr_t>(get_register(sp)));
+ }
+
+ // Accessor to the internal simulator stack area.
+ uintptr_t StackLimit() const;
+
+ // Executes PPC instructions until the PC reaches end_sim_pc.
+ void Execute();
+
+ // Call on program start.
+ static void Initialize(Isolate* isolate);
+
+ // V8 generally calls into generated JS code with 5 parameters and into
+ // generated RegExp code with 7 parameters. This is a convenience function,
+ // which sets up the simulator state and grabs the result on return.
+ intptr_t Call(byte* entry, int argument_count, ...);
+ // Alternative: call a 2-argument double function.
+ void CallFP(byte* entry, double d0, double d1);
+ int32_t CallFPReturnsInt(byte* entry, double d0, double d1);
+ double CallFPReturnsDouble(byte* entry, double d0, double d1);
+
+ // Push an address onto the JS stack.
+ uintptr_t PushAddress(uintptr_t address);
+
+ // Pop an address from the JS stack.
+ uintptr_t PopAddress();
+
+ // Debugger input.
+ void set_last_debugger_input(char* input);
+ char* last_debugger_input() { return last_debugger_input_; }
+
+ // ICache checking.
+ static void FlushICache(v8::internal::HashMap* i_cache, void* start,
+ size_t size);
+
+ // Returns true if pc register contains one of the 'special_values' defined
+ // below (bad_lr, end_sim_pc).
+ bool has_bad_pc() const;
+
+ private:
+ enum special_values {
+ // Known bad pc value to ensure that the simulator does not execute
+ // without being properly setup.
+ bad_lr = -1,
+ // A pc value used to signal the simulator to stop execution. Generally
+ // the lr is set to this value on transition from native C code to
+ // simulated execution, so that the simulator can "return" to the native
+ // C code.
+ end_sim_pc = -2
+ };
+
+ // Unsupported instructions use Format to print an error and stop execution.
+ void Format(Instruction* instr, const char* format);
+
+ // Helper functions to set the conditional flags in the architecture state.
+ bool CarryFrom(int32_t left, int32_t right, int32_t carry = 0);
+ bool BorrowFrom(int32_t left, int32_t right);
+ bool OverflowFrom(int32_t alu_out, int32_t left, int32_t right,
+ bool addition);
+
+ // Helper functions to decode common "addressing" modes
+ int32_t GetShiftRm(Instruction* instr, bool* carry_out);
+ int32_t GetImm(Instruction* instr, bool* carry_out);
+ void ProcessPUW(Instruction* instr, int num_regs, int operand_size,
+ intptr_t* start_address, intptr_t* end_address);
+ void HandleRList(Instruction* instr, bool load);
+ void HandleVList(Instruction* inst);
+ void SoftwareInterrupt(Instruction* instr);
+
+ // Stop helper functions.
+ inline bool isStopInstruction(Instruction* instr);
+ inline bool isWatchedStop(uint32_t bkpt_code);
+ inline bool isEnabledStop(uint32_t bkpt_code);
+ inline void EnableStop(uint32_t bkpt_code);
+ inline void DisableStop(uint32_t bkpt_code);
+ inline void IncreaseStopCounter(uint32_t bkpt_code);
+ void PrintStopInfo(uint32_t code);
+
+ // Read and write memory.
+ inline uint8_t ReadBU(intptr_t addr);
+ inline int8_t ReadB(intptr_t addr);
+ inline void WriteB(intptr_t addr, uint8_t value);
+ inline void WriteB(intptr_t addr, int8_t value);
+
+ inline uint16_t ReadHU(intptr_t addr, Instruction* instr);
+ inline int16_t ReadH(intptr_t addr, Instruction* instr);
+ // Note: Overloaded on the sign of the value.
+ inline void WriteH(intptr_t addr, uint16_t value, Instruction* instr);
+ inline void WriteH(intptr_t addr, int16_t value, Instruction* instr);
+
+ inline uint32_t ReadWU(intptr_t addr, Instruction* instr);
+ inline int32_t ReadW(intptr_t addr, Instruction* instr);
+ inline void WriteW(intptr_t addr, uint32_t value, Instruction* instr);
+ inline void WriteW(intptr_t addr, int32_t value, Instruction* instr);
+
+ intptr_t* ReadDW(intptr_t addr);
+ void WriteDW(intptr_t addr, int64_t value);
+
+ void Trace(Instruction* instr);
+ void SetCR0(intptr_t result, bool setSO = false);
+ void ExecuteBranchConditional(Instruction* instr);
+ void ExecuteExt1(Instruction* instr);
+ bool ExecuteExt2_10bit(Instruction* instr);
+ bool ExecuteExt2_9bit_part1(Instruction* instr);
+ void ExecuteExt2_9bit_part2(Instruction* instr);
+ void ExecuteExt2(Instruction* instr);
+ void ExecuteExt4(Instruction* instr);
+#if V8_TARGET_ARCH_PPC64
+ void ExecuteExt5(Instruction* instr);
+#endif
+ void ExecuteGeneric(Instruction* instr);
+
+ // Executes one instruction.
+ void ExecuteInstruction(Instruction* instr);
+
+ // ICache.
+ static void CheckICache(v8::internal::HashMap* i_cache, Instruction* instr);
+ static void FlushOnePage(v8::internal::HashMap* i_cache, intptr_t start,
+ int size);
+ static CachePage* GetCachePage(v8::internal::HashMap* i_cache, void* page);
+
+ // Runtime call support.
+ static void* RedirectExternalReference(
+ void* external_function, v8::internal::ExternalReference::Type type);
+
+ // Handle arguments and return value for runtime FP functions.
+ void GetFpArgs(double* x, double* y, intptr_t* z);
+ void SetFpResult(const double& result);
+ void TrashCallerSaveRegisters();
+
+ void CallInternal(byte* entry);
+
+ // Architecture state.
+ // Saturating instructions require a Q flag to indicate saturation.
+ // There is currently no way to read the CPSR directly, and thus read the Q
+ // flag, so this is left unimplemented.
+ intptr_t registers_[kNumGPRs];
+ int32_t condition_reg_;
+ int32_t fp_condition_reg_;
+ intptr_t special_reg_lr_;
+ intptr_t special_reg_pc_;
+ intptr_t special_reg_ctr_;
+ int32_t special_reg_xer_;
+
+ double fp_registers_[kNumFPRs];
+
+ // Simulator support.
+ char* stack_;
+ bool pc_modified_;
+ int icount_;
+
+ // Debugger input.
+ char* last_debugger_input_;
+
+ // Icache simulation
+ v8::internal::HashMap* i_cache_;
+
+ // Registered breakpoints.
+ Instruction* break_pc_;
+ Instr break_instr_;
+
+ v8::internal::Isolate* isolate_;
+
+ // A stop is watched if its code is less than kNumOfWatchedStops.
+ // Only watched stops support enabling/disabling and the counter feature.
+ static const uint32_t kNumOfWatchedStops = 256;
+
+ // Breakpoint is disabled if bit 31 is set.
+ static const uint32_t kStopDisabledBit = 1 << 31;
+
+ // A stop is enabled, meaning the simulator will stop when meeting the
+ // instruction, if bit 31 of watched_stops_[code].count is unset.
+ // The value watched_stops_[code].count & ~(1 << 31) indicates how many times
+ // the breakpoint was hit or gone through.
+ struct StopCountAndDesc {
+ uint32_t count;
+ char* desc;
+ };
+ StopCountAndDesc watched_stops_[kNumOfWatchedStops];
+};
+
+
+// When running with the simulator transition into simulated execution at this
+// point.
+#define CALL_GENERATED_CODE(entry, p0, p1, p2, p3, p4) \
+ reinterpret_cast<Object*>(Simulator::current(Isolate::Current())->Call( \
+ FUNCTION_ADDR(entry), 5, (intptr_t)p0, (intptr_t)p1, (intptr_t)p2, \
+ (intptr_t)p3, (intptr_t)p4))
+
+#define CALL_GENERATED_REGEXP_CODE(entry, p0, p1, p2, p3, p4, p5, p6, p7, p8) \
+ Simulator::current(Isolate::Current()) \
+ ->Call(entry, 10, (intptr_t)p0, (intptr_t)p1, (intptr_t)p2, \
+ (intptr_t)p3, (intptr_t)p4, (intptr_t)p5, (intptr_t)p6, \
+ (intptr_t)p7, (intptr_t)NULL, (intptr_t)p8)
+
+
+// The simulator has its own stack. Thus it has a different stack limit from
+// the C-based native code. Setting the c_limit to indicate a very small
+// stack cause stack overflow errors, since the simulator ignores the input.
+// This is unlikely to be an issue in practice, though it might cause testing
+// trouble down the line.
+class SimulatorStack : public v8::internal::AllStatic {
+ public:
+ static inline uintptr_t JsLimitFromCLimit(v8::internal::Isolate* isolate,
+ uintptr_t c_limit) {
+ return Simulator::current(isolate)->StackLimit();
+ }
+
+ static inline uintptr_t RegisterCTryCatch(uintptr_t try_catch_address) {
+ Simulator* sim = Simulator::current(Isolate::Current());
+ return sim->PushAddress(try_catch_address);
+ }
+
+ static inline void UnregisterCTryCatch() {
+ Simulator::current(Isolate::Current())->PopAddress();
+ }
+};
+}
+} // namespace v8::internal
+
+#endif // !defined(USE_SIMULATOR)
+#endif // V8_PPC_SIMULATOR_PPC_H_
projects / platform / upstream / v8.git / commitdiff