First draft of the sh4 port

src/sh4/lithium-codegen-sh4.cc

+// Copyright 2011-2012 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * 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_SH4)
+
+#include "sh4/lithium-codegen-sh4.h"
+#include "sh4/lithium-gap-resolver-sh4.h"
+#include "code-stubs.h"
+#include "stub-cache.h"
+
+namespace v8 {
+namespace internal {
+
+
+class SafepointGenerator : 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 { }
+
+  virtual void AfterCall() const {
+    codegen_->RecordSafepoint(pointers_, deopt_mode_);
+  }
+
+ private:
+  LCodeGen* codegen_;
+  LPointerMap* pointers_;
+  Safepoint::DeoptMode deopt_mode_;
+};
+
+
+#define __ masm()->
+
+bool LCodeGen::GenerateCode() {
+  UNIMPLEMENTED();
+  return false;
+}
+
+
+void LCodeGen::FinishCode(Handle<Code> code) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::Abort(const char* reason) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::Comment(const char* format, ...) {
+  UNIMPLEMENTED();
+}
+
+
+bool LCodeGen::GeneratePrologue() {
+  UNIMPLEMENTED();
+  return false;
+}
+
+
+bool LCodeGen::GenerateBody() {
+  UNIMPLEMENTED();
+  return false;
+}
+
+
+LInstruction* LCodeGen::GetNextInstruction() {
+  UNIMPLEMENTED();
+  return NULL;
+}
+
+
+bool LCodeGen::GenerateDeferredCode() {
+  UNIMPLEMENTED();
+  return false;
+}
+
+
+bool LCodeGen::GenerateDeoptJumpTable() {
+  UNIMPLEMENTED();
+  return false;
+}
+
+
+bool LCodeGen::GenerateSafepointTable() {
+  UNIMPLEMENTED();
+  return false;
+}
+
+
+Register LCodeGen::ToRegister(int index) const {
+  UNIMPLEMENTED();
+  return no_reg;
+}
+
+
+DoubleRegister LCodeGen::ToDoubleRegister(int index) const {
+  UNIMPLEMENTED();
+  return no_dreg;
+}
+
+
+Register LCodeGen::ToRegister(LOperand* op) const {
+  UNIMPLEMENTED();
+  return no_reg;
+}
+
+
+Register LCodeGen::EmitLoadRegister(LOperand* op, Register scratch) {
+  UNIMPLEMENTED();
+  return no_reg;
+}
+
+
+DoubleRegister LCodeGen::ToDoubleRegister(LOperand* op) const {
+  UNIMPLEMENTED();
+  return no_dreg;
+}
+
+
+DoubleRegister LCodeGen::EmitLoadDoubleRegister(LOperand* op,
+                                                SwVfpRegister flt_scratch,
+                                                DoubleRegister dbl_scratch) {
+  UNIMPLEMENTED();
+  return no_dreg;
+}
+
+
+Handle<Object> LCodeGen::ToHandle(LConstantOperand* op) const {
+  UNIMPLEMENTED();
+  return Handle<Object>();
+}
+
+
+bool LCodeGen::IsInteger32(LConstantOperand* op) const {
+  UNIMPLEMENTED();
+  return false;
+}
+
+
+int LCodeGen::ToInteger32(LConstantOperand* op) const {
+  UNIMPLEMENTED();
+  return 0;
+}
+
+
+double LCodeGen::ToDouble(LConstantOperand* op) const {
+  UNIMPLEMENTED();
+  return 0.0;
+}
+
+
+Operand LCodeGen::ToOperand(LOperand* op) {
+  UNIMPLEMENTED();
+  return Operand(0);
+}
+
+
+MemOperand LCodeGen::ToMemOperand(LOperand* op) const {
+  UNIMPLEMENTED();
+  return MemOperand(no_reg, 0);
+}
+
+
+MemOperand LCodeGen::ToHighMemOperand(LOperand* op) const {
+  UNIMPLEMENTED();
+  return MemOperand(no_reg, 0);
+}
+
+
+void LCodeGen::WriteTranslation(LEnvironment* environment,
+                                Translation* translation,
+                                int* arguments_index,
+                                int* arguments_count) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::AddToTranslation(Translation* translation,
+                                LOperand* op,
+                                bool is_tagged,
+                                bool is_uint32,
+                                int arguments_index,
+                                int arguments_count) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::CallRuntime(const Runtime::Function* function,
+                           int num_arguments,
+                           LInstruction* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::CallRuntimeFromDeferred(Runtime::FunctionId id,
+                                       int argc,
+                                       LInstruction* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::RegisterEnvironmentForDeoptimization(LEnvironment* environment,
+                                                    Safepoint::DeoptMode mode) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DeoptimizeIf(Condition cc, LEnvironment* environment) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::PopulateDeoptimizationData(Handle<Code> code) {
+  UNIMPLEMENTED();
+}
+
+
+int LCodeGen::DefineDeoptimizationLiteral(Handle<Object> literal) {
+  return 0;
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions() {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::RecordSafepoint(
+    LPointerMap* pointers,
+    Safepoint::Kind kind,
+    int arguments,
+    Safepoint::DeoptMode deopt_mode) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::RecordSafepoint(LPointerMap* pointers,
+                               Safepoint::DeoptMode deopt_mode) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::RecordSafepoint(Safepoint::DeoptMode deopt_mode) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::RecordSafepointWithRegisters(LPointerMap* pointers,
+                                            int arguments,
+                                            Safepoint::DeoptMode deopt_mode) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::RecordSafepointWithRegistersAndDoubles(
+    LPointerMap* pointers,
+    int arguments,
+    Safepoint::DeoptMode deopt_mode) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::RecordPosition(int position) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLabel(LLabel* label) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoParallelMove(LParallelMove* move) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoGap(LGap* gap) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoInstructionGap(LInstructionGap* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoParameter(LParameter* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCallStub(LCallStub* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoUnknownOSRValue(LUnknownOSRValue* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoModI(LModI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::EmitSignedIntegerDivisionByConstant(
+    Register result,
+    Register dividend,
+    int32_t divisor,
+    Register remainder,
+    Register scratch,
+    LEnvironment* environment) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDivI(LDivI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoMathFloorOfDiv(LMathFloorOfDiv* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeferredBinaryOpStub(LPointerMap* pointer_map,
+                                      LOperand* left_argument,
+                                      LOperand* right_argument,
+                                      Token::Value op) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoMulI(LMulI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoBitI(LBitI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoShiftI(LShiftI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoSubI(LSubI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoConstantI(LConstantI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoConstantD(LConstantD* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoConstantT(LConstantT* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoJSArrayLength(LJSArrayLength* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoFixedArrayBaseLength(LFixedArrayBaseLength* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoMapEnumLength(LMapEnumLength* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoElementsKind(LElementsKind* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoValueOf(LValueOf* instr) {
+  UNIMPLEMENTED();
+}
+
+void LCodeGen::DoDateField(LDateField* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoBitNotI(LBitNotI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoThrow(LThrow* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoAddI(LAddI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoMathMinMax(LMathMinMax* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoArithmeticD(LArithmeticD* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoArithmeticT(LArithmeticT* instr) {
+  UNIMPLEMENTED();
+}
+
+
+int LCodeGen::GetNextEmittedBlock(int block) {
+  UNIMPLEMENTED();
+  return 0;
+}
+
+
+void LCodeGen::EmitBranch(int left_block, int right_block, Condition cc) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoBranch(LBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::EmitGoto(int block) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoGoto(LGoto* instr) {
+  UNIMPLEMENTED();
+}
+
+
+Condition LCodeGen::TokenToCondition(Token::Value op, bool is_unsigned) {
+  UNIMPLEMENTED();
+  return ne;
+}
+
+
+void LCodeGen::DoCmpIDAndBranch(LCmpIDAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCmpObjectEqAndBranch(LCmpObjectEqAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCmpConstantEqAndBranch(LCmpConstantEqAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoIsNilAndBranch(LIsNilAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+Condition LCodeGen::EmitIsObject(Register input,
+                                 Register temp1,
+                                 Label* is_not_object,
+                                 Label* is_object) {
+  UNIMPLEMENTED();
+  return ne;
+}
+
+
+void LCodeGen::DoIsObjectAndBranch(LIsObjectAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+Condition LCodeGen::EmitIsString(Register input,
+                                 Register temp1,
+                                 Label* is_not_string) {
+  UNIMPLEMENTED();
+  return ne;
+}
+
+
+void LCodeGen::DoIsStringAndBranch(LIsStringAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoIsSmiAndBranch(LIsSmiAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoIsUndetectableAndBranch(LIsUndetectableAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStringCompareAndBranch(LStringCompareAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoHasInstanceTypeAndBranch(LHasInstanceTypeAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoGetCachedArrayIndex(LGetCachedArrayIndex* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoHasCachedArrayIndexAndBranch(
+    LHasCachedArrayIndexAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+// 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) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoClassOfTestAndBranch(LClassOfTestAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCmpMapAndBranch(LCmpMapAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoInstanceOf(LInstanceOf* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeferredInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr,
+                                               Label* map_check) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCmpT(LCmpT* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoReturn(LReturn* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadGlobalCell(LLoadGlobalCell* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadGlobalGeneric(LLoadGlobalGeneric* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStoreGlobalCell(LStoreGlobalCell* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStoreGlobalGeneric(LStoreGlobalGeneric* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadContextSlot(LLoadContextSlot* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStoreContextSlot(LStoreContextSlot* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::EmitLoadFieldOrConstantFunction(Register result,
+                                               Register object,
+                                               Handle<Map> type,
+                                               Handle<String> name,
+                                               LEnvironment* env) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadNamedFieldPolymorphic(LLoadNamedFieldPolymorphic* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadNamedGeneric(LLoadNamedGeneric* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadFunctionPrototype(LLoadFunctionPrototype* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadElements(LLoadElements* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadExternalArrayPointer(
+    LLoadExternalArrayPointer* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoAccessArgumentsAt(LAccessArgumentsAt* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadKeyedFixedArray(LLoadKeyed* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadKeyed(LLoadKeyed* instr) {
+  UNIMPLEMENTED();
+}
+
+
+MemOperand LCodeGen::PrepareKeyedOperand(Register key,
+                                         Register base,
+                                         bool key_is_constant,
+                                         int constant_key,
+                                         int element_size,
+                                         int shift_size,
+                                         int additional_index,
+                                         int additional_offset) {
+  UNIMPLEMENTED();
+  return MemOperand(no_reg, 0);
+}
+
+
+
+void LCodeGen::DoLoadKeyedGeneric(LLoadKeyedGeneric* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoArgumentsElements(LArgumentsElements* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoArgumentsLength(LArgumentsLength* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoWrapReceiver(LWrapReceiver* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoPushArgument(LPushArgument* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDrop(LDrop* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoThisFunction(LThisFunction* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoContext(LContext* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoOuterContext(LOuterContext* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeclareGlobals(LDeclareGlobals* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoGlobalObject(LGlobalObject* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoGlobalReceiver(LGlobalReceiver* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::CallKnownFunction(Handle<JSFunction> function,
+                                 int arity,
+                                 LInstruction* instr,
+                                 CallKind call_kind,
+                                 R1State r1_state) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCallConstantFunction(LCallConstantFunction* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeferredMathAbsTaggedHeapNumber(LUnaryMathOperation* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::EmitIntegerMathAbs(LUnaryMathOperation* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoMathAbs(LUnaryMathOperation* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoMathFloor(LUnaryMathOperation* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoMathRound(LUnaryMathOperation* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoMathSqrt(LUnaryMathOperation* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoMathPowHalf(LUnaryMathOperation* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoPower(LPower* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoRandom(LRandom* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeferredRandom(LRandom* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoMathLog(LUnaryMathOperation* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoMathCos(LUnaryMathOperation* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoMathSin(LUnaryMathOperation* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoUnaryMathOperation(LUnaryMathOperation* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCallKeyed(LCallKeyed* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCallNamed(LCallNamed* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCallFunction(LCallFunction* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCallGlobal(LCallGlobal* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCallKnownGlobal(LCallKnownGlobal* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCallNew(LCallNew* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCallRuntime(LCallRuntime* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStoreNamedGeneric(LStoreNamedGeneric* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DeoptIfTaggedButNotSmi(LEnvironment* environment,
+                                      HValue* value,
+                                      LOperand* operand) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoBoundsCheck(LBoundsCheck* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStoreKeyedExternalArray(LStoreKeyed* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStoreKeyedFixedDoubleArray(LStoreKeyed* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStoreKeyedFixedArray(LStoreKeyed* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStoreKeyed(LStoreKeyed* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStringAdd(LStringAdd* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeferredStringCharCodeAt(LStringCharCodeAt* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeferredStringCharFromCode(LStringCharFromCode* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStringLength(LStringLength* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoUint32ToDouble(LUint32ToDouble* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeferredNumberTagI(LInstruction* instr,
+                                    LOperand* value,
+                                    IntegerSignedness signedness) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeferredNumberTagD(LNumberTagD* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoSmiTag(LSmiTag* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoSmiUntag(LSmiUntag* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::EmitNumberUntagD(Register input_reg,
+                                DoubleRegister result_reg,
+                                bool deoptimize_on_undefined,
+                                bool deoptimize_on_minus_zero,
+                                LEnvironment* env) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoTaggedToI(LTaggedToI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoNumberUntagD(LNumberUntagD* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDoubleToI(LDoubleToI* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCheckSmi(LCheckSmi* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCheckNonSmi(LCheckNonSmi* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCheckInstanceType(LCheckInstanceType* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCheckFunction(LCheckFunction* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCheckMapCommon(Register reg,
+                                Register scratch,
+                                Handle<Map> map,
+                                CompareMapMode mode,
+                                LEnvironment* env) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoClampIToUint8(LClampIToUint8* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCheckPrototypeMaps(LCheckPrototypeMaps* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoAllocateObject(LAllocateObject* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeferredAllocateObject(LAllocateObject* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoArrayLiteral(LArrayLiteral* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::EmitDeepCopy(Handle<JSObject> object,
+                            Register result,
+                            Register source,
+                            int* offset) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoFastLiteral(LFastLiteral* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoObjectLiteral(LObjectLiteral* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoToFastProperties(LToFastProperties* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoRegExpLiteral(LRegExpLiteral* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoFunctionLiteral(LFunctionLiteral* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoTypeof(LTypeof* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoTypeofIsAndBranch(LTypeofIsAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+Condition LCodeGen::EmitTypeofIs(Label* true_label,
+                                 Label* false_label,
+                                 Register input,
+                                 Handle<String> type_name) {
+  UNIMPLEMENTED();
+  return ne;
+}
+
+
+void LCodeGen::DoIsConstructCallAndBranch(LIsConstructCallAndBranch* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::EmitIsConstructCall(Register temp1, Register temp2) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::EnsureSpaceForLazyDeopt() {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLazyBailout(LLazyBailout* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeoptimize(LDeoptimize* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeleteProperty(LDeleteProperty* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoIn(LIn* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoDeferredStackCheck(LStackCheck* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoStackCheck(LStackCheck* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoOsrEntry(LOsrEntry* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoForInPrepareMap(LForInPrepareMap* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoForInCacheArray(LForInCacheArray* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoCheckMapValue(LCheckMapValue* instr) {
+  UNIMPLEMENTED();
+}
+
+
+void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
+  UNIMPLEMENTED();
+}
+
+
+} }  // namespace v8::internal
+
+#endif  // V8_TARGET_ARCH_SH4