home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gdb-4.16-base.tgz / gdb-4.16-base.tar / fsf / gdb / sim / ppc / interrupts.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-19  |  9.8 KB  |  419 lines

  1. /*  This file is part of the program psim.
  2.  
  3.     Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>
  4.  
  5.     This program is free software; you can redistribute it and/or modify
  6.     it under the terms of the GNU General Public License as published by
  7.     the Free Software Foundation; either version 2 of the License, or
  8.     (at your option) any later version.
  9.  
  10.     This program is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.     GNU General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU General Public License
  16.     along with this program; if not, write to the Free Software
  17.     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18.  
  19.     */
  20.  
  21.  
  22. #ifndef _INTERRUPTS_C_
  23. #define _INTERRUPTS_C_
  24.  
  25. #include <signal.h>
  26.  
  27. #include "cpu.h"
  28. #include "idecode.h"
  29. #include "os_emul.h"
  30.  
  31.  
  32. /* Operating environment support code
  33.  
  34.    Unlike the VEA, the OEA must fully model the effect an interrupt
  35.    has on the processors state.
  36.  
  37.    Each function below return updated values for registers effected by
  38.    interrupts */
  39.  
  40.  
  41. STATIC_INLINE_INTERRUPTS\
  42. (msreg)
  43. interrupt_msr(msreg old_msr,
  44.           msreg msr_clear,
  45.           msreg msr_set)
  46. {
  47.   msreg msr_set_to_0 = (msr_branch_trace_enable
  48.             | msr_data_relocate
  49.             | msr_external_interrupt_enable
  50.             | msr_floating_point_exception_mode_0
  51.             | msr_floating_point_exception_mode_1
  52.             | msr_floating_point_available
  53.             | msr_instruction_relocate
  54.             | msr_power_management_enable
  55.             | msr_problem_state
  56.             | msr_recoverable_interrupt
  57.             | msr_single_step_trace_enable);
  58.   /* remember, in 32bit mode msr_64bit_mode is zero */
  59.   msreg new_msr = ((((old_msr & ~msr_set_to_0)
  60.              | msr_64bit_mode)
  61.             & ~msr_clear)
  62.            | msr_set);
  63.   return new_msr;
  64. }
  65.  
  66.  
  67. STATIC_INLINE_INTERRUPTS\
  68. (msreg)
  69. interrupt_srr1(msreg old_msr,
  70.            msreg srr1_clear,
  71.            msreg srr1_set)
  72. {
  73.   spreg srr1_mask = (MASK(0,32)
  74.                | MASK(37, 41)
  75.                | MASK(48, 63));
  76.   spreg srr1 = (old_msr & srr1_mask & ~srr1_clear) | srr1_set;
  77.   return srr1;
  78. }
  79.  
  80.  
  81. STATIC_INLINE_INTERRUPTS\
  82. (unsigned_word)
  83. interrupt_base_ea(msreg msr)
  84. {
  85.   if (msr & msr_interrupt_prefix)
  86.     return MASK(0, 43);
  87.   else
  88.     return 0;
  89. }
  90.  
  91.  
  92. /* finish off an interrupt for the OEA model, updating all registers
  93.    and forcing a restart of the processor */
  94.  
  95. STATIC_INLINE_INTERRUPTS\
  96. (unsigned_word)
  97. perform_oea_interrupt(cpu *processor,
  98.               unsigned_word cia,
  99.               unsigned_word vector_offset,
  100.               msreg msr_clear,
  101.               msreg msr_set,
  102.               msreg srr1_clear,
  103.               msreg srr1_set)
  104. {
  105.   msreg old_msr = MSR;
  106.   msreg new_msr = interrupt_msr(old_msr, msr_clear, msr_set);
  107.   unsigned_word nia;
  108.   if (!(old_msr & msr_recoverable_interrupt))
  109.     error("perform_oea_interrupt() recoverable_interrupt bit clear, cia=0x%x, msr=0x%x\n",
  110.       cia, old_msr);
  111.   SRR0 = (spreg)(cia);
  112.   SRR1 = interrupt_srr1(old_msr, srr1_clear, srr1_set);
  113.   MSR = new_msr;
  114.   nia = interrupt_base_ea(new_msr) + vector_offset;
  115.   cpu_synchronize_context(processor);
  116.   return nia;
  117. }
  118.  
  119.  
  120. INLINE_INTERRUPTS\
  121. (void)
  122. machine_check_interrupt(cpu *processor,
  123.             unsigned_word cia)
  124. {
  125.   switch (CURRENT_ENVIRONMENT) {
  126.  
  127.   case USER_ENVIRONMENT:
  128.   case VIRTUAL_ENVIRONMENT:
  129.     error("%s - cia=0x%x\n",
  130.       "machine_check_interrupt", cia);
  131.  
  132.   case OPERATING_ENVIRONMENT:
  133.     cia = perform_oea_interrupt(processor, cia, 0x00200, 0, 0, 0, 0);
  134.     cpu_restart(processor, cia);
  135.  
  136.   default:
  137.     error("machine_check_interrupt() - internal error\n");
  138.  
  139.   }
  140. }
  141.  
  142.  
  143. INLINE_INTERRUPTS\
  144. (void)
  145. data_storage_interrupt(cpu *processor,
  146.                unsigned_word cia,
  147.                unsigned_word ea,
  148.                storage_interrupt_reasons reason,
  149.                int is_store)
  150. {
  151.   switch (CURRENT_ENVIRONMENT) {
  152.  
  153.   case USER_ENVIRONMENT:
  154.   case VIRTUAL_ENVIRONMENT:
  155.     error("data_storage_interrupt() should not be called in VEA mode\n");
  156.  
  157.   case OPERATING_ENVIRONMENT:
  158.     {
  159.       spreg direction = (is_store ? dsisr_store_operation : 0);
  160.       switch (reason) {
  161.       case direct_store_storage_interrupt:
  162.     DSISR = dsisr_direct_store_error_exception | direction;
  163.     break;
  164.       case hash_table_miss_storage_interrupt:
  165.     DSISR = dsisr_hash_table_or_dbat_miss | direction;
  166.     break;
  167.       case protection_violation_storage_interrupt:
  168.     DSISR = dsisr_protection_violation | direction;
  169.     break;
  170.       case earwax_violation_storage_interrupt:
  171.     DSISR = dsisr_earwax_violation | direction;
  172.     break;
  173.       case segment_table_miss_storage_interrupt:
  174.     DSISR = dsisr_segment_table_miss | direction;
  175.     break;
  176.       case earwax_disabled_storage_interrupt:
  177.     DSISR = dsisr_earwax_disabled | direction;
  178.     break;
  179.       default:
  180.     error("data_storage_interrupt: unknown reason %d\n", reason);
  181.     break;
  182.       }
  183.       DAR = (spreg)ea;
  184.       cia = perform_oea_interrupt(processor, cia, 0x00300, 0, 0, 0, 0);
  185.       cpu_restart(processor, cia);
  186.     }
  187.  
  188.   default:
  189.     error("data_storage_interrupt() - internal error\n");
  190.  
  191.   }
  192. }
  193.  
  194.  
  195. INLINE_INTERRUPTS\
  196. (void)
  197. instruction_storage_interrupt(cpu *processor,
  198.                   unsigned_word cia,
  199.                   storage_interrupt_reasons reason)
  200. {
  201.   switch (CURRENT_ENVIRONMENT) {
  202.  
  203.   case USER_ENVIRONMENT:
  204.   case VIRTUAL_ENVIRONMENT:
  205.     error("instruction_storage_interrupt - cia=0x%x - not implemented\n",
  206.       cia);
  207.  
  208.   case OPERATING_ENVIRONMENT:
  209.     {
  210.       msreg srr1_set;
  211.       switch(reason) {
  212.       case hash_table_miss_storage_interrupt:
  213.     srr1_set = srr1_hash_table_or_ibat_miss;
  214.     break;
  215.       case direct_store_storage_interrupt:
  216.     srr1_set = srr1_direct_store_error_exception;
  217.     break;
  218.       case protection_violation_storage_interrupt:
  219.     srr1_set = srr1_protection_violation;
  220.     break;
  221.       case segment_table_miss_storage_interrupt:
  222.     srr1_set = srr1_segment_table_miss;
  223.     break;
  224.       default:
  225.     srr1_set = 0;
  226.     error("instruction_storage_interrupt: unknown reason %d\n", reason);
  227.     break;
  228.       }
  229.       cia = perform_oea_interrupt(processor, cia, 0x00400, 0, 0, 0, srr1_set);
  230.       cpu_restart(processor, cia);
  231.     }
  232.  
  233.   default:
  234.     error("instruction_storage_interrupt() - internal error\n");
  235.  
  236.   }
  237. }
  238.  
  239.  
  240.  
  241. INLINE_INTERRUPTS\
  242. (void)
  243. alignment_interrupt(cpu *processor,
  244.             unsigned_word cia,
  245.             unsigned_word ra)
  246. {
  247.   switch (CURRENT_ENVIRONMENT) {
  248.  
  249.   case USER_ENVIRONMENT:
  250.   case VIRTUAL_ENVIRONMENT:
  251.     error("%s - cia=0x%x, ra=0x%x\n",
  252.       "alignment_interrupt", cia, ra);
  253.     
  254.   case OPERATING_ENVIRONMENT:
  255.     DAR = (spreg)ra;
  256.     DSISR = 0; /* FIXME */
  257.     cia = perform_oea_interrupt(processor, cia, 0x00600, 0, 0, 0, 0);
  258.     cpu_restart(processor, cia);
  259.  
  260.   default:
  261.     error("alignment_interrupt() - internal error\n");
  262.     
  263.   }
  264. }
  265.  
  266.  
  267.  
  268.  
  269. INLINE_INTERRUPTS\
  270. (void)
  271. program_interrupt(cpu *processor,
  272.           unsigned_word cia,
  273.           program_interrupt_reasons reason)
  274. {
  275.   switch (CURRENT_ENVIRONMENT) {
  276.  
  277.   case USER_ENVIRONMENT:
  278.   case VIRTUAL_ENVIRONMENT:
  279.     switch (reason) {
  280.     default:
  281.       error("%s - cia=0x%x, reason=%d - not implemented\n",
  282.         "program_interrupt", cia, reason);
  283.     }
  284.  
  285.   case OPERATING_ENVIRONMENT:
  286.     {
  287.       msreg srr1_set;
  288.       switch (reason) {
  289.       case illegal_instruction_program_interrupt:
  290.     srr1_set = srr1_illegal_instruction;
  291.     break;
  292.       case privileged_instruction_program_interrupt:
  293.     srr1_set = srr1_priviliged_instruction;
  294.     break;
  295.       case trap_program_interrupt:
  296.     srr1_set = srr1_trap;
  297.     break;
  298.       default:
  299.     srr1_set = 0;
  300.     error("program_interrupt - cia=0x%x, reason=%d(%s) - not implemented\n",
  301.           cia, reason);
  302.       }
  303.       cia = perform_oea_interrupt(processor, cia, 0x00700, 0, 0, 0, srr1_set);
  304.       cpu_restart(processor, cia);
  305.     }
  306.  
  307.   default:
  308.     error("program_interrupt() - internal error\n");
  309.  
  310.   }
  311. }
  312.  
  313.  
  314. INLINE_INTERRUPTS\
  315. (void)
  316. floating_point_unavailable_interrupt(cpu *processor,
  317.                      unsigned_word cia)
  318. {
  319.   switch (CURRENT_ENVIRONMENT) {
  320.     
  321.   case USER_ENVIRONMENT:
  322.   case VIRTUAL_ENVIRONMENT:
  323.     error("%s - cia=0x%x - not implemented\n",
  324.       "floating_point_unavailable_interrupt", cia);
  325.  
  326.   case OPERATING_ENVIRONMENT:
  327.     cia = perform_oea_interrupt(processor, cia, 0x00800, 0, 0, 0, 0);
  328.     cpu_restart(processor, cia);
  329.  
  330.   default:
  331.     error("floating_point_unavailable_interrupt() - internal error\n");
  332.  
  333.   }
  334. }
  335.  
  336.  
  337. INLINE_INTERRUPTS\
  338. (void)
  339. system_call_interrupt(cpu *processor,
  340.               unsigned_word cia)
  341. {
  342.   switch (CURRENT_ENVIRONMENT) {
  343.  
  344.   case USER_ENVIRONMENT:
  345.   case VIRTUAL_ENVIRONMENT:
  346.     os_emul_system_call(processor, cia);
  347.     cpu_restart(processor, cia+4);
  348.  
  349.   case OPERATING_ENVIRONMENT:
  350.     cia = perform_oea_interrupt(processor, cia+4, 0x00c00, 0, 0, 0, 0);
  351.     cpu_restart(processor, cia);
  352.  
  353.   default:
  354.     error("system_call_interrupt() - internal error\n");
  355.  
  356.   }
  357. }
  358.  
  359. INLINE_INTERRUPTS\
  360. (void)
  361. floating_point_assist_interrupt(cpu *processor,
  362.                 unsigned_word cia)
  363. {
  364.   switch (CURRENT_ENVIRONMENT) {
  365.  
  366.   case USER_ENVIRONMENT:
  367.   case VIRTUAL_ENVIRONMENT:
  368.     error("%s - cia=0x%x - not implemented\n",
  369.       "floating_point_assist_interrupt", cia);
  370.  
  371.   case OPERATING_ENVIRONMENT:
  372.     cia = perform_oea_interrupt(processor, cia, 0x00e00, 0, 0, 0, 0);
  373.     cpu_restart(processor, cia);
  374.  
  375.   default:
  376.     error("floating_point_assist_interrupt() - internal error\n");
  377.  
  378.   }
  379. }
  380.  
  381.  
  382.  
  383. /* handle an externally generated event */
  384.  
  385. INLINE_INTERRUPTS\
  386. (int)
  387. decrementer_interrupt(cpu *processor)
  388. {
  389.   if (cpu_registers(processor)->msr & msr_external_interrupt_enable) {
  390.     unsigned_word cia = cpu_get_program_counter(processor);
  391.     unsigned_word nia = perform_oea_interrupt(processor,
  392.                           cia, 0x00900, 0, 0, 0, 0);
  393.     cpu_set_program_counter(processor, nia);
  394.     return 1;
  395.   }
  396.   else {
  397.     return 0;
  398.   }
  399. }
  400.  
  401. INLINE_INTERRUPTS\
  402. (int)
  403. external_interrupt(cpu *processor)
  404. {
  405.   if (cpu_registers(processor)->msr & msr_external_interrupt_enable) {
  406.     unsigned_word cia = cpu_get_program_counter(processor);
  407.     unsigned_word nia = perform_oea_interrupt(processor,
  408.                           cia, 0x00500, 0, 0, 0, 0);
  409.     cpu_set_program_counter(processor, nia);
  410.     return 1;
  411.   }
  412.   else {
  413.     return 0; /* not delivered */
  414.   }
  415. }
  416.  
  417.  
  418. #endif /* _INTERRUPTS_C_ */
  419.