diff options
Diffstat (limited to '')
-rw-r--r-- | src/seastar/include/seastar/core/unaligned.hh | 78 |
1 files changed, 78 insertions, 0 deletions
diff --git a/src/seastar/include/seastar/core/unaligned.hh b/src/seastar/include/seastar/core/unaligned.hh new file mode 100644 index 000000000..78ce39bac --- /dev/null +++ b/src/seastar/include/seastar/core/unaligned.hh @@ -0,0 +1,78 @@ +/* + * This file is open source software, licensed to you under the terms + * of the Apache License, Version 2.0 (the "License"). See the NOTICE file + * distributed with this work for additional information regarding copyright + * ownership. You may not use this file except in compliance with the License. + * + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +/* + * Copyright (C) 2015 Cloudius Systems, Ltd. + */ + +#pragma once + +// The following unaligned_cast<T*>(p) is a portable replacement for +// reinterpret_cast<T*>(p) which should be used every time address p +// is not guaranteed to be properly aligned to alignof(T). +// +// On architectures like x86 and ARM, where unaligned access is allowed, +// unaligned_cast will behave the same as reinterpret_cast and will generate +// the same code. +// +// Certain architectures (e.g., MIPS) make it extremely slow or outright +// forbidden to use ordinary machine instructions on a primitive type at an +// unaligned addresses - e.g., access a uint32_t at an address which is not +// a multiple of 4. Gcc's "undefined behavior sanitizer" (enabled in our debug +// build) also catches such unaligned accesses and reports them as errors, +// even when running on x86. +// +// Therefore, reinterpret_cast<int32_t*> on an address which is not guaranteed +// to be a multiple of 4 may generate extremely slow code or runtime errors, +// and must be avoided. The compiler needs to be told about the unaligned +// access, so it can generate reasonably-efficient code for the access +// (in MIPS, this means generating two instructions "lwl" and "lwr", instead +// of the one instruction "lw" which faults on unaligned/ access). The way to +// tell the compiler this is with __attribute__((packed)). This will also +// cause the sanitizer not to generate runtime alignment checks for this +// access. + +#include <type_traits> + +namespace seastar { + +template <typename T> +struct unaligned { + // This is made to support only simple types, so it is fine to + // require them to be trivially copy constructible. + static_assert(std::is_trivially_copy_constructible_v<T>); + T raw; + unaligned() noexcept = default; + unaligned(T x) noexcept : raw(x) {} + unaligned& operator=(const T& x) noexcept { raw = x; return *this; } + operator T() const noexcept { return raw; } +} __attribute__((packed)); + + +// deprecated: violates strict aliasing rules +template <typename T, typename F> +inline auto unaligned_cast(F* p) noexcept { + return reinterpret_cast<unaligned<std::remove_pointer_t<T>>*>(p); +} + +// deprecated: violates strict aliasing rules +template <typename T, typename F> +inline auto unaligned_cast(const F* p) noexcept { + return reinterpret_cast<const unaligned<std::remove_pointer_t<T>>*>(p); +} + +} |