Допустим есть две абсолютно одинаковые функции. В компиляторах есть оптимизации которые выкидывают одну функцию, оставляя другую, и вместо вызовов первой подставляют вторую?

Сначала надо строго сформулировать словосочетание "одинаковые функции", от этого все и зависит.

Альфа-эквивалентные?

а можно пример ситуации, когда эта оптимизация даст ощутимую пользу?

Я такого не видел. В общем виде это к поиску изоморфизмов (например, графа IR), что стоит дорого. А выхлоп от оптимизации наверняка копеечный, ибо кажется, что пар абсолютно идентичных функций мало, особенно после выкидывания тривиальных аксессоров (которые всё равно инлайнятся в подавляющем большинстве случаев). Могу себе представить, что подобное склеивание ведёт к весёлой отладке, когда брейкпоинт в одной функции срабатывает в "другой", когда хотпатч одной функции ведёт к изменению "другой", и т.п. :)

есть

я как-то clang заставлял делать что-то подобное. но это еле-еле работает, ибо определять одинаковость функций - дело такое

Обычно оптимизации нацелены на повышение скорости исполнения, зачастую за счет увеличения размера кода (раскрутка циклов, инлайнинг, и т.д.)

Единственная известная мне оптимизация, которая сокращает размер генерируемого кода по сравнению с исходником и не влияет на скорость - это dead code elimination, и то она идет "бесплатным бонусом" к SSA

Да, в GCC, например, это называется identical code folding

peephole? там вроде есть кейсы по свертке инструкций, в среднем это вроде как должно приводить к уменьшению конечного кода

имхо штуки типа x + 0 => x в основном работают не на оригинальном коде, а на том что нагенерировало несколько слоев макросов и прочих правил подстановки

т.е. что-то сначала раздуло генерируемый из исходника код, а пипхол его чуть-чуть обратно присжал

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

Во первых DAE может никак быть не связан SSA так как выполняется на уровнее базовых блоков и CFG. То что что можно извлечь на уровне SSA - это DeadInstElimination (или вакуум) и он обычно дает довольно маленький профит в плане размера и больше полезен для последующих проходов. Есть еще GVE (то же самое долько для глобальных переменных) Есть еще DSE (Dead Store Elimination). Но в LLVM самый главный пасс - это GlobalDCE который как раз таки работает с dpendency graph и удаляет: функции целиком, глобальные алиасы и переменные, виртуальные и непрямые вызовы

В LLVM этого нету, но есть еще очень классная трансформация которая может уменьшить код и заодно убрать дубликаты - это CNE (Common Node Elimination)

Common Node Elimination (CNE) permits the removal of redundant computations by detecting congruent nodes.These nodes always produce the same results, enabling the redirection of their result edges to a single node. Thisrenders the other nodes dead, permitting Dead Node Elimination to remove them. CNE is similar to commonsubexpression elimination and value numberin

Забавно, кто знает хорошо польский? Есть дипломная работа сравнивающая Rust и AssemblyScript для wasm таргета:
https://github.com/jakubbrodzinski/js/blob/master/W8_229781_2020_praca_magisterska.pdf

Правда там AS скомпилирован с дефолтным -O вместо -O3 ну и без использования unchecked доступа к массивам (у AS пока нету Bounds Check Ellimination).
Но результаты все равно довольно забавные

А почему контекстно зависимые языки не прижились? Просто везде пишут что то типо

В современной практике такие языки
большого значения не имеют