Merge bleeding edge into the GC branch up to 7948. The asserts

src/ia32/macro-assembler-ia32.h

 // Copyright 2011 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
@@ skipping 11 matching lines @@
 // 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.
 
 #ifndef V8_IA32_MACRO_ASSEMBLER_IA32_H_
 #define V8_IA32_MACRO_ASSEMBLER_IA32_H_
 
 #include "assembler.h"
-#include "type-info.h"
+#include "v8globals.h"
 
 namespace v8 {
 namespace internal {
 
 // Flags used for the AllocateInNewSpace functions.
 enum AllocationFlags {
   // No special flags.
   NO_ALLOCATION_FLAGS = 0,
   // Return the pointer to the allocated already tagged as a heap object.
   TAG_OBJECT = 1 << 0,
   // The content of the result register already contains the allocation top in
   // new space.
   RESULT_CONTAINS_TOP = 1 << 1
 };
 
+
 // Convenience for platform-independent signatures.  We do not normally
 // distinguish memory operands from other operands on ia32.
 typedef Operand MemOperand;
 
 enum EmitRememberedSet { EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET };
 enum SmiCheck { INLINE_SMI_CHECK, OMIT_SMI_CHECK };
 
 
 bool Aliasing(Register r1, Register r2, Register r3, Register r4);
 
@@ skipping 16 matching lines @@
 
   // For page containing |object| mark region covering |addr| dirty.
   // RememberedSetHelper only works if the object is not in new
   // space.
   void RememberedSetHelper(Register addr,
                            Register scratch,
                            SaveFPRegsMode save_fp);
 
   // Check if object is in new space.
   // scratch can be object itself, but it will be clobbered.
-  template <typename LabelType>
   void InNewSpace(Register object,
                   Register scratch,
                   Condition cc,  // equal for new space, not_equal otherwise.
-                  LabelType* branch);
+                  Label* branch,
+                  Label::Distance branch_distance = Label::kFar);
 
-  template<typename LabelType>
-  void CheckPageFlag(Register object,
-                     Register scratch,
-                     MemoryChunk::MemoryChunkFlags flag,
-                     Condition cc,
-                     LabelType* condition_met);
+  inline void CheckPageFlag(
+      Register object,
+      Register scratch,
+      MemoryChunk::MemoryChunkFlags flag,
+      Condition cc,
+      Label* condition_met,
+      Label::Distance condition_met_distance = Label::kFar);
 
   // Check if an object has a given incremental marking colour.  Also uses ecx!
   // The colour bits are found by splitting the address at the bit offset
   // indicated by the mask: bits that are zero in the mask are used for the
   // address of the bitmap, and bits that are one in the mask are used for the
   // index of the bit.
-  template <typename LabelType>
-  void HasColour(Register object,
-                 Register scratch0,
-                 Register scratch1,
-                 LabelType* has_colour,
-                 int first_bit,
-                 int second_bit);
+  inline void HasColour(Register object,
+                        Register scratch0,
+                        Register scratch1,
+                        Label* has_colour,
+                        Label::Distance has_colour_distance,
+                        int first_bit,
+                        int second_bit);
 
-  template <typename LabelType>
-  void InOldSpaceIsBlack(Register object,
-                         Register scratch0,
-                         Register scratch1,
-                         LabelType* is_black);
+  inline void InOldSpaceIsBlack(
+      Register object,
+      Register scratch0,
+      Register scratch1,
+      Label* is_black,
+      Label::Distance is_black_distance = Label::kFar);
 
-  template <typename LabelType>
-  void InNewSpaceIsBlack(Register object,
-                         Register scratch0,
-                         Register scratch1,
-                         LabelType* is_black);
+  inline void InNewSpaceIsBlack(
+      Register object,
+      Register scratch0,
+      Register scratch1,
+      Label* is_black,
+      Label::Distance is_black_distance = Label::kFar);
 
   // Checks the colour 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.
-  template <typename LabelType>
-  void EnsureNotWhite(Register object,
-                      Register scratch1,
-                      Register scratch2,
-                      LabelType* object_is_white_and_not_data,
-                      bool in_new_space);
+  inline void EnsureNotWhite(Register object,
+                             Register scratch1,
+                             Register scratch2,
+                             Label* object_is_white_and_not_data,
+                             Label::Distance distance,
+                             bool in_new_space);
 
   // Checks whether an object is data-only, ie it does need to be scanned by the
   // garbage collector.
-  template <typename LabelType>
-  void IsDataObject(Register value,
-                    Register scratch,
-                    LabelType* not_data_object,
-                    bool in_new_space);
+  inline void IsDataObject(Register value,
+                           Register scratch,
+                           Label* not_data_object,
+                           Label::Distance not_data_object_distance,
+                           bool in_new_space);
 
   // 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.  All registers are clobbered by the operation.  RecordWriteField
   // filters out smis so it does not update the write barrier if the value is a
   // smi.  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,
@@ skipping 138 matching lines @@
   // Store the function for the given builtin in the target register.
   void GetBuiltinFunction(Register target, Builtins::JavaScript id);
 
   // Store the code object for the given builtin in the target register.
   void GetBuiltinEntry(Register target, Builtins::JavaScript id);
 
   // Expression support
   void Set(Register dst, const Immediate& x);
   void Set(const Operand& dst, const Immediate& x);
 
+  // Support for constant splitting.
+  bool IsUnsafeImmediate(const Immediate& x);
+  void SafeSet(Register dst, const Immediate& x);
+  void SafePush(const Immediate& x);
+
   // Compare object type for heap object.
   // Incoming register is heap_object and outgoing register is map.
   void CmpObjectType(Register heap_object, InstanceType type, Register map);
 
   // Compare instance type for map.
   void CmpInstanceType(Register map, InstanceType type);
 
-  // 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)
+  // 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)
   void CheckMap(Register obj,
                 Handle<Map> map,
                 Label* fail,
-                bool is_heap_object);
+                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,
+                   Handle<Map> map,
+                   Handle<Code> success,
+                   SmiCheckType smi_check_type);
 
   // Check if the object in register heap_object is a string. Afterwards the
   // register map contains the object map and the register instance_type
   // contains the instance_type. The registers map and instance_type can be the
   // same in which case it contains the instance type afterwards. Either of the
   // registers map and instance_type can be the same as heap_object.
   Condition IsObjectStringType(Register heap_object,
                                Register map,
                                Register instance_type);
 
   // Check if a heap object's type is in the JSObject range, not including
   // JSFunction.  The object's map will be loaded in the map register.
   // Any or all of the three registers may be the same.
   // The contents of the scratch register will always be overwritten.
   void IsObjectJSObjectType(Register heap_object,
                             Register map,
                             Register scratch,
                             Label* fail);
 
   // The contents of the scratch register will be overwritten.
   void IsInstanceJSObjectType(Register map, Register scratch, Label* fail);
 
   // FCmp is similar to integer cmp, but requires unsigned
   // jcc instructions (je, ja, jae, jb, jbe, je, and jz).
   void FCmp();
 
