Síntesis del operador VHDL, numeric_std.vhd

si incluyo la biblioteca numeric_std.vhd (la implementación está aquí enlace ) puede ver que el operador *, + (como instancia se implementan de la siguiente manera)

1. Suma sin firmar

   function ADD_UNSIGNED (L, R: UNSIGNED; C: STD_LOGIC) return UNSIGNED is
       constant L_LEFT: INTEGER := L'LENGTH-1;
       alias XL: UNSIGNED(L_LEFT downto 0) is L;
       alias XR: UNSIGNED(L_LEFT downto 0) is R;
       variable RESULT: UNSIGNED(L_LEFT downto 0);
       variable CBIT: STD_LOGIC := C;
     begin
       for I in 0 to L_LEFT loop
         RESULT(I) := CBIT xor XL(I) xor XR(I);
         CBIT := (CBIT and XL(I)) or (CBIT and XR(I)) or (XL(I) and XR(I));
       end loop;
       return RESULT;
   end ADD_UNSIGNED;
   

2. Multiplicación

   function "*" (L, R: UNSIGNED) return UNSIGNED is
       constant L_LEFT: INTEGER := L'LENGTH-1;
       constant R_LEFT: INTEGER := R'LENGTH-1;
       alias XXL: UNSIGNED(L_LEFT downto 0) is L;
       alias XXR: UNSIGNED(R_LEFT downto 0) is R;
       variable XL: UNSIGNED(L_LEFT downto 0);
       variable XR: UNSIGNED(R_LEFT downto 0);
       variable RESULT: UNSIGNED((L'LENGTH+R'LENGTH-1) downto 0) := (others => '0');
       variable ADVAL: UNSIGNED((L'LENGTH+R'LENGTH-1) downto 0);
     begin
       if ((L'LENGTH < 1) or (R'LENGTH < 1)) then return NAU;
       end if;
       XL := TO_01(XXL, 'X');
       XR := TO_01(XXR, 'X');
       if ((XL(XL'LEFT)='X') or (XR(XR'LEFT)='X')) then
         RESULT := (others => 'X');
         return RESULT;
       end if;
       ADVAL := RESIZE(XR, RESULT'LENGTH);
       for I in 0 to L_LEFT loop
         if XL(I)='1' then RESULT := RESULT + ADVAL;
         end if;
         ADVAL := SHIFT_LEFT(ADVAL, 1);
       end loop;
       return RESULT;
   end "*";
   

Ahora no estoy seguro de cómo funcionaría un compilador VHDL, pero mi pregunta es ... Dado que, básicamente, los algoritmos que muestro son "aditivo de acarreo de rizo" y "suma y cambio" respectivamente, además de la optimización lógica que el compilador usualmente puede hacer donde sea que use el operador "*, +" el compilador siempre sintetizará un "sumador de acarreo de rizo" y una "suma y cambio" no es? Por lo general, el compilador no intenta dibujar un sumador de acarreo anticipado o un multiplicador mejor por sí mismo, así que, aparte de las opciones relacionadas con el retardo optimizado o el área optimizada (que se realizan a nivel lógico no a nivel arquitectónico), el programador tiene para realizar la optimización arquitectónica por su cuenta no es?

Lo pregunto porque no sé si una cadena de herramientas específica (excepto el paquete externo o la biblioteca, que de todas formas utiliza el programador) podría realizar este tipo de optimización por sí misma.