Merge branch 'main' into add-wifi-st-b-l4

Author: Ellerbach

CMake/Modules/FindESP32_IDF.cmake

@@ -33,9 +33,10 @@ list(APPEND ESP32_IDF_INCLUDE_DIRS ${IDF_PATH_CMAKED}/components/esp_driver_dac/
 list(APPEND ESP32_IDF_INCLUDE_DIRS ${IDF_PATH_CMAKED}/components/esp_driver_ledc/include)
 list(APPEND ESP32_IDF_INCLUDE_DIRS ${IDF_PATH_CMAKED}/components/esp_driver_pcnt/include)
 list(APPEND ESP32_IDF_INCLUDE_DIRS ${IDF_PATH_CMAKED}/components/esp_driver_sdmmc/include)
+list(APPEND ESP32_IDF_INCLUDE_DIRS ${IDF_PATH_CMAKED}/components/esp_driver_rmt/include)
 list(APPEND ESP32_IDF_INCLUDE_DIRS ${IDF_PATH_CMAKED}/components/esp_driver_sdspi/include)
 
-# Use depecated drivers for RMT, I2S etc
+# Use depecated drivers for I2S etc
 list(APPEND ESP32_IDF_INCLUDE_DIRS ${IDF_PATH_CMAKED}/components/driver/deprecated)
 
 # includes specific to ESP32 or ESP32S2 or ESP32S3

CMake/Modules/FindnanoFramework.Hardware.Esp32.Rmt.cmake

@@ -22,6 +22,9 @@ set(nanoFramework.Hardware.Esp32.Rmt_SRCS
     nanoFramework_hardware_esp32_rmt_native_nanoFramework_Hardware_Esp32_Rmt_RmtChannel.cpp
     nanoFramework_hardware_esp32_rmt_native_nanoFramework_Hardware_Esp32_Rmt_TransmitterChannel.cpp
     nanoFramework_hardware_esp32_rmt_native_nanoFramework_Hardware_Esp32_Rmt_ReceiverChannel.cpp
+    nanoFramework_hardware_esp32_rmt_native_nanoFramework_Hardware_Esp32_Rmt_TransmitSyncManager.cpp
+    rmt_multi_stage_encoder.cpp
+    nanoFramework_hardware_esp32_rmt_native_nanoFramework_Hardware_Esp32_Rmt_Utils.cpp
 )
 
 foreach(SRC_FILE ${nanoFramework.Hardware.Esp32.Rmt_SRCS})

src/CLR/Core/Execution.cpp

@@ -638,9 +638,7 @@ HRESULT CLR_RT_ExecutionEngine::Execute(wchar_t *entryPointArgs, int maxContextS
 
     NANOCLR_CHECK_HRESULT(WaitForDebugger());
 
-#if defined(NANOCLR_ENABLE_SOURCELEVELDEBUGGING)
     CLR_EE_DBG_SET_MASK(StateProgramRunning, StateMask);
-#endif // #if defined(NANOCLR_ENABLE_SOURCELEVELDEBUGGING)
 
     NANOCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Delegate::CreateInstance(ref, g_CLR_RT_TypeSystem.m_entryPoint, NULL));
 

src/CLR/Core/GarbageCollector.cpp

@@ -41,10 +41,38 @@ void CLR_RT_ProtectFromGC::Initialize(void **data, Callback fpn)
     m_flags = c_Generic;
 }
 
