[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 ↗

(On Diff #31642)

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 ↗

(On Diff #31642)

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.

libunwind/trunk/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;
+#if !defined(_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;
+#if !defined(_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;

libunwind/trunk/src/UnwindCursor.hpp

typename A::pint_t DwarfFDECache<A>::findFDE(pint_t mh, pint_t pc) {
   }
   _LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_unlock(&_lock));
   return result;
 }
 
 template <typename A>
 void DwarfFDECache<A>::add(pint_t mh, pint_t ip_start, pint_t ip_end,
                            pint_t fde) {
+#if !defined(_LIBUNWIND_NO_HEAP)
   _LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_wrlock(&_lock));
   if (_bufferUsed >= _bufferEnd) {
     size_t oldSize = (size_t)(_bufferEnd - _buffer);
     size_t newSize = oldSize * 4;
     // Can't use operator new (we are below it).
     entry *newBuffer = (entry *)malloc(newSize * sizeof(entry));
     memcpy(newBuffer, _buffer, oldSize * sizeof(entry));
     if (_buffer != _initialBuffer)
#if !defined(_LIBUNWIND_NO_HEAP)
   ++_bufferUsed;
 #ifdef __APPLE__
   if (!_registeredForDyldUnloads) {
     _dyld_register_func_for_remove_image(&dyldUnloadHook);
     _registeredForDyldUnloads = true;
   }
 #endif
   _LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_unlock(&_lock));
+#endif
 }
 
 template <typename A>
 void DwarfFDECache<A>::removeAllIn(pint_t mh) {
   _LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_wrlock(&_lock));
   entry *d = _buffer;
   for (const entry *s = _buffer; s < _bufferUsed; ++s) {
     if (s->mh != mh) {