[libunwind] Make it possible to use libunwind without heap.

[whitequark]

Summary

This patch allows to use libunwind on bare-metal systems that do not include malloc/free by conditionally turning off nonessential functionality that requires these functions.

The disabled functionality includes:

• the .cfi_remember_state and .cfi_restore_state instructions;
• the DWARF FDE cache.

The .cfi_{remember,restore}_state instructions don't seem to be used by contemporary compilers. None of the LLVM backends emit it.

The DWARF FDE cache is bypassed if _LIBUNWIND_NO_HEAP is defined. Specifically, entries are never added to it, so the search begins and ends at the statically allocated, empty initial cache.

Such heap-less libunwind on a bare metal system is successfully used in the ARTIQ project, and it is my hope that it will be useful elsewhere.

[whitequark]

Whitespace.

[whitequark]

Whitespace.

[compnerd]

src/UnwindCursor.hpp

898

Please use:

#if !defined(_LIBUNWIND_NO_HEAP)
    DwarfFDECache<A>::add(sects.dso_base, fdeInfo.pcStart, fdeInfo.pcEnd,
                          fdeInfo.fdeStart);
#endif

rather than the empty clause with a semicolon.

Even better would be be make the add operation a no-op if built without support for the heap. You could do that statically, avoiding the mess of conditional compilation.

[whitequark]

src/UnwindCursor.hpp

898

This would break the preceding conditionally included:

if (sects.dwarf_index_section == 0)

I could refactor it.

How would you suggest doing it statically?

[compnerd]

The FDECache already is templated, take a second parameter which is _LIBUNWIND_NO_HEAP. If disabled, just return.

[whitequark]

I've tried to do that, but it appears that you cannot partially specialize a member function. As a result, the object has the annoying property of having undefined references to malloc/free, which the current solution avoids.

[whitequark]

Do you think it would be valuable to have no references to malloc/free in no-heap builds? (I think it is: as opposed to having a stub implementation, it allows to catch erroneous references in third-party code earlier.)

If yes, can you suggest a way to conditionally call them that wouldn't involve the preprocessor?

[compnerd]

I agree that would be useful. Unfortunately, partial template specialization in this case would be difficult. I would just create a functor that represents the body and is templated on the heap availability.

[whitequark]

I've tried to refactor this code to use a functor, but the functor would have to somehow gain access to the private fields of DwarfFDECache. Every solution I could imagine was far more contrived than a #ifdef; if you have a good one, I'm all ears.

In light of this and also the fact that there are more #ifdef's anyway in the DWARF parser, I've instead changed the patch to remove the heinous semicolon hack. Now it is just the body of add() which is conditionally included. This looks straightforward enough to me.

What do you think?

[whitequark]

I've realized there is no need to disable any of the _unw_* functions now that DwarfFDECache::add() is a no-op on heapless systems, so I have simplified the patch.

[whitequark]

Ping?

[compnerd]

I tend to prefer !defined() over ndef. But thats stylistic.

src/DwarfParser.hpp

