The very old GCC based compilers for C167/ST10 are laughably poor when it comes to the code optimization...

It may simply be that the 'project setup' used for compiling the C code was code 'configured' in large memory model and the compiler switches generated included the large memory execution in the IDE, potential simply due to this you see this kind of strangeness. So maybe not even a bug... just poor code optimization. Recall that you can also configure specifically if you want addressing via stack, registers, directly or automatic. That too could be a reason (stupid yes but a reason).
 
If the code was slight better generated it could actually be useful in certain use cases.

For instance you've got data currently in a flash segmented area that is accessibly directly (without use of extp instructions due to dpp setup) and you want to support capabilities such as dynamic map switching, etc. but in this instance I would have felt it would make more sense to pass in the segment via a register or on the stack to the function itself, that way if the code was built as a shared library it would be possible to re-use it regardless. Having the segment in the instruction is dumb...

I've found myself having to rebuild/patch small memory model compiled functions like gfk_ipol_s8() and patch them to include extp instructions so I can switch maps but in this case i did it something like this... For the C167 so segments are different but the concept is identical...

; ------------------------------------------------------------------------------
; gfk_ipol_s8()
;
;$Inputs:
;
;                               r10 = e.g. KFZW2 segment   <---- added
;                               r11 = e.g. SRL12ZUUB segment <---- added
;
;                               r12 = e.g. KFZW2
;                               r13 = e.g. SRL12ZUUB
;                               r14 = e.g. esst_snm16zuub
;                               r15 = e.g. esst_srl12zuub
; ------------------------------------------------------------------------------
                                                       
GKF_IPOL_S8_SEG204:                                     
                MOV     R10,  #204h           ; E6FA0402         ; KFZW2 SEG
                MOV     R11,  #204h           ; E6FB0402         ; SRL12ZUUB SEG
                JMPR    CC_UC, GKF_IPOL_S8    ; 0D04     
                                                       
GKF_IPOL_S8_SEG207:                                     
                MOV     R10,  #207h           ; E6FA0702         ; KFZW2 SEG
                MOV     R11,  #207h           ; E6FB0702         ; SRL12ZUUB SEG
                                                       
GKF_IPOL_S8:                                           
                EXTP    R11, #1               ; DC4B             ; EXTP
                MOVB    RL2, [R13]            ; A94D             ; *(SRL12ZUUB)

                ... cut ....


I retained the original function prototypes and registers (drop in replacement) but added stubs so that the segments could be configured by the stubs themselves either by setting up registers OR directly invoking the stubs.

This allowed these new version of the lookup's to be substituted so you don't need to change function stubs at all if you didn't want to and still access alternative flash segments, particuarly useful when you don't have much space and cannot be bothered to relocate the function or you doing it with automated patching (like I do).

Not sure they even used GCC... Keil is just as shit, there's zero optimization basically braindead translation of C to asm...

Try this tool I just found for C compilation. Never heard of Cosmic before myself! Its from China it seems..
 
http://www.jzxy.com.cn/support/download/Cosmic/cxST10_C16X_idea_sim_eval.exe

Yes its old, last updated in circa 2005 so pretty 'dead' now (unsurprisingly since ST10's/C16x's are no longer manufactured) but it seems the code generation is a bit better from C...
Yes this is the demo version and you'll need to copy the 'example' folder elsewhere as its trying to write to it but since its in the "programs folder" permission is blocked by modern windows versions. (yes its that old)...

Demo is restricted to 4kbytes code generation however that's trivial to overcome.

Code generation seems pretty clean and readable..

111                         ; 26 int fact(int n)
 111                         ; 27    {
 112                            switch   .text
 113                            even
 114  001a                   _fact:
 116  001a ecf6                 push   r6
 119  001c f06c                 mov   r6,r12
 120                         ; 28    if (n < 2)
 122  001e 4862                 cmp   r6,#2
 123  0020 dd02                 jmp   cc_sge,L35
 124                         ; 29       return (1);
 126  0022 e014                 mov   r4,#1
 128  0024 0d07                 jmp   L01
 129  0026                   L35:
 130                         ; 31       return (n * fact(n - 1));
 132  0026 f0c6                 mov   r12,r6
 133  0028 28c1                 sub   r12,#1
 134  002a da1a1a00             calls   _fact
 136  002e 1b46                 mulu   r4,r6
 137  0030 f2f40efe             mov   r4,mdl
 139  0034                   L01:
 141  0034 fcf6                 pop   r6
 142  0036 db00                 rets


Disclaimer: only spent 5 minutes looking at it so ymmv...