+void CLR_RT_ProtectFromGC::UnlinkOutOfOrder()
+{
+    NATIVE_PROFILE_CLR_CORE();
+
+    for (CLR_RT_ProtectFromGC **slot = &s_first; *slot != NULL; slot = &(*slot)->m_next)
+    {
+        if (*slot == this)
+        {
+            *slot = m_next;
+            break;
+        }
+    }
+}
+
 void CLR_RT_ProtectFromGC::Cleanup()
 {
     NATIVE_PROFILE_CLR_CORE();
-    s_first = m_next;
+
+    if (s_first == this)
+    {
+        // LIFO fast path: instances are stack scoped and nest, so this is a pop.
+        s_first = m_next;
+    }
+    else
+    {
+        // Destroyed out of order. Popping here would drop every outer registration and let the GC
+        // collect objects that are still live, so recover in all builds -- but this is a bug, not a
+        // supported case: it means an instance escaped its scope.
+        _ASSERTE(false);
+
+        UnlinkOutOfOrder();
+    }
 
     if (m_flags & c_ResetKeepAlive)
     {

src/CLR/Core/Hardware/Hardware.cpp

@@ -163,6 +163,11 @@ void CLR_HW_Hardware::ProcessActivity()
         eventsCLR |= Event_I2cSlave;
     }
 
+    if (events & SYSTEM_EVENT_FLAG_RMT_RX)
+    {
+        eventsCLR |= Event_RmtRx;
+    }
+
     if (events & SYSTEM_EVENT_FLAG_ONEWIRE_MASTER)
     {
         eventsCLR |= Event_OneWireHost;

src/CLR/Core/TypeSystem.cpp

@@ -2881,7 +2881,7 @@ static const TypeIndexLookup c_TypeIndexLookup[] = {
 
     TIL("System.Device.I2c", "I2cTransferResult", m_I2cTransferResult),
 
-    TIL("nanoFramework.Hardware.Esp32.Rmt", "RmtCommand", m_RmtCommand),
+    TIL("nanoFramework.Hardware.Esp32.Rmt", "RmtSymbol", m_RmtSymbol),
 
 #undef TIL
 };

src/CLR/Include/nanoCLR_Hardware.h

@@ -26,8 +26,7 @@ struct CLR_HW_Hardware
         SYSTEM_EVENT_FLAG_SPI_MASTER | SYSTEM_EVENT_FLAG_I2C_MASTER | SYSTEM_EVENT_FLAG_I2C_SLAVE |
         SYSTEM_EVENT_HW_INTERRUPT | SYSTEM_EVENT_FLAG_SOCKET | SYSTEM_EVENT_FLAG_DEBUGGER_ACTIVITY |
         SYSTEM_EVENT_FLAG_MESSAGING_ACTIVITY | SYSTEM_EVENT_FLAG_ONEWIRE_MASTER | SYSTEM_EVENT_FLAG_RADIO |
-        SYSTEM_EVENT_FLAG_WIFI_STATION | SYSTEM_EVENT_FLAG_BLUETOOTH;
-
+        SYSTEM_EVENT_FLAG_WIFI_STATION | SYSTEM_EVENT_FLAG_BLUETOOTH | SYSTEM_EVENT_FLAG_RMT_RX;
     //--//
 
     struct HalInterruptRecord

src/CLR/Include/nanoCLR_PlatformDef.h

@@ -201,6 +201,16 @@
 #define ULONGLONGCONSTANT(v) (v##ull)
 #endif
 
+// Keeps a function out of line even under LTO. Use it for cold error/recovery paths that would
+// otherwise be inlined into every one of their call sites and bloat the image.
+#if defined(__GNUC__)
+#define NANOCLR_NOINLINE __attribute__((noinline))
+#elif defined(_MSC_VER)
+#define NANOCLR_NOINLINE __declspec(noinline)
+#else
+#define NANOCLR_NOINLINE
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////

src/CLR/Include/nanoCLR_Runtime.h

@@ -8,6 +8,7 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+#include <type_traits>
 #include <nanoCLR_Types.h>
 #include <nanoCLR_Interop.h>
 #include <nanoCLR_ErrorCodes.h>
@@ -515,6 +516,15 @@ struct CLR_RT_Memory
         memset(buf, 0, len);
     }
 
+    template <typename T> static void Clear(T &ref)
+    {
+        // A type with a non-trivial destructor owns something that has to be released
+        // for example, an entry in the CLR_RT_ProtectFromGC chain on which zero-filling it silently orphans that.
+        static_assert(std::is_trivially_destructible<T>::value, "NANOCLR_CLEAR on a type that owns resources");
+
+        ZeroFill(&ref, sizeof(T));
+    }
+
     //--//
 
     static void Reset();
@@ -551,7 +561,7 @@ extern void CLR_RT_GetVersion(
     unsigned short int *pBuild,
     unsigned short int *pRevision);
 
-#define NANOCLR_CLEAR(ref) CLR_RT_Memory::ZeroFill(&ref, sizeof(ref))
+#define NANOCLR_CLEAR(ref) CLR_RT_Memory::Clear(ref)
 
 //--//
 
@@ -1581,7 +1591,7 @@ struct CLR_RT_WellKnownTypes
     CLR_RT_TypeDef_Index m_I2cTransferResult;
     CLR_RT_TypeDef_Index m_I2cTransferResult_old;
 
-    CLR_RT_TypeDef_Index m_RmtCommand;
+    CLR_RT_TypeDef_Index m_RmtSymbol;
 
     PROHIBIT_COPY_CONSTRUCTORS(CLR_RT_WellKnownTypes);
 };
