truffle: src/cpu/x86/vm/stubGenerator_x86

comparison src/cpu/x86/vm/stubGenerator_x86_32.cpp @ 11173:6b0fd0964b87

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 31 Jul 2013 11:00:54 +0200
parents	40b8c383bc31 980532a806a5
children	58fc8e2b7b6d

comparison

equal deleted inserted replaced

-:4ea54634f03e
+:6b0fd0964b87
 /*
-* Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 class StubGenerator: public StubCodeGenerator {
 private:
 #ifdef PRODUCT
-#define inc_counter_np(counter) (0)
+#define inc_counter_np(counter) ((void)0)
 #else
 void inc_counter_np_(int& counter) {
 __ incrementl(ExternalAddress((address)&counter));
 }
 #define inc_counter_np(counter) \
 __ jmp(L_exit);
 return start;
 }
+/**
+*  Arguments:
+*
+* Inputs:
+*   rsp(4)   - int crc
+*   rsp(8)   - byte* buf
+*   rsp(12)  - int length
+*
+* Ouput:
+*       rax   - int crc result
+*/
+address generate_updateBytesCRC32() {
+assert(UseCRC32Intrinsics, "need AVX and CLMUL instructions");
+__ align(CodeEntryAlignment);
+StubCodeMark mark(this, "StubRoutines", "updateBytesCRC32");
+address start = __ pc();
+const Register crc   = rdx;  // crc
+const Register buf   = rsi;  // source java byte array address
+const Register len   = rcx;  // length
+const Register table = rdi;  // crc_table address (reuse register)
+const Register tmp   = rbx;
+assert_different_registers(crc, buf, len, table, tmp, rax);
+BLOCK_COMMENT("Entry:");
+__ enter(); // required for proper stackwalking of RuntimeStub frame
+__ push(rsi);
+__ push(rdi);
+__ push(rbx);
+Address crc_arg(rbp, 8 + 0);
+Address buf_arg(rbp, 8 + 4);
+Address len_arg(rbp, 8 + 8);
+// Load up:
+__ movl(crc,   crc_arg);
+__ movptr(buf, buf_arg);
+__ movl(len,   len_arg);
+__ kernel_crc32(crc, buf, len, table, tmp);
+__ movl(rax, crc);
+__ pop(rbx);
+__ pop(rdi);
+__ pop(rsi);
+__ leave(); // required for proper stackwalking of RuntimeStub frame
+__ ret(0);
+return start;
+}
+// Safefetch stubs.
+void generate_safefetch(const char* name, int size, address* entry,
+address* fault_pc, address* continuation_pc) {
+// safefetch signatures:
+//   int      SafeFetch32(int*      adr, int      errValue);
+//   intptr_t SafeFetchN (intptr_t* adr, intptr_t errValue);
+StubCodeMark mark(this, "StubRoutines", name);
+// Entry point, pc or function descriptor.
+*entry = __ pc();
+__ movl(rax, Address(rsp, 0x8));
+__ movl(rcx, Address(rsp, 0x4));
+// Load *adr into eax, may fault.
+*fault_pc = __ pc();
+switch (size) {
+case 4:
+// int32_t
+__ movl(rax, Address(rcx, 0));
+break;
+case 8:
+// int64_t
+Unimplemented();
+break;
+default:
+ShouldNotReachHere();
+}
+// Return errValue or *adr.
+*continuation_pc = __ pc();
+__ ret(0);
+}
 public:
 // Information about frame layout at time of blocking runtime call.
 // Note that we only have to preserve callee-saved registers since
 // the compilers are responsible for supplying a continuation point
 StubRoutines::_d2l_wrapper                              = generate_d2i_wrapper(T_LONG,
 CAST_FROM_FN_PTR(address, SharedRuntime::d2l));
 // Build this early so it's available for the interpreter
 StubRoutines::_throw_StackOverflowError_entry          = generate_throw_exception("StackOverflowError throw_exception",           CAST_FROM_FN_PTR(address, SharedRuntime::throw_StackOverflowError));
+if (UseCRC32Intrinsics) {
+// set table address before stub generation which use it
+StubRoutines::_crc_table_adr = (address)StubRoutines::x86::_crc_table;
+StubRoutines::_updateBytesCRC32 = generate_updateBytesCRC32();
+}
 }
 void generate_all() {
 // Generates all stubs and initializes the entry points
 StubRoutines::_aescrypt_encryptBlock = generate_aescrypt_encryptBlock();
 StubRoutines::_aescrypt_decryptBlock = generate_aescrypt_decryptBlock();
 StubRoutines::_cipherBlockChaining_encryptAESCrypt = generate_cipherBlockChaining_encryptAESCrypt();
 StubRoutines::_cipherBlockChaining_decryptAESCrypt = generate_cipherBlockChaining_decryptAESCrypt();
 }
+// Safefetch stubs.
+generate_safefetch("SafeFetch32", sizeof(int), &StubRoutines::_safefetch32_entry,
+&StubRoutines::_safefetch32_fault_pc,
+&StubRoutines::_safefetch32_continuation_pc);
+StubRoutines::_safefetchN_entry           = StubRoutines::_safefetch32_entry;
+StubRoutines::_safefetchN_fault_pc        = StubRoutines::_safefetch32_fault_pc;
+StubRoutines::_safefetchN_continuation_pc = StubRoutines::_safefetch32_continuation_pc;
 }
 public:
 StubGenerator(CodeBuffer* code, bool all) : StubCodeGenerator(code) {

Mercurial > hg > truffle

comparison src/cpu/x86/vm/stubGenerator_x86_32.cpp @ 11173:6b0fd0964b87