Experimental: periodic merge from the bleeding edge branch to the code...

src/assembler-ia32.cc

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // 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.
 //
@@ skipping 51 matching lines @@
 XMMRegister xmm4 = { 4 };
 XMMRegister xmm5 = { 5 };
 XMMRegister xmm6 = { 6 };
 XMMRegister xmm7 = { 7 };
 
 
 // -----------------------------------------------------------------------------
 // Implementation of CpuFeatures
 
 // Safe default is no features.
-uint32_t CpuFeatures::supported_ = 0;
-uint32_t CpuFeatures::enabled_ = 0;
+uint64_t CpuFeatures::supported_ = 0;
+uint64_t CpuFeatures::enabled_ = 0;
 
 
-typedef int (*F0)();
-
 // The Probe method needs executable memory, so it uses Heap::CreateCode.
 // Allocation failure is silent and leads to safe default.
 void CpuFeatures::Probe() {
-  supported_ = 0;
+  ASSERT(Heap::HasBeenSetup());
+  ASSERT(supported_ == 0);
   if (Serializer::enabled()) return;  // No features if we might serialize.
+
   Assembler assm(NULL, 0);
-  Label done;
+  Label cpuid, done;
 #define __ assm.
   // Save old esp, since we are going to modify the stack.
   __ push(ebp);
   __ pushfd();
   __ push(ecx);
-  __ push(edx);
   __ push(ebx);
   __ mov(ebp, Operand(esp));
+
   // If we can modify bit 21 of the EFLAGS register, then CPUID is supported.
   __ pushfd();
   __ pop(eax);
   __ mov(edx, Operand(eax));
   __ xor_(eax, 0x200000);  // Flip bit 21.
   __ push(eax);
   __ popfd();
   __ pushfd();
   __ pop(eax);
   __ xor_(eax, Operand(edx));  // Different if CPUID is supported.
-  __ j(zero, &done);
-  // Invoke CPUID with 1 in eax to get feature information in edx.
+  __ j(not_zero, &cpuid);
+
+  // CPUID not supported. Clear the supported features in edx:eax.
+  __ xor_(eax, Operand(eax));
+  __ xor_(edx, Operand(edx));
+  __ jmp(&done);
+
+  // Invoke CPUID with 1 in eax to get feature information in
+  // ecx:edx. Temporarily enable CPUID support because we know it's
+  // safe here.
+  __ bind(&cpuid);
   __ mov(eax, 1);
-  // Temporarily force CPUID support, since we know it is safe here.
   supported_ = (1 << CPUID);
   { Scope fscope(CPUID);
     __ cpuid();
   }
   supported_ = 0;
-  // Return result in eax.
+
+  // Move the result from ecx:edx to edx:eax and make sure to mark the
+  // CPUID feature as supported.
   __ mov(eax, Operand(edx));
+  __ or_(eax, 1 << CPUID);
+  __ mov(edx, Operand(ecx));
+
+  // Done.
   __ bind(&done);
   __ mov(esp, Operand(ebp));
   __ pop(ebx);
-  __ pop(edx);
   __ pop(ecx);
   __ popfd();
   __ pop(ebp);
   __ ret(0);
 #undef __
+
   CodeDesc desc;
   assm.GetCode(&desc);
   Object* code =
       Heap::CreateCode(desc, NULL, Code::ComputeFlags(Code::STUB), NULL);
   if (!code->IsCode()) return;
-  F0 f = FUNCTION_CAST<F0>(Code::cast(code)->entry());
-  uint32_t res = f();
-  supported_ = (res | (1 << CPUID));
+  typedef uint64_t (*F0)();
+  F0 probe = FUNCTION_CAST<F0>(Code::cast(code)->entry());
+  supported_ = probe();
 }
 
 
 // -----------------------------------------------------------------------------
 // Implementation of Displacement
 
 void Displacement::init(Label* L, Type type) {
   ASSERT(!L->is_bound());
   int next = 0;
   if (L->is_linked()) {
@@ skipping 1478 matching lines @@
 
 
 void Assembler::fistp_s(const Operand& adr) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   EMIT(0xDB);
   emit_operand(ebx, adr);
 }
 
 
+void Assembler::fisttp_s(const Operand& adr) {
+  ASSERT(CpuFeatures::IsEnabled(CpuFeatures::SSE3));
+  EnsureSpace ensure_space(this);
+  last_pc_ = pc_;
+  EMIT(0xDB);
+  emit_operand(ecx, adr);
+}
+
+
 void Assembler::fist_s(const Operand& adr) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   EMIT(0xDB);
   emit_operand(edx, adr);
 }
 
 
 void Assembler::fistp_d(const Operand& adr) {
   EnsureSpace ensure_space(this);
@@ skipping 175 matching lines @@
 
 
 void Assembler::frndint() {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   EMIT(0xD9);
   EMIT(0xFC);
 }
 
 
+void Assembler::fnclex() {
+  EnsureSpace ensure_space(this);
+  last_pc_ = pc_;
+  EMIT(0xDB);
+  EMIT(0xE2);
+}
+
+
 void Assembler::sahf() {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   EMIT(0x9E);
 }
 
 
 void Assembler::setcc(Condition cc, Register reg) {
   ASSERT(reg.is_byte_register());
   EnsureSpace ensure_space(this);
@@ skipping 330 matching lines @@
   ASSERT(bound_label.is_bound());
   ASSERT(0 <= position);
   ASSERT(position + static_cast<int>(sizeof(uint32_t)) <= pc_offset());
   ASSERT(long_at(position) == 0);  // only initialize once!
 
   uint32_t label_loc = reinterpret_cast<uint32_t>(addr_at(bound_label.pos()));
   long_at_put(position, label_loc);
 }
 
 } }  // namespace v8::internal