@@ -1968,6 +1978,50 @@ struct CLR_RT_MethodDef_Instance : public CLR_RT_MethodDef_Index
 #endif // #if defined(NANOCLR_ENABLE_SOURCELEVELDEBUGGING)
 };
 
+////////////////////////////////////////////////////////////////////////////////
+
+struct CLR_RT_ProtectFromGC
+{
+    static const CLR_UINT32 c_Generic = 0x00000001;
+    static const CLR_UINT32 c_HeapBlock = 0x00000002;
+    static const CLR_UINT32 c_ResetKeepAlive = 0x00000004;
+
+    typedef void (*Callback)(void *state);
+
+    static CLR_RT_ProtectFromGC *s_first;
+
+    CLR_RT_ProtectFromGC *m_next;
+    void **m_data;
+    Callback m_fpn;
+    CLR_UINT32 m_flags;
+
+    CLR_RT_ProtectFromGC(CLR_RT_HeapBlock &ref)
+    {
+        Initialize(ref);
+    }
+    CLR_RT_ProtectFromGC(void **data, Callback fpn)
+    {
+        Initialize(data, fpn);
+    }
+    ~CLR_RT_ProtectFromGC()
+    {
+        Cleanup();
+    }
+
+    static void InvokeAll();
+
+  private:
+    void Initialize(CLR_RT_HeapBlock &ref);
+    void Initialize(void **data, Callback fpn);
+    void Cleanup();
+
+    // Cold recovery path for Cleanup(), kept out of line so that it isn't inlined into every
+    // destruction site.
+    NANOCLR_NOINLINE void UnlinkOutOfOrder();
+
+    void Invoke();
+};
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 struct CLR_RT_AttributeEnumerator
@@ -1994,6 +2048,9 @@ struct CLR_RT_AttributeEnumerator
     void Initialize(CLR_RT_Assembly *assm);
 };
 
+// Developer note: Value::m_valueGC holds a live entry in the CLR_RT_ProtectFromGC chain for this object whole lifetime.
+// Never memset/memcpy an instance (NANOCLR_CLEAR included) and never give one a lifetime that doesn't nest with the
+// enclosing scope.
 struct CLR_RT_AttributeParser
 {
     struct Value
@@ -2004,10 +2061,34 @@ struct CLR_RT_AttributeParser
         static const int c_DefaultConstructor = 4;
 
         int m_mode;
-        CLR_RT_HeapBlock m_value;
+        // Declaration order below is load-bearing: CLR_RT_ProtectFromGC's constructor reads
+        // m_value.IsForcedAlive(), so m_value has to be declared -- and zeroed -- before m_valueGC.
+        CLR_RT_HeapBlock m_value{};
+        CLR_RT_ProtectFromGC m_valueGC{m_value};
 
         int m_pos;
         const char *m_name;
+
+        //--//
+
+        // Required, not decorative: declaring the deleted copy constructor below suppresses the
+        // implicit default constructor. It also has to stay defaulted *here*, in the class body --
+        // an out of line "= default" would make it user provided, which drops the zero
+        // initialization that m_valueGC's constructor depends on.
+        Value() = default;
+
+        // Prevent copying because shallow copies of CLR_RT_ProtectFromGC
+        // can corrupt the GC protection list during destruction.
+
+        // Delete copy constructor
+        Value(const Value &) = delete;
+        // Delete copy-assignment operator
+        Value &operator=(const Value &) = delete;
+
+        // Stack only: the CLR_RT_ProtectFromGC entry is released by popping the chain, not by
+        // searching it, so this object's lifetime has to nest with the enclosing scope.
+        static void *operator new(size_t) = delete;
+        static void *operator new[](size_t) = delete;
     };
 
     //--//
