flang/runtime/temporary-stack.cpp

   1 //===-- runtime/temporary-stack.cpp ---------------------------------------===//
   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 // Implements std::vector like storage for a dynamically resizable number of
  10 // temporaries. For use in HLFIR lowering.
  11
  12 #include "flang/Runtime/temporary-stack.h"
  13 #include "terminator.h"
  14 #include "flang/ISO_Fortran_binding_wrapper.h"
  15 #include "flang/Runtime/assign.h"
  16 #include "flang/Runtime/descriptor.h"
  17 #include "flang/Runtime/memory.h"
  18
  19 namespace {
  20
  21 using namespace Fortran::runtime;
  22
  23 // the number of elements to allocate when first creating the vector
  24 constexpr size_t INITIAL_ALLOC = 8;
  25
  26 /// To store C style data. Does not run constructors/destructors.
  27 /// Not using std::vector to avoid linking the runtime library to stdc++
  28 template <bool COPY_VALUES> class DescriptorStorage final {
  29   using size_type = uint64_t; // see checkedMultiply()
  30
  31   size_type capacity_{0};
  32   size_type size_{0};
  33   Descriptor **data_{nullptr};
  34   Terminator terminator_;
  35
  36   // return true on overflow
  37   static bool checkedMultiply(size_type x, size_type y, size_type &res);
  38
  39   void resize(size_type newCapacity);
  40
  41   Descriptor *cloneDescriptor(const Descriptor &source);
  42
  43 public:
  44   DescriptorStorage(const char *sourceFile, int line);
  45   ~DescriptorStorage();
  46
  47   // `new` but using the runtime allocation API
  48   static inline DescriptorStorage *allocate(const char *sourceFile, int line) {
  49     Terminator term{sourceFile, line};
  50     void *ptr = AllocateMemoryOrCrash(term, sizeof(DescriptorStorage));
  51     return new (ptr) DescriptorStorage{sourceFile, line};
  52   }
  53
  54   // `delete` but using the runtime allocation API
  55   static inline void destroy(DescriptorStorage *instance) {
  56     instance->~DescriptorStorage();
  57     FreeMemory(instance);
  58   }
  59
  60   // clones a descriptor into this storage
  61   void push(const Descriptor &source);
  62
  63   // out must be big enough to hold a descriptor of the right rank and addendum
  64   void pop(Descriptor &out);
  65
  66   // out must be big enough to hold a descriptor of the right rank and addendum
  67   void at(size_type i, Descriptor &out);
  68 };
  69
  70 using ValueStack = DescriptorStorage</*COPY_VALUES=*/true>;
  71 using DescriptorStack = DescriptorStorage</*COPY_VALUES=*/false>;
  72 } // namespace
  73
  74 template <bool COPY_VALUES>
  75 bool DescriptorStorage<COPY_VALUES>::checkedMultiply(
  76     size_type x, size_type y, size_type &res) {
  77   // TODO: c++20 [[unlikely]]
  78   if (x > UINT64_MAX / y) {
  79     return true;
  80   }
  81   res = x * y;
  82   return false;
  83 }
  84
  85 template <bool COPY_VALUES>
  86 void DescriptorStorage<COPY_VALUES>::resize(size_type newCapacity) {
  87   if (newCapacity <= capacity_) {
  88     return;
  89   }
  90   size_type bytes;
  91   if (checkedMultiply(newCapacity, sizeof(Descriptor *), bytes)) {
  92     terminator_.Crash("temporary-stack: out of memory");
  93   }
  94   Descriptor **newData =
  95       static_cast<Descriptor **>(AllocateMemoryOrCrash(terminator_, bytes));
  96   // "memcpy" in glibc has a "nonnull" attribute on the source pointer.
  97   // Avoid passing a null pointer, since it would result in an undefined
  98   // behavior.
  99   if (data_ != nullptr) {
 100     memcpy(newData, data_, capacity_ * sizeof(Descriptor *));
 101     FreeMemory(data_);
 102   }
 103   data_ = newData;
 104   capacity_ = newCapacity;
 105 }
 106
 107 template <bool COPY_VALUES>
 108 Descriptor *DescriptorStorage<COPY_VALUES>::cloneDescriptor(
 109     const Descriptor &source) {
 110   const std::size_t bytes = source.SizeInBytes();
 111   void *memory = AllocateMemoryOrCrash(terminator_, bytes);
 112   Descriptor *desc = new (memory) Descriptor{source};
 113   return desc;
 114 }
 115
 116 template <bool COPY_VALUES>
 117 DescriptorStorage<COPY_VALUES>::DescriptorStorage(
 118     const char *sourceFile, int line)
 119     : terminator_{sourceFile, line} {
 120   resize(INITIAL_ALLOC);
 121 }
 122
 123 template <bool COPY_VALUES>
 124 DescriptorStorage<COPY_VALUES>::~DescriptorStorage() {
 125   for (size_type i = 0; i < size_; ++i) {
 126     Descriptor *element = data_[i];
 127     if constexpr (COPY_VALUES) {
 128       element->Destroy(false, true);
 129     }
 130     FreeMemory(element);
 131   }
 132   FreeMemory(data_);
 133 }
 134
 135 template <bool COPY_VALUES>
 136 void DescriptorStorage<COPY_VALUES>::push(const Descriptor &source) {
 137   if (size_ == capacity_) {
 138     size_type newSize;
 139     if (checkedMultiply(capacity_, 2, newSize)) {
 140       terminator_.Crash("temporary-stack: out of address space");
 141     }
 142     resize(newSize);
 143   }
 144   data_[size_] = cloneDescriptor(source);
 145   Descriptor &box = *data_[size_];
 146   size_ += 1;
 147
 148   if constexpr (COPY_VALUES) {
 149     // copy the data pointed to by the box
 150     box.set_base_addr(nullptr);
 151     box.Allocate();
 152     RTNAME(AssignTemporary)
 153     (box, source, terminator_.sourceFileName(), terminator_.sourceLine());
 154   }
 155 }
 156
 157 template <bool COPY_VALUES>
 158 void DescriptorStorage<COPY_VALUES>::pop(Descriptor &out) {
 159   if (size_ == 0) {
 160     terminator_.Crash("temporary-stack: pop empty storage");
 161   }
 162   size_ -= 1;
 163   Descriptor *ptr = data_[size_];
 164   out = *ptr; // Descriptor::operator= handles the different sizes
 165   FreeMemory(ptr);
 166 }
 167
 168 template <bool COPY_VALUES>
 169 void DescriptorStorage<COPY_VALUES>::at(size_type i, Descriptor &out) {
 170   if (i >= size_) {
 171     terminator_.Crash("temporary-stack: out of bounds access");
 172   }
 173   Descriptor *ptr = data_[i];
 174   out = *ptr; // Descriptor::operator= handles the different sizes
 175 }
 176
 177 inline static ValueStack *getValueStorage(void *opaquePtr) {
 178   return static_cast<ValueStack *>(opaquePtr);
 179 }
 180 inline static DescriptorStack *getDescriptorStorage(void *opaquePtr) {
 181   return static_cast<DescriptorStack *>(opaquePtr);
 182 }
 183
 184 namespace Fortran::runtime {
 185 extern "C" {
 186 void *RTNAME(CreateValueStack)(const char *sourceFile, int line) {
 187   return ValueStack::allocate(sourceFile, line);
 188 }
 189
 190 void RTNAME(PushValue)(void *opaquePtr, const Descriptor &value) {
 191   getValueStorage(opaquePtr)->push(value);
 192 }
 193
 194 void RTNAME(PopValue)(void *opaquePtr, Descriptor &value) {
 195   getValueStorage(opaquePtr)->pop(value);
 196 }
 197
 198 void RTNAME(ValueAt)(void *opaquePtr, uint64_t i, Descriptor &value) {
 199   getValueStorage(opaquePtr)->at(i, value);
 200 }
 201
 202 void RTNAME(DestroyValueStack)(void *opaquePtr) {
 203   ValueStack::destroy(getValueStorage(opaquePtr));
 204 }
 205
 206 void *RTNAME(CreateDescriptorStack)(const char *sourceFile, int line) {
 207   return DescriptorStack::allocate(sourceFile, line);
 208 }
 209
 210 void RTNAME(PushDescriptor)(void *opaquePtr, const Descriptor &value) {
 211   getDescriptorStorage(opaquePtr)->push(value);
 212 }
 213
 214 void RTNAME(PopDescriptor)(void *opaquePtr, Descriptor &value) {
 215   getDescriptorStorage(opaquePtr)->pop(value);
 216 }
 217
 218 void RTNAME(DescriptorAt)(void *opaquePtr, uint64_t i, Descriptor &value) {
 219   getValueStorage(opaquePtr)->at(i, value);
 220 }
 221
 222 void RTNAME(DestroyDescriptorStack)(void *opaquePtr) {
 223   DescriptorStack::destroy(getDescriptorStorage(opaquePtr));
 224 }
 225
 226 } // extern "C"
 227 } // namespace Fortran::runtime