kcpsm3.vhd
上传用户:hbxtsdjs
上传日期:2022-07-03
资源大小:753k
文件大小:66k
源码类别:

汇编语言

开发平台:

Windows_Unix

  1. -- PicoBlaze
  2. --
  3. -- Constant (K) Coded Programmable State Machine for Spartan-3 Devices.
  4. -- Also suitable for use with Virtex-II and Virtex-IIPRO devices.
  5. --
  6. -- Includes additional code for enhanced VHDL simulation. 
  7. --
  8. -- Version : 1.30 
  9. -- Version Date : 14th June 2004
  10. -- Reasons : Avoid issue caused when ENABLE INTERRUPT is used when interrupts are
  11. --           already enabled when an an interrupt input is applied.
  12. --           Improved design for faster ZERO and CARRY flag logic   
  13. --
  14. --
  15. -- Previous Version : 1.20 
  16. -- Version Date : 9th July 2003
  17. --
  18. -- Start of design entry : 19th May 2003
  19. --
  20. -- Ken Chapman
  21. -- Xilinx Ltd
  22. -- Benchmark House
  23. -- 203 Brooklands Road
  24. -- Weybridge
  25. -- Surrey KT13 ORH
  26. -- United Kingdom
  27. --
  28. -- chapman@xilinx.com
  29. --
  30. -- Instruction disassembly concept inspired by the work of Prof. Dr.-Ing. Bernhard Lang.
  31. -- University of Applied Sciences, Osnabrueck, Germany.
  32. --
  33. ------------------------------------------------------------------------------------
  34. --
  35. -- NOTICE:
  36. --
  37. -- Copyright Xilinx, Inc. 2003.   This code may be contain portions patented by other 
  38. -- third parties.  By providing this core as one possible implementation of a standard,
  39. -- Xilinx is making no representation that the provided implementation of this standard 
  40. -- is free from any claims of infringement by any third party.  Xilinx expressly 
  41. -- disclaims any warranty with respect to the adequacy of the implementation, including 
  42. -- but not limited to any warranty or representation that the implementation is free 
  43. -- from claims of any third party.  Furthermore, Xilinx is providing this core as a 
  44. -- courtesy to you and suggests that you contact all third parties to obtain the 
  45. -- necessary rights to use this implementation.
  46. --
  47. ------------------------------------------------------------------------------------
  48. --
  49. -- Format of this file.
  50. --
  51. -- This file contains the definition of KCPSM3 as one complete module with sections 
  52. -- created using generate loops. This 'flat' approach has been adopted to decrease 
  53. -- the time taken to load the module into simulators and the synthesis process.
  54. --
  55. -- The module defines the implementation of the logic using Xilinx primitives.
  56. -- These ensure predictable synthesis results and maximise the density of the implementation. 
  57. -- The Unisim Library is used to define Xilinx primitives. It is also used during
  58. -- simulation. The source can be viewed at %XILINX%vhdlsrcunisimsunisim_VCOMP.vhd
  59. -- 
  60. ------------------------------------------------------------------------------------
  61. --
  62. -- Library declarations
  63. --
  64. -- Standard IEEE libraries
  65. --
  66. library IEEE;
  67. use IEEE.STD_LOGIC_1164.ALL;
  68. use IEEE.STD_LOGIC_ARITH.ALL;
  69. use IEEE.STD_LOGIC_UNSIGNED.ALL;
  70. library unisim;
  71. use unisim.vcomponents.all;
  72. --
  73. ------------------------------------------------------------------------------------
  74. --
  75. -- Main Entity for KCPSM3
  76. --
  77. entity kcpsm3 is
  78.     Port (      address : out std_logic_vector(9 downto 0);
  79.             instruction : in std_logic_vector(17 downto 0);
  80.                 port_id : out std_logic_vector(7 downto 0);
  81.            write_strobe : out std_logic;
  82.                out_port : out std_logic_vector(7 downto 0);
  83.             read_strobe : out std_logic;
  84.                 in_port : in std_logic_vector(7 downto 0);
  85.               interrupt : in std_logic;
  86.           interrupt_ack : out std_logic;
  87.                   reset : in std_logic;
  88.                     clk : in std_logic);
  89.     end kcpsm3;
  90. --
  91. ------------------------------------------------------------------------------------
  92. --
  93. -- Start of Main Architecture for KCPSM3
  94. --  
  95. architecture low_level_definition of kcpsm3 is
  96. --
  97. ------------------------------------------------------------------------------------
  98. --
  99. -- Signals used in KCPSM3
  100. --
  101. ------------------------------------------------------------------------------------
  102. --
  103. -- Fundamental control and decode signals
  104. --  
  105. signal t_state                : std_logic;
  106. signal not_t_state            : std_logic;
  107. signal internal_reset         : std_logic;
  108. signal reset_delay            : std_logic;
  109. signal move_group             : std_logic;
  110. signal condition_met          : std_logic;
  111. signal normal_count           : std_logic;
  112. signal call_type              : std_logic;
  113. signal push_or_pop_type       : std_logic;
  114. signal valid_to_move          : std_logic;
  115. --
  116. -- Flag signals
  117. -- 
  118. signal flag_type              : std_logic;
  119. signal flag_write             : std_logic;
  120. signal flag_enable            : std_logic;
  121. signal zero_flag              : std_logic;
  122. signal sel_shadow_zero        : std_logic;
  123. signal low_zero               : std_logic;
  124. signal high_zero              : std_logic;
  125. signal low_zero_carry         : std_logic;
  126. signal high_zero_carry        : std_logic;
  127. signal zero_carry             : std_logic;
  128. signal zero_fast_route        : std_logic;
  129. signal low_parity             : std_logic;
  130. signal high_parity            : std_logic;
  131. signal parity_carry           : std_logic;
  132. signal parity                 : std_logic;
  133. signal carry_flag             : std_logic;
  134. signal sel_parity             : std_logic;
  135. signal sel_arith_carry        : std_logic;
  136. signal sel_shift_carry        : std_logic;
  137. signal sel_shadow_carry       : std_logic;
  138. signal sel_carry              : std_logic_vector(3 downto 0);
  139. signal carry_fast_route       : std_logic;
  140. --
  141. -- Interrupt signals
  142. -- 
  143. signal active_interrupt       : std_logic;
  144. signal int_pulse              : std_logic;
  145. signal clean_int              : std_logic;
  146. signal shadow_carry           : std_logic;
  147. signal shadow_zero            : std_logic;
  148. signal int_enable             : std_logic;
  149. signal int_update_enable      : std_logic;
  150. signal int_enable_value       : std_logic;
  151. signal interrupt_ack_internal : std_logic;
  152. --
  153. -- Program Counter signals
  154. --
  155. signal pc                     : std_logic_vector(9 downto 0);
  156. signal pc_vector              : std_logic_vector(9 downto 0);
  157. signal pc_vector_carry        : std_logic_vector(8 downto 0);
  158. signal inc_pc_vector          : std_logic_vector(9 downto 0);
  159. signal pc_value               : std_logic_vector(9 downto 0);
  160. signal pc_value_carry         : std_logic_vector(8 downto 0);
  161. signal inc_pc_value           : std_logic_vector(9 downto 0);
  162. signal pc_enable              : std_logic;
  163. --
  164. -- Data Register signals
  165. --
  166. signal sx                     : std_logic_vector(7 downto 0);
  167. signal sy                     : std_logic_vector(7 downto 0);
  168. signal register_type          : std_logic;
  169. signal register_write         : std_logic;
  170. signal register_enable        : std_logic;
  171. signal second_operand         : std_logic_vector(7 downto 0);
  172. --
  173. -- Scratch Pad Memory signals
  174. --
  175. signal memory_data            : std_logic_vector(7 downto 0);
  176. signal store_data             : std_logic_vector(7 downto 0);
  177. signal memory_type            : std_logic;
  178. signal memory_write           : std_logic;
  179. signal memory_enable          : std_logic;
  180. --
  181. -- Stack signals
  182. --
  183. signal stack_pop_data         : std_logic_vector(9 downto 0);
  184. signal stack_ram_data         : std_logic_vector(9 downto 0);
  185. signal stack_address          : std_logic_vector(4 downto 0);
  186. signal half_stack_address     : std_logic_vector(4 downto 0);
  187. signal stack_address_carry    : std_logic_vector(3 downto 0);
  188. signal next_stack_address     : std_logic_vector(4 downto 0);
  189. signal stack_write_enable     : std_logic;
  190. signal not_active_interrupt   : std_logic;
  191. --
  192. -- ALU signals
  193. --
  194. signal logical_result         : std_logic_vector(7 downto 0);
  195. signal logical_value          : std_logic_vector(7 downto 0);
  196. signal sel_logical            : std_logic;
  197. signal shift_result           : std_logic_vector(7 downto 0);
  198. signal shift_value            : std_logic_vector(7 downto 0);
  199. signal sel_shift              : std_logic;
  200. signal high_shift_in          : std_logic;
  201. signal low_shift_in           : std_logic;
  202. signal shift_in               : std_logic;
  203. signal shift_carry            : std_logic;
  204. signal shift_carry_value      : std_logic;
  205. signal arith_result           : std_logic_vector(7 downto 0);
  206. signal arith_value            : std_logic_vector(7 downto 0);
  207. signal half_arith             : std_logic_vector(7 downto 0);
  208. signal arith_internal_carry   : std_logic_vector(7 downto 0);
  209. signal sel_arith_carry_in     : std_logic;
  210. signal arith_carry_in         : std_logic;
  211. signal invert_arith_carry     : std_logic;
  212. signal arith_carry_out        : std_logic;
  213. signal sel_arith              : std_logic;
  214. signal arith_carry            : std_logic;
  215. --
  216. -- ALU multiplexer signals
  217. --
  218. signal input_fetch_type       : std_logic;
  219. signal sel_group              : std_logic;
  220. signal alu_group              : std_logic_vector(7 downto 0);
  221. signal input_group            : std_logic_vector(7 downto 0);
  222. signal alu_result             : std_logic_vector(7 downto 0);
  223. --
  224. -- read and write strobes 
  225. --
  226. signal io_initial_decode      : std_logic;
  227. signal write_active           : std_logic;
  228. signal read_active            : std_logic;
  229. --
  230. --
  231. ------------------------------------------------------------------------------------
  232. --
  233. -- Attributes to define LUT contents during implementation for primitives not 
  234. -- contained within generate loops. In each case the information is repeated
  235. -- in the generic map for functional simulation
  236. --
  237. attribute INIT : string; 
  238. attribute INIT of t_state_lut           : label is "1"; 
  239. attribute INIT of int_pulse_lut         : label is "0080";
  240. attribute INIT of int_update_lut        : label is "EAAA";
  241. attribute INIT of int_value_lut         : label is "04";
  242. attribute INIT of move_group_lut        : label is "7400";
  243. attribute INIT of condition_met_lut     : label is "5A3C";
  244. attribute INIT of normal_count_lut      : label is "2F";
  245. attribute INIT of call_type_lut         : label is "1000";
  246. attribute INIT of push_pop_lut          : label is "5400";
  247. attribute INIT of valid_move_lut        : label is "D";
  248. attribute INIT of flag_type_lut         : label is "41FC";
  249. attribute INIT of flag_enable_lut       : label is "8";
  250. attribute INIT of low_zero_lut          : label is "0001";
  251. attribute INIT of high_zero_lut         : label is "0001";
  252. attribute INIT of sel_shadow_zero_lut   : label is "3F";
  253. attribute INIT of low_parity_lut        : label is "6996";
  254. attribute INIT of high_parity_lut       : label is "6996";
  255. attribute INIT of sel_parity_lut        : label is "F3FF";
  256. attribute INIT of sel_arith_carry_lut   : label is "F3";
  257. attribute INIT of sel_shift_carry_lut   : label is "C";
  258. attribute INIT of sel_shadow_carry_lut  : label is "3";
  259. attribute INIT of register_type_lut     : label is "0145";
  260. attribute INIT of register_enable_lut   : label is "8";
  261. attribute INIT of memory_type_lut       : label is "0400";
  262. attribute INIT of memory_enable_lut     : label is "8000";
  263. attribute INIT of sel_logical_lut       : label is "FFE2";
  264. attribute INIT of low_shift_in_lut      : label is "E4";
  265. attribute INIT of high_shift_in_lut     : label is "E4";
  266. attribute INIT of shift_carry_lut       : label is "E4";
  267. attribute INIT of sel_arith_lut         : label is "1F";
  268. attribute INIT of input_fetch_type_lut  : label is "0002";
  269. attribute INIT of io_decode_lut         : label is "0010";
  270. attribute INIT of write_active_lut      : label is "4000";
  271. attribute INIT of read_active_lut       : label is "0100";
  272. --
  273. ------------------------------------------------------------------------------------
  274. --
  275. -- Start of KCPSM3 circuit description
  276. --
  277. ------------------------------------------------------------------------------------
  278. --
  279. begin
  280. --
  281. ------------------------------------------------------------------------------------
  282. --
  283. -- Fundamental Control
  284. --
  285. -- Definition of T-state and internal reset
  286. --
  287. ------------------------------------------------------------------------------------
  288. --
  289.   t_state_lut: LUT1
  290.   --synthesis translate_off
  291.     generic map (INIT => X"1")
  292.   --synthesis translate_on
  293.   port map( I0 => t_state,
  294.              O => not_t_state );
  295.   toggle_flop: FDR
  296.   port map ( D => not_t_state,
  297.              Q => t_state,
  298.              R => internal_reset,
  299.              C => clk);
  300.   reset_flop1: FDS
  301.   port map ( D => '0',
  302.              Q => reset_delay,
  303.              S => reset,
  304.              C => clk);
  305.   reset_flop2: FDS
  306.   port map ( D => reset_delay,
  307.              Q => internal_reset,
  308.              S => reset,
  309.              C => clk);
  310. --
  311. ------------------------------------------------------------------------------------
  312. --
  313. -- Interrupt input logic, Interrupt enable and shadow Flags.
  314. --
  315. -- Captures interrupt input and enables the shadow flags.
  316. -- Decodes instructions which set and reset the interrupt enable flip-flop. 
  317. --
  318. ------------------------------------------------------------------------------------
  319. --
  320.   -- Interrupt capture
  321.   int_capture_flop: FDR
  322.   port map ( D => interrupt,
  323.              Q => clean_int,
  324.              R => internal_reset,
  325.              C => clk);
  326.   int_pulse_lut: LUT4
  327.   --synthesis translate_off
  328.     generic map (INIT => X"0080")
  329.   --synthesis translate_on
  330.   port map( I0 => t_state,
  331.             I1 => clean_int,
  332.             I2 => int_enable,
  333.             I3 => active_interrupt,
  334.              O => int_pulse );
  335.   int_flop: FDR
  336.   port map ( D => int_pulse,
  337.              Q => active_interrupt,
  338.              R => internal_reset,
  339.              C => clk);
  340.   ack_flop: FD
  341.   port map ( D => active_interrupt,
  342.              Q => interrupt_ack_internal,
  343.              C => clk);
  344.   interrupt_ack <= interrupt_ack_internal;
  345.   -- Shadow flags
  346.   shadow_carry_flop: FDE
  347.   port map ( D => carry_flag,
  348.              Q => shadow_carry,
  349.             CE => active_interrupt,
  350.              C => clk);
  351.   shadow_zero_flop: FDE
  352.   port map ( D => zero_flag,
  353.              Q => shadow_zero,
  354.             CE => active_interrupt,
  355.              C => clk);
  356.   -- Decode instructions that set or reset interrupt enable
  357.   int_update_lut: LUT4
  358.   --synthesis translate_off
  359.     generic map (INIT => X"EAAA")
  360.   --synthesis translate_on
  361.   port map( I0 => active_interrupt,
  362.             I1 => instruction(15),
  363.             I2 => instruction(16),
  364.             I3 => instruction(17),
  365.              O => int_update_enable );
  366.   int_value_lut: LUT3
  367.   --synthesis translate_off
  368.     generic map (INIT => X"04")
  369.   --synthesis translate_on
  370.   port map( I0 => active_interrupt,
  371.             I1 => instruction(0),
  372.             I2 => interrupt_ack_internal,
  373.              O => int_enable_value );
  374.   int_enable_flop: FDRE
  375.   port map ( D => int_enable_value,
  376.              Q => int_enable,
  377.             CE => int_update_enable,
  378.              R => internal_reset,
  379.              C => clk);
  380. --
  381. ------------------------------------------------------------------------------------
  382. --
  383. -- Decodes for the control of the program counter and CALL/RETURN stack
  384. --
  385. ------------------------------------------------------------------------------------
  386. --
  387.   move_group_lut: LUT4
  388.   --synthesis translate_off
  389.     generic map (INIT => X"7400")
  390.   --synthesis translate_on
  391.   port map( I0 => instruction(14),
  392.             I1 => instruction(15),
  393.             I2 => instruction(16),
  394.             I3 => instruction(17),
  395.              O => move_group );
  396.   condition_met_lut: LUT4
  397.   --synthesis translate_off
  398.     generic map (INIT => X"5A3C")
  399.   --synthesis translate_on
  400.   port map( I0 => carry_flag,
  401.             I1 => zero_flag,
  402.             I2 => instruction(10),
  403.             I3 => instruction(11),
  404.              O => condition_met );
  405.   normal_count_lut: LUT3
  406.   --synthesis translate_off
  407.     generic map (INIT => X"2F")
  408.   --synthesis translate_on
  409.   port map( I0 => instruction(12),
  410.             I1 => condition_met,
  411.             I2 => move_group,
  412.              O => normal_count );
  413.   call_type_lut: LUT4
  414.   --synthesis translate_off
  415.     generic map (INIT => X"1000")
  416.   --synthesis translate_on
  417.   port map( I0 => instruction(14),
  418.             I1 => instruction(15),
  419.             I2 => instruction(16),
  420.             I3 => instruction(17),
  421.              O => call_type );
  422.   push_pop_lut: LUT4
  423.   --synthesis translate_off
  424.     generic map (INIT => X"5400")
  425.   --synthesis translate_on
  426.   port map( I0 => instruction(14),
  427.             I1 => instruction(15),
  428.             I2 => instruction(16),
  429.             I3 => instruction(17),
  430.              O => push_or_pop_type );
  431.   valid_move_lut: LUT2
  432.   --synthesis translate_off
  433.     generic map (INIT => X"D")
  434.   --synthesis translate_on
  435.   port map( I0 => instruction(12),
  436.             I1 => condition_met,
  437.              O => valid_to_move );
  438. --
  439. ------------------------------------------------------------------------------------
  440. --
  441. -- The ZERO and CARRY Flags
  442. --
  443. ------------------------------------------------------------------------------------
  444. --
  445.   -- Enable for flags
  446.   flag_type_lut: LUT4
  447.   --synthesis translate_off
  448.     generic map (INIT => X"41FC")
  449.   --synthesis translate_on
  450.   port map( I0 => instruction(14),
  451.             I1 => instruction(15),
  452.             I2 => instruction(16),
  453.             I3 => instruction(17),
  454.              O => flag_type );
  455.   flag_write_flop: FD
  456.   port map ( D => flag_type,
  457.              Q => flag_write,
  458.              C => clk);
  459.   flag_enable_lut: LUT2
  460.   --synthesis translate_off
  461.     generic map (INIT => X"8")
  462.   --synthesis translate_on
  463.   port map( I0 => t_state,
  464.             I1 => flag_write,
  465.              O => flag_enable );
  466.   -- Zero Flag
  467.   low_zero_lut: LUT4
  468.   --synthesis translate_off
  469.     generic map (INIT => X"0001")
  470.   --synthesis translate_on
  471.   port map( I0 => alu_result(0),
  472.             I1 => alu_result(1),
  473.             I2 => alu_result(2),
  474.             I3 => alu_result(3),
  475.              O => low_zero );
  476.   high_zero_lut: LUT4
  477.   --synthesis translate_off
  478.     generic map (INIT => X"0001")
  479.   --synthesis translate_on
  480.   port map( I0 => alu_result(4),
  481.             I1 => alu_result(5),
  482.             I2 => alu_result(6),
  483.             I3 => alu_result(7),
  484.              O => high_zero );
  485.   low_zero_muxcy: MUXCY
  486.   port map( DI => '0',
  487.             CI => '1',
  488.              S => low_zero,
  489.              O => low_zero_carry );
  490.   high_zero_cymux: MUXCY
  491.   port map( DI => '0',
  492.             CI => low_zero_carry,
  493.              S => high_zero,
  494.              O => high_zero_carry );
  495.   sel_shadow_zero_lut: LUT3
  496.   --synthesis translate_off
  497.     generic map (INIT => X"3F")
  498.   --synthesis translate_on
  499.   port map( I0 => shadow_zero,
  500.             I1 => instruction(16),
  501.             I2 => instruction(17),
  502.              O => sel_shadow_zero );
  503.   zero_cymux: MUXCY
  504.   port map( DI => shadow_zero,
  505.             CI => high_zero_carry,
  506.              S => sel_shadow_zero,
  507.              O => zero_carry );
  508.   zero_xor: XORCY
  509.   port map( LI => '0',
  510.             CI => zero_carry,
  511.              O => zero_fast_route);
  512.   zero_flag_flop: FDRE
  513.   port map ( D => zero_fast_route,
  514.              Q => zero_flag,
  515.             CE => flag_enable,
  516.              R => internal_reset,
  517.              C => clk);
  518.   -- Parity detection
  519.   low_parity_lut: LUT4
  520.   --synthesis translate_off
  521.     generic map (INIT => X"6996")
  522.   --synthesis translate_on
  523.   port map( I0 => logical_result(0),
  524.             I1 => logical_result(1),
  525.             I2 => logical_result(2),
  526.             I3 => logical_result(3),
  527.              O => low_parity );
  528.   high_parity_lut: LUT4
  529.   --synthesis translate_off
  530.     generic map (INIT => X"6996")
  531.   --synthesis translate_on
  532.   port map( I0 => logical_result(4),
  533.             I1 => logical_result(5),
  534.             I2 => logical_result(6),
  535.             I3 => logical_result(7),
  536.              O => high_parity );
  537.   parity_muxcy: MUXCY
  538.   port map( DI => '0',
  539.             CI => '1',
  540.              S => low_parity,
  541.              O => parity_carry );
  542.   parity_xor: XORCY
  543.   port map( LI => high_parity,
  544.             CI => parity_carry,
  545.              O => parity);
  546.   -- CARRY flag selection
  547.   sel_parity_lut: LUT4
  548.   --synthesis translate_off
  549.     generic map (INIT => X"F3FF")
  550.   --synthesis translate_on
  551.   port map( I0 => parity,
  552.             I1 => instruction(13),
  553.             I2 => instruction(15),
  554.             I3 => instruction(16),
  555.              O => sel_parity );
  556.   sel_arith_carry_lut: LUT3
  557.   --synthesis translate_off
  558.     generic map (INIT => X"F3")
  559.   --synthesis translate_on
  560.   port map( I0 => arith_carry,
  561.             I1 => instruction(16),
  562.             I2 => instruction(17),
  563.              O => sel_arith_carry );
  564.   sel_shift_carry_lut: LUT2
  565.   --synthesis translate_off
  566.     generic map (INIT => X"C")
  567.   --synthesis translate_on
  568.   port map( I0 => shift_carry,
  569.             I1 => instruction(15),
  570.              O => sel_shift_carry );
  571.   sel_shadow_carry_lut: LUT2
  572.   --synthesis translate_off
  573.     generic map (INIT => X"3")
  574.   --synthesis translate_on
  575.   port map( I0 => shadow_carry,
  576.             I1 => instruction(17),
  577.              O => sel_shadow_carry );
  578.   sel_shadow_muxcy: MUXCY
  579.   port map( DI => shadow_carry,
  580.             CI => '0',
  581.              S => sel_shadow_carry,
  582.              O => sel_carry(0) );
  583.   sel_shift_muxcy: MUXCY
  584.   port map( DI => shift_carry,
  585.             CI => sel_carry(0),
  586.              S => sel_shift_carry,
  587.              O => sel_carry(1) );
  588.   sel_arith_muxcy: MUXCY
  589.   port map( DI => arith_carry,
  590.             CI => sel_carry(1),
  591.              S => sel_arith_carry,
  592.              O => sel_carry(2) );
  593.   sel_parity_muxcy: MUXCY
  594.   port map( DI => parity,
  595.             CI => sel_carry(2),
  596.              S => sel_parity,
  597.              O => sel_carry(3) );
  598.   carry_xor: XORCY
  599.   port map( LI => '0',
  600.             CI => sel_carry(3),
  601.              O => carry_fast_route);
  602.   carry_flag_flop: FDRE
  603.   port map ( D => carry_fast_route,
  604.              Q => carry_flag,
  605.             CE => flag_enable,
  606.              R => internal_reset,
  607.              C => clk);
  608. --
  609. ------------------------------------------------------------------------------------
  610. --
  611. -- The Program Counter
  612. --
  613. -- Definition of a 10-bit counter which can be loaded from two sources
  614. --
  615. ------------------------------------------------------------------------------------
  616. --
  617.   invert_enable: INV   -- Inverter should be implemented in the CE to flip flops
  618.   port map(  I => t_state,
  619.              O => pc_enable);  
  620.  
  621.   pc_loop: for i in 0 to 9 generate
  622.   --
  623.   -- Attribute to define LUT contents during implementation 
  624.   -- The information is repeated in the generic map for functional simulation
  625.   --
  626.   attribute INIT : string; 
  627.   attribute INIT of vector_select_mux : label is "E4";
  628.   attribute INIT of value_select_mux  : label is "E4";
  629.   --
  630.   begin
  631.     vector_select_mux: LUT3
  632.     --synthesis translate_off
  633.       generic map (INIT => X"E4")
  634.     --synthesis translate_on
  635.     port map( I0 => instruction(15),
  636.               I1 => instruction(i),
  637.               I2 => stack_pop_data(i), 
  638.                O => pc_vector(i) );
  639.     value_select_mux: LUT3
  640.     --synthesis translate_off
  641.       generic map (INIT => X"E4")
  642.     --synthesis translate_on
  643.     port map( I0 => normal_count,
  644.               I1 => inc_pc_vector(i),
  645.               I2 => pc(i),
  646.                O => pc_value(i) );
  647.      register_bit: FDRSE
  648.      port map ( D => inc_pc_value(i),
  649.                 Q => pc(i),
  650.                 R => internal_reset,
  651.                 S => active_interrupt,
  652.                CE => pc_enable,
  653.                 C => clk);
  654.      pc_lsb_carry: if i=0 generate
  655.        begin
  656.          pc_vector_muxcy: MUXCY
  657.          port map( DI => '0',
  658.                    CI => instruction(13),
  659.                     S => pc_vector(i),
  660.                     O => pc_vector_carry(i));
  661.          pc_vector_xor: XORCY
  662.          port map( LI => pc_vector(i),
  663.                    CI => instruction(13),
  664.                     O => inc_pc_vector(i));
  665.          pc_value_muxcy: MUXCY
  666.          port map( DI => '0',
  667.                    CI => normal_count,
  668.                     S => pc_value(i),
  669.                     O => pc_value_carry(i));
  670.          pc_value_xor: XORCY
  671.          port map( LI => pc_value(i),
  672.                    CI => normal_count,
  673.                     O => inc_pc_value(i));
  674.        
  675.        end generate pc_lsb_carry;
  676.      pc_mid_carry: if i>0 and i<9 generate
  677.  begin
  678.          pc_vector_muxcy: MUXCY
  679.          port map( DI => '0',
  680.                    CI => pc_vector_carry(i-1),
  681.                     S => pc_vector(i),
  682.                     O => pc_vector_carry(i));
  683.          pc_vector_xor: XORCY
  684.          port map( LI => pc_vector(i),
  685.                    CI => pc_vector_carry(i-1),
  686.                     O => inc_pc_vector(i));
  687.          pc_value_muxcy: MUXCY
  688.          port map( DI => '0',
  689.                    CI => pc_value_carry(i-1),
  690.                     S => pc_value(i),
  691.                     O => pc_value_carry(i));
  692.          pc_value_xor: XORCY
  693.          port map( LI => pc_value(i),
  694.                    CI => pc_value_carry(i-1),
  695.                     O => inc_pc_value(i));
  696.        end generate pc_mid_carry;
  697.      pc_msb_carry: if i=9 generate
  698.        begin
  699.          pc_vector_xor: XORCY
  700.          port map( LI => pc_vector(i),
  701.                    CI => pc_vector_carry(i-1),
  702.                     O => inc_pc_vector(i));
  703.           pc_value_xor: XORCY
  704.          port map( LI => pc_value(i),
  705.                    CI => pc_value_carry(i-1),
  706.                     O => inc_pc_value(i));
  707.        end generate pc_msb_carry;
  708.   end generate pc_loop;
  709.   address <= pc;
  710. --
  711. ------------------------------------------------------------------------------------
  712. --
  713. -- Register Bank and second operand selection.
  714. --
  715. -- Definition of an 8-bit dual port RAM with 16 locations 
  716. -- including write enable decode.
  717. --
  718. -- Outputs are assigned to PORT_ID and OUT_PORT.
  719. --
  720. ------------------------------------------------------------------------------------
  721. --
  722.   -- Forming decode signal
  723.   register_type_lut: LUT4
  724.   --synthesis translate_off
  725.     generic map (INIT => X"0145")
  726.   --synthesis translate_on
  727.   port map( I0 => active_interrupt,
  728.             I1 => instruction(15),
  729.             I2 => instruction(16),
  730.             I3 => instruction(17),
  731.              O => register_type );
  732.   register_write_flop: FD
  733.   port map ( D => register_type,
  734.              Q => register_write,
  735.              C => clk);
  736.   register_enable_lut: LUT2
  737.   --synthesis translate_off
  738.     generic map (INIT => X"8")
  739.   --synthesis translate_on
  740.   port map( I0 => t_state,
  741.             I1 => register_write,
  742.              O => register_enable );
  743.   reg_loop: for i in 0 to 7 generate
  744.   --
  745.   -- Attribute to define RAM contents during implementation 
  746.   -- The information is repeated in the generic map for functional simulation
  747.   --
  748.   attribute INIT : string; 
  749.   attribute INIT of register_bit       : label is "0000"; 
  750.   attribute INIT of operand_select_mux : label is "E4"; 
  751.   --
  752.   begin
  753.     register_bit: RAM16X1D
  754.     --synthesis translate_off
  755.     generic map(INIT => X"0000")
  756.     --synthesis translate_on
  757.     port map (       D => alu_result(i),
  758.                     WE => register_enable,
  759.                   WCLK => clk,
  760.                     A0 => instruction(8),
  761.                     A1 => instruction(9),
  762.                     A2 => instruction(10),
  763.                     A3 => instruction(11),
  764.                  DPRA0 => instruction(4),
  765.                  DPRA1 => instruction(5),
  766.                  DPRA2 => instruction(6),
  767.                  DPRA3 => instruction(7),
  768.                    SPO => sx(i),
  769.                    DPO => sy(i));
  770.     operand_select_mux: LUT3
  771.     --synthesis translate_off
  772.       generic map (INIT => X"E4")
  773.     --synthesis translate_on
  774.     port map( I0 => instruction(12),
  775.               I1 => instruction(i),
  776.               I2 => sy(i),
  777.                O => second_operand(i) );
  778.   end generate reg_loop;
  779.   out_port <= sx;
  780.   port_id <= second_operand;
  781. --
  782. ------------------------------------------------------------------------------------
  783. --
  784. -- Store Memory
  785. --
  786. -- Definition of an 8-bit single port RAM with 64 locations 
  787. -- including write enable decode.
  788. --
  789. ------------------------------------------------------------------------------------
  790. --
  791.   -- Forming decode signal
  792.   memory_type_lut: LUT4
  793.   --synthesis translate_off
  794.     generic map (INIT => X"0400")
  795.   --synthesis translate_on
  796.   port map( I0 => active_interrupt,
  797.             I1 => instruction(15),
  798.             I2 => instruction(16),
  799.             I3 => instruction(17),
  800.              O => memory_type );
  801.   memory_write_flop: FD
  802.   port map ( D => memory_type,
  803.              Q => memory_write,
  804.              C => clk);
  805.   memory_enable_lut: LUT4
  806.   --synthesis translate_off
  807.     generic map (INIT => X"8000")
  808.   --synthesis translate_on
  809.   port map( I0 => t_state,
  810.             I1 => instruction(13),
  811.             I2 => instruction(14),
  812.             I3 => memory_write,
  813.              O => memory_enable );
  814.   store_loop: for i in 0 to 7 generate
  815.   --
  816.   -- Attribute to define RAM contents during implementation 
  817.   -- The information is repeated in the generic map for functional simulation
  818.   --
  819.   attribute INIT : string; 
  820.   attribute INIT of memory_bit : label is "0000000000000000"; 
  821.   --
  822.   begin
  823.     memory_bit: RAM64X1S
  824.     --synthesis translate_off
  825.     generic map(INIT => X"0000000000000000")
  826.     --synthesis translate_on
  827.     port map (       D => sx(i),
  828.                     WE => memory_enable,
  829.                   WCLK => clk,
  830.                     A0 => second_operand(0),
  831.                     A1 => second_operand(1),
  832.                     A2 => second_operand(2),
  833.                     A3 => second_operand(3),
  834.                     A4 => second_operand(4),
  835.                     A5 => second_operand(5),
  836.                      O => memory_data(i));
  837.     store_flop: FD
  838.     port map ( D => memory_data(i),
  839.                Q => store_data(i),
  840.                C => clk);
  841.   end generate store_loop;
  842. --
  843. ------------------------------------------------------------------------------------
  844. --
  845. -- Logical operations
  846. --
  847. -- Definition of AND, OR, XOR and LOAD functions which also provides TEST.
  848. -- Includes pipeline stage used to form ALU multiplexer including decode.
  849. --
  850. ------------------------------------------------------------------------------------
  851. --
  852.   sel_logical_lut: LUT4
  853.   --synthesis translate_off
  854.     generic map (INIT => X"FFE2")
  855.   --synthesis translate_on
  856.   port map( I0 => instruction(14),
  857.             I1 => instruction(15),
  858.             I2 => instruction(16),
  859.             I3 => instruction(17),
  860.              O => sel_logical );
  861.   logical_loop: for i in 0 to 7 generate
  862.   --
  863.   -- Attribute to define LUT contents during implementation 
  864.   -- The information is repeated in the generic map for functional simulation
  865.   attribute INIT : string; 
  866.   attribute INIT of logical_lut : label is "6E8A"; 
  867.   --
  868.   begin
  869.     logical_lut: LUT4
  870.     --synthesis translate_off
  871.     generic map (INIT => X"6E8A")
  872.     --synthesis translate_on
  873.     port map( I0 => second_operand(i),
  874.               I1 => sx(i),
  875.               I2 => instruction(13),
  876.               I3 => instruction(14),
  877.                O => logical_value(i));
  878.     logical_flop: FDR
  879.     port map ( D => logical_value(i),
  880.                Q => logical_result(i),
  881.                R => sel_logical,
  882.                C => clk);
  883.   end generate logical_loop;
  884. --
  885. --
  886. ------------------------------------------------------------------------------------
  887. --
  888. -- Shift and Rotate operations
  889. --
  890. -- Includes pipeline stage used to form ALU multiplexer including decode.
  891. --
  892. ------------------------------------------------------------------------------------
  893. --
  894.   sel_shift_inv: INV   -- Inverter should be implemented in the reset to flip flops
  895.   port map(  I => instruction(17),
  896.              O => sel_shift); 
  897.   -- Bit to input to shift register
  898.   high_shift_in_lut: LUT3
  899.   --synthesis translate_off
  900.     generic map (INIT => X"E4")
  901.   --synthesis translate_on
  902.   port map( I0 => instruction(1),
  903.             I1 => sx(0),
  904.             I2 => instruction(0),
  905.              O => high_shift_in );
  906.   low_shift_in_lut: LUT3
  907.   --synthesis translate_off
  908.     generic map (INIT => X"E4")
  909.   --synthesis translate_on
  910.   port map( I0 => instruction(1),
  911.             I1 => carry_flag,
  912.             I2 => sx(7),
  913.              O => low_shift_in );
  914.   shift_in_muxf5: MUXF5
  915.   port map(  I1 => high_shift_in,
  916.              I0 => low_shift_in,
  917.               S => instruction(2),
  918.               O => shift_in ); 
  919.   -- Forming shift carry signal
  920.   shift_carry_lut: LUT3
  921.   --synthesis translate_off
  922.     generic map (INIT => X"E4")
  923.   --synthesis translate_on
  924.   port map( I0 => instruction(3),
  925.             I1 => sx(7),
  926.             I2 => sx(0),
  927.              O => shift_carry_value );
  928.    
  929.   pipeline_bit: FD
  930.   port map ( D => shift_carry_value,
  931.              Q => shift_carry,
  932.              C => clk);
  933.   shift_loop: for i in 0 to 7 generate
  934.   begin
  935.     lsb_shift: if i=0 generate
  936.     --
  937.     -- Attribute to define LUT contents during implementation 
  938.     -- The information is repeated in the generic map for functional simulation
  939.     attribute INIT : string; 
  940.     attribute INIT of shift_mux_lut : label is "E4";
  941.     --
  942.     begin
  943.       shift_mux_lut: LUT3
  944.       --synthesis translate_off
  945.         generic map (INIT => X"E4")
  946.       --synthesis translate_on
  947.       port map( I0 => instruction(3),
  948.                 I1 => shift_in,
  949.                 I2 => sx(i+1),
  950.                  O => shift_value(i) );
  951.    
  952.     end generate lsb_shift;
  953.     mid_shift: if i>0 and i<7 generate
  954.     --
  955.     -- Attribute to define LUT contents during implementation 
  956.     -- The information is repeated in the generic map for functional simulation
  957.     attribute INIT : string; 
  958.     attribute INIT of shift_mux_lut : label is "E4";
  959.     --
  960.     begin
  961.       shift_mux_lut: LUT3
  962.       --synthesis translate_off
  963.         generic map (INIT => X"E4")
  964.       --synthesis translate_on
  965.       port map( I0 => instruction(3),
  966.                 I1 => sx(i-1),
  967.                 I2 => sx(i+1),
  968.                  O => shift_value(i) );
  969.    
  970.     end generate mid_shift;
  971.     msb_shift: if i=7 generate
  972.     --
  973.     -- Attribute to define LUT contents during implementation 
  974.     -- The information is repeated in the generic map for functional simulation
  975.     attribute INIT : string; 
  976.     attribute INIT of shift_mux_lut : label is "E4";
  977.     --
  978.     begin
  979.       shift_mux_lut: LUT3
  980.       --synthesis translate_off
  981.         generic map (INIT => X"E4")
  982.       --synthesis translate_on
  983.       port map( I0 => instruction(3),
  984.                 I1 => sx(i-1),
  985.                 I2 => shift_in,
  986.                  O => shift_value(i) );
  987.    
  988.     end generate msb_shift;
  989.     shift_flop: FDR
  990.     port map ( D => shift_value(i),
  991.                Q => shift_result(i),
  992.                R => sel_shift,
  993.                C => clk);
  994.   end generate shift_loop;
  995. --
  996. ------------------------------------------------------------------------------------
  997. --
  998. -- Arithmetic operations
  999. --
  1000. -- Definition of ADD, ADDCY, SUB and SUBCY functions which also provides COMPARE.
  1001. -- Includes pipeline stage used to form ALU multiplexer including decode.
  1002. --
  1003. ------------------------------------------------------------------------------------
  1004. --
  1005.   sel_arith_lut: LUT3
  1006.   --synthesis translate_off
  1007.     generic map (INIT => X"1F")
  1008.   --synthesis translate_on
  1009.   port map( I0 => instruction(14),
  1010.             I1 => instruction(15),
  1011.             I2 => instruction(16),
  1012.              O => sel_arith );
  1013.   arith_loop: for i in 0 to 7 generate
  1014.   --
  1015.   -- Attribute to define LUT contents during implementation 
  1016.   -- The information is repeated in the generic map for functional simulation
  1017.   attribute INIT : string; 
  1018.   attribute INIT of arith_lut : label is "96"; 
  1019.   --
  1020.   begin
  1021.     lsb_arith: if i=0 generate
  1022.     --
  1023.     -- Attribute to define LUT contents during implementation 
  1024.     -- The information is repeated in the generic map for functional simulation
  1025.     attribute INIT : string; 
  1026.     attribute INIT of arith_carry_in_lut : label is "6C";
  1027.     --
  1028.     begin
  1029.       arith_carry_in_lut: LUT3
  1030.       --synthesis translate_off
  1031.         generic map (INIT => X"6C")
  1032.       --synthesis translate_on
  1033.       port map( I0 => instruction(13),
  1034.                 I1 => instruction(14),
  1035.                 I2 => carry_flag,
  1036.                  O => sel_arith_carry_in );
  1037.       arith_carry_in_muxcy: MUXCY
  1038.       port map( DI => '0',
  1039.                 CI => '1',
  1040.                  S => sel_arith_carry_in,
  1041.                  O => arith_carry_in);
  1042.       arith_muxcy: MUXCY
  1043.       port map( DI => sx(i),
  1044.                 CI => arith_carry_in,
  1045.                  S => half_arith(i),
  1046.                  O => arith_internal_carry(i));
  1047.       arith_xor: XORCY
  1048.       port map( LI => half_arith(i),
  1049.                 CI => arith_carry_in,
  1050.                  O => arith_value(i));
  1051.    
  1052.     end generate lsb_arith;
  1053.     mid_arith: if i>0 and i<7 generate
  1054.     begin
  1055.       arith_muxcy: MUXCY
  1056.       port map( DI => sx(i),
  1057.                 CI => arith_internal_carry(i-1),
  1058.                  S => half_arith(i),
  1059.                  O => arith_internal_carry(i));
  1060.       arith_xor: XORCY
  1061.       port map( LI => half_arith(i),
  1062.                 CI => arith_internal_carry(i-1),
  1063.                  O => arith_value(i));
  1064.    
  1065.     end generate mid_arith;
  1066.     msb_arith: if i=7 generate
  1067.     --
  1068.     -- Attribute to define LUT contents during implementation 
  1069.     -- The information is repeated in the generic map for functional simulation
  1070.     attribute INIT : string; 
  1071.     attribute INIT of arith_carry_out_lut : label is "2";
  1072.     --
  1073.     begin
  1074.       arith_muxcy: MUXCY
  1075.       port map( DI => sx(i),
  1076.                 CI => arith_internal_carry(i-1),
  1077.                  S => half_arith(i),
  1078.                  O => arith_internal_carry(i));
  1079.       arith_xor: XORCY
  1080.       port map( LI => half_arith(i),
  1081.                 CI => arith_internal_carry(i-1),
  1082.                  O => arith_value(i));
  1083.       arith_carry_out_lut: LUT1
  1084.       --synthesis translate_off
  1085.         generic map (INIT => X"2")
  1086.       --synthesis translate_on
  1087.       port map( I0 => instruction(14),
  1088.                  O => invert_arith_carry );
  1089.       arith_carry_out_xor: XORCY
  1090.       port map( LI => invert_arith_carry,
  1091.                 CI => arith_internal_carry(i),
  1092.                  O => arith_carry_out);
  1093.       arith_carry_flop: FDR
  1094.       port map ( D => arith_carry_out,
  1095.                  Q => arith_carry,
  1096.                  R => sel_arith,
  1097.                  C => clk);
  1098.     end generate msb_arith;
  1099.     arith_lut: LUT3
  1100.     --synthesis translate_off
  1101.     generic map (INIT => X"96")
  1102.     --synthesis translate_on
  1103.     port map( I0 => sx(i),
  1104.               I1 => second_operand(i),
  1105.               I2 => instruction(14),
  1106.                O => half_arith(i));
  1107.     arith_flop: FDR
  1108.     port map ( D => arith_value(i),
  1109.                Q => arith_result(i),
  1110.                R => sel_arith,
  1111.                C => clk);
  1112.   end generate arith_loop;
  1113. --
  1114. --
  1115. ------------------------------------------------------------------------------------
  1116. --
  1117. -- ALU multiplexer
  1118. --
  1119. ------------------------------------------------------------------------------------
  1120. --
  1121.   input_fetch_type_lut: LUT4
  1122.   --synthesis translate_off
  1123.     generic map (INIT => X"0002")
  1124.   --synthesis translate_on
  1125.   port map( I0 => instruction(14),
  1126.             I1 => instruction(15),
  1127.             I2 => instruction(16),
  1128.             I3 => instruction(17),
  1129.              O => input_fetch_type );
  1130.   sel_group_flop: FD
  1131.   port map ( D => input_fetch_type,
  1132.              Q => sel_group,
  1133.              C => clk);
  1134.   alu_mux_loop: for i in 0 to 7 generate
  1135.   --
  1136.   -- Attribute to define LUT contents during implementation 
  1137.   -- The information is repeated in the generic map for functional simulation
  1138.   attribute INIT : string; 
  1139.   attribute INIT of or_lut  : label is "FE"; 
  1140.   attribute INIT of mux_lut : label is "E4"; 
  1141.   --
  1142.   begin
  1143.     or_lut: LUT3
  1144.     --synthesis translate_off
  1145.     generic map (INIT => X"FE")
  1146.     --synthesis translate_on
  1147.     port map( I0 => logical_result(i),
  1148.               I1 => arith_result(i),
  1149.               I2 => shift_result(i),
  1150.                O => alu_group(i));
  1151.     mux_lut: LUT3
  1152.     --synthesis translate_off
  1153.     generic map (INIT => X"E4")
  1154.     --synthesis translate_on
  1155.     port map( I0 => instruction(13),
  1156.               I1 => in_port(i),
  1157.               I2 => store_data(i),
  1158.                O => input_group(i));
  1159.     shift_in_muxf5: MUXF5
  1160.     port map(  I1 => input_group(i),
  1161.                I0 => alu_group(i),
  1162.                 S => sel_group,
  1163.                 O => alu_result(i) ); 
  1164.   end generate alu_mux_loop;
  1165. --
  1166. ------------------------------------------------------------------------------------
  1167. --
  1168. -- Read and Write Strobes
  1169. --
  1170. ------------------------------------------------------------------------------------
  1171. --
  1172.   io_decode_lut: LUT4
  1173.   --synthesis translate_off
  1174.     generic map (INIT => X"0010")
  1175.   --synthesis translate_on
  1176.   port map( I0 => active_interrupt,
  1177.             I1 => instruction(13),
  1178.             I2 => instruction(14),
  1179.             I3 => instruction(16),
  1180.              O => io_initial_decode );
  1181.   write_active_lut: LUT4
  1182.   --synthesis translate_off
  1183.     generic map (INIT => X"4000")
  1184.   --synthesis translate_on
  1185.   port map( I0 => t_state,
  1186.             I1 => instruction(15),
  1187.             I2 => instruction(17),
  1188.             I3 => io_initial_decode,
  1189.              O => write_active );
  1190.   write_strobe_flop: FDR
  1191.   port map ( D => write_active,
  1192.              Q => write_strobe,
  1193.              R => internal_reset,
  1194.              C => clk);
  1195.   read_active_lut: LUT4
  1196.   --synthesis translate_off
  1197.     generic map (INIT => X"0100")
  1198.   --synthesis translate_on
  1199.   port map( I0 => t_state,
  1200.             I1 => instruction(15),
  1201.             I2 => instruction(17),
  1202.             I3 => io_initial_decode,
  1203.              O => read_active );
  1204.   read_strobe_flop: FDR
  1205.   port map ( D => read_active,
  1206.              Q => read_strobe,
  1207.              R => internal_reset,
  1208.              C => clk);
  1209. --
  1210. ------------------------------------------------------------------------------------
  1211. --
  1212. -- Program CALL/RETURN stack
  1213. --
  1214. -- Provided the counter and memory for a 32 deep stack supporting nested 
  1215. -- subroutine calls to a depth of 31 levels.
  1216. --
  1217. ------------------------------------------------------------------------------------
  1218. --
  1219.   -- Stack memory is 32 locations of 10-bit single port.
  1220.   
  1221.   stack_ram_inv: INV   -- Inverter should be implemented in the WE to RAM
  1222.   port map(  I => t_state,
  1223.              O => stack_write_enable); 
  1224.   stack_ram_loop: for i in 0 to 9 generate
  1225.   --
  1226.   -- Attribute to define RAM contents during implementation 
  1227.   -- The information is repeated in the generic map for functional simulation
  1228.   --
  1229.   attribute INIT : string; 
  1230.   attribute INIT of stack_bit : label is "00000000"; 
  1231.   --
  1232.   begin
  1233.     stack_bit: RAM32X1S
  1234.     --synthesis translate_off
  1235.     generic map(INIT => X"00000000")
  1236.     --synthesis translate_on
  1237.     port map (       D => pc(i),
  1238.                     WE => stack_write_enable,
  1239.                   WCLK => clk,
  1240.                     A0 => stack_address(0),
  1241.                     A1 => stack_address(1),
  1242.                     A2 => stack_address(2),
  1243.                     A3 => stack_address(3),
  1244.                     A4 => stack_address(4),
  1245.                      O => stack_ram_data(i));
  1246.     stack_flop: FD
  1247.     port map ( D => stack_ram_data(i),
  1248.                Q => stack_pop_data(i),
  1249.                C => clk);
  1250.   end generate stack_ram_loop;
  1251.   -- Stack address pointer is a 5-bit counter
  1252.   stack_count_inv: INV   -- Inverter should be implemented in the CE to the flip-flops
  1253.   port map(  I => active_interrupt,
  1254.              O => not_active_interrupt); 
  1255.   stack_count_loop: for i in 0 to 4 generate
  1256.   begin
  1257.   
  1258.     register_bit: FDRE
  1259.     port map ( D => next_stack_address(i),
  1260.                Q => stack_address(i),
  1261.                R => internal_reset,
  1262.               CE => not_active_interrupt,
  1263.                C => clk);
  1264.     lsb_stack_count: if i=0 generate
  1265.     --
  1266.     -- Attribute to define LUT contents during implementation 
  1267.     -- The information is repeated in the generic map for functional simulation
  1268.     --
  1269.     attribute INIT : string; 
  1270.     attribute INIT of count_lut : label is "6555"; 
  1271.     --
  1272.     begin
  1273.     
  1274.       count_lut: LUT4
  1275.       --synthesis translate_off
  1276.       generic map (INIT => X"6555")
  1277.       --synthesis translate_on
  1278.       port map( I0 => stack_address(i),
  1279.                 I1 => t_state,
  1280.                 I2 => valid_to_move,
  1281.                 I3 => push_or_pop_type,
  1282.                  O => half_stack_address(i) );
  1283.     
  1284.       count_muxcy: MUXCY
  1285.       port map( DI => stack_address(i),
  1286.                 CI => '0',
  1287.                  S => half_stack_address(i),
  1288.                  O => stack_address_carry(i));
  1289.     
  1290.       count_xor: XORCY
  1291.       port map( LI => half_stack_address(i),
  1292.                 CI => '0',
  1293.                  O => next_stack_address(i));
  1294.             
  1295.     end generate lsb_stack_count;
  1296.     mid_stack_count: if i>0 and i<4 generate
  1297.     --
  1298.     -- Attribute to define LUT contents during implementation 
  1299.     -- The information is repeated in the generic map for functional simulation
  1300.     --
  1301.     attribute INIT : string; 
  1302.     attribute INIT of count_lut : label is "A999"; 
  1303.     --
  1304.     begin
  1305.     
  1306.       count_lut: LUT4
  1307.       --synthesis translate_off
  1308.       generic map (INIT => X"A999")
  1309.       --synthesis translate_on
  1310.       port map( I0 => stack_address(i),
  1311.                 I1 => t_state,
  1312.                 I2 => valid_to_move,
  1313.                 I3 => call_type,
  1314.                  O => half_stack_address(i) );
  1315.     
  1316.       count_muxcy: MUXCY
  1317.       port map( DI => stack_address(i),
  1318.                 CI => stack_address_carry(i-1),
  1319.                  S => half_stack_address(i),
  1320.                  O => stack_address_carry(i));
  1321.     
  1322.       count_xor: XORCY
  1323.       port map( LI => half_stack_address(i),
  1324.                 CI => stack_address_carry(i-1),
  1325.                  O => next_stack_address(i));
  1326.             
  1327.     end generate mid_stack_count;
  1328.     msb_stack_count: if i=4 generate
  1329.     --
  1330.     -- Attribute to define LUT contents during implementation 
  1331.     -- The information is repeated in the generic map for functional simulation
  1332.     --
  1333.     attribute INIT : string; 
  1334.     attribute INIT of count_lut : label is "A999"; 
  1335.     --
  1336.     begin
  1337.     
  1338.       count_lut: LUT4
  1339.       --synthesis translate_off
  1340.       generic map (INIT => X"A999")
  1341.       --synthesis translate_on
  1342.       port map( I0 => stack_address(i),
  1343.                 I1 => t_state,
  1344.                 I2 => valid_to_move,
  1345.                 I3 => call_type,
  1346.                  O => half_stack_address(i) );
  1347.     
  1348.       count_xor: XORCY
  1349.       port map( LI => half_stack_address(i),
  1350.                 CI => stack_address_carry(i-1),
  1351.                  O => next_stack_address(i));
  1352.             
  1353.     end generate msb_stack_count;
  1354.   end generate stack_count_loop;
  1355. --
  1356. ------------------------------------------------------------------------------------
  1357. --
  1358. -- End of description for KCPSM3 macro.
  1359. --
  1360. ------------------------------------------------------------------------------------
  1361. --
  1362. --**********************************************************************************
  1363. -- Code for simulation purposes only after this line
  1364. --**********************************************************************************
  1365. --
  1366. ------------------------------------------------------------------------------------
  1367. --
  1368. -- Code for simulation.
  1369. --
  1370. -- Disassemble the instruction codes to form a text string variable for display.
  1371. -- Determine status of reset and flags and present in the form of a text string.
  1372. -- Provide a local variables to simulate the contents of each register and scratch 
  1373. -- pad memory location.
  1374. --
  1375. ------------------------------------------------------------------------------------
  1376. --
  1377.   --All of this section is ignored during synthesis.
  1378.   --synthesis translate off
  1379.   simulation: process (clk, instruction)
  1380.   --
  1381.   --complete instruction decode
  1382.   --
  1383.   variable kcpsm3_opcode : string(1 to 19);
  1384.   --
  1385.   --Status of flags and processor
  1386.   --
  1387.   variable kcpsm3_status : string(1 to 13):= "NZ, NC, Reset";
  1388.   --
  1389.   --contents of each register
  1390.   --
  1391.   variable s0_contents : std_logic_vector(7 downto 0):=X"00";
  1392.   variable s1_contents : std_logic_vector(7 downto 0):=X"00";
  1393.   variable s2_contents : std_logic_vector(7 downto 0):=X"00";
  1394.   variable s3_contents : std_logic_vector(7 downto 0):=X"00";
  1395.   variable s4_contents : std_logic_vector(7 downto 0):=X"00";
  1396.   variable s5_contents : std_logic_vector(7 downto 0):=X"00";
  1397.   variable s6_contents : std_logic_vector(7 downto 0):=X"00";
  1398.   variable s7_contents : std_logic_vector(7 downto 0):=X"00";
  1399.   variable s8_contents : std_logic_vector(7 downto 0):=X"00";
  1400.   variable s9_contents : std_logic_vector(7 downto 0):=X"00";
  1401.   variable sa_contents : std_logic_vector(7 downto 0):=X"00";
  1402.   variable sb_contents : std_logic_vector(7 downto 0):=X"00";
  1403.   variable sc_contents : std_logic_vector(7 downto 0):=X"00";
  1404.   variable sd_contents : std_logic_vector(7 downto 0):=X"00";
  1405.   variable se_contents : std_logic_vector(7 downto 0):=X"00";
  1406.   variable sf_contents : std_logic_vector(7 downto 0):=X"00";
  1407.   --
  1408.   --contents of each scratch pad memory location
  1409.   --
  1410.   variable spm00_contents : std_logic_vector(7 downto 0):=X"00";
  1411.   variable spm01_contents : std_logic_vector(7 downto 0):=X"00";
  1412.   variable spm02_contents : std_logic_vector(7 downto 0):=X"00";
  1413.   variable spm03_contents : std_logic_vector(7 downto 0):=X"00";
  1414.   variable spm04_contents : std_logic_vector(7 downto 0):=X"00";
  1415.   variable spm05_contents : std_logic_vector(7 downto 0):=X"00";
  1416.   variable spm06_contents : std_logic_vector(7 downto 0):=X"00";
  1417.   variable spm07_contents : std_logic_vector(7 downto 0):=X"00";
  1418.   variable spm08_contents : std_logic_vector(7 downto 0):=X"00";
  1419.   variable spm09_contents : std_logic_vector(7 downto 0):=X"00";
  1420.   variable spm0a_contents : std_logic_vector(7 downto 0):=X"00";
  1421.   variable spm0b_contents : std_logic_vector(7 downto 0):=X"00";
  1422.   variable spm0c_contents : std_logic_vector(7 downto 0):=X"00";
  1423.   variable spm0d_contents : std_logic_vector(7 downto 0):=X"00";
  1424.   variable spm0e_contents : std_logic_vector(7 downto 0):=X"00";
  1425.   variable spm0f_contents : std_logic_vector(7 downto 0):=X"00";
  1426.   variable spm10_contents : std_logic_vector(7 downto 0):=X"00";
  1427.   variable spm11_contents : std_logic_vector(7 downto 0):=X"00";
  1428.   variable spm12_contents : std_logic_vector(7 downto 0):=X"00";
  1429.   variable spm13_contents : std_logic_vector(7 downto 0):=X"00";
  1430.   variable spm14_contents : std_logic_vector(7 downto 0):=X"00";
  1431.   variable spm15_contents : std_logic_vector(7 downto 0):=X"00";
  1432.   variable spm16_contents : std_logic_vector(7 downto 0):=X"00";
  1433.   variable spm17_contents : std_logic_vector(7 downto 0):=X"00";
  1434.   variable spm18_contents : std_logic_vector(7 downto 0):=X"00";
  1435.   variable spm19_contents : std_logic_vector(7 downto 0):=X"00";
  1436.   variable spm1a_contents : std_logic_vector(7 downto 0):=X"00";
  1437.   variable spm1b_contents : std_logic_vector(7 downto 0):=X"00";
  1438.   variable spm1c_contents : std_logic_vector(7 downto 0):=X"00";
  1439.   variable spm1d_contents : std_logic_vector(7 downto 0):=X"00";
  1440.   variable spm1e_contents : std_logic_vector(7 downto 0):=X"00";
  1441.   variable spm1f_contents : std_logic_vector(7 downto 0):=X"00";  
  1442.   variable spm20_contents : std_logic_vector(7 downto 0):=X"00";
  1443.   variable spm21_contents : std_logic_vector(7 downto 0):=X"00";
  1444.   variable spm22_contents : std_logic_vector(7 downto 0):=X"00";
  1445.   variable spm23_contents : std_logic_vector(7 downto 0):=X"00";
  1446.   variable spm24_contents : std_logic_vector(7 downto 0):=X"00";
  1447.   variable spm25_contents : std_logic_vector(7 downto 0):=X"00";
  1448.   variable spm26_contents : std_logic_vector(7 downto 0):=X"00";
  1449.   variable spm27_contents : std_logic_vector(7 downto 0):=X"00";
  1450.   variable spm28_contents : std_logic_vector(7 downto 0):=X"00";
  1451.   variable spm29_contents : std_logic_vector(7 downto 0):=X"00";
  1452.   variable spm2a_contents : std_logic_vector(7 downto 0):=X"00";
  1453.   variable spm2b_contents : std_logic_vector(7 downto 0):=X"00";
  1454.   variable spm2c_contents : std_logic_vector(7 downto 0):=X"00";
  1455.   variable spm2d_contents : std_logic_vector(7 downto 0):=X"00";
  1456.   variable spm2e_contents : std_logic_vector(7 downto 0):=X"00";
  1457.   variable spm2f_contents : std_logic_vector(7 downto 0):=X"00";  
  1458.   variable spm30_contents : std_logic_vector(7 downto 0):=X"00";
  1459.   variable spm31_contents : std_logic_vector(7 downto 0):=X"00";
  1460.   variable spm32_contents : std_logic_vector(7 downto 0):=X"00";
  1461.   variable spm33_contents : std_logic_vector(7 downto 0):=X"00";
  1462.   variable spm34_contents : std_logic_vector(7 downto 0):=X"00";
  1463.   variable spm35_contents : std_logic_vector(7 downto 0):=X"00";
  1464.   variable spm36_contents : std_logic_vector(7 downto 0):=X"00";
  1465.   variable spm37_contents : std_logic_vector(7 downto 0):=X"00";
  1466.   variable spm38_contents : std_logic_vector(7 downto 0):=X"00";
  1467.   variable spm39_contents : std_logic_vector(7 downto 0):=X"00";
  1468.   variable spm3a_contents : std_logic_vector(7 downto 0):=X"00";
  1469.   variable spm3b_contents : std_logic_vector(7 downto 0):=X"00";
  1470.   variable spm3c_contents : std_logic_vector(7 downto 0):=X"00";
  1471.   variable spm3d_contents : std_logic_vector(7 downto 0):=X"00";
  1472.   variable spm3e_contents : std_logic_vector(7 downto 0):=X"00";
  1473.   variable spm3f_contents : std_logic_vector(7 downto 0):=X"00";
  1474.   --
  1475.   --temporary variables
  1476.   --
  1477.   variable     sx_decode : string(1 to 2);                     --sX register specification
  1478.   variable     sy_decode : string(1 to 2);                     --sY register specification
  1479.   variable     kk_decode : string(1 to 2);                     --constant value specification
  1480.   variable    aaa_decode : string(1 to 3);                     --address specification
  1481.   --
  1482.   --------------------------------------------------------------------------------
  1483.   --
  1484.   -- Function to convert 4-bit binary nibble to hexadecimal character
  1485.   --
  1486.   --------------------------------------------------------------------------------
  1487.   --
  1488.   function hexcharacter (nibble: std_logic_vector(3 downto 0))
  1489.   return character is
  1490.   variable hex: character;
  1491.   begin
  1492.     case nibble is
  1493.       when "0000" => hex := '0';
  1494.       when "0001" => hex := '1';
  1495.       when "0010" => hex := '2';
  1496.       when "0011" => hex := '3';
  1497.       when "0100" => hex := '4';
  1498.       when "0101" => hex := '5';
  1499.       when "0110" => hex := '6';
  1500.       when "0111" => hex := '7';
  1501.       when "1000" => hex := '8';
  1502.       when "1001" => hex := '9';
  1503.       when "1010" => hex := 'A';
  1504.       when "1011" => hex := 'B';
  1505.       when "1100" => hex := 'C';
  1506.       when "1101" => hex := 'D';
  1507.       when "1110" => hex := 'E';
  1508.       when "1111" => hex := 'F';
  1509.       when others => hex := 'x';
  1510.     end case;
  1511.     return hex;
  1512.   end hexcharacter;
  1513.   --
  1514.   --------------------------------------------------------------------------------
  1515.   --
  1516.   begin
  1517.      
  1518.     -- decode first register
  1519.     sx_decode(1) := 's';
  1520.     sx_decode(2) := hexcharacter(instruction(11 downto 8));             
  1521.     -- decode second register
  1522.     sy_decode(1) := 's';
  1523.     sy_decode(2) := hexcharacter(instruction(7 downto 4));  
  1524.     -- decode constant value
  1525.     kk_decode(1) := hexcharacter(instruction(7 downto 4));
  1526.     kk_decode(2) := hexcharacter(instruction(3 downto 0));
  1527.     -- address value
  1528.     aaa_decode(1) := hexcharacter("00" & instruction(9 downto 8));
  1529.     aaa_decode(2) := hexcharacter(instruction(7 downto 4));
  1530.     aaa_decode(3) := hexcharacter(instruction(3 downto 0));
  1531.     -- decode instruction
  1532.     case instruction(17 downto 12) is
  1533.       when "000000" => kcpsm3_opcode := "LOAD " & sx_decode & ',' & kk_decode & "         ";
  1534.       when "000001" => kcpsm3_opcode := "LOAD " & sx_decode & ',' & sy_decode & "         ";
  1535.       when "001010" => kcpsm3_opcode := "AND " & sx_decode & ',' & kk_decode & "          ";
  1536.       when "001011" => kcpsm3_opcode := "AND " & sx_decode & ',' & sy_decode & "          ";
  1537.       when "001100" => kcpsm3_opcode := "OR " & sx_decode & ',' & kk_decode & "           ";
  1538.       when "001101" => kcpsm3_opcode := "OR " & sx_decode & ',' & sy_decode & "           ";
  1539.       when "001110" => kcpsm3_opcode := "XOR " & sx_decode & ',' & kk_decode & "          ";
  1540.       when "001111" => kcpsm3_opcode := "XOR " & sx_decode & ',' & sy_decode & "          ";
  1541.       when "010010" => kcpsm3_opcode := "TEST " & sx_decode & ',' & kk_decode & "         ";
  1542.       when "010011" => kcpsm3_opcode := "TEST " & sx_decode & ',' & sy_decode & "         ";
  1543.       when "011000" => kcpsm3_opcode := "ADD " & sx_decode & ',' & kk_decode & "          ";
  1544.       when "011001" => kcpsm3_opcode := "ADD " & sx_decode & ',' & sy_decode & "          ";
  1545.       when "011010" => kcpsm3_opcode := "ADDCY " & sx_decode & ',' & kk_decode & "        ";
  1546.       when "011011" => kcpsm3_opcode := "ADDCY " & sx_decode & ',' & sy_decode & "        ";
  1547.       when "011100" => kcpsm3_opcode := "SUB " & sx_decode & ',' & kk_decode & "          ";
  1548.       when "011101" => kcpsm3_opcode := "SUB " & sx_decode & ',' & sy_decode & "          ";
  1549.       when "011110" => kcpsm3_opcode := "SUBCY " & sx_decode & ',' & kk_decode & "        ";
  1550.       when "011111" => kcpsm3_opcode := "SUBCY " & sx_decode & ',' & sy_decode & "        ";
  1551.       when "010100" => kcpsm3_opcode := "COMPARE " & sx_decode & ',' & kk_decode & "      ";
  1552.       when "010101" => kcpsm3_opcode := "COMPARE " & sx_decode & ',' & sy_decode & "      ";
  1553.       when "100000" => 
  1554.         case instruction(3 downto 0) is
  1555.           when "0110" => kcpsm3_opcode := "SL0 " & sx_decode & "             ";
  1556.           when "0111" => kcpsm3_opcode := "SL1 " & sx_decode & "             ";
  1557.           when "0100" => kcpsm3_opcode := "SLX " & sx_decode & "             ";
  1558.           when "0000" => kcpsm3_opcode := "SLA " & sx_decode & "             ";
  1559.           when "0010" => kcpsm3_opcode := "RL " & sx_decode & "              ";
  1560.           when "1110" => kcpsm3_opcode := "SR0 " & sx_decode & "             ";
  1561.           when "1111" => kcpsm3_opcode := "SR1 " & sx_decode & "             ";
  1562.           when "1010" => kcpsm3_opcode := "SRX " & sx_decode & "             ";
  1563.           when "1000" => kcpsm3_opcode := "SRA " & sx_decode & "             ";
  1564.           when "1100" => kcpsm3_opcode := "RR " & sx_decode & "              ";
  1565.           when others => kcpsm3_opcode := "Invalid Instruction";
  1566.         end case;
  1567.       when "101100" => kcpsm3_opcode := "OUTPUT " & sx_decode & ',' & kk_decode & "       ";
  1568.       when "101101" => kcpsm3_opcode := "OUTPUT " & sx_decode & ",(" & sy_decode & ")     ";
  1569.       when "000100" => kcpsm3_opcode := "INPUT " & sx_decode & ',' & kk_decode & "        ";
  1570.       when "000101" => kcpsm3_opcode := "INPUT " & sx_decode & ",(" & sy_decode & ")      ";
  1571.       when "101110" => kcpsm3_opcode := "STORE " & sx_decode & ',' & kk_decode & "        ";
  1572.       when "101111" => kcpsm3_opcode := "STORE " & sx_decode & ",(" & sy_decode & ")      ";
  1573.       when "000110" => kcpsm3_opcode := "FETCH " & sx_decode & ',' & kk_decode & "        ";
  1574.       when "000111" => kcpsm3_opcode := "FETCH " & sx_decode & ",(" & sy_decode & ")      ";
  1575.       when "110100" => kcpsm3_opcode := "JUMP " & aaa_decode & "           ";
  1576.       when "110101" =>
  1577.         case instruction(11 downto 10) is
  1578.           when "00" => kcpsm3_opcode := "JUMP Z," & aaa_decode & "         ";
  1579.           when "01" => kcpsm3_opcode := "JUMP NZ," & aaa_decode & "        ";
  1580.           when "10" => kcpsm3_opcode := "JUMP C," & aaa_decode & "         ";
  1581.           when "11" => kcpsm3_opcode := "JUMP NC," & aaa_decode & "        ";
  1582.           when others => kcpsm3_opcode := "Invalid Instruction";
  1583.         end case;
  1584.       when "110000" => kcpsm3_opcode := "CALL " & aaa_decode & "           ";
  1585.       when "110001" =>
  1586.         case instruction(11 downto 10) is
  1587.           when "00" => kcpsm3_opcode := "CALL Z," & aaa_decode & "         ";
  1588.           when "01" => kcpsm3_opcode := "CALL NZ," & aaa_decode & "        ";
  1589.           when "10" => kcpsm3_opcode := "CALL C," & aaa_decode & "         ";
  1590.           when "11" => kcpsm3_opcode := "CALL NC," & aaa_decode & "        ";
  1591.           when others => kcpsm3_opcode := "Invalid Instruction";
  1592.         end case;
  1593.       when "101010" => kcpsm3_opcode := "RETURN             ";
  1594.       when "101011" =>
  1595.         case instruction(11 downto 10) is
  1596.           when "00" => kcpsm3_opcode := "RETURN Z           ";
  1597.           when "01" => kcpsm3_opcode := "RETURN NZ          ";
  1598.           when "10" => kcpsm3_opcode := "RETURN C           ";
  1599.           when "11" => kcpsm3_opcode := "RETURN NC          ";
  1600.           when others => kcpsm3_opcode := "Invalid Instruction";
  1601.         end case;
  1602.       when "111000" =>
  1603.         case instruction(0) is
  1604.           when '0' => kcpsm3_opcode := "RETURNI DISABLE    ";
  1605.           when '1' => kcpsm3_opcode := "RETURNI ENABLE     ";
  1606.           when others => kcpsm3_opcode := "Invalid Instruction";
  1607.         end case;
  1608.       when "111100" =>
  1609.         case instruction(0) is
  1610.           when '0' => kcpsm3_opcode := "DISABLE INTERRUPT  ";
  1611.           when '1' => kcpsm3_opcode := "ENABLE INTERRUPT   ";
  1612.           when others => kcpsm3_opcode := "Invalid Instruction";
  1613.         end case;
  1614.       when others => kcpsm3_opcode := "Invalid Instruction";
  1615.     end case;
  1616.     if clk'event and clk='1' then 
  1617.       --reset and flag status information
  1618.       if reset='1' or reset_delay='1' then
  1619.         kcpsm3_status := "NZ, NC, Reset";
  1620.        else
  1621.         kcpsm3_status(7 to 13) := "       ";
  1622.         if flag_enable='1' then
  1623.           if zero_carry='1' then
  1624.             kcpsm3_status(1 to 4) := " Z, ";
  1625.            else
  1626.             kcpsm3_status(1 to 4) := "NZ, ";
  1627.           end if;
  1628.           if sel_carry(3)='1' then
  1629.             kcpsm3_status(5 to 6) := " C";
  1630.            else
  1631.             kcpsm3_status(5 to 6) := "NC";
  1632.           end if;
  1633.         end if;
  1634.       end if;
  1635.       --simulation of register contents
  1636.       if register_enable='1' then
  1637.         case instruction(11 downto 8) is
  1638.           when "0000" => s0_contents := alu_result;
  1639.           when "0001" => s1_contents := alu_result;
  1640.           when "0010" => s2_contents := alu_result;
  1641.           when "0011" => s3_contents := alu_result;
  1642.           when "0100" => s4_contents := alu_result;
  1643.           when "0101" => s5_contents := alu_result;
  1644.           when "0110" => s6_contents := alu_result;
  1645.           when "0111" => s7_contents := alu_result;
  1646.           when "1000" => s8_contents := alu_result;
  1647.           when "1001" => s9_contents := alu_result;
  1648.           when "1010" => sa_contents := alu_result;
  1649.           when "1011" => sb_contents := alu_result;
  1650.           when "1100" => sc_contents := alu_result;
  1651.           when "1101" => sd_contents := alu_result;
  1652.           when "1110" => se_contents := alu_result;
  1653.           when "1111" => sf_contents := alu_result;
  1654.           when others => null;
  1655.         end case;
  1656.       end if;
  1657.       --simulation of scratch pad memory contents
  1658.       if memory_enable='1' then
  1659.         case second_operand(5 downto 0) is
  1660.           when "000000" => spm00_contents := sx;
  1661.           when "000001" => spm01_contents := sx;
  1662.           when "000010" => spm02_contents := sx;
  1663.           when "000011" => spm03_contents := sx;
  1664.           when "000100" => spm04_contents := sx;
  1665.           when "000101" => spm05_contents := sx;
  1666.           when "000110" => spm06_contents := sx;
  1667.           when "000111" => spm07_contents := sx;
  1668.           when "001000" => spm08_contents := sx;
  1669.           when "001001" => spm09_contents := sx;
  1670.           when "001010" => spm0a_contents := sx;
  1671.           when "001011" => spm0b_contents := sx;
  1672.           when "001100" => spm0c_contents := sx;
  1673.           when "001101" => spm0d_contents := sx;
  1674.           when "001110" => spm0e_contents := sx;
  1675.           when "001111" => spm0f_contents := sx;
  1676.           when "010000" => spm10_contents := sx;
  1677.           when "010001" => spm11_contents := sx;
  1678.           when "010010" => spm12_contents := sx;
  1679.           when "010011" => spm13_contents := sx;
  1680.           when "010100" => spm14_contents := sx;
  1681.           when "010101" => spm15_contents := sx;
  1682.           when "010110" => spm16_contents := sx;
  1683.           when "010111" => spm17_contents := sx;
  1684.           when "011000" => spm18_contents := sx;
  1685.           when "011001" => spm19_contents := sx;
  1686.           when "011010" => spm1a_contents := sx;
  1687.           when "011011" => spm1b_contents := sx;
  1688.           when "011100" => spm1c_contents := sx;
  1689.           when "011101" => spm1d_contents := sx;
  1690.           when "011110" => spm1e_contents := sx;
  1691.           when "011111" => spm1f_contents := sx;
  1692.           when "100000" => spm20_contents := sx;
  1693.           when "100001" => spm21_contents := sx;
  1694.           when "100010" => spm22_contents := sx;
  1695.           when "100011" => spm23_contents := sx;
  1696.           when "100100" => spm24_contents := sx;
  1697.           when "100101" => spm25_contents := sx;
  1698.           when "100110" => spm26_contents := sx;
  1699.           when "100111" => spm27_contents := sx;
  1700.           when "101000" => spm28_contents := sx;
  1701.           when "101001" => spm29_contents := sx;
  1702.           when "101010" => spm2a_contents := sx;
  1703.           when "101011" => spm2b_contents := sx;
  1704.           when "101100" => spm2c_contents := sx;
  1705.           when "101101" => spm2d_contents := sx;
  1706.           when "101110" => spm2e_contents := sx;
  1707.           when "101111" => spm2f_contents := sx;
  1708.           when "110000" => spm30_contents := sx;
  1709.           when "110001" => spm31_contents := sx;
  1710.           when "110010" => spm32_contents := sx;
  1711.           when "110011" => spm33_contents := sx;
  1712.           when "110100" => spm34_contents := sx;
  1713.           when "110101" => spm35_contents := sx;
  1714.           when "110110" => spm36_contents := sx;
  1715.           when "110111" => spm37_contents := sx;
  1716.           when "111000" => spm38_contents := sx;
  1717.           when "111001" => spm39_contents := sx;
  1718.           when "111010" => spm3a_contents := sx;
  1719.           when "111011" => spm3b_contents := sx;
  1720.           when "111100" => spm3c_contents := sx;
  1721.           when "111101" => spm3d_contents := sx;
  1722.           when "111110" => spm3e_contents := sx;
  1723.           when "111111" => spm3f_contents := sx;
  1724.           when others => null;
  1725.         end case;
  1726.       end if;
  1727.     end if;
  1728.   end process simulation;
  1729.   
  1730.   --synthesis translate on
  1731. --
  1732. --**********************************************************************************
  1733. -- End of simulation code.
  1734. --**********************************************************************************
  1735. --
  1736. --
  1737. end low_level_definition;
  1738. --
  1739. ------------------------------------------------------------------------------------
  1740. --
  1741. -- END OF FILE KCPSM3.VHD
  1742. --
  1743. ------------------------------------------------------------------------------------