-------------------------------------------------------------------------- -- -- -- Copyright (c) 1990,1991,1992 by Synopsys, Inc. All rights reserved. -- -- -- -- This source file may be used and distributed without restriction -- -- provided that this copyright statement is not removed from the file -- -- and that any derivative work contains this copyright notice. -- -- -- -- Package name: STD_LOGIC_ARITH -- -- -- -- Purpose: -- -- A set of arithemtic, conversion, and comparison functions -- -- for SIGNED, UNSIGNED, SMALL_INT, INTEGER, -- -- STD_ULOGIC, STD_LOGIC, and STD_LOGIC_VECTOR. -- -- -- -------------------------------------------------------------------------- library IEEE; use IEEE.std_logic_1164.all; package std_logic_arith is type UNSIGNED is array (NATURAL range <>) of STD_LOGIC; type SIGNED is array (NATURAL range <>) of STD_LOGIC; subtype SMALL_INT is INTEGER range 0 to 1; function "+"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED; function "+"(L: SIGNED; R: SIGNED) return SIGNED; function "+"(L: UNSIGNED; R: SIGNED) return SIGNED; function "+"(L: SIGNED; R: UNSIGNED) return SIGNED; function "+"(L: UNSIGNED; R: INTEGER) return UNSIGNED; function "+"(L: INTEGER; R: UNSIGNED) return UNSIGNED; function "+"(L: SIGNED; R: INTEGER) return SIGNED; function "+"(L: INTEGER; R: SIGNED) return SIGNED; function "+"(L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED; function "+"(L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED; function "+"(L: SIGNED; R: STD_ULOGIC) return SIGNED; function "+"(L: STD_ULOGIC; R: SIGNED) return SIGNED; function "+"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR; function "+"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR; function "+"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR; function "+"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR; function "+"(L: UNSIGNED; R: INTEGER) return STD_LOGIC_VECTOR; function "+"(L: INTEGER; R: UNSIGNED) return STD_LOGIC_VECTOR; function "+"(L: SIGNED; R: INTEGER) return STD_LOGIC_VECTOR; function "+"(L: INTEGER; R: SIGNED) return STD_LOGIC_VECTOR; function "+"(L: UNSIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR; function "+"(L: STD_ULOGIC; R: UNSIGNED) return STD_LOGIC_VECTOR; function "+"(L: SIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR; function "+"(L: STD_ULOGIC; R: SIGNED) return STD_LOGIC_VECTOR; function "-"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED; function "-"(L: SIGNED; R: SIGNED) return SIGNED; function "-"(L: UNSIGNED; R: SIGNED) return SIGNED; function "-"(L: SIGNED; R: UNSIGNED) return SIGNED; function "-"(L: UNSIGNED; R: INTEGER) return UNSIGNED; function "-"(L: INTEGER; R: UNSIGNED) return UNSIGNED; function "-"(L: SIGNED; R: INTEGER) return SIGNED; function "-"(L: INTEGER; R: SIGNED) return SIGNED; function "-"(L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED; function "-"(L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED; function "-"(L: SIGNED; R: STD_ULOGIC) return SIGNED; function "-"(L: STD_ULOGIC; R: SIGNED) return SIGNED; function "-"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR; function "-"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR; function "-"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR; function "-"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR; function "-"(L: UNSIGNED; R: INTEGER) return STD_LOGIC_VECTOR; function "-"(L: INTEGER; R: UNSIGNED) return STD_LOGIC_VECTOR; function "-"(L: SIGNED; R: INTEGER) return STD_LOGIC_VECTOR; function "-"(L: INTEGER; R: SIGNED) return STD_LOGIC_VECTOR; function "-"(L: UNSIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR; function "-"(L: STD_ULOGIC; R: UNSIGNED) return STD_LOGIC_VECTOR; function "-"(L: SIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR; function "-"(L: STD_ULOGIC; R: SIGNED) return STD_LOGIC_VECTOR; function "+"(L: UNSIGNED) return UNSIGNED; function "+"(L: SIGNED) return SIGNED; function "-"(L: SIGNED) return SIGNED; function "ABS"(L: SIGNED) return SIGNED; function "+"(L: UNSIGNED) return STD_LOGIC_VECTOR; function "+"(L: SIGNED) return STD_LOGIC_VECTOR; function "-"(L: SIGNED) return STD_LOGIC_VECTOR; function "ABS"(L: SIGNED) return STD_LOGIC_VECTOR; function "*"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED; function "*"(L: SIGNED; R: SIGNED) return SIGNED; function "*"(L: SIGNED; R: UNSIGNED) return SIGNED; function "*"(L: UNSIGNED; R: SIGNED) return SIGNED; function "*"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR; function "*"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR; function "*"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR; function "*"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR; function "<"(L: UNSIGNED; R: UNSIGNED) return BOOLEAN; function "<"(L: SIGNED; R: SIGNED) return BOOLEAN; function "<"(L: UNSIGNED; R: SIGNED) return BOOLEAN; function "<"(L: SIGNED; R: UNSIGNED) return BOOLEAN; function "<"(L: UNSIGNED; R: INTEGER) return BOOLEAN; function "<"(L: INTEGER; R: UNSIGNED) return BOOLEAN; function "<"(L: SIGNED; R: INTEGER) return BOOLEAN; function "<"(L: INTEGER; R: SIGNED) return BOOLEAN; function "<="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN; function "<="(L: SIGNED; R: SIGNED) return BOOLEAN; function "<="(L: UNSIGNED; R: SIGNED) return BOOLEAN; function "<="(L: SIGNED; R: UNSIGNED) return BOOLEAN; function "<="(L: UNSIGNED; R: INTEGER) return BOOLEAN; function "<="(L: INTEGER; R: UNSIGNED) return BOOLEAN; function "<="(L: SIGNED; R: INTEGER) return BOOLEAN; function "<="(L: INTEGER; R: SIGNED) return BOOLEAN; function ">"(L: UNSIGNED; R: UNSIGNED) return BOOLEAN; function ">"(L: SIGNED; R: SIGNED) return BOOLEAN; function ">"(L: UNSIGNED; R: SIGNED) return BOOLEAN; function ">"(L: SIGNED; R: UNSIGNED) return BOOLEAN; function ">"(L: UNSIGNED; R: INTEGER) return BOOLEAN; function ">"(L: INTEGER; R: UNSIGNED) return BOOLEAN; function ">"(L: SIGNED; R: INTEGER) return BOOLEAN; function ">"(L: INTEGER; R: SIGNED) return BOOLEAN; function ">="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN; function ">="(L: SIGNED; R: SIGNED) return BOOLEAN; function ">="(L: UNSIGNED; R: SIGNED) return BOOLEAN; function ">="(L: SIGNED; R: UNSIGNED) return BOOLEAN; function ">="(L: UNSIGNED; R: INTEGER) return BOOLEAN; function ">="(L: INTEGER; R: UNSIGNED) return BOOLEAN; function ">="(L: SIGNED; R: INTEGER) return BOOLEAN; function ">="(L: INTEGER; R: SIGNED) return BOOLEAN; function "="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN; function "="(L: SIGNED; R: SIGNED) return BOOLEAN; function "="(L: UNSIGNED; R: SIGNED) return BOOLEAN; function "="(L: SIGNED; R: UNSIGNED) return BOOLEAN; function "="(L: UNSIGNED; R: INTEGER) return BOOLEAN; function "="(L: INTEGER; R: UNSIGNED) return BOOLEAN; function "="(L: SIGNED; R: INTEGER) return BOOLEAN; function "="(L: INTEGER; R: SIGNED) return BOOLEAN; function "/="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN; function "/="(L: SIGNED; R: SIGNED) return BOOLEAN; function "/="(L: UNSIGNED; R: SIGNED) return BOOLEAN; function "/="(L: SIGNED; R: UNSIGNED) return BOOLEAN; function "/="(L: UNSIGNED; R: INTEGER) return BOOLEAN; function "/="(L: INTEGER; R: UNSIGNED) return BOOLEAN; function "/="(L: SIGNED; R: INTEGER) return BOOLEAN; function "/="(L: INTEGER; R: SIGNED) return BOOLEAN; function SHL(ARG: UNSIGNED; COUNT: UNSIGNED) return UNSIGNED; function SHL(ARG: SIGNED; COUNT: UNSIGNED) return SIGNED; function SHR(ARG: UNSIGNED; COUNT: UNSIGNED) return UNSIGNED; function SHR(ARG: SIGNED; COUNT: UNSIGNED) return SIGNED; function CONV_INTEGER(ARG: INTEGER) return INTEGER; function CONV_INTEGER(ARG: UNSIGNED) return INTEGER; function CONV_INTEGER(ARG: SIGNED) return INTEGER; function CONV_INTEGER(ARG: STD_ULOGIC) return SMALL_INT; function CONV_UNSIGNED(ARG: INTEGER; SIZE: INTEGER) return UNSIGNED; function CONV_UNSIGNED(ARG: UNSIGNED; SIZE: INTEGER) return UNSIGNED; function CONV_UNSIGNED(ARG: SIGNED; SIZE: INTEGER) return UNSIGNED; function CONV_UNSIGNED(ARG: STD_ULOGIC; SIZE: INTEGER) return UNSIGNED; function CONV_SIGNED(ARG: INTEGER; SIZE: INTEGER) return SIGNED; function CONV_SIGNED(ARG: UNSIGNED; SIZE: INTEGER) return SIGNED; function CONV_SIGNED(ARG: SIGNED; SIZE: INTEGER) return SIGNED; function CONV_SIGNED(ARG: STD_ULOGIC; SIZE: INTEGER) return SIGNED; function CONV_STD_LOGIC_VECTOR(ARG: INTEGER; SIZE: INTEGER) return STD_LOGIC_VECTOR; function CONV_STD_LOGIC_VECTOR(ARG: UNSIGNED; SIZE: INTEGER) return STD_LOGIC_VECTOR; function CONV_STD_LOGIC_VECTOR(ARG: SIGNED; SIZE: INTEGER) return STD_LOGIC_VECTOR; function CONV_STD_LOGIC_VECTOR(ARG: STD_ULOGIC; SIZE: INTEGER) return STD_LOGIC_VECTOR; -- zero extend STD_LOGIC_VECTOR (ARG) to SIZE, -- SIZE < 0 is same as SIZE = 0 -- returns STD_LOGIC_VECTOR(SIZE-1 downto 0) function EXT(ARG: STD_LOGIC_VECTOR; SIZE: INTEGER) return STD_LOGIC_VECTOR; -- sign extend STD_LOGIC_VECTOR (ARG) to SIZE, -- SIZE < 0 is same as SIZE = 0 -- return STD_LOGIC_VECTOR(SIZE-1 downto 0) function SXT(ARG: STD_LOGIC_VECTOR; SIZE: INTEGER) return STD_LOGIC_VECTOR; end Std_logic_arith; library IEEE; use IEEE.std_logic_1164.all; package body std_logic_arith is function max(L, R: INTEGER) return INTEGER is begin if L > R then return L; else return R; end if; end; function min(L, R: INTEGER) return INTEGER is begin if L < R then return L; else return R; end if; end; -- synopsys synthesis_off type tbl_type is array (STD_ULOGIC) of STD_ULOGIC; constant tbl_BINARY : tbl_type := ('X', 'X', '0', '1', 'X', 'X', '0', '1', 'X'); -- synopsys synthesis_on -- synopsys synthesis_off type tbl_mvl9_boolean is array (STD_ULOGIC) of boolean; constant IS_X : tbl_mvl9_boolean := (true, true, false, false, true, true, false, false, true); -- synopsys synthesis_on function MAKE_BINARY(A : STD_ULOGIC) return STD_ULOGIC is -- synopsys built_in SYN_FEED_THRU begin -- synopsys synthesis_off if (IS_X(A)) then assert false report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)." severity warning; return ('X'); end if; return tbl_BINARY(A); -- synopsys synthesis_on end; function MAKE_BINARY(A : UNSIGNED) return UNSIGNED is -- synopsys built_in SYN_FEED_THRU variable one_bit : STD_ULOGIC; variable result : UNSIGNED (A'range); begin -- synopsys synthesis_off for i in A'range loop if (IS_X(A(i))) then assert false report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)." severity warning; result := (others => 'X'); return result; end if; result(i) := tbl_BINARY(A(i)); end loop; return result; -- synopsys synthesis_on end; function MAKE_BINARY(A : UNSIGNED) return SIGNED is -- synopsys built_in SYN_FEED_THRU variable one_bit : STD_ULOGIC; variable result : SIGNED (A'range); begin -- synopsys synthesis_off for i in A'range loop if (IS_X(A(i))) then assert false report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)." severity warning; result := (others => 'X'); return result; end if; result(i) := tbl_BINARY(A(i)); end loop; return result; -- synopsys synthesis_on end; function MAKE_BINARY(A : SIGNED) return UNSIGNED is -- synopsys built_in SYN_FEED_THRU variable one_bit : STD_ULOGIC; variable result : UNSIGNED (A'range); begin -- synopsys synthesis_off for i in A'range loop if (IS_X(A(i))) then assert false report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)." severity warning; result := (others => 'X'); return result; end if; result(i) := tbl_BINARY(A(i)); end loop; return result; -- synopsys synthesis_on end; function MAKE_BINARY(A : SIGNED) return SIGNED is -- synopsys built_in SYN_FEED_THRU variable one_bit : STD_ULOGIC; variable result : SIGNED (A'range); begin -- synopsys synthesis_off for i in A'range loop if (IS_X(A(i))) then assert false report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)." severity warning; result := (others => 'X'); return result; end if; result(i) := tbl_BINARY(A(i)); end loop; return result; -- synopsys synthesis_on end; function MAKE_BINARY(A : STD_LOGIC_VECTOR) return STD_LOGIC_VECTOR is -- synopsys built_in SYN_FEED_THRU variable one_bit : STD_ULOGIC; variable result : STD_LOGIC_VECTOR (A'range); begin -- synopsys synthesis_off for i in A'range loop if (IS_X(A(i))) then assert false report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)." severity warning; result := (others => 'X'); return result; end if; result(i) := tbl_BINARY(A(i)); end loop; return result; -- synopsys synthesis_on end; function MAKE_BINARY(A : UNSIGNED) return STD_LOGIC_VECTOR is -- synopsys built_in SYN_FEED_THRU variable one_bit : STD_ULOGIC; variable result : STD_LOGIC_VECTOR (A'range); begin -- synopsys synthesis_off for i in A'range loop if (IS_X(A(i))) then assert false report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)." severity warning; result := (others => 'X'); return result; end if; result(i) := tbl_BINARY(A(i)); end loop; return result; -- synopsys synthesis_on end; function MAKE_BINARY(A : SIGNED) return STD_LOGIC_VECTOR is -- synopsys built_in SYN_FEED_THRU variable one_bit : STD_ULOGIC; variable result : STD_LOGIC_VECTOR (A'range); begin -- synopsys synthesis_off for i in A'range loop if (IS_X(A(i))) then assert false report "There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, the result will be 'X'(es)." severity warning; result := (others => 'X'); return result; end if; result(i) := tbl_BINARY(A(i)); end loop; return result; -- synopsys synthesis_on end; -- Type propagation function which returns a signed type with the -- size of the left arg. function LEFT_SIGNED_ARG(A,B: SIGNED) return SIGNED is variable Z: SIGNED (A'left downto 0); -- pragma return_port_name Z begin return(Z); end; -- Type propagation function which returns an unsigned type with the -- size of the left arg. function LEFT_UNSIGNED_ARG(A,B: UNSIGNED) return UNSIGNED is variable Z: UNSIGNED (A'left downto 0); -- pragma return_port_name Z begin return(Z); end; -- Type propagation function which returns a signed type with the -- size of the result of a signed multiplication function MULT_SIGNED_ARG(A,B: SIGNED) return SIGNED is variable Z: SIGNED ((A'length+B'length-1) downto 0); -- pragma return_port_name Z begin return(Z); end; -- Type propagation function which returns an unsigned type with the -- size of the result of a unsigned multiplication function MULT_UNSIGNED_ARG(A,B: UNSIGNED) return UNSIGNED is variable Z: UNSIGNED ((A'length+B'length-1) downto 0); -- pragma return_port_name Z begin return(Z); end; function mult(A,B: SIGNED) return SIGNED is variable BA: SIGNED((A'length+B'length-1) downto 0); variable PA: SIGNED((A'length+B'length-1) downto 0); variable AA: SIGNED(A'length downto 0); variable neg: STD_ULOGIC; constant one : UNSIGNED(1 downto 0) := "01"; -- pragma map_to_operator MULT_TC_OP -- pragma type_function MULT_SIGNED_ARG -- pragma return_port_name Z begin if (A(A'left) = 'X' or B(B'left) = 'X') then PA := (others => 'X'); return(PA); end if; PA := (others => '0'); neg := B(B'left) xor A(A'left); BA := CONV_SIGNED(('0' & ABS(B)),(A'length+B'length)); AA := '0' & ABS(A); for i in 0 to A'length-1 loop if AA(i) = '1' then PA := PA+BA; end if; BA := SHL(BA,one); end loop; if (neg= '1') then return(-PA); else return(PA); end if; end; function mult(A,B: UNSIGNED) return UNSIGNED is variable BA: UNSIGNED((A'length+B'length-1) downto 0); variable PA: UNSIGNED((A'length+B'length-1) downto 0); constant one : UNSIGNED(1 downto 0) := "01"; -- pragma map_to_operator MULT_UNS_OP -- pragma type_function MULT_UNSIGNED_ARG -- pragma return_port_name Z begin if (A(A'left) = 'X' or B(B'left) = 'X') then PA := (others => 'X'); return(PA); end if; PA := (others => '0'); BA := CONV_UNSIGNED(B,(A'length+B'length)); for i in 0 to A'length-1 loop if A(i) = '1' then PA := PA+BA; end if; BA := SHL(BA,one); end loop; return(PA); end; -- subtract two signed numbers of the same length -- both arrays must have range (msb downto 0) function minus(A, B: SIGNED) return SIGNED is variable carry: STD_ULOGIC; variable BV: STD_ULOGIC_VECTOR (A'left downto 0); variable sum: SIGNED (A'left downto 0); -- pragma map_to_operator SUB_TC_OP -- pragma type_function LEFT_SIGNED_ARG -- pragma return_port_name Z begin if (A(A'left) = 'X' or B(B'left) = 'X') then sum := (others => 'X'); return(sum); end if; carry := '1'; BV := not STD_ULOGIC_VECTOR(B); for i in 0 to A'left loop sum(i) := A(i) xor BV(i) xor carry; carry := (A(i) and BV(i)) or (A(i) and carry) or (carry and BV(i)); end loop; return sum; end; -- add two signed numbers of the same length -- both arrays must have range (msb downto 0) function plus(A, B: SIGNED) return SIGNED is variable carry: STD_ULOGIC; variable BV, sum: SIGNED (A'left downto 0); -- pragma map_to_operator ADD_TC_OP -- pragma type_function LEFT_SIGNED_ARG -- pragma return_port_name Z begin if (A(A'left) = 'X' or B(B'left) = 'X') then sum := (others => 'X'); return(sum); end if; carry := '0'; BV := B; for i in 0 to A'left loop sum(i) := A(i) xor BV(i) xor carry; carry := (A(i) and BV(i)) or (A(i) and carry) or (carry and BV(i)); end loop; return sum; end; -- subtract two unsigned numbers of the same length -- both arrays must have range (msb downto 0) function unsigned_minus(A, B: UNSIGNED) return UNSIGNED is variable carry: STD_ULOGIC; variable BV: STD_ULOGIC_VECTOR (A'left downto 0); variable sum: UNSIGNED (A'left downto 0); -- pragma map_to_operator SUB_UNS_OP -- pragma type_function LEFT_UNSIGNED_ARG -- pragma return_port_name Z begin if (A(A'left) = 'X' or B(B'left) = 'X') then sum := (others => 'X'); return(sum); end if; carry := '1'; BV := not STD_ULOGIC_VECTOR(B); for i in 0 to A'left loop sum(i) := A(i) xor BV(i) xor carry; carry := (A(i) and BV(i)) or (A(i) and carry) or (carry and BV(i)); end loop; return sum; end; -- add two unsigned numbers of the same length -- both arrays must have range (msb downto 0) function unsigned_plus(A, B: UNSIGNED) return UNSIGNED is variable carry: STD_ULOGIC; variable BV, sum: UNSIGNED (A'left downto 0); -- pragma map_to_operator ADD_UNS_OP -- pragma type_function LEFT_UNSIGNED_ARG -- pragma return_port_name Z begin if (A(A'left) = 'X' or B(B'left) = 'X') then sum := (others => 'X'); return(sum); end if; carry := '0'; BV := B; for i in 0 to A'left loop sum(i) := A(i) xor BV(i) xor carry; carry := (A(i) and BV(i)) or (A(i) and carry) or (carry and BV(i)); end loop; return sum; end; function "*"(L: SIGNED; R: SIGNED) return SIGNED is -- pragma label_applies_to mult -- synopsys subpgm_id 296 begin return mult(CONV_SIGNED(L, L'length), CONV_SIGNED(R, R'length)); -- pragma label mult end; function "*"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED is -- pragma label_applies_to mult -- synopsys subpgm_id 295 begin return mult(CONV_UNSIGNED(L, L'length), CONV_UNSIGNED(R, R'length)); -- pragma label mult end; function "*"(L: UNSIGNED; R: SIGNED) return SIGNED is -- pragma label_applies_to mult -- synopsys subpgm_id 297 begin return mult(CONV_SIGNED(L, L'length+1), CONV_SIGNED(R, R'length)); -- pragma label mult end; function "*"(L: SIGNED; R: UNSIGNED) return SIGNED is -- pragma label_applies_to mult -- synopsys subpgm_id 298 begin return mult(CONV_SIGNED(L, L'length), CONV_SIGNED(R, R'length+1)); -- pragma label mult end; function "*"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to mult -- synopsys subpgm_id 301 begin return STD_LOGIC_VECTOR ( mult(-- pragma label mult CONV_SIGNED(L, L'length), CONV_SIGNED(R, R'length))); end; function "*"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to mult -- synopsys subpgm_id 300 begin return STD_LOGIC_VECTOR ( mult(-- pragma label mult CONV_UNSIGNED(L, L'length), CONV_UNSIGNED(R, R'length))); end; function "*"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to mult -- synopsys subpgm_id 302 begin return STD_LOGIC_VECTOR ( mult(-- pragma label mult CONV_SIGNED(L, L'length+1), CONV_SIGNED(R, R'length))); end; function "*"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to mult -- synopsys subpgm_id 303 begin return STD_LOGIC_VECTOR ( mult(-- pragma label mult CONV_SIGNED(L, L'length), CONV_SIGNED(R, R'length+1))); end; function "+"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED is -- pragma label_applies_to plus -- synopsys subpgm_id 236 constant length: INTEGER := max(L'length, R'length); begin return unsigned_plus(CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length)); -- pragma label plus end; function "+"(L: SIGNED; R: SIGNED) return SIGNED is -- pragma label_applies_to plus -- synopsys subpgm_id 237 constant length: INTEGER := max(L'length, R'length); begin return plus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label plus end; function "+"(L: UNSIGNED; R: SIGNED) return SIGNED is -- pragma label_applies_to plus -- synopsys subpgm_id 238 constant length: INTEGER := max(L'length + 1, R'length); begin return plus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label plus end; function "+"(L: SIGNED; R: UNSIGNED) return SIGNED is -- pragma label_applies_to plus -- synopsys subpgm_id 239 constant length: INTEGER := max(L'length, R'length + 1); begin return plus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label plus end; function "+"(L: UNSIGNED; R: INTEGER) return UNSIGNED is -- pragma label_applies_to plus -- synopsys subpgm_id 240 constant length: INTEGER := L'length + 1; begin return CONV_UNSIGNED( plus( -- pragma label plus CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1); end; function "+"(L: INTEGER; R: UNSIGNED) return UNSIGNED is -- pragma label_applies_to plus -- synopsys subpgm_id 241 constant length: INTEGER := R'length + 1; begin return CONV_UNSIGNED( plus( -- pragma label plus CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1); end; function "+"(L: SIGNED; R: INTEGER) return SIGNED is -- pragma label_applies_to plus -- synopsys subpgm_id 242 constant length: INTEGER := L'length; begin return plus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label plus end; function "+"(L: INTEGER; R: SIGNED) return SIGNED is -- pragma label_applies_to plus -- synopsys subpgm_id 243 constant length: INTEGER := R'length; begin return plus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label plus end; function "+"(L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED is -- pragma label_applies_to plus -- synopsys subpgm_id 244 constant length: INTEGER := L'length; begin return unsigned_plus(CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length)) ; -- pragma label plus end; function "+"(L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED is -- pragma label_applies_to plus -- synopsys subpgm_id 245 constant length: INTEGER := R'length; begin return unsigned_plus(CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length)); -- pragma label plus end; function "+"(L: SIGNED; R: STD_ULOGIC) return SIGNED is -- pragma label_applies_to plus -- synopsys subpgm_id 246 constant length: INTEGER := L'length; begin return plus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label plus end; function "+"(L: STD_ULOGIC; R: SIGNED) return SIGNED is -- pragma label_applies_to plus -- synopsys subpgm_id 247 constant length: INTEGER := R'length; begin return plus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label plus end; function "+"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to plus -- synopsys subpgm_id 260 constant length: INTEGER := max(L'length, R'length); begin return STD_LOGIC_VECTOR ( unsigned_plus(-- pragma label plus CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length))); end; function "+"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to plus -- synopsys subpgm_id 261 constant length: INTEGER := max(L'length, R'length); begin return STD_LOGIC_VECTOR ( plus(-- pragma label plus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "+"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to plus -- synopsys subpgm_id 262 constant length: INTEGER := max(L'length + 1, R'length); begin return STD_LOGIC_VECTOR ( plus(-- pragma label plus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "+"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to plus -- synopsys subpgm_id 263 constant length: INTEGER := max(L'length, R'length + 1); begin return STD_LOGIC_VECTOR ( plus(-- pragma label plus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "+"(L: UNSIGNED; R: INTEGER) return STD_LOGIC_VECTOR is -- pragma label_applies_to plus -- synopsys subpgm_id 264 constant length: INTEGER := L'length + 1; begin return STD_LOGIC_VECTOR (CONV_UNSIGNED( plus( -- pragma label plus CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1)); end; function "+"(L: INTEGER; R: UNSIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to plus -- synopsys subpgm_id 265 constant length: INTEGER := R'length + 1; begin return STD_LOGIC_VECTOR (CONV_UNSIGNED( plus( -- pragma label plus CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1)); end; function "+"(L: SIGNED; R: INTEGER) return STD_LOGIC_VECTOR is -- pragma label_applies_to plus -- synopsys subpgm_id 266 constant length: INTEGER := L'length; begin return STD_LOGIC_VECTOR ( plus(-- pragma label plus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "+"(L: INTEGER; R: SIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to plus -- synopsys subpgm_id 267 constant length: INTEGER := R'length; begin return STD_LOGIC_VECTOR ( plus(-- pragma label plus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "+"(L: UNSIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR is -- pragma label_applies_to plus -- synopsys subpgm_id 268 constant length: INTEGER := L'length; begin return STD_LOGIC_VECTOR ( unsigned_plus(-- pragma label plus CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length))) ; end; function "+"(L: STD_ULOGIC; R: UNSIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to plus -- synopsys subpgm_id 269 constant length: INTEGER := R'length; begin return STD_LOGIC_VECTOR ( unsigned_plus(-- pragma label plus CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length))); end; function "+"(L: SIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR is -- pragma label_applies_to plus -- synopsys subpgm_id 270 constant length: INTEGER := L'length; begin return STD_LOGIC_VECTOR ( plus(-- pragma label plus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "+"(L: STD_ULOGIC; R: SIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to plus -- synopsys subpgm_id 271 constant length: INTEGER := R'length; begin return STD_LOGIC_VECTOR ( plus(-- pragma label plus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "-"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 248 constant length: INTEGER := max(L'length, R'length); begin return unsigned_minus(CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length)); -- pragma label minus end; function "-"(L: SIGNED; R: SIGNED) return SIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 249 constant length: INTEGER := max(L'length, R'length); begin return minus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label minus end; function "-"(L: UNSIGNED; R: SIGNED) return SIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 250 constant length: INTEGER := max(L'length + 1, R'length); begin return minus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label minus end; function "-"(L: SIGNED; R: UNSIGNED) return SIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 251 constant length: INTEGER := max(L'length, R'length + 1); begin return minus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label minus end; function "-"(L: UNSIGNED; R: INTEGER) return UNSIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 252 constant length: INTEGER := L'length + 1; begin return CONV_UNSIGNED( minus( -- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1); end; function "-"(L: INTEGER; R: UNSIGNED) return UNSIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 253 constant length: INTEGER := R'length + 1; begin return CONV_UNSIGNED( minus( -- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1); end; function "-"(L: SIGNED; R: INTEGER) return SIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 254 constant length: INTEGER := L'length; begin return minus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label minus end; function "-"(L: INTEGER; R: SIGNED) return SIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 255 constant length: INTEGER := R'length; begin return minus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label minus end; function "-"(L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 256 constant length: INTEGER := L'length + 1; begin return CONV_UNSIGNED( minus( -- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1); end; function "-"(L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 257 constant length: INTEGER := R'length + 1; begin return CONV_UNSIGNED( minus( -- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1); end; function "-"(L: SIGNED; R: STD_ULOGIC) return SIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 258 constant length: INTEGER := L'length; begin return minus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label minus end; function "-"(L: STD_ULOGIC; R: SIGNED) return SIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 259 constant length: INTEGER := R'length; begin return minus(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label minus end; function "-"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 272 constant length: INTEGER := max(L'length, R'length); begin return STD_LOGIC_VECTOR ( unsigned_minus(-- pragma label minus CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length))); end; function "-"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 273 constant length: INTEGER := max(L'length, R'length); begin return STD_LOGIC_VECTOR ( minus(-- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "-"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 274 constant length: INTEGER := max(L'length + 1, R'length); begin return STD_LOGIC_VECTOR ( minus(-- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "-"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 275 constant length: INTEGER := max(L'length, R'length + 1); begin return STD_LOGIC_VECTOR ( minus(-- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "-"(L: UNSIGNED; R: INTEGER) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 276 constant length: INTEGER := L'length + 1; begin return STD_LOGIC_VECTOR (CONV_UNSIGNED( minus( -- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1)); end; function "-"(L: INTEGER; R: UNSIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 277 constant length: INTEGER := R'length + 1; begin return STD_LOGIC_VECTOR (CONV_UNSIGNED( minus( -- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1)); end; function "-"(L: SIGNED; R: INTEGER) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 278 constant length: INTEGER := L'length; begin return STD_LOGIC_VECTOR ( minus(-- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "-"(L: INTEGER; R: SIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 279 constant length: INTEGER := R'length; begin return STD_LOGIC_VECTOR ( minus(-- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "-"(L: UNSIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 280 constant length: INTEGER := L'length + 1; begin return STD_LOGIC_VECTOR (CONV_UNSIGNED( minus( -- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1)); end; function "-"(L: STD_ULOGIC; R: UNSIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 281 constant length: INTEGER := R'length + 1; begin return STD_LOGIC_VECTOR (CONV_UNSIGNED( minus( -- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length)), length-1)); end; function "-"(L: SIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 282 constant length: INTEGER := L'length; begin return STD_LOGIC_VECTOR ( minus(-- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "-"(L: STD_ULOGIC; R: SIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 283 constant length: INTEGER := R'length; begin return STD_LOGIC_VECTOR ( minus(-- pragma label minus CONV_SIGNED(L, length), CONV_SIGNED(R, length))); end; function "+"(L: UNSIGNED) return UNSIGNED is -- synopsys subpgm_id 284 begin return L; end; function "+"(L: SIGNED) return SIGNED is -- synopsys subpgm_id 285 begin return L; end; function "-"(L: SIGNED) return SIGNED is -- pragma label_applies_to minus -- synopsys subpgm_id 286 begin return 0 - L; -- pragma label minus end; function "ABS"(L: SIGNED) return SIGNED is -- synopsys subpgm_id 287 begin if (L(L'left) = '0' or L(L'left) = 'L') then return L; else return 0 - L; end if; end; function "+"(L: UNSIGNED) return STD_LOGIC_VECTOR is -- synopsys subpgm_id 289 begin return STD_LOGIC_VECTOR (L); end; function "+"(L: SIGNED) return STD_LOGIC_VECTOR is -- synopsys subpgm_id 290 begin return STD_LOGIC_VECTOR (L); end; function "-"(L: SIGNED) return STD_LOGIC_VECTOR is -- pragma label_applies_to minus -- synopsys subpgm_id 292 variable tmp: SIGNED(L'length-1 downto 0); begin tmp := 0 - L; -- pragma label minus return STD_LOGIC_VECTOR (tmp); end; function "ABS"(L: SIGNED) return STD_LOGIC_VECTOR is -- synopsys subpgm_id 294 variable tmp: SIGNED(L'length-1 downto 0); begin if (L(L'left) = '0' or L(L'left) = 'L') then return STD_LOGIC_VECTOR (L); else tmp := 0 - L; return STD_LOGIC_VECTOR (tmp); end if; end; -- Type propagation function which returns the type BOOLEAN function UNSIGNED_RETURN_BOOLEAN(A,B: UNSIGNED) return BOOLEAN is variable Z: BOOLEAN; -- pragma return_port_name Z begin return(Z); end; -- Type propagation function which returns the type BOOLEAN function SIGNED_RETURN_BOOLEAN(A,B: SIGNED) return BOOLEAN is variable Z: BOOLEAN; -- pragma return_port_name Z begin return(Z); end; -- compare two signed numbers of the same length -- both arrays must have range (msb downto 0) function is_less(A, B: SIGNED) return BOOLEAN is constant sign: INTEGER := A'left; variable a_is_0, b_is_1, result : boolean; -- pragma map_to_operator LT_TC_OP -- pragma type_function SIGNED_RETURN_BOOLEAN -- pragma return_port_name Z begin if A(sign) /= B(sign) then result := A(sign) = '1'; else result := FALSE; for i in 0 to sign-1 loop a_is_0 := A(i) = '0'; b_is_1 := B(i) = '1'; result := (a_is_0 and b_is_1) or (a_is_0 and result) or (b_is_1 and result); end loop; end if; return result; end; -- compare two signed numbers of the same length -- both arrays must have range (msb downto 0) function is_less_or_equal(A, B: SIGNED) return BOOLEAN is constant sign: INTEGER := A'left; variable a_is_0, b_is_1, result : boolean; -- pragma map_to_operator LEQ_TC_OP -- pragma type_function SIGNED_RETURN_BOOLEAN -- pragma return_port_name Z begin if A(sign) /= B(sign) then result := A(sign) = '1'; else result := TRUE; for i in 0 to sign-1 loop a_is_0 := A(i) = '0'; b_is_1 := B(i) = '1'; result := (a_is_0 and b_is_1) or (a_is_0 and result) or (b_is_1 and result); end loop; end if; return result; end; -- compare two unsigned numbers of the same length -- both arrays must have range (msb downto 0) function unsigned_is_less(A, B: UNSIGNED) return BOOLEAN is constant sign: INTEGER := A'left; variable a_is_0, b_is_1, result : boolean; -- pragma map_to_operator LT_UNS_OP -- pragma type_function UNSIGNED_RETURN_BOOLEAN -- pragma return_port_name Z begin result := FALSE; for i in 0 to sign loop a_is_0 := A(i) = '0'; b_is_1 := B(i) = '1'; result := (a_is_0 and b_is_1) or (a_is_0 and result) or (b_is_1 and result); end loop; return result; end; -- compare two unsigned numbers of the same length -- both arrays must have range (msb downto 0) function unsigned_is_less_or_equal(A, B: UNSIGNED) return BOOLEAN is constant sign: INTEGER := A'left; variable a_is_0, b_is_1, result : boolean; -- pragma map_to_operator LEQ_UNS_OP -- pragma type_function UNSIGNED_RETURN_BOOLEAN -- pragma return_port_name Z begin result := TRUE; for i in 0 to sign loop a_is_0 := A(i) = '0'; b_is_1 := B(i) = '1'; result := (a_is_0 and b_is_1) or (a_is_0 and result) or (b_is_1 and result); end loop; return result; end; function "<"(L: UNSIGNED; R: UNSIGNED) return BOOLEAN is -- pragma label_applies_to lt -- synopsys subpgm_id 305 constant length: INTEGER := max(L'length, R'length); begin return unsigned_is_less(CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length)); -- pragma label lt end; function "<"(L: SIGNED; R: SIGNED) return BOOLEAN is -- pragma label_applies_to lt -- synopsys subpgm_id 306 constant length: INTEGER := max(L'length, R'length); begin return is_less(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label lt end; function "<"(L: UNSIGNED; R: SIGNED) return BOOLEAN is -- pragma label_applies_to lt -- synopsys subpgm_id 307 constant length: INTEGER := max(L'length + 1, R'length); begin return is_less(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label lt end; function "<"(L: SIGNED; R: UNSIGNED) return BOOLEAN is -- pragma label_applies_to lt -- synopsys subpgm_id 308 constant length: INTEGER := max(L'length, R'length + 1); begin return is_less(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label lt end; function "<"(L: UNSIGNED; R: INTEGER) return BOOLEAN is -- pragma label_applies_to lt -- synopsys subpgm_id 309 constant length: INTEGER := L'length + 1; begin return is_less(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label lt end; function "<"(L: INTEGER; R: UNSIGNED) return BOOLEAN is -- pragma label_applies_to lt -- synopsys subpgm_id 310 constant length: INTEGER := R'length + 1; begin return is_less(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label lt end; function "<"(L: SIGNED; R: INTEGER) return BOOLEAN is -- pragma label_applies_to lt -- synopsys subpgm_id 311 constant length: INTEGER := L'length; begin return is_less(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label lt end; function "<"(L: INTEGER; R: SIGNED) return BOOLEAN is -- pragma label_applies_to lt -- synopsys subpgm_id 312 constant length: INTEGER := R'length; begin return is_less(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label lt end; function "<="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN is -- pragma label_applies_to leq -- synopsys subpgm_id 314 constant length: INTEGER := max(L'length, R'length); begin return unsigned_is_less_or_equal(CONV_UNSIGNED(L, length), CONV_UNSIGNED(R, length)); -- pragma label leq end; function "<="(L: SIGNED; R: SIGNED) return BOOLEAN is -- pragma label_applies_to leq -- synopsys subpgm_id 315 constant length: INTEGER := max(L'length, R'length); begin return is_less_or_equal(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label leq end; function "<="(L: UNSIGNED; R: SIGNED) return BOOLEAN is -- pragma label_applies_to leq -- synopsys subpgm_id 316 constant length: INTEGER := max(L'length + 1, R'length); begin return is_less_or_equal(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label leq end; function "<="(L: SIGNED; R: UNSIGNED) return BOOLEAN is -- pragma label_applies_to leq -- synopsys subpgm_id 317 constant length: INTEGER := max(L'length, R'length + 1); begin return is_less_or_equal(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label leq end; function "<="(L: UNSIGNED; R: INTEGER) return BOOLEAN is -- pragma label_applies_to leq -- synopsys subpgm_id 318 constant length: INTEGER := L'length + 1; begin return is_less_or_equal(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label leq end; function "<="(L: INTEGER; R: UNSIGNED) return BOOLEAN is -- pragma label_applies_to leq -- synopsys subpgm_id 319 constant length: INTEGER := R'length + 1; begin return is_less_or_equal(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label leq end; function "<="(L: SIGNED; R: INTEGER) return BOOLEAN is -- pragma label_applies_to leq -- synopsys subpgm_id 320 constant length: INTEGER := L'length; begin return is_less_or_equal(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label leq end; function "<="(L: INTEGER; R: SIGNED) return BOOLEAN is -- pragma label_applies_to leq -- synopsys subpgm_id 321 constant length: INTEGER := R'length; begin return is_less_or_equal(CONV_SIGNED(L, length), CONV_SIGNED(R, length)); -- pragma label leq end; function ">"(L: UNSIGNED; R: UNSIGNED) return BOOLEAN is -- pragma label_applies_to gt -- synopsys subpgm_id 323 constant length: INTEGER := max(L'length, R'length); begin return unsigned_is_less(CONV_UNSIGNED(R, length), CONV_UNSIGNED(L, length)); -- pragma label gt end; function ">"(L: SIGNED; R: SIGNED) return BOOLEAN is -- pragma label_applies_to gt -- synopsys subpgm_id 324 constant length: INTEGER := max(L'length, R'length); begin return is_less(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label gt end; function ">"(L: UNSIGNED; R: SIGNED) return BOOLEAN is -- pragma label_applies_to gt -- synopsys subpgm_id 325 constant length: INTEGER := max(L'length + 1, R'length); begin return is_less(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label gt end; function ">"(L: SIGNED; R: UNSIGNED) return BOOLEAN is -- pragma label_applies_to gt -- synopsys subpgm_id 326 constant length: INTEGER := max(L'length, R'length + 1); begin return is_less(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label gt end; function ">"(L: UNSIGNED; R: INTEGER) return BOOLEAN is -- pragma label_applies_to gt -- synopsys subpgm_id 327 constant length: INTEGER := L'length + 1; begin return is_less(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label gt end; function ">"(L: INTEGER; R: UNSIGNED) return BOOLEAN is -- pragma label_applies_to gt -- synopsys subpgm_id 328 constant length: INTEGER := R'length + 1; begin return is_less(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label gt end; function ">"(L: SIGNED; R: INTEGER) return BOOLEAN is -- pragma label_applies_to gt -- synopsys subpgm_id 329 constant length: INTEGER := L'length; begin return is_less(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label gt end; function ">"(L: INTEGER; R: SIGNED) return BOOLEAN is -- pragma label_applies_to gt -- synopsys subpgm_id 330 constant length: INTEGER := R'length; begin return is_less(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label gt end; function ">="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN is -- pragma label_applies_to geq -- synopsys subpgm_id 332 constant length: INTEGER := max(L'length, R'length); begin return unsigned_is_less_or_equal(CONV_UNSIGNED(R, length), CONV_UNSIGNED(L, length)); -- pragma label geq end; function ">="(L: SIGNED; R: SIGNED) return BOOLEAN is -- pragma label_applies_to geq -- synopsys subpgm_id 333 constant length: INTEGER := max(L'length, R'length); begin return is_less_or_equal(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label geq end; function ">="(L: UNSIGNED; R: SIGNED) return BOOLEAN is -- pragma label_applies_to geq -- synopsys subpgm_id 334 constant length: INTEGER := max(L'length + 1, R'length); begin return is_less_or_equal(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label geq end; function ">="(L: SIGNED; R: UNSIGNED) return BOOLEAN is -- pragma label_applies_to geq -- synopsys subpgm_id 335 constant length: INTEGER := max(L'length, R'length + 1); begin return is_less_or_equal(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label geq end; function ">="(L: UNSIGNED; R: INTEGER) return BOOLEAN is -- pragma label_applies_to geq -- synopsys subpgm_id 336 constant length: INTEGER := L'length + 1; begin return is_less_or_equal(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label geq end; function ">="(L: INTEGER; R: UNSIGNED) return BOOLEAN is -- pragma label_applies_to geq -- synopsys subpgm_id 337 constant length: INTEGER := R'length + 1; begin return is_less_or_equal(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label geq end; function ">="(L: SIGNED; R: INTEGER) return BOOLEAN is -- pragma label_applies_to geq -- synopsys subpgm_id 338 constant length: INTEGER := L'length; begin return is_less_or_equal(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label geq end; function ">="(L: INTEGER; R: SIGNED) return BOOLEAN is -- pragma label_applies_to geq -- synopsys subpgm_id 339 constant length: INTEGER := R'length; begin return is_less_or_equal(CONV_SIGNED(R, length), CONV_SIGNED(L, length)); -- pragma label geq end; -- for internal use only. Assumes SIGNED arguments of equal length. function bitwise_eql(L: STD_ULOGIC_VECTOR; R: STD_ULOGIC_VECTOR) return BOOLEAN is -- pragma built_in SYN_EQL begin for i in L'range loop if L(i) /= R(i) then return FALSE; end if; end loop; return TRUE; end; -- for internal use only. Assumes SIGNED arguments of equal length. function bitwise_neq(L: STD_ULOGIC_VECTOR; R: STD_ULOGIC_VECTOR) return BOOLEAN is -- pragma built_in SYN_NEQ begin for i in L'range loop if L(i) /= R(i) then return TRUE; end if; end loop; return FALSE; end; function "="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN is -- synopsys subpgm_id 341 constant length: INTEGER := max(L'length, R'length); begin return bitwise_eql( STD_ULOGIC_VECTOR( CONV_UNSIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_UNSIGNED(R, length) ) ); end; function "="(L: SIGNED; R: SIGNED) return BOOLEAN is -- synopsys subpgm_id 342 constant length: INTEGER := max(L'length, R'length); begin return bitwise_eql( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "="(L: UNSIGNED; R: SIGNED) return BOOLEAN is -- synopsys subpgm_id 343 constant length: INTEGER := max(L'length + 1, R'length); begin return bitwise_eql( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "="(L: SIGNED; R: UNSIGNED) return BOOLEAN is -- synopsys subpgm_id 344 constant length: INTEGER := max(L'length, R'length + 1); begin return bitwise_eql( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "="(L: UNSIGNED; R: INTEGER) return BOOLEAN is -- synopsys subpgm_id 345 constant length: INTEGER := L'length + 1; begin return bitwise_eql( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "="(L: INTEGER; R: UNSIGNED) return BOOLEAN is -- synopsys subpgm_id 346 constant length: INTEGER := R'length + 1; begin return bitwise_eql( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "="(L: SIGNED; R: INTEGER) return BOOLEAN is -- synopsys subpgm_id 347 constant length: INTEGER := L'length; begin return bitwise_eql( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "="(L: INTEGER; R: SIGNED) return BOOLEAN is -- synopsys subpgm_id 348 constant length: INTEGER := R'length; begin return bitwise_eql( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "/="(L: UNSIGNED; R: UNSIGNED) return BOOLEAN is -- synopsys subpgm_id 350 constant length: INTEGER := max(L'length, R'length); begin return bitwise_neq( STD_ULOGIC_VECTOR( CONV_UNSIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_UNSIGNED(R, length) ) ); end; function "/="(L: SIGNED; R: SIGNED) return BOOLEAN is -- synopsys subpgm_id 351 constant length: INTEGER := max(L'length, R'length); begin return bitwise_neq( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "/="(L: UNSIGNED; R: SIGNED) return BOOLEAN is -- synopsys subpgm_id 352 constant length: INTEGER := max(L'length + 1, R'length); begin return bitwise_neq( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "/="(L: SIGNED; R: UNSIGNED) return BOOLEAN is -- synopsys subpgm_id 353 constant length: INTEGER := max(L'length, R'length + 1); begin return bitwise_neq( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "/="(L: UNSIGNED; R: INTEGER) return BOOLEAN is -- synopsys subpgm_id 354 constant length: INTEGER := L'length + 1; begin return bitwise_neq( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "/="(L: INTEGER; R: UNSIGNED) return BOOLEAN is -- synopsys subpgm_id 355 constant length: INTEGER := R'length + 1; begin return bitwise_neq( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "/="(L: SIGNED; R: INTEGER) return BOOLEAN is -- synopsys subpgm_id 356 constant length: INTEGER := L'length; begin return bitwise_neq( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function "/="(L: INTEGER; R: SIGNED) return BOOLEAN is -- synopsys subpgm_id 357 constant length: INTEGER := R'length; begin return bitwise_neq( STD_ULOGIC_VECTOR( CONV_SIGNED(L, length) ), STD_ULOGIC_VECTOR( CONV_SIGNED(R, length) ) ); end; function SHL(ARG: UNSIGNED; COUNT: UNSIGNED) return UNSIGNED is -- synopsys subpgm_id 358 constant control_msb: INTEGER := COUNT'length - 1; variable control: UNSIGNED (control_msb downto 0); constant result_msb: INTEGER := ARG'length-1; subtype rtype is UNSIGNED (result_msb downto 0); variable result, temp: rtype; begin control := MAKE_BINARY(COUNT); -- synopsys synthesis_off if (control(0) = 'X') then result := rtype'(others => 'X'); return result; end if; -- synopsys synthesis_on result := ARG; for i in 0 to control_msb loop if control(i) = '1' then temp := rtype'(others => '0'); if 2**i <= result_msb then temp(result_msb downto 2**i) := result(result_msb - 2**i downto 0); end if; result := temp; end if; end loop; return result; end; function SHL(ARG: SIGNED; COUNT: UNSIGNED) return SIGNED is -- synopsys subpgm_id 359 constant control_msb: INTEGER := COUNT'length - 1; variable control: UNSIGNED (control_msb downto 0); constant result_msb: INTEGER := ARG'length-1; subtype rtype is SIGNED (result_msb downto 0); variable result, temp: rtype; begin control := MAKE_BINARY(COUNT); -- synopsys synthesis_off if (control(0) = 'X') then result := rtype'(others => 'X'); return result; end if; -- synopsys synthesis_on result := ARG; for i in 0 to control_msb loop if control(i) = '1' then temp := rtype'(others => '0'); if 2**i <= result_msb then temp(result_msb downto 2**i) := result(result_msb - 2**i downto 0); end if; result := temp; end if; end loop; return result; end; function SHR(ARG: UNSIGNED; COUNT: UNSIGNED) return UNSIGNED is -- synopsys subpgm_id 360 constant control_msb: INTEGER := COUNT'length - 1; variable control: UNSIGNED (control_msb downto 0); constant result_msb: INTEGER := ARG'length-1; subtype rtype is UNSIGNED (result_msb downto 0); variable result, temp: rtype; begin control := MAKE_BINARY(COUNT); -- synopsys synthesis_off if (control(0) = 'X') then result := rtype'(others => 'X'); return result; end if; -- synopsys synthesis_on result := ARG; for i in 0 to control_msb loop if control(i) = '1' then temp := rtype'(others => '0'); if 2**i <= result_msb then temp(result_msb - 2**i downto 0) := result(result_msb downto 2**i); end if; result := temp; end if; end loop; return result; end; function SHR(ARG: SIGNED; COUNT: UNSIGNED) return SIGNED is -- synopsys subpgm_id 361 constant control_msb: INTEGER := COUNT'length - 1; variable control: UNSIGNED (control_msb downto 0); constant result_msb: INTEGER := ARG'length-1; subtype rtype is SIGNED (result_msb downto 0); variable result, temp: rtype; variable sign_bit: STD_ULOGIC; begin control := MAKE_BINARY(COUNT); -- synopsys synthesis_off if (control(0) = 'X') then result := rtype'(others => 'X'); return result; end if; -- synopsys synthesis_on result := ARG; sign_bit := ARG(ARG'left); for i in 0 to control_msb loop if control(i) = '1' then temp := rtype'(others => sign_bit); if 2**i <= result_msb then temp(result_msb - 2**i downto 0) := result(result_msb downto 2**i); end if; result := temp; end if; end loop; return result; end; function CONV_INTEGER(ARG: INTEGER) return INTEGER is -- synopsys subpgm_id 365 begin return ARG; end; function CONV_INTEGER(ARG: UNSIGNED) return INTEGER is variable result: INTEGER; variable tmp: STD_ULOGIC; -- synopsys built_in SYN_UNSIGNED_TO_INTEGER -- synopsys subpgm_id 366 begin -- synopsys synthesis_off assert ARG'length <= 31 report "ARG is too large in CONV_INTEGER" severity FAILURE; result := 0; for i in ARG'range loop result := result * 2; tmp := tbl_BINARY(ARG(i)); if tmp = '1' then result := result + 1; elsif tmp = 'X' then assert false report "CONV_INTEGER: There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, and it has been converted to 0." severity WARNING; end if; end loop; return result; -- synopsys synthesis_on end; function CONV_INTEGER(ARG: SIGNED) return INTEGER is variable result: INTEGER; variable tmp: STD_ULOGIC; -- synopsys built_in SYN_SIGNED_TO_INTEGER -- synopsys subpgm_id 367 begin -- synopsys synthesis_off assert ARG'length <= 32 report "ARG is too large in CONV_INTEGER" severity FAILURE; result := 0; for i in ARG'range loop if i /= ARG'left then result := result * 2; tmp := tbl_BINARY(ARG(i)); if tmp = '1' then result := result + 1; elsif tmp = 'X' then assert false report "CONV_INTEGER: There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, and it has been converted to 0." severity WARNING; end if; end if; end loop; tmp := MAKE_BINARY(ARG(ARG'left)); if tmp = '1' then if ARG'length = 32 then result := (result - 2**30) - 2**30; else result := result - (2 ** (ARG'length-1)); end if; end if; return result; -- synopsys synthesis_on end; function CONV_INTEGER(ARG: STD_ULOGIC) return SMALL_INT is variable tmp: STD_ULOGIC; -- synopsys built_in SYN_FEED_THRU -- synopsys subpgm_id 370 begin -- synopsys synthesis_off tmp := tbl_BINARY(ARG); if tmp = '1' then return 1; elsif tmp = 'X' then assert false report "CONV_INTEGER: There is an 'U'|'X'|'W'|'Z'|'-' in an arithmetic operand, and it has been converted to 0." severity WARNING; return 0; else return 0; end if; -- synopsys synthesis_on end; -- convert an integer to a unsigned STD_ULOGIC_VECTOR function CONV_UNSIGNED(ARG: INTEGER; SIZE: INTEGER) return UNSIGNED is variable result: UNSIGNED(SIZE-1 downto 0); variable temp: integer; -- synopsys built_in SYN_INTEGER_TO_UNSIGNED -- synopsys subpgm_id 371 begin -- synopsys synthesis_off temp := ARG; for i in 0 to SIZE-1 loop if (temp mod 2) = 1 then result(i) := '1'; else result(i) := '0'; end if; if temp > 0 then temp := temp / 2; else temp := (temp - 1) / 2; -- simulate ASR end if; end loop; return result; -- synopsys synthesis_on end; function CONV_UNSIGNED(ARG: UNSIGNED; SIZE: INTEGER) return UNSIGNED is constant msb: INTEGER := min(ARG'length, SIZE) - 1; subtype rtype is UNSIGNED (SIZE-1 downto 0); variable new_bounds: UNSIGNED (ARG'length-1 downto 0); variable result: rtype; -- synopsys built_in SYN_ZERO_EXTEND -- synopsys subpgm_id 372 begin -- synopsys synthesis_off new_bounds := MAKE_BINARY(ARG); if (new_bounds(0) = 'X') then result := rtype'(others => 'X'); return result; end if; result := rtype'(others => '0'); result(msb downto 0) := new_bounds(msb downto 0); return result; -- synopsys synthesis_on end; function CONV_UNSIGNED(ARG: SIGNED; SIZE: INTEGER) return UNSIGNED is constant msb: INTEGER := min(ARG'length, SIZE) - 1; subtype rtype is UNSIGNED (SIZE-1 downto 0); variable new_bounds: UNSIGNED (ARG'length-1 downto 0); variable result: rtype; -- synopsys built_in SYN_SIGN_EXTEND -- synopsys subpgm_id 373 begin -- synopsys synthesis_off new_bounds := MAKE_BINARY(ARG); if (new_bounds(0) = 'X') then result := rtype'(others => 'X'); return result; end if; result := rtype'(others => new_bounds(new_bounds'left)); result(msb downto 0) := new_bounds(msb downto 0); return result; -- synopsys synthesis_on end; function CONV_UNSIGNED(ARG: STD_ULOGIC; SIZE: INTEGER) return UNSIGNED is subtype rtype is UNSIGNED (SIZE-1 downto 0); variable result: rtype; -- synopsys built_in SYN_ZERO_EXTEND -- synopsys subpgm_id 375 begin -- synopsys synthesis_off result := rtype'(others => '0'); result(0) := MAKE_BINARY(ARG); if (result(0) = 'X') then result := rtype'(others => 'X'); end if; return result; -- synopsys synthesis_on end; -- convert an integer to a 2's complement STD_ULOGIC_VECTOR function CONV_SIGNED(ARG: INTEGER; SIZE: INTEGER) return SIGNED is variable result: SIGNED (SIZE-1 downto 0); variable temp: integer; -- synopsys built_in SYN_INTEGER_TO_SIGNED -- synopsys subpgm_id 376 begin -- synopsys synthesis_off temp := ARG; for i in 0 to SIZE-1 loop if (temp mod 2) = 1 then result(i) := '1'; else result(i) := '0'; end if; if temp > 0 then temp := temp / 2; elsif (temp > integer'low) then temp := (temp - 1) / 2; -- simulate ASR else temp := temp / 2; -- simulate ASR end if; end loop; return result; -- synopsys synthesis_on end; function CONV_SIGNED(ARG: UNSIGNED; SIZE: INTEGER) return SIGNED is constant msb: INTEGER := min(ARG'length, SIZE) - 1; subtype rtype is SIGNED (SIZE-1 downto 0); variable new_bounds : SIGNED (ARG'length-1 downto 0); variable result: rtype; -- synopsys built_in SYN_ZERO_EXTEND -- synopsys subpgm_id 377 begin -- synopsys synthesis_off new_bounds := MAKE_BINARY(ARG); if (new_bounds(0) = 'X') then result := rtype'(others => 'X'); return result; end if; result := rtype'(others => '0'); result(msb downto 0) := new_bounds(msb downto 0); return result; -- synopsys synthesis_on end; function CONV_SIGNED(ARG: SIGNED; SIZE: INTEGER) return SIGNED is constant msb: INTEGER := min(ARG'length, SIZE) - 1; subtype rtype is SIGNED (SIZE-1 downto 0); variable new_bounds : SIGNED (ARG'length-1 downto 0); variable result: rtype; -- synopsys built_in SYN_SIGN_EXTEND -- synopsys subpgm_id 378 begin -- synopsys synthesis_off new_bounds := MAKE_BINARY(ARG); if (new_bounds(0) = 'X') then result := rtype'(others => 'X'); return result; end if; result := rtype'(others => new_bounds(new_bounds'left)); result(msb downto 0) := new_bounds(msb downto 0); return result; -- synopsys synthesis_on end; function CONV_SIGNED(ARG: STD_ULOGIC; SIZE: INTEGER) return SIGNED is subtype rtype is SIGNED (SIZE-1 downto 0); variable result: rtype; -- synopsys built_in SYN_ZERO_EXTEND -- synopsys subpgm_id 380 begin -- synopsys synthesis_off result := rtype'(others => '0'); result(0) := MAKE_BINARY(ARG); if (result(0) = 'X') then result := rtype'(others => 'X'); end if; return result; -- synopsys synthesis_on end; -- convert an integer to an STD_LOGIC_VECTOR function CONV_STD_LOGIC_VECTOR(ARG: INTEGER; SIZE: INTEGER) return STD_LOGIC_VECTOR is variable result: STD_LOGIC_VECTOR (SIZE-1 downto 0); variable temp: integer; -- synopsys built_in SYN_INTEGER_TO_SIGNED -- synopsys subpgm_id 381 begin -- synopsys synthesis_off temp := ARG; for i in 0 to SIZE-1 loop if (temp mod 2) = 1 then result(i) := '1'; else result(i) := '0'; end if; if temp > 0 then temp := temp / 2; elsif (temp > integer'low) then temp := (temp - 1) / 2; -- simulate ASR else temp := temp / 2; -- simulate ASR end if; end loop; return result; -- synopsys synthesis_on end; function CONV_STD_LOGIC_VECTOR(ARG: UNSIGNED; SIZE: INTEGER) return STD_LOGIC_VECTOR is constant msb: INTEGER := min(ARG'length, SIZE) - 1; subtype rtype is STD_LOGIC_VECTOR (SIZE-1 downto 0); variable new_bounds : STD_LOGIC_VECTOR (ARG'length-1 downto 0); variable result: rtype; -- synopsys built_in SYN_ZERO_EXTEND -- synopsys subpgm_id 382 begin -- synopsys synthesis_off new_bounds := MAKE_BINARY(ARG); if (new_bounds(0) = 'X') then result := rtype'(others => 'X'); return result; end if; result := rtype'(others => '0'); result(msb downto 0) := new_bounds(msb downto 0); return result; -- synopsys synthesis_on end; function CONV_STD_LOGIC_VECTOR(ARG: SIGNED; SIZE: INTEGER) return STD_LOGIC_VECTOR is constant msb: INTEGER := min(ARG'length, SIZE) - 1; subtype rtype is STD_LOGIC_VECTOR (SIZE-1 downto 0); variable new_bounds : STD_LOGIC_VECTOR (ARG'length-1 downto 0); variable result: rtype; -- synopsys built_in SYN_SIGN_EXTEND -- synopsys subpgm_id 383 begin -- synopsys synthesis_off new_bounds := MAKE_BINARY(ARG); if (new_bounds(0) = 'X') then result := rtype'(others => 'X'); return result; end if; result := rtype'(others => new_bounds(new_bounds'left)); result(msb downto 0) := new_bounds(msb downto 0); return result; -- synopsys synthesis_on end; function CONV_STD_LOGIC_VECTOR(ARG: STD_ULOGIC; SIZE: INTEGER) return STD_LOGIC_VECTOR is subtype rtype is STD_LOGIC_VECTOR (SIZE-1 downto 0); variable result: rtype; -- synopsys built_in SYN_ZERO_EXTEND -- synopsys subpgm_id 384 begin -- synopsys synthesis_off result := rtype'(others => '0'); result(0) := MAKE_BINARY(ARG); if (result(0) = 'X') then result := rtype'(others => 'X'); end if; return result; -- synopsys synthesis_on end; function EXT(ARG: STD_LOGIC_VECTOR; SIZE: INTEGER) return STD_LOGIC_VECTOR is constant msb: INTEGER := min(ARG'length, SIZE) - 1; subtype rtype is STD_LOGIC_VECTOR (SIZE-1 downto 0); variable new_bounds: STD_LOGIC_VECTOR (ARG'length-1 downto 0); variable result: rtype; -- synopsys built_in SYN_ZERO_EXTEND -- synopsys subpgm_id 385 begin -- synopsys synthesis_off new_bounds := MAKE_BINARY(ARG); if (new_bounds(0) = 'X') then result := rtype'(others => 'X'); return result; end if; result := rtype'(others => '0'); result(msb downto 0) := new_bounds(msb downto 0); return result; -- synopsys synthesis_on end; function SXT(ARG: STD_LOGIC_VECTOR; SIZE: INTEGER) return STD_LOGIC_VECTOR is constant msb: INTEGER := min(ARG'length, SIZE) - 1; subtype rtype is STD_LOGIC_VECTOR (SIZE-1 downto 0); variable new_bounds : STD_LOGIC_VECTOR (ARG'length-1 downto 0); variable result: rtype; -- synopsys built_in SYN_SIGN_EXTEND -- synopsys subpgm_id 386 begin -- synopsys synthesis_off new_bounds := MAKE_BINARY(ARG); if (new_bounds(0) = 'X') then result := rtype'(others => 'X'); return result; end if; result := rtype'(others => new_bounds(new_bounds'left)); result(msb downto 0) := new_bounds(msb downto 0); return result; -- synopsys synthesis_on end; end std_logic_arith;