1  //===-- sanitizer_local_address_space_view.h --------------------*- C++ -*-===//
       2  //
       3  // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
       4  // See https://llvm.org/LICENSE.txt for license information.
       5  // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
       6  //
       7  //===----------------------------------------------------------------------===//
       8  //
       9  // `LocalAddressSpaceView` provides the local (i.e. target and current address
      10  // space are the same) implementation of the `AddressSpaceView` interface which
      11  // provides a simple interface to load memory from another process (i.e.
      12  // out-of-process)
      13  //
      14  // The `AddressSpaceView` interface requires that the type can be used as a
      15  // template parameter to objects that wish to be able to operate in an
      16  // out-of-process manner. In normal usage, objects are in-process and are thus
      17  // instantiated with the `LocalAddressSpaceView` type. This type is used to
      18  // load any pointers in instance methods. This implementation is effectively
      19  // a no-op. When an object is to be used in an out-of-process manner it is
      20  // instantiated with the `RemoteAddressSpaceView` type.
      21  //
      22  // By making `AddressSpaceView` a template parameter of an object, it can
      23  // change its implementation at compile time which has no run time overhead.
      24  // This also allows unifying in-process and out-of-process code which avoids
      25  // code duplication.
      26  //
      27  //===----------------------------------------------------------------------===//
      28  #ifndef SANITIZER_LOCAL_ADDRES_SPACE_VIEW_H
      29  #define SANITIZER_LOCAL_ADDRES_SPACE_VIEW_H
      30  
      31  namespace __sanitizer {
      32  struct LocalAddressSpaceView {
      33    // Load memory `sizeof(T) * num_elements` bytes of memory from the target
      34    // process (always local for this implementation) starting at address
      35    // `target_address`. The local copy of this memory is returned as a pointer.
      36    // The caller should not write to this memory. The behaviour when doing so is
      37    // undefined. Callers should use `LoadWritable()` to get access to memory
      38    // that is writable.
      39    //
      40    // The lifetime of loaded memory is implementation defined.
      41    template <typename T>
      42    static const T *Load(const T *target_address, uptr num_elements = 1) {
      43      // The target address space is the local address space so
      44      // nothing needs to be copied. Just return the pointer.
      45      return target_address;
      46    }
      47  
      48    // Load memory `sizeof(T) * num_elements` bytes of memory from the target
      49    // process (always local for this implementation) starting at address
      50    // `target_address`. The local copy of this memory is returned as a pointer.
      51    // The memory returned may be written to.
      52    //
      53    // Writes made to the returned memory will be visible in the memory returned
      54    // by subsequent `Load()` or `LoadWritable()` calls provided the
      55    // `target_address` parameter is the same. It is not guaranteed that the
      56    // memory returned by previous calls to `Load()` will contain any performed
      57    // writes.  If two or more overlapping regions of memory are loaded via
      58    // separate calls to `LoadWritable()`, it is implementation defined whether
      59    // writes made to the region returned by one call are visible in the regions
      60    // returned by other calls.
      61    //
      62    // Given the above it is recommended to load the largest possible object
      63    // that requires modification (e.g. a class) rather than individual fields
      64    // from a class to avoid issues with overlapping writable regions.
      65    //
      66    // The lifetime of loaded memory is implementation defined.
      67    template <typename T>
      68    static T *LoadWritable(T *target_address, uptr num_elements = 1) {
      69      // The target address space is the local address space so
      70      // nothing needs to be copied. Just return the pointer.
      71      return target_address;
      72    }
      73  };
      74  }  // namespace __sanitizer
      75  
      76  #endif