Может ли кто нибудь объяснить на низком уровне, пошагово, то как работают исключения в с++?

Вот описание части Itanium ABI связанной с раскруткой стека:
https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html

ABI процессоров других архитектур устроены в этом месте точно так же.

Вот подробное описание структур, используемых при раскрутке стека в коде генерируемом gcc:
www.airs.com/blog/archives/460
www.airs.com/blog/archives/464

Документы по ссылкам достаточно сложны для восприятия. Для облегчения понимания можно откомпилировать простой С++ код выбрасывающий и ловящий исключение и найти в нем части описанные в первом документе.
Например

void e_destructor();
void s_destructor();

struct E {
        int code;

        E(int c): code(c)
        {
        }
        ~E()
        {
                e_destructor();
        }
};

struct S {
        ~S()
        {
                s_destructor();
        }
};

void f(int v)
{
        throw E(v);
}

int g(void (*p)(int v), int v)
{
        try {
                struct S s;
                p(v);
        } catch(struct E e) {
                return e.code;
        } catch (int i) {
                return i;
        } catch (...) {
                throw;
        }
        return 0;
}

после g++ -O2 -S превращается в следующие фрагменты:
функция f:

_Z1fi:
.LFB9:
        .cfi_startproc
        pushq   %rbx
        .cfi_def_cfa_offset 16
        .cfi_offset 3, -16
        movl    %edi, %ebx
        movl    $4, %edi
        call    __cxa_allocate_exception
        movl    $_ZN1ED1Ev, %edx
        movl    %ebx, (%rax)  <---- инициализация E::code
        movl    $_ZTI1E, %esi
        movq    %rax, %rdi
        call    __cxa_throw
        .cfi_endproc

Здесь видны вызовы __cxa_allocate_exception, конструктора объекта класса E и __cxa_throw
функция g:

_Z1gPFviEi:
.LFB10:
        .cfi_startproc
        .cfi_personality 0x3,__gxx_personality_v0
        .cfi_lsda 0x3,.LLSDA10
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        pushq   %rbx
        .cfi_def_cfa_offset 24
        .cfi_offset 3, -24
        movq    %rdi, %rax
        movl    %esi, %edi
        subq    $8, %rsp
        .cfi_def_cfa_offset 32
.LEHB0:
        call    *%rax  <--- вызов функции по указателю
.LEHE0:
.LEHB1:
        call    _Z12s_destructorv  <--- вызов деструктора объекта s при нормальном выходе из блока try
.LEHE1:
        xorl    %eax, %eax
.L17:
        addq    $8, %rsp
        .cfi_remember_state
        .cfi_def_cfa_offset 24
        popq    %rbx
        .cfi_def_cfa_offset 16
        popq    %rbp
        .cfi_def_cfa_offset 8
        ret

Хвост с обработчиками исключений:

.L13:
        .cfi_restore_state
        movq    %rdx, %rbx
        movq    %rax, %rbp
        call    _Z12s_destructorv
        movq    %rbx, %rdx
.L6:
        cmpq    $1, %rdx
        je      .L8
        cmpq    $2, %rdx
        jne     .L22
        movq    %rbp, %rdi
        call    __cxa_begin_catch
        movl    (%rax), %ebx
        call    __cxa_end_catch
        movl    %ebx, %eax
        jmp     .L17
.L14:
        movq    %rax, %rbp
        jmp     .L6
.L22:
        movq    %rbp, %rdi
        call    __cxa_begin_catch
.LEHB2:
        call    __cxa_rethrow
.LEHE2:
.L8:
        movq    %rbp, %rdi
        call    __cxa_get_exception_ptr
        movq    %rbp, %rdi
        movl    (%rax), %ebx
        call    __cxa_begin_catch
.LEHB3:
        call    _Z12e_destructorv
.LEHE3:
.LEHB4:
        call    __cxa_end_catch
.LEHE4:
        movl    %ebx, %eax
        jmp     .L17
.L16:
        movq    %rax, %rbx
        call    __cxa_end_catch
        movq    %rbx, %rdi
.LEHB5:
        call    _Unwind_Resume
.LEHE5:
.L15:
        movq    %rax, %rbx
        call    __cxa_end_catch
        movq    %rbx, %rdi
.LEHB6:
        call    _Unwind_Resume
.LEHE6:
        .cfi_endproc

Здесь видны вызовы __cxa_begin_catch и __cxa_end_catch, __cxa_rethrow повторно выбрасывающий пойманное исключение, __cxa_get_exception_ptr и _Unwind_Resume, вызываемый если блок catch не ловит это исключение.

Дальше идёт структура LSDA описанная в третьем документе.

Сама раскрутка стека в этом коде отсутствует. Она выполняется следующим кодом libgcc: фаза 1 и фаза 2.

Ну вот, опять знатоки советуют добавить звёздочек и указателей на указатели ):

Все примеры дальше передают в функцию трёхмерный массив и присваивают v значение его элемента p[1][2][3].

Если функция принимает массив фиксированных размерностей, то прямо так можно и написать:

int f(int p[][20][30])
{
    int i = 1, j = 2, k = 3;
    int v = p[i][j][k];
}
...
int p[10][20][30];
f(p);

Первую размерность (самую старшую) можно опустить.

Если же нет, то перед вами следующий выбор:

- у вас старый стандарт С (до С99) -- передавайте указатель на самый первый элемент и значения размерностей. Внутри функции пересчитывайте набор индексов многомерного массива в линейный индекс:

int f(int *p, int n2, int n3) // p[][n2][n3]
{
    int i = 1, j= 2, k = 3;
    int v = p[(((i * n2) + j) * n3) + k]; // v = p[i][j][k];
}
...
int p[10][20][30];
f(&p[0][0][0], 20, 30);

- у вас С99 или новее: воспользуйтесь поддержкой языка:

int f(int n2, int n3, int p[][n2][n3])
{
    int i = 1, j = 2, k = 3;
    int v = p[i][j][k];
}
...
int p[10][20][30];
f(20, 30, p);

Есть исходный код на Си, который вызывает функцию на ассемблере, но передаваемые аргументы как получить,

Гуглить словосочетание "имя целевой процессорной архитектуры" + ABI.
Например: x86_64 abi, x86 abi, arm64 abi...
В найденном документе искать раздел "parameter passing", "function calling" или с похожим по смыслу названием.