| // Copyright 2010 the V8 project authors. All rights reserved. |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions 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 Google Inc. nor the names of its |
| // 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. |
| |
| |
| #include "v8.h" |
| |
| #if defined(V8_TARGET_ARCH_MIPS) |
| |
| #include "bootstrapper.h" |
| #include "code-stubs.h" |
| #include "codegen-inl.h" |
| #include "compiler.h" |
| #include "debug.h" |
| #include "ic-inl.h" |
| #include "jsregexp.h" |
| #include "jump-target-inl.h" |
| #include "parser.h" |
| #include "regexp-macro-assembler.h" |
| #include "regexp-stack.h" |
| #include "register-allocator-inl.h" |
| #include "runtime.h" |
| #include "scopes.h" |
| #include "stub-cache.h" |
| #include "virtual-frame-inl.h" |
| #include "virtual-frame-mips-inl.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| |
| #define __ ACCESS_MASM(masm_) |
| |
| // ------------------------------------------------------------------------- |
| // Platform-specific DeferredCode functions. |
| |
| void DeferredCode::SaveRegisters() { |
| // On MIPS you either have a completely spilled frame or you |
| // handle it yourself, but at the moment there's no automation |
| // of registers and deferred code. |
| } |
| |
| |
| void DeferredCode::RestoreRegisters() { |
| } |
| |
| |
| // ------------------------------------------------------------------------- |
| // Platform-specific RuntimeCallHelper functions. |
| |
| void VirtualFrameRuntimeCallHelper::BeforeCall(MacroAssembler* masm) const { |
| frame_state_->frame()->AssertIsSpilled(); |
| } |
| |
| |
| void VirtualFrameRuntimeCallHelper::AfterCall(MacroAssembler* masm) const { |
| } |
| |
| |
| void StubRuntimeCallHelper::BeforeCall(MacroAssembler* masm) const { |
| masm->EnterInternalFrame(); |
| } |
| |
| |
| void StubRuntimeCallHelper::AfterCall(MacroAssembler* masm) const { |
| masm->LeaveInternalFrame(); |
| } |
| |
| |
| // ----------------------------------------------------------------------------- |
| // CodeGenState implementation. |
| |
| CodeGenState::CodeGenState(CodeGenerator* owner) |
| : owner_(owner), |
| previous_(owner->state()) { |
| owner->set_state(this); |
| } |
| |
| |
| ConditionCodeGenState::ConditionCodeGenState(CodeGenerator* owner, |
| JumpTarget* true_target, |
| JumpTarget* false_target) |
| : CodeGenState(owner), |
| true_target_(true_target), |
| false_target_(false_target) { |
| owner->set_state(this); |
| } |
| |
| |
| TypeInfoCodeGenState::TypeInfoCodeGenState(CodeGenerator* owner, |
| Slot* slot, |
| TypeInfo type_info) |
| : CodeGenState(owner), |
| slot_(slot) { |
| owner->set_state(this); |
| old_type_info_ = owner->set_type_info(slot, type_info); |
| } |
| |
| |
| CodeGenState::~CodeGenState() { |
| ASSERT(owner_->state() == this); |
| owner_->set_state(previous_); |
| } |
| |
| |
| TypeInfoCodeGenState::~TypeInfoCodeGenState() { |
| owner()->set_type_info(slot_, old_type_info_); |
| } |
| |
| |
| // ----------------------------------------------------------------------------- |
| // CodeGenerator implementation. |
| |
| CodeGenerator::CodeGenerator(MacroAssembler* masm) |
| : deferred_(8), |
| masm_(masm), |
| info_(NULL), |
| frame_(NULL), |
| allocator_(NULL), |
| cc_reg_(cc_always), |
| state_(NULL), |
| loop_nesting_(0), |
| type_info_(NULL), |
| function_return_(JumpTarget::BIDIRECTIONAL), |
| function_return_is_shadowed_(false) { |
| } |
| |
| |
| // Calling conventions: |
| // fp: caller's frame pointer |
| // sp: stack pointer |
| // a1: called JS function |
| // cp: callee's context |
| |
| void CodeGenerator::Generate(CompilationInfo* info) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| int CodeGenerator::NumberOfSlot(Slot* slot) { |
| UNIMPLEMENTED_MIPS(); |
| return 0; |
| } |
| |
| |
| MemOperand CodeGenerator::SlotOperand(Slot* slot, Register tmp) { |
| UNIMPLEMENTED_MIPS(); |
| return MemOperand(zero_reg, 0); |
| } |
| |
| |
| MemOperand CodeGenerator::ContextSlotOperandCheckExtensions( |
| Slot* slot, |
| Register tmp, |
| Register tmp2, |
| JumpTarget* slow) { |
| UNIMPLEMENTED_MIPS(); |
| return MemOperand(zero_reg, 0); |
| } |
| |
| |
| void CodeGenerator::LoadCondition(Expression* x, |
| JumpTarget* true_target, |
| JumpTarget* false_target, |
| bool force_cc) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::Load(Expression* x) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::LoadGlobal() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::LoadGlobalReceiver(Register scratch) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| ArgumentsAllocationMode CodeGenerator::ArgumentsMode() { |
| UNIMPLEMENTED_MIPS(); |
| return EAGER_ARGUMENTS_ALLOCATION; |
| } |
| |
| |
| void CodeGenerator::StoreArgumentsObject(bool initial) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::LoadTypeofExpression(Expression* x) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| Reference::Reference(CodeGenerator* cgen, |
| Expression* expression, |
| bool persist_after_get) |
| : cgen_(cgen), |
| expression_(expression), |
| type_(ILLEGAL), |
| persist_after_get_(persist_after_get) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| Reference::~Reference() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::LoadReference(Reference* ref) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::UnloadReference(Reference* ref) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| // ECMA-262, section 9.2, page 30: ToBoolean(). Convert the given |
| // register to a boolean in the condition code register. The code |
| // may jump to 'false_target' in case the register converts to 'false'. |
| void CodeGenerator::ToBoolean(JumpTarget* true_target, |
| JumpTarget* false_target) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenericBinaryOperation(Token::Value op, |
| OverwriteMode overwrite_mode, |
| GenerateInlineSmi inline_smi, |
| int constant_rhs) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| class DeferredInlineSmiOperation: public DeferredCode { |
| public: |
| DeferredInlineSmiOperation(Token::Value op, |
| int value, |
| bool reversed, |
| OverwriteMode overwrite_mode, |
| Register tos) |
| : op_(op), |
| value_(value), |
| reversed_(reversed), |
| overwrite_mode_(overwrite_mode), |
| tos_register_(tos) { |
| set_comment("[ DeferredInlinedSmiOperation"); |
| } |
| |
| virtual void Generate(); |
| // This stub makes explicit calls to SaveRegisters(), RestoreRegisters() and |
| // Exit(). Currently on MIPS SaveRegisters() and RestoreRegisters() are empty |
| // methods, it is the responsibility of the deferred code to save and restore |
| // registers. |
| virtual bool AutoSaveAndRestore() { return false; } |
| |
| void JumpToNonSmiInput(Condition cond, Register cmp1, const Operand& cmp2); |
| void JumpToAnswerOutOfRange(Condition cond, |
| Register cmp1, |
| const Operand& cmp2); |
| |
| private: |
| void GenerateNonSmiInput(); |
| void GenerateAnswerOutOfRange(); |
| void WriteNonSmiAnswer(Register answer, |
| Register heap_number, |
| Register scratch); |
| |
| Token::Value op_; |
| int value_; |
| bool reversed_; |
| OverwriteMode overwrite_mode_; |
| Register tos_register_; |
| Label non_smi_input_; |
| Label answer_out_of_range_; |
| }; |
| |
| |
| // For bit operations we try harder and handle the case where the input is not |
| // a Smi but a 32bits integer without calling the generic stub. |
| void DeferredInlineSmiOperation::JumpToNonSmiInput(Condition cond, |
| Register cmp1, |
| const Operand& cmp2) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| // For bit operations the result is always 32bits so we handle the case where |
| // the result does not fit in a Smi without calling the generic stub. |
| void DeferredInlineSmiOperation::JumpToAnswerOutOfRange(Condition cond, |
| Register cmp1, |
| const Operand& cmp2) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| // On entry the non-constant side of the binary operation is in tos_register_ |
| // and the constant smi side is nowhere. The tos_register_ is not used by the |
| // virtual frame. On exit the answer is in the tos_register_ and the virtual |
| // frame is unchanged. |
| void DeferredInlineSmiOperation::Generate() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| // Convert and write the integer answer into heap_number. |
| void DeferredInlineSmiOperation::WriteNonSmiAnswer(Register answer, |
| Register heap_number, |
| Register scratch) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void DeferredInlineSmiOperation::GenerateNonSmiInput() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void DeferredInlineSmiOperation::GenerateAnswerOutOfRange() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::SmiOperation(Token::Value op, |
| Handle<Object> value, |
| bool reversed, |
| OverwriteMode mode) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| // On MIPS we load registers condReg1 and condReg2 with the values which should |
| // be compared. With the CodeGenerator::cc_reg_ condition, functions will be |
| // able to evaluate correctly the condition. (eg CodeGenerator::Branch) |
| void CodeGenerator::Comparison(Condition cc, |
| Expression* left, |
| Expression* right, |
| bool strict) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::CallWithArguments(ZoneList<Expression*>* args, |
| CallFunctionFlags flags, |
| int position) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::CallApplyLazy(Expression* applicand, |
| Expression* receiver, |
| VariableProxy* arguments, |
| int position) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::Branch(bool if_true, JumpTarget* target) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::CheckStack() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitStatements(ZoneList<Statement*>* statements) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitBlock(Block* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitDeclaration(Declaration* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitExpressionStatement(ExpressionStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitEmptyStatement(EmptyStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitIfStatement(IfStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitContinueStatement(ContinueStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitBreakStatement(BreakStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitReturnStatement(ReturnStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateReturnSequence() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitWithEnterStatement(WithEnterStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitWithExitStatement(WithExitStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitSwitchStatement(SwitchStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitDoWhileStatement(DoWhileStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitWhileStatement(WhileStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitForStatement(ForStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitForInStatement(ForInStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitTryCatchStatement(TryCatchStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitDebuggerStatement(DebuggerStatement* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::InstantiateFunction( |
| Handle<SharedFunctionInfo> function_info, |
| bool pretenure) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitFunctionLiteral(FunctionLiteral* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitSharedFunctionInfoLiteral( |
| SharedFunctionInfoLiteral* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitConditional(Conditional* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::LoadFromSlot(Slot* slot, TypeofState typeof_state) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::LoadFromSlotCheckForArguments(Slot* slot, |
| TypeofState state) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::StoreToSlot(Slot* slot, InitState init_state) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::LoadFromGlobalSlotCheckExtensions(Slot* slot, |
| TypeofState typeof_state, |
| JumpTarget* slow) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::EmitDynamicLoadFromSlotFastCase(Slot* slot, |
| TypeofState typeof_state, |
| JumpTarget* slow, |
| JumpTarget* done) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitSlot(Slot* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitVariableProxy(VariableProxy* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitLiteral(Literal* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitRegExpLiteral(RegExpLiteral* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitObjectLiteral(ObjectLiteral* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitArrayLiteral(ArrayLiteral* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitCatchExtensionObject(CatchExtensionObject* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::EmitSlotAssignment(Assignment* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::EmitNamedPropertyAssignment(Assignment* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::EmitKeyedPropertyAssignment(Assignment* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitAssignment(Assignment* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitThrow(Throw* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitProperty(Property* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitCall(Call* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitCallNew(CallNew* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateClassOf(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateValueOf(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateSetValueOf(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateIsSmi(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateLog(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateIsNonNegativeSmi(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateMathPow(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateMathSqrt(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| class DeferredStringCharCodeAt : public DeferredCode { |
| public: |
| DeferredStringCharCodeAt(Register object, |
| Register index, |
| Register scratch, |
| Register result) |
| : result_(result), |
| char_code_at_generator_(object, |
| index, |
| scratch, |
| result, |
| &need_conversion_, |
| &need_conversion_, |
| &index_out_of_range_, |
| STRING_INDEX_IS_NUMBER) {} |
| |
| StringCharCodeAtGenerator* fast_case_generator() { |
| return &char_code_at_generator_; |
| } |
| |
| virtual void Generate() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| private: |
| Register result_; |
| |
| Label need_conversion_; |
| Label index_out_of_range_; |
| |
| StringCharCodeAtGenerator char_code_at_generator_; |
| }; |
| |
| |
| void CodeGenerator::GenerateStringCharCodeAt(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| class DeferredStringCharFromCode : public DeferredCode { |
| public: |
| DeferredStringCharFromCode(Register code, |
| Register result) |
| : char_from_code_generator_(code, result) {} |
| |
| StringCharFromCodeGenerator* fast_case_generator() { |
| return &char_from_code_generator_; |
| } |
| |
| virtual void Generate() { |
| VirtualFrameRuntimeCallHelper call_helper(frame_state()); |
| char_from_code_generator_.GenerateSlow(masm(), call_helper); |
| } |
| |
| private: |
| StringCharFromCodeGenerator char_from_code_generator_; |
| }; |
| |
| |
| void CodeGenerator::GenerateStringCharFromCode(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| class DeferredStringCharAt : public DeferredCode { |
| public: |
| DeferredStringCharAt(Register object, |
| Register index, |
| Register scratch1, |
| Register scratch2, |
| Register result) |
| : result_(result), |
| char_at_generator_(object, |
| index, |
| scratch1, |
| scratch2, |
| result, |
| &need_conversion_, |
| &need_conversion_, |
| &index_out_of_range_, |
| STRING_INDEX_IS_NUMBER) {} |
| |
| StringCharAtGenerator* fast_case_generator() { |
| return &char_at_generator_; |
| } |
| |
| virtual void Generate() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| private: |
| Register result_; |
| |
| Label need_conversion_; |
| Label index_out_of_range_; |
| |
| StringCharAtGenerator char_at_generator_; |
| }; |
| |
| |
| void CodeGenerator::GenerateStringCharAt(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateIsArray(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateIsRegExp(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateIsObject(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateIsSpecObject(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| class DeferredIsStringWrapperSafeForDefaultValueOf : public DeferredCode { |
| public: |
| DeferredIsStringWrapperSafeForDefaultValueOf(Register object, |
| Register map_result, |
| Register scratch1, |
| Register scratch2) |
| : object_(object), |
| map_result_(map_result), |
| scratch1_(scratch1), |
| scratch2_(scratch2) { } |
| |
| virtual void Generate() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| private: |
| Register object_; |
| Register map_result_; |
| Register scratch1_; |
| Register scratch2_; |
| }; |
| |
| |
| void CodeGenerator::GenerateIsStringWrapperSafeForDefaultValueOf( |
| ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateIsFunction(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateIsUndetectableObject(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateIsConstructCall(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateArguments(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateRandomHeapNumber( |
| ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateStringAdd(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateSubString(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateStringCompare(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateRegExpExec(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateRegExpConstructResult(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| class DeferredSearchCache: public DeferredCode { |
| public: |
| DeferredSearchCache(Register dst, Register cache, Register key) |
| : dst_(dst), cache_(cache), key_(key) { |
| set_comment("[ DeferredSearchCache"); |
| } |
| |
| virtual void Generate(); |
| |
| private: |
| Register dst_, cache_, key_; |
| }; |
| |
| |
| void DeferredSearchCache::Generate() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateGetFromCache(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateNumberToString(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| class DeferredSwapElements: public DeferredCode { |
| public: |
| DeferredSwapElements(Register object, Register index1, Register index2) |
| : object_(object), index1_(index1), index2_(index2) { |
| set_comment("[ DeferredSwapElements"); |
| } |
| |
| virtual void Generate(); |
| |
| private: |
| Register object_, index1_, index2_; |
| }; |
| |
| |
| void DeferredSwapElements::Generate() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateSwapElements(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateCallFunction(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateMathSin(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateMathCos(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateMathLog(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateObjectEquals(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateIsRegExpEquivalent(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateHasCachedArrayIndex(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateGetCachedArrayIndex(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateFastAsciiArrayJoin(ZoneList<Expression*>* args) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitCallRuntime(CallRuntime* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitUnaryOperation(UnaryOperation* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| class DeferredCountOperation: public DeferredCode { |
| public: |
| DeferredCountOperation(Register value, |
| bool is_increment, |
| bool is_postfix, |
| int target_size) |
| : value_(value), |
| is_increment_(is_increment), |
| is_postfix_(is_postfix), |
| target_size_(target_size) {} |
| |
| virtual void Generate() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| private: |
| Register value_; |
| bool is_increment_; |
| bool is_postfix_; |
| int target_size_; |
| }; |
| |
| |
| void CodeGenerator::VisitCountOperation(CountOperation* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::GenerateLogicalBooleanOperation(BinaryOperation* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitBinaryOperation(BinaryOperation* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitThisFunction(ThisFunction* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitCompareOperation(CompareOperation* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::VisitCompareToNull(CompareToNull* node) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| class DeferredReferenceGetNamedValue: public DeferredCode { |
| public: |
| explicit DeferredReferenceGetNamedValue(Register receiver, |
| Handle<String> name, |
| bool is_contextual) |
| : receiver_(receiver), |
| name_(name), |
| is_contextual_(is_contextual), |
| is_dont_delete_(false) { |
| set_comment(is_contextual |
| ? "[ DeferredReferenceGetNamedValue (contextual)" |
| : "[ DeferredReferenceGetNamedValue"); |
| } |
| |
| virtual void Generate(); |
| |
| void set_is_dont_delete(bool value) { |
| ASSERT(is_contextual_); |
| is_dont_delete_ = value; |
| } |
| |
| private: |
| Register receiver_; |
| Handle<String> name_; |
| bool is_contextual_; |
| bool is_dont_delete_; |
| }; |
| |
| |
| |
| void DeferredReferenceGetNamedValue::Generate() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| class DeferredReferenceGetKeyedValue: public DeferredCode { |
| public: |
| DeferredReferenceGetKeyedValue(Register key, Register receiver) |
| : key_(key), receiver_(receiver) { |
| set_comment("[ DeferredReferenceGetKeyedValue"); |
| } |
| |
| virtual void Generate(); |
| |
| private: |
| Register key_; |
| Register receiver_; |
| }; |
| |
| |
| void DeferredReferenceGetKeyedValue::Generate() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| class DeferredReferenceSetKeyedValue: public DeferredCode { |
| public: |
| DeferredReferenceSetKeyedValue(Register value, |
| Register key, |
| Register receiver) |
| : value_(value), key_(key), receiver_(receiver) { |
| set_comment("[ DeferredReferenceSetKeyedValue"); |
| } |
| |
| virtual void Generate(); |
| |
| private: |
| Register value_; |
| Register key_; |
| Register receiver_; |
| }; |
| |
| |
| void DeferredReferenceSetKeyedValue::Generate() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| class DeferredReferenceSetNamedValue: public DeferredCode { |
| public: |
| DeferredReferenceSetNamedValue(Register value, |
| Register receiver, |
| Handle<String> name) |
| : value_(value), receiver_(receiver), name_(name) { |
| set_comment("[ DeferredReferenceSetNamedValue"); |
| } |
| |
| virtual void Generate(); |
| |
| private: |
| Register value_; |
| Register receiver_; |
| Handle<String> name_; |
| }; |
| |
| |
| void DeferredReferenceSetNamedValue::Generate() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::EmitNamedLoad(Handle<String> name, bool is_contextual) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::EmitNamedStore(Handle<String> name, bool is_contextual) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::EmitKeyedLoad() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void CodeGenerator::EmitKeyedStore(StaticType* key_type, |
| WriteBarrierCharacter wb_info) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| #ifdef DEBUG |
| bool CodeGenerator::HasValidEntryRegisters() { |
| UNIMPLEMENTED_MIPS(); |
| return false; |
| } |
| #endif |
| |
| |
| #undef __ |
| #define __ ACCESS_MASM(masm) |
| |
| // ----------------------------------------------------------------------------- |
| // Reference support. |
| |
| |
| Handle<String> Reference::GetName() { |
| UNIMPLEMENTED_MIPS(); |
| return Handle<String>(); |
| } |
| |
| |
| void Reference::DupIfPersist() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void Reference::GetValue() { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| void Reference::SetValue(InitState init_state, WriteBarrierCharacter wb_info) { |
| UNIMPLEMENTED_MIPS(); |
| } |
| |
| |
| const char* GenericBinaryOpStub::GetName() { |
| UNIMPLEMENTED_MIPS(); |
| return name_; |
| } |
| |
| |
| #undef __ |
| |
| } } // namespace v8::internal |
| |
| #endif // V8_TARGET_ARCH_MIPS |