@@ -2040,6 +2121,11 @@ struct CLR_RT_AttributeParser
         const CLR_UINT32 size);
     HRESULT ReadString(CLR_RT_HeapBlock *&value);
 
+    // Stack only, for the same reason as CLR_RT_AttributeParser::Value above: this owns the
+    // registration through m_lastValue.
+    static void *operator new(size_t) = delete;
+    static void *operator new[](size_t) = delete;
+
   private:
     const char *GetString();
 };
@@ -2509,46 +2595,6 @@ CT_ASSERT(
 
 #endif // _MSC_VER
 
-////////////////////////////////////////////////////////////////////////////////
-
-struct CLR_RT_ProtectFromGC
-{
-    static const CLR_UINT32 c_Generic = 0x00000001;
-    static const CLR_UINT32 c_HeapBlock = 0x00000002;
-    static const CLR_UINT32 c_ResetKeepAlive = 0x00000004;
-
-    typedef void (*Callback)(void *state);
-
-    static CLR_RT_ProtectFromGC *s_first;
-
-    CLR_RT_ProtectFromGC *m_next;
-    void **m_data;
-    Callback m_fpn;
-    CLR_UINT32 m_flags;
-
-    CLR_RT_ProtectFromGC(CLR_RT_HeapBlock &ref)
-    {
-        Initialize(ref);
-    }
-    CLR_RT_ProtectFromGC(void **data, Callback fpn)
-    {
-        Initialize(data, fpn);
-    }
-    ~CLR_RT_ProtectFromGC()
-    {
-        Cleanup();
-    }
-
-    static void InvokeAll();
-
-  private:
-    void Initialize(CLR_RT_HeapBlock &ref);
-    void Initialize(void **data, Callback fpn);
-    void Cleanup();
-
-    void Invoke();
-};
-
 ////////////////////////////////////////
 
 #if defined(NANOCLR_TRACE_EARLYCOLLECTION)
@@ -3452,6 +3498,7 @@ typedef enum Events
     Event_UsbOut            = 0x00004000,
     Event_IO                = 0x00008000,
     Event_I2cSlave          = 0x00010000,
+    Event_RmtRx             = 0x00020000,
     Event_AppDomain         = 0x02000000,
     Event_Socket            = 0x20000000,
     Event_IdleCPU           = 0x40000000,

src/CLR/Startup/CLRStartup.cpp

@@ -425,8 +425,8 @@ void ClrStartup(CLR_SETTINGS params)
 
         if (CLR_EE_DBG_IS_NOT(RebootPending))
         {
-#if defined(NANOCLR_ENABLE_SOURCELEVELDEBUGGING)
             CLR_EE_DBG_SET_MASK(StateProgramExited, StateMask);
+#if defined(NANOCLR_ENABLE_SOURCELEVELDEBUGGING)
             CLR_EE_DBG_EVENT_BROADCAST(CLR_DBG_Commands_c_Monitor_ProgramExit, 0, NULL, WP_Flags_c_NonCritical);
 #endif // #if defined(NANOCLR_ENABLE_SOURCELEVELDEBUGGING)