Zuweisung abhängig von Generic

[Fred (Gast)]

Hallo zusammen,

ich habe mal wieder eine Tool-Frage, diesmal bekomme ich meinen Code mit 
dem Active HDL 3.5 nicht kompiliert. Nachfolgend habe ich den Code mal 
abstrahiert, um den Fehler zu reproduzieren.
Wenn ich die nachfolgenden Componente mit dem generic
gComponentIndex = 0 kompiliere, erhalte ich die Fehlermeldung

# ELAB2: Fatal Error: ELAB2_0013 MyComponent.vhd (22): Index -16 is out of range (15 downto 0) of "oVector".

gComponentIndex = 1 führt entsprechend zu

# ELAB2: Fatal Error: ELAB2_0013 MyComponent.vhd (22): Index -15 is out of range (15 downto 0) of "oVector"..

und gComponentIndex = 16 zu

# ELAB2: Fatal Error: ELAB2_0013 MyComponent.vhd (22): Index 16 is out of range (15 downto 0) of "oVector".

etc.

Schuld sind also die beiden Zuweisungen auf oVector.
Seltsamer Weise machen die Zuweisungen auf oBit keine Probleme, obwohl 
das Prinzip gleich ist, nur dass die der Index rechts von der Zuweisung 
berechnet wird.
Die Synthese kommt mit dem Code gut zurechet.

library IEEE;
 use IEEE.std_logic_1164.all;
 use ieee.numeric_std.all;

entity myComponent is
    generic (
        gComponentIndex : integer range 0 to 31
    );
    port
    (
        iSysRst : in  std_logic;
        iSysClk : in  std_logic;
        iBit    : in  std_logic;
        iVector : in  std_logic_vector( 15 downto 0);
        oBit    : out std_logic;
        oVector : out std_logic_vector( 15 downto 0)
    );
end myComponent;

architecture RTL of myComponent is
begin
    plMyProcess : process (iSysRst, iSysClk)
    begin
        if rising_edge(iSysClk) then

            if gComponentIndex < 16 then
                oVector(gComponentIndex) <= iBit;
            end if;

            if (gComponentIndex > 16) and (gComponentIndex < 32) then
                oVector(gComponentIndex - 16) <= iBit;
            end if;

            if gComponentIndex < 16 then
                oBit  <= iVector(gComponentIndex);
            end if;

            if gComponentIndex >= 16 and gComponentIndex < 32 then
                oBit  <= iVector(gComponentIndex - 16);
            end if;
...

Zum technischen Hintergrund:
Ich habe mehrere Componenten mit jeweils einem interne Adressdecoder. 
Dieser ist für alle gleich, soll aber abhängig vom Componenten Index nur 
auf bestimmte Adressen reagieren. Teilweise soll auch nur ein Bit des 
einen oder anderen Datenregisters gelesen oder gesetzt werden. Alle 
Ausgänge der Adressdecoder werden abschließend miteinander verodert.

Habt Ihr eine Idee, wie ich das Problem lösen kann, dass die Simulation 
es schluckt? Wie kann ich einzelne Zuweisungen in einem getakteten 
Prozess abhängig von einem Generic "ausklammern"?

[Fred (Gast)]

Ich könnte natürlich einen Dummy Vector einfügen, der die Maximale Länge 
hat und dann später nur die unteren Bits nach aussen geben, aber so 
richtig schön kömmt mir das auch nicht vor und führt wohl zu weiteren 
Synthese Warnings... Aber immerhin besser, als auf die Simulation 
verzichten zu müssen.

architecture RTL of myComponent is
    signal sVector : std_logic_vector(31 downto 0);
begin
    oVector <= sVector(oVector'range);
    
    plMyProcess : process (iSysRst, iSysClk)
    begin
        if rising_edge(iSysClk) then

            if gComponentIndex < 16 then
                sVector(gComponentIndex) <= iBit;
            end if;

            if (gComponentIndex > 16) and (gComponentIndex < 32) then
                sVector(gComponentIndex - 16) <= iBit;
            end if;

[VHDL-Polizei (Gast)]

Würden die nichtbenötigten Funktionen in den Fällen der Nichtverwendung 
durch andere Komponenten / Situationen nicht wegsynthetisiert und liefen 
ins Leere?

Ansonsten würde ich eine dynamische Maske anlegen.

[Fred (Gast)]

Die "nicht benötigten" if clauses werden wegsynthetisiert, wie ich es 
mir wünsche. Lediglich die Simulation hat ein Problem damit.

Was meinst Du mit Dynamischer Maske?