← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libv8/trusty

« back to all changes in this revision

Viewing changes to src/mips/debug-mips.cc

  • Committer: Package Import Robot
  • Author(s): Jérémy Lal
  • Date: 2012-02-20 14:08:17 UTC
  • mfrom: (15.1.24 sid)
  • Revision ID: package-import@ubuntu.com-20120220140817-bsvmeoa4sxsj5hbz
Tags: 3.7.12.22-3
Fix mipsel build, allow test debug-step-3 to fail (non-crucial)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mips/debug-mips.cc
124
124
static void Generate_DebugBreakCallHelper(MacroAssembler* masm,
125
125
                                          RegList object_regs,
126
126
                                          RegList non_object_regs) {
127
 
  __ EnterInternalFrame();
 
127
  {
 
128
    FrameScope scope(masm, StackFrame::INTERNAL);
128
129
 
129
 
  // Store the registers containing live values on the expression stack to
130
 
  // make sure that these are correctly updated during GC. Non object values
131
 
  // are stored as a smi causing it to be untouched by GC.
132
 
  ASSERT((object_regs & ~kJSCallerSaved) == 0);
133
 
  ASSERT((non_object_regs & ~kJSCallerSaved) == 0);
134
 
  ASSERT((object_regs & non_object_regs) == 0);
135
 
  if ((object_regs | non_object_regs) != 0) {
136
 
    for (int i = 0; i < kNumJSCallerSaved; i++) {
137
 
      int r = JSCallerSavedCode(i);
138
 
      Register reg = { r };
139
 
      if ((non_object_regs & (1 << r)) != 0) {
140
 
        if (FLAG_debug_code) {
141
 
          __ And(at, reg, 0xc0000000);
142
 
          __ Assert(eq, "Unable to encode value as smi", at, Operand(zero_reg));
 
130
    // Store the registers containing live values on the expression stack to
 
131
    // make sure that these are correctly updated during GC. Non object values
 
132
    // are stored as a smi causing it to be untouched by GC.
 
133
    ASSERT((object_regs & ~kJSCallerSaved) == 0);
 
134
    ASSERT((non_object_regs & ~kJSCallerSaved) == 0);
 
135
    ASSERT((object_regs & non_object_regs) == 0);
 
136
    if ((object_regs | non_object_regs) != 0) {
 
137
      for (int i = 0; i < kNumJSCallerSaved; i++) {
 
138
        int r = JSCallerSavedCode(i);
 
139
        Register reg = { r };
 
140
        if ((non_object_regs & (1 << r)) != 0) {
 
141
          if (FLAG_debug_code) {
 
142
            __ And(at, reg, 0xc0000000);
 
143
            __ Assert(
 
144
                eq, "Unable to encode value as smi", at, Operand(zero_reg));
 
145
          }
 
146
          __ sll(reg, reg, kSmiTagSize);
143
147
        }
144
 
        __ sll(reg, reg, kSmiTagSize);
145
148
      }
 
149
      __ MultiPush(object_regs | non_object_regs);
146
150
    }
147
 
    __ MultiPush(object_regs | non_object_regs);
148
 
  }
149
151
 
150
152
#ifdef DEBUG
151
 
  __ RecordComment("// Calling from debug break to runtime - come in - over");
 
153
    __ RecordComment("// Calling from debug break to runtime - come in - over");
152
154
#endif
153
 
  __ mov(a0, zero_reg);  // No arguments.
154
 
  __ li(a1, Operand(ExternalReference::debug_break(masm->isolate())));
155
 
 
156
 
  CEntryStub ceb(1);
157
 
  __ CallStub(&ceb);
158
 
 
159
 
  // Restore the register values from the expression stack.
160
 
  if ((object_regs | non_object_regs) != 0) {
161
 
    __ MultiPop(object_regs | non_object_regs);
162
 
    for (int i = 0; i < kNumJSCallerSaved; i++) {
163
 
      int r = JSCallerSavedCode(i);
164
 
      Register reg = { r };
165
 
      if ((non_object_regs & (1 << r)) != 0) {
166
 
        __ srl(reg, reg, kSmiTagSize);
167
 
      }
168
 
      if (FLAG_debug_code &&
169
 
          (((object_regs |non_object_regs) & (1 << r)) == 0)) {
170
 
        __ li(reg, kDebugZapValue);
 
155
    __ mov(a0, zero_reg);  // No arguments.
 
156
    __ li(a1, Operand(ExternalReference::debug_break(masm->isolate())));
 
157
 
 
158
    CEntryStub ceb(1);
 
159
    __ CallStub(&ceb);
 
160
 
 
161
    // Restore the register values from the expression stack.
 
162
    if ((object_regs | non_object_regs) != 0) {
 
163
      __ MultiPop(object_regs | non_object_regs);
 
164
      for (int i = 0; i < kNumJSCallerSaved; i++) {
 
165
        int r = JSCallerSavedCode(i);
 
166
        Register reg = { r };
 
167
        if ((non_object_regs & (1 << r)) != 0) {
 
168
          __ srl(reg, reg, kSmiTagSize);
 
169
        }
 
170
        if (FLAG_debug_code &&
 
171
            (((object_regs |non_object_regs) & (1 << r)) == 0)) {
 
172
          __ li(reg, kDebugZapValue);
 
173
        }
171
174
      }
172
175
    }
 
176
 
 
177
    // Leave the internal frame.
173
178
  }
174
179
 
175
 
  __ LeaveInternalFrame();
176
 
 
177
180
  // Now that the break point has been handled, resume normal execution by
178
181
  // jumping to the target address intended by the caller and that was
179
182
  // overwritten by the address of DebugBreakXXX.
256
259
}
257
260
 
258
261
 
259
 
void Debug::GenerateStubNoRegistersDebugBreak(MacroAssembler* masm) {
 
262
void Debug::GenerateCallFunctionStubDebugBreak(MacroAssembler* masm) {
260
263
  // ----------- S t a t e -------------
261
 
  //  No registers used on entry.
 
264
  //  -- a1 : function
262
265
  // -----------------------------------
263
 
  Generate_DebugBreakCallHelper(masm, 0, 0);
 
266
  Generate_DebugBreakCallHelper(masm, a1.bit(), 0);
264
267
}
265
268
 
266
269