forked from OSchip/llvm-project
54 lines
2.3 KiB
C++
54 lines
2.3 KiB
C++
//===-- sanitizer_local_address_space_view.h --------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// `LocalAddressSpaceView` provides the local (i.e. target and current address
|
|
// space are the same) implementation of the `AddressSpaveView` interface which
|
|
// provides a simple interface to load memory from another process (i.e.
|
|
// out-of-process)
|
|
//
|
|
// The `AddressSpaveView` interface requires that the type can be used as a
|
|
// template parameter to objects that wish to be able to operate in an
|
|
// out-of-process manner. In normal usage, objects are in-process and are thus
|
|
// instantiated with the `LocalAddressSpaceView` type. This type is used to
|
|
// load any pointers in instance methods. This implementation is effectively
|
|
// a no-op. When an object is to be used in an out-of-process manner it is
|
|
// instansiated with the `RemoteAddressSpaceView` type.
|
|
//
|
|
// By making `AddressSpaceView` a template parameter of an object, it can
|
|
// change its implementation at compile time which has no run time overhead.
|
|
// This also allows unifying in-process and out-of-process code which avoids
|
|
// code duplication.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#ifndef SANITIZER_LOCAL_ADDRES_SPACE_VIEW_H
|
|
#define SANITIZER_LOCAL_ADDRES_SPACE_VIEW_H
|
|
|
|
namespace __sanitizer {
|
|
struct LocalAddressSpaceView {
|
|
// Load memory `sizeof(T) * num_elements` bytes of memory
|
|
// from the target process (always local for this implementation)
|
|
// starting at address `target_address`. The local copy of
|
|
// this memory is returned as a pointer. It is guaranteed that
|
|
//
|
|
// * That the function will always return the same value
|
|
// for a given set of arguments.
|
|
// * That the memory returned is writable and that writes will persist.
|
|
//
|
|
// The lifetime of loaded memory is implementation defined.
|
|
template <typename T>
|
|
static T *Load(T *target_address, uptr num_elements = 1) {
|
|
// The target address space is the local address space so
|
|
// nothing needs to be copied. Just return the pointer.
|
|
return target_address;
|
|
}
|
|
};
|
|
} // namespace __sanitizer
|
|
|
|
#endif
|