migrate code to AS7, including fucked up arduino import

arduino as a library will not build with -flto. I can't figure it out. so we
waste some space compared to what platformio was building. oh well. there's
still over 1K of space left for programs.

fw/HackSpaceCon_AS7/Arduino/megatinycore/new.cpp

@@ -0,0 +1,180 @@
+/*
+  Copyright (c) 2014 Arduino.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library 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 Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+  Updated 2020-21 Spence Konde to support C++ 14 sized
+  dealocations, and give useful compile errors when aligned
+  new and delete operators are referenced. I do not think adding
+  support for them is warranted at this time, though we have
+  candidates for the simplest of them, both were written by
+  @henrygab (Henry Gabryjelski, which is fitting because that's
+  who asked for C++ 17 mode, over on ATTinyCore, but releases
+  are more frequent for the new parts, and this is equally
+  applicable to all of the cores.)
+*/
+
+#include <stdlib.h>
+
+// For C++11, only need the following:
+void *operator new  (size_t size) {
+  return malloc(size);
+}
+
+void *operator new[](size_t size) {
+  return malloc(size);
+}
+
+void  operator delete  (void * ptr) {
+  free(ptr);
+}
+
+void  operator delete[](void * ptr) {
+  free(ptr);
+}
+
+void * operator new  (size_t size, void * ptr) noexcept {
+  (void)size;
+  return ptr;
+}
+
+void * operator new[](size_t size, void * ptr) noexcept {
+  (void)size;
+  return ptr;
+}
+
+// Since C++14, also need two more delete variants...
+// Note thnat this CAN break code that compiled amd worked in C++11.
+#if (__cpp_sized_deallocation >= 201309L)
+  void  operator delete  (void* ptr, size_t size) noexcept {
+    (void) size;
+    free(ptr);
+  }
+  void  operator delete[](void* ptr, size_t size) noexcept {
+    (void) size;
+    free(ptr);
+  }
+#endif
+
+// Since C++17, there's four more each for new / delete, to support allocation
+// of objects with alignment greater than __STDCPP_DEFAULT_NEW_ALIGNMENT__.
+// Almost the entirety of AVR is using C++ 11. Any code that works elsewhere, but NOT on these cores and give these error messages either
+// is trying to get alignment that it doesn't actually need, or is - by sheet luck - ending up with the addresses which worked. E
+#if (__cpp_aligned_new >= 201606L)
+  #if !defined(LTODISABLED)
+  void badAlloc(const char*) __attribute__((error("")));
+  #endif
+
+  void* operator new  (size_t size, std::align_val_t al) {
+    #if !defined(LTODISABLED)
+      badAlloc("Alignment aware new/delete operators, a C++ 17 feaure, are not supported by this core or any other AVR cores at this point in time");
+    #endif
+    (void) al;
+    return malloc(size);
+  }
+
+/*
+void* operator new  (size_t size, std::align_val_t al) {
+
+  if (al <= alignof(std::max_align_t)) {
+      return malloc(size);
+  }
+
+  // how many extra bytes required to ensure can find an aligned pointer?
+  size_t toAllocate = size + (al - alignof(std::max_align_t)) - 1;
+  toAllocate += sizeof(uintptr_t);  // to store the original pointer
+
+  uintptr_t allocated = malloc(toAllocate);
+
+  // ensure to save space for the back-pointer.
+  uintptr_t alignedPtr = allocated + sizeof(uintptr_t);
+
+  size_t mask = al  1; // alignment mask ... the bits that must be zero
+  uintptr_t alignedPtr =
+      (allocated & mask) == 0 ?
+      allocated :
+      (allocated & (~mask)) + al;
+
+  // save the original pointer just before the pointer value returned to caller
+  static_assert(alignof(uintptr_t) <= alignof(std::max_align_t), "" );
+  uintptr_t* storeOriginalPointerAt = (uintptr_t)(alignedPtr - sizeof(uintptr_t));
+  *storeOriginalPointerAt = allocated;
+
+  return alignedPtr;
+}
+*/
+
+  void* operator new[](size_t size, std::align_val_t al) {
+    #if !defined(LTODISABLED)
+      badAlloc("Alignment aware new/delete operators, a C++ 17 feaure, are not supported by this core or any other AVR cores at this point in time");
+    #endif
+    (void) al;
+    return malloc(size);
+  }
+  void  operator delete  (void* ptr, std::align_val_t al) noexcept {
+    #if !defined(LTODISABLED)
+      badAlloc("Alignment aware new/delete operators, a C++ 17 feaure, are not supported by this core or any other AVR cores at this point in time");
+    #endif
+    (void) al;
+    free(ptr);
+  }
+  /*
+  void operator delete (void* ptr, std::align_val_t al) noexcept {
+
+    if (al <= STDCPP_DEFAULT_NEW_ALIGNMENT) {
+        free(ptr);
+        return;
+    }
+
+    // Get the original pointer value from just prior to the provided pointer.
+    uintptr_t aligned = ptr;
+    uintptr_t tmp = aligned - sizeof(uintptr_t); // go back 2 bytes
+    uintptr_t original = *((uintptr_t *)tmp); // extract the original pointer
+
+    // sanity check the original value... for iot, infinite loop recommended
+    // as it's better than memory corruption!rhy
+    size_t overhead = (al - STDCPP_DEFAULT_NEW_ALIGNMENT) + sizeof(uintptr_t);
+    assert(original < aligned);
+    assert(original + overhead <= aligned);
+
+    // and finally free the original memory
+    free(original);
+  }
+  */
+  void  operator delete[](void* ptr, std::align_val_t al) noexcept {
+    #if !defined(LTODISABLED)
+      badAlloc("Alignment aware new/delete operators, a C++ 17 feaure, are not supported by this core or any other AVR cores at this point in time");
+    #endif
+    (void) al;
+    free(ptr);
+  }
+  void  operator delete  (void* ptr, size_t size, std::align_val_t al) noexcept{
+    #if !defined(LTODISABLED)
+      badAlloc("Alignment aware new/delete operators, a C++ 17 feaure, are not supported by this core or any other AVR cores at this point in time");
+    #endif
+    (void) al;
+    (void) size;
+    free(ptr);
+  }
+  void  operator delete[](void* ptr, size_t size, std::align_val_t al) noexcept {
+    #if !defined(LTODISABLED)
+      badAlloc("Overaligned allocation/deallocation is a C++ 17 feature, and is not supported by this or other AVR cores at this point in time");
+    #endif
+    (void) al;
+    (void) size;
+    free(ptr);
+  }
+
+#endif