bool CFI_Parser<A>::parseInstructions(A &addressSpace, pint_t instructions,
   // see Dwarf Spec, section 6.4.2 for details on unwind opcodes
   while ((p < instructionsEnd) && (codeOffset < pcoffset)) {
     uint64_t reg;
     uint64_t reg2;
     int64_t offset;
     uint64_t length;
     uint8_t opcode = addressSpace.get8(p);
     uint8_t operand;
+#ifndef _LIBUNWIND_NO_HEAP
     PrologInfoStackEntry *entry;
+#endif
     ++p;
     switch (opcode) {
     case DW_CFA_nop:
       if (logDwarf)
         fprintf(stderr, "DW_CFA_nop\n");
       break;
     case DW_CFA_set_loc:
       codeOffset =
case DW_CFA_register:
       results->savedRegisters[reg].location = kRegisterInRegister;
       results->savedRegisters[reg].value = (int64_t)reg2;
       // set flag to disable conversion to compact unwind
       results->registersInOtherRegisters = true;
       if (logDwarf)
         fprintf(stderr, "DW_CFA_register(reg=%" PRIu64 ", reg2=%" PRIu64 ")\n",
                 reg, reg2);
       break;
+#ifndef _LIBUNWIND_NO_HEAP
     case DW_CFA_remember_state:
       // avoid operator new, because that would be an upward dependency
       entry = (PrologInfoStackEntry *)malloc(sizeof(PrologInfoStackEntry));
       if (entry != NULL) {
         entry->next = rememberStack;
         entry->info = *results;
         rememberStack = entry;
       } else {
case DW_CFA_restore_state:
         rememberStack = top->next;
         free((char *)top);
       } else {
         return false;
       }
       if (logDwarf)
         fprintf(stderr, "DW_CFA_restore_state\n");
       break;
+#endif
     case DW_CFA_def_cfa:
       reg = addressSpace.getULEB128(p, instructionsEnd);
       offset = (int64_t)addressSpace.getULEB128(p, instructionsEnd);
       if (reg > kMaxRegisterNumber) {
         fprintf(stderr, "malformed DW_CFA_def_cfa dwarf unwind, reg too big\n");
         return false;
       }
       results->cfaRegister = (uint32_t)reg;

src/UnwindCursor.hpp

if (CFI_Parser<A>::parseFDEInstructions(_addressSpace, fdeInfo, cieInfo, pc,
       _info.extra             = (unw_word_t) sects.dso_base;
 
       // Add to cache (to make next lookup faster) if we had no hint
       // and there was no index.
       if (!foundInCache && (fdeSectionOffsetHint == 0)) {
   #if _LIBUNWIND_SUPPORT_DWARF_INDEX
         if (sects.dwarf_index_section == 0)
   #endif
+  #ifdef _LIBUNWIND_NO_HEAP
+          ;
+  #else
         DwarfFDECache<A>::add(sects.dso_base, fdeInfo.pcStart, fdeInfo.pcEnd,
                               fdeInfo.fdeStart);
+  #endif
       }
       return true;
     }
   }
   //_LIBUNWIND_DEBUG_LOG("can't find/use FDE for pc=0x%llX\n", (uint64_t)pc);
   return false;
 }
 #endif // _LIBUNWIND_SUPPORT_DWARF_UNWIND

src/libunwind.cpp

_LIBUNWIND_EXPORT void unw_save_vfp_as_X(unw_cursor_t *cursor) {
   _LIBUNWIND_TRACE_API("unw_fpreg_save_vfp_as_X(cursor=%p)\n",
                        static_cast<void *>(cursor));
   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
   return co->saveVFPAsX();
 }
 #endif
 
 
-#if _LIBUNWIND_SUPPORT_DWARF_UNWIND
+#if !defined(_LIBUNWIND_NO_HEAP) && _LIBUNWIND_SUPPORT_DWARF_UNWIND
 /// SPI: walks cached dwarf entries
 _LIBUNWIND_EXPORT void unw_iterate_dwarf_unwind_cache(void (*func)(
     unw_word_t ip_start, unw_word_t ip_end, unw_word_t fde, unw_word_t mh)) {
   _LIBUNWIND_TRACE_API("unw_iterate_dwarf_unwind_cache(func=%p)\n",
                        reinterpret_cast<void *>(func));
   DwarfFDECache<LocalAddressSpace>::iterateCacheEntries(func);
 }
 
void _unw_add_dynamic_fde(unw_word_t fde) {
   }
 }
 
 /// IPI: for __deregister_frame()
 void _unw_remove_dynamic_fde(unw_word_t fde) {
   // fde is own mh_group
   DwarfFDECache<LocalAddressSpace>::removeAllIn((LocalAddressSpace::pint_t)fde);
 }
-#endif // _LIBUNWIND_SUPPORT_DWARF_UNWIND
+#endif // !defined(_LIBUNWIND_NO_HEAP) && _LIBUNWIND_SUPPORT_DWARF_UNWIND
 
 
 
 // Add logging hooks in Debug builds only
 #ifndef NDEBUG
 #include <stdlib.h>
 
 _LIBUNWIND_HIDDEN