+  void ClampUint8(Register reg);
+
+  void ClampDoubleToUint8(XMMRegister input_reg,
+                          XMMRegister scratch_reg,
+                          Register result_reg);
+
+
   // Smi tagging support.
   void SmiTag(Register reg) {
     ASSERT(kSmiTag == 0);
     ASSERT(kSmiTagSize == 1);
     add(reg, Operand(reg));
   }
   void SmiUntag(Register reg) {
     sar(reg, kSmiTagSize);
   }
 
   // Modifies the register even if it does not contain a Smi!
-  void SmiUntag(Register reg, TypeInfo info, Label* non_smi) {
-    ASSERT(kSmiTagSize == 1);
-    sar(reg, kSmiTagSize);
-    if (info.IsSmi()) {
-      ASSERT(kSmiTag == 0);
-      j(carry, non_smi);
-    }
-  }
-
-  // Modifies the register even if it does not contain a Smi!
   void SmiUntag(Register reg, Label* is_smi) {
     ASSERT(kSmiTagSize == 1);
     sar(reg, kSmiTagSize);
     ASSERT(kSmiTag == 0);
     j(not_carry, is_smi);
   }
 
   // Jump the register contains a smi.
   inline void JumpIfSmi(Register value, Label* smi_label) {
     test(value, Immediate(kSmiTagMask));
-    j(zero, smi_label, not_taken);
+    j(zero, smi_label);
   }
   // Jump if register contain a non-smi.
   inline void JumpIfNotSmi(Register value, Label* not_smi_label) {
     test(value, Immediate(kSmiTagMask));
-    j(not_zero, not_smi_label, not_taken);
+    j(not_zero, not_smi_label);
   }
 
