В этот момент я не закапывался, но уверен что у них есть встроенная таблица имён. Как минимум get_identifier возвращает узел дерева. Можно проверить что при двух вызовах будет возвращён одинаковый узел. Если это так, то нужно будет искать ссылку из этого дерева на родительский элемент

*если нужно прямо предыдущее, а не родительский элемент, то не знаю, но советую посмотреть что происходит внутри get_identifier

Но мы же в modify_expr  передаем
Готоввй узел а не результат get_identifier()

Да, но узел то всё равно имеет ссылку на узел, полученный из get_identifier. Весь вопрос существует ли там обратная связь чтобы из узла с именем перейти к VAR_DECL, например (сильно не факт что существует). В этом плане я бы рекомендовал иметь собственную таблицу символов с привязкой к лексическим блоком. Просто будет проще чем закапываться в особенности gcc

Обратной связи там 99% - нет
Ибо GIMPLE - направленый граф
А для идентификатора мы ничего не указываем
(Разве что где-то есть хитрый макрос)

Меня кстати удивляет макрос
DECL_SUBBLOCKS() =
Он очень похож на перегруженый +=
(Хотя не может им являтся)

Это в каком gcc? У меня в 9.3 этого макроса нет

Ошибся BLOCK_SUBBLOCKS()
2 часть 4 пример

И нужно ли мне хранитт функции в одной таблице с символами
Ведь в теории я могу
jmp в любой void*

Есть подозрение что второе присваивание лишнее. Оно просто перезаписывает поле. Спасибо что заметили, посмотрю действительно ли это так

Не очень понял вопрос. Если Вы создаёте свою таблицу символов, то она будет представлять из себя дерево, в котором узлом будет своя таблица. Каждый узел, соответственно, будет привязан к лексической области видимости. Т.е. никаких пересечений по именам между метками и функциями быть не должно

А как правильно сделать граматику присваивания?
Я начал с
ASSIGN -> IDENT := EXPR
Но потом начал думать над массивами
И получилось что мне нужно
ASSIGN -> IDENT := EXPR
|   IDENT [ EXPR ] := EXPR
Но так же IDENT [ EXPR ] - является EXPR  в ситуации a := arr[i];
А еще массив может быть возвращен функцией (которая тоже EXPR)
И получается что легче всего сделать

ASSIGN -> EXPR := EXPR
Чтобы массивы, функции, и тд были как справа, так и слева
И можно было делать вещи аля
somefunc(args)[i] := otherfunc(args)[j]

И у меня вопрос, нормальная ли практика определения присваивания как
ASSIGN -> EXPR := EXPR
И чем это может быть черевато?

Присваивание в массив?

Ну
arr[i] := VALUE
Такое же возможно?

Как я понял главное это проверить чтобы слева от равно небыло RVALUE
Т.е констант, и прямых результатов

Вопрос как это делать? Ведь
0хdeadbeef это rvalue
А *(0xdeadbeef) это уже адресс куда можно что то положить

Я конечно не специалист, но может быть расширить IDENT чтобы взятие элемента массива так же было IDENT?

ASSIGN -> IDENT := EXPR
|   IDENT [ EXPR ] := EXPR

Но вопрос: что делать если массив возврашен функцией?

Вы грамматику для C/Fortran пишите, или для нормального языка? 😉

А так же IDENT [ EXPR ] сам по себе является EXPR (взятие элемента)
Некрасиво выходит.....

Ну хотелось бы в результате получить что-то нормальное

Но неизвесно что выйдет