| /* |
| * Copyright (c) 2012, 2018, 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. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| * |
| */ |
| |
| #ifndef SHARE_VM_JFR_UTILITIES_JFRBIGENDIAN_HPP |
| #define SHARE_VM_JFR_UTILITIES_JFRBIGENDIAN_HPP |
| |
| #include "memory/allocation.hpp" |
| #include "utilities/bytes.hpp" |
| #include "utilities/macros.hpp" |
| |
| #ifndef VM_LITTLE_ENDIAN |
| # define bigendian_16(x) (x) |
| # define bigendian_32(x) (x) |
| # define bigendian_64(x) (x) |
| #else |
| # define bigendian_16(x) Bytes::swap_u2(x) |
| # define bigendian_32(x) Bytes::swap_u4(x) |
| # define bigendian_64(x) Bytes::swap_u8(x) |
| #endif |
| |
| class JfrBigEndian : AllStatic { |
| private: |
| template <typename T> |
| static T read_bytes(const address location); |
| template <typename T> |
| static T read_unaligned(const address location); |
| public: |
| static bool platform_supports_unaligned_reads(void); |
| static bool is_aligned(const void* location, size_t size); |
| template <typename T> |
| static T read(const void* location); |
| }; |
| |
| inline bool JfrBigEndian::is_aligned(const void* location, size_t size) { |
| assert(size <= sizeof(u8), "just checking"); |
| if (size == sizeof(u1)) { |
| return true; |
| } |
| // check address alignment for datum access |
| return (((uintptr_t)location & (size -1)) == 0); |
| } |
| |
| template <> |
| inline u1 JfrBigEndian::read_bytes(const address location) { |
| return (*location & 0xFF); |
| } |
| |
| template <> |
| inline u2 JfrBigEndian::read_bytes(const address location) { |
| return Bytes::get_Java_u2(location); |
| } |
| |
| template <> |
| inline u4 JfrBigEndian::read_bytes(const address location) { |
| return Bytes::get_Java_u4(location); |
| } |
| |
| template <> |
| inline u8 JfrBigEndian::read_bytes(const address location) { |
| return Bytes::get_Java_u8(location); |
| } |
| |
| template <typename T> |
| inline T JfrBigEndian::read_unaligned(const address location) { |
| assert(location != NULL, "just checking"); |
| switch (sizeof(T)) { |
| case sizeof(u1) : |
| return read_bytes<u1>(location); |
| case sizeof(u2): |
| return read_bytes<u2>(location); |
| case sizeof(u4): |
| return read_bytes<u4>(location); |
| case sizeof(u8): |
| return read_bytes<u8>(location); |
| default: |
| assert(false, "not reach"); |
| } |
| return 0; |
| } |
| |
| inline bool JfrBigEndian::platform_supports_unaligned_reads(void) { |
| #if defined(IA32) || defined(AMD64) || defined(PPC) || defined(S390) |
| return true; |
| #elif defined(SPARC) || defined(ARM) || defined(AARCH64) |
| return false; |
| #else |
| #warning "Unconfigured platform" |
| return false; |
| #endif |
| } |
| |
| template<typename T> |
| inline T JfrBigEndian::read(const void* location) { |
| assert(location != NULL, "just checking"); |
| assert(sizeof(T) <= sizeof(u8), "no support for arbitrary sizes"); |
| if (sizeof(T) == sizeof(u1)) { |
| return *(T*)location; |
| } |
| if (is_aligned(location, sizeof(T)) || platform_supports_unaligned_reads()) { |
| // fastest case |
| switch (sizeof(T)) { |
| case sizeof(u1): |
| return *(T*)location; |
| case sizeof(u2): |
| return bigendian_16(*(T*)(location)); |
| case sizeof(u4): |
| return bigendian_32(*(T*)(location)); |
| case sizeof(u8): |
| return bigendian_64(*(T*)(location)); |
| } |
| } |
| return read_unaligned<T>((const address)location); |
| } |
| |
| #endif // SHARE_VM_JFR_UTILITIES_JFRBIGENDIAN_HPP |