-  // Assumes input is a heap object.
-  void JumpIfNotNumber(Register reg, TypeInfo info, Label* on_not_number);
-
-  // Assumes input is a heap number.  Jumps on things out of range.  Also jumps
-  // on the min negative int32.  Ignores frational parts.
-  void ConvertToInt32(Register dst,
-                      Register src,      // Can be the same as dst.
-                      Register scratch,  // Can be no_reg or dst, but not src.
-                      TypeInfo info,
-                      Label* on_not_int32);
-
   void LoadPowerOf2(XMMRegister dst, Register scratch, int power);
 
   // Abort execution if argument is not a number. Used in debug code.
   void AbortIfNotNumber(Register object);
 
   // Abort execution if argument is not a smi. Used in debug code.
   void AbortIfNotSmi(Register object);
 
   // Abort execution if argument is a smi. Used in debug code.
   void AbortIfSmi(Register object);
@@ skipping 343 matching lines @@
   bool generating_stub_;
   bool allow_stub_calls_;
   // This handle will be patched with the code object on installation.
   Handle<Object> code_object_;
 
   // Helper functions for generating invokes.
   void InvokePrologue(const ParameterCount& expected,
                       const ParameterCount& actual,
                       Handle<Code> code_constant,
                       const Operand& code_operand,
-                      NearLabel* done,
+                      Label* done,
                       InvokeFlag flag,
+                      Label::Distance done_distance,
                       const CallWrapper& call_wrapper = NullCallWrapper());
 
   // Activation support.
   void EnterFrame(StackFrame::Type type);
   void LeaveFrame(StackFrame::Type type);
 
   void EnterExitFramePrologue();
   void EnterExitFrameEpilogue(int argc, bool save_doubles);
 
   void LeaveExitFrameEpilogue();
@@ skipping 22 matching lines @@
   // Compute memory operands for safepoint stack slots.
   Operand SafepointRegisterSlot(Register reg);
   static int SafepointRegisterStackIndex(int reg_code);
 
   // Needs access to SafepointRegisterStackIndex for optimized frame
   // traversal.
   friend class OptimizedFrame;
 };
 
 
-template <typename LabelType>
-void MacroAssembler::InNewSpace(Register object,
-                                Register scratch,
-                                Condition cc,
-                                LabelType* branch) {
-  ASSERT(cc == equal || cc == not_equal);
-  if (Serializer::enabled()) {
-    // Can't do arithmetic on external references if it might get serialized.
-    Move(scratch, object);
-    // The mask isn't really an address.  We load it as an external reference in
-    // case the size of the new space is different between the snapshot maker
-    // and the running system.
-    and_(Operand(scratch),
-         Immediate(ExternalReference::new_space_mask(isolate())));
-    cmp(Operand(scratch),
-        Immediate(ExternalReference::new_space_start(isolate())));
-    j(cc, branch);
-  } else {
-    int32_t new_space_start = reinterpret_cast<int32_t>(
-        ExternalReference::new_space_start(isolate()).address());
-    if (object.is(scratch)) {
-      sub(Operand(scratch), Immediate(new_space_start));
-    } else {
-      lea(scratch, Operand(object, -new_space_start));
-    }
-    and_(scratch, isolate()->heap()->NewSpaceMask());
-    j(cc, branch);
-  }
-}
-
-
 // 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. Is not legal to emit
 // relocation information. If any of these constraints are violated it causes
 // an assertion.
 class CodePatcher {
  public:
   CodePatcher(byte* address, int size);
   virtual ~CodePatcher();
 
@@ skipping 57 matching lines @@
   }                                                                       \
   masm->
 #else
 #define ACCESS_MASM(masm) masm->
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_IA32_MACRO_ASSEMBLER_IA32_H_