Как мне организовать код двоичного анализатора?

Вы можете создать карту, которая сопоставляет идентификатор со строкой, с помощью bsearch:

#include <stdlib.h>  // for bsearch - binary search

// a struct to hold the value and string for _one_ identifier
typedef struct {
    uint32_t val;
    char const *str;
} identifier;

// all your identifiers goes here, in ascending order
const identifier identifiers[] = {
    {LC_SEGMENT_64, "LC_SEGMENT_64"},
    {SOMETHING_ELSE, "SOMETHING_ELSE"},
};

// comparison function for bsearch
int compare(const void *lhs, const void *rhs) {
    const identifier *lid = lhs;
    const identifier *rid = rhs;
    if (lid->val < rid->val) return -1;
    if (lid->val > rid->val) return 1;
    return 0;
}

// a function to encapsulate the call to bsearch
const char *lookup(uint32_t id) {
    identifier key = {id, NULL};
    identifier *res = bsearch(&key,
                              identifiers,
                              sizeof identifiers / sizeof key,
                              sizeof key,
                              compare);
    if (res) return res->str;
    return NULL;
}

Тогда вместо

if (buffer == LC_SEGMENT_64) {
      printf("LC_SEGMENT_64\n");
} else if (buffer == SOMETHING_ELSE) {
      printf("SOMETHING_ELSE\n");
} else if (buffer == ...) {
      printf("...\n");
} else {
      printf("\n");
}

Вам понадобится только один if:

const char *id = lookup(buffer);
if (id) {
    puts(id);
} else {
    putchar('\n');
}

Демо

Я прочитал файл loader.h , предоставленный из этого вопроса для формата Mach-O, с которым вы работаете, и постараюсь ответить на то, что я там прочитал. Если эта ссылка устарела или неверна, откорректируйте ее в зависимости от того, с чем вы работаете.

Упомянутые вами константы являются последовательными, начиная с #define LC_SEGMENT 0x1 и заканчивая #define LC_BUILD_VERSION 0x32. Создайте сопоставление этих констант с индексами в таблице строк, как показано ниже.

/* This is how many identifiers I saw listed in loader.h add one 
   for the 0th unused slot. Number based on the last identifier in
   the list of constants or count by hand. Either works. */
#define NUM_IDENTIFIERS LC_BUILD_VERSION + 1
static const char *const identifier_strings[NUM_IDENTIFIERS] = {
    /* Probably unused 0th slot. */
    [0] = "",
    [LC_SEGMENT] = "LC_SEGMENT",
    [LC_SYMTAB] = "LC_SYMTAB",
    /* ...continues for rest of identifier constants */

    /* careful with constants OR'd with LC_REQ_DYLD bit.
       Or do this to all values to be safe, maybe? */
    [LC_RPATH & ~LC_REQ_DYLD] = "LC_RPATH",

    /* ...continues */
    [LC_BUILD_VERSION] = "LC_BUILD_VERSION",
};

Строки теперь всегда синхронизированы с этими константами, а таблицу строк можно реорганизовать любым способом для удобства чтения благодаря используемой нотации [index] = "string",.

Теперь функция поиска может выглядеть так.

const char *lookup(uint32_t identifier) {
    /* While the identifiers are sequential be mindful of
       the LC_REQ_DYLD bit that has been OR'd to some in
       the list. That would mess up the indexing. See the
       comment above this constant for more info. */
    identifier &= ~LC_REQ_DYLD;
    if (identifier && identifier < NUM_IDENTIFIERS) {
        return identifier_strings[identifier];
    }
    return NULL;
}

Тогда то же самое, что и другой ответ.

const char *id = lookup(buffer);
if (id) {
    puts(id);
} else {
    puts('\n');
}

Предупреждение: я предполагаю, что вас интересует только раздел идентификаторов LC_*. И ответ Теда Люнгмо, и мой ответ не сработали бы, если бы вы добавили больше констант для печати из loader.h, потому что я вижу одни и те же значения, используемые для множества разных #define по всему файлу.