1 // Copyright 2010 the V8 project authors. All rights reserved. 2 // Redistribution and use in source and binary forms, with or without 3 // modification, are permitted provided that the following conditions are 4 // met: 5 // 6 // * Redistributions of source code must retain the above copyright 7 // notice, this list of conditions and the following disclaimer. 8 // * Redistributions in binary form must reproduce the above 9 // copyright notice, this list of conditions and the following 10 // disclaimer in the documentation and/or other materials provided 11 // with the distribution. 12 // * Neither the name of Google Inc. nor the names of its 13 // contributors may be used to endorse or promote products derived 14 // from this software without specific prior written permission. 15 // 16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 28 29 30 #include "v8.h" 31 32 #include "codegen-inl.h" 33 #include "register-allocator-inl.h" 34 #include "scopes.h" 35 36 namespace v8 { 37 namespace internal { 38 39 // ------------------------------------------------------------------------- 40 // VirtualFrame implementation. 41 42 #define __ ACCESS_MASM(masm()) 43 44 45 // On entry to a function, the virtual frame already contains the 46 // receiver and the parameters. All initial frame elements are in 47 // memory. 48 VirtualFrame::VirtualFrame() 49 : elements_(parameter_count() + local_count() + kPreallocatedElements), 50 stack_pointer_(parameter_count()) { // 0-based index of TOS. 51 UNIMPLEMENTED_MIPS(); 52 } 53 54 55 void VirtualFrame::SyncElementBelowStackPointer(int index) { 56 UNREACHABLE(); 57 } 58 59 60 void VirtualFrame::SyncElementByPushing(int index) { 61 UNREACHABLE(); 62 } 63 64 65 void VirtualFrame::SyncRange(int begin, int end) { 66 UNIMPLEMENTED_MIPS(); 67 } 68 69 70 void VirtualFrame::MergeTo(VirtualFrame* expected) { 71 UNIMPLEMENTED_MIPS(); 72 } 73 74 75 void VirtualFrame::Enter() { 76 UNIMPLEMENTED_MIPS(); 77 } 78 79 80 void VirtualFrame::Exit() { 81 UNIMPLEMENTED_MIPS(); 82 } 83 84 85 void VirtualFrame::AllocateStackSlots() { 86 UNIMPLEMENTED_MIPS(); 87 } 88 89 90 void VirtualFrame::SaveContextRegister() { 91 UNIMPLEMENTED_MIPS(); 92 } 93 94 95 void VirtualFrame::RestoreContextRegister() { 96 UNIMPLEMENTED_MIPS(); 97 } 98 99 100 void VirtualFrame::PushReceiverSlotAddress() { 101 UNIMPLEMENTED_MIPS(); 102 } 103 104 105 int VirtualFrame::InvalidateFrameSlotAt(int index) { 106 return kIllegalIndex; 107 } 108 109 110 void VirtualFrame::TakeFrameSlotAt(int index) { 111 UNIMPLEMENTED_MIPS(); 112 } 113 114 115 void VirtualFrame::StoreToFrameSlotAt(int index) { 116 UNIMPLEMENTED_MIPS(); 117 } 118 119 120 void VirtualFrame::PushTryHandler(HandlerType type) { 121 UNIMPLEMENTED_MIPS(); 122 } 123 124 125 void VirtualFrame::RawCallStub(CodeStub* stub) { 126 UNIMPLEMENTED_MIPS(); 127 } 128 129 130 void VirtualFrame::CallStub(CodeStub* stub, Result* arg) { 131 UNIMPLEMENTED_MIPS(); 132 } 133 134 135 void VirtualFrame::CallStub(CodeStub* stub, Result* arg0, Result* arg1) { 136 UNIMPLEMENTED_MIPS(); 137 } 138 139 140 void VirtualFrame::CallRuntime(Runtime::Function* f, int arg_count) { 141 UNIMPLEMENTED_MIPS(); 142 } 143 144 145 void VirtualFrame::CallRuntime(Runtime::FunctionId id, int arg_count) { 146 UNIMPLEMENTED_MIPS(); 147 } 148 149 150 void VirtualFrame::CallAlignedRuntime(Runtime::Function* f, int arg_count) { 151 UNIMPLEMENTED_MIPS(); 152 } 153 154 155 void VirtualFrame::CallAlignedRuntime(Runtime::FunctionId id, int arg_count) { 156 UNIMPLEMENTED_MIPS(); 157 } 158 159 160 void VirtualFrame::InvokeBuiltin(Builtins::JavaScript id, 161 InvokeJSFlags flags, 162 Result* arg_count_register, 163 int arg_count) { 164 UNIMPLEMENTED_MIPS(); 165 } 166 167 168 void VirtualFrame::RawCallCodeObject(Handle<Code> code, 169 RelocInfo::Mode rmode) { 170 UNIMPLEMENTED_MIPS(); 171 } 172 173 174 void VirtualFrame::CallCodeObject(Handle<Code> code, 175 RelocInfo::Mode rmode, 176 int dropped_args) { 177 UNIMPLEMENTED_MIPS(); 178 } 179 180 181 void VirtualFrame::CallCodeObject(Handle<Code> code, 182 RelocInfo::Mode rmode, 183 Result* arg, 184 int dropped_args) { 185 UNIMPLEMENTED_MIPS(); 186 } 187 188 189 void VirtualFrame::CallCodeObject(Handle<Code> code, 190 RelocInfo::Mode rmode, 191 Result* arg0, 192 Result* arg1, 193 int dropped_args, 194 bool set_auto_args_slots) { 195 UNIMPLEMENTED_MIPS(); 196 } 197 198 199 void VirtualFrame::Drop(int count) { 200 UNIMPLEMENTED_MIPS(); 201 } 202 203 204 void VirtualFrame::DropFromVFrameOnly(int count) { 205 UNIMPLEMENTED_MIPS(); 206 } 207 208 209 Result VirtualFrame::Pop() { 210 UNIMPLEMENTED_MIPS(); 211 Result res = Result(); 212 return res; // UNIMPLEMENTED RETUR 213 } 214 215 216 void VirtualFrame::EmitPop(Register reg) { 217 UNIMPLEMENTED_MIPS(); 218 } 219 220 void VirtualFrame::EmitMultiPop(RegList regs) { 221 UNIMPLEMENTED_MIPS(); 222 } 223 224 225 void VirtualFrame::EmitPush(Register reg) { 226 UNIMPLEMENTED_MIPS(); 227 } 228 229 void VirtualFrame::EmitMultiPush(RegList regs) { 230 UNIMPLEMENTED_MIPS(); 231 } 232 233 void VirtualFrame::EmitArgumentSlots(RegList reglist) { 234 UNIMPLEMENTED_MIPS(); 235 } 236 237 #undef __ 238 239 } } // namespace v8::internal 240 241