riscv-gnu-toolchain/gcc.git - Unnamed repository; edit this file 'description' to name the repository.

diff options

author	Jeff Law <law@redhat.com>	2005-03-04 14:35:49 -0700
committer	Jeff Law <law@gcc.gnu.org>	2005-03-04 14:35:49 -0700
commit	d38ffc55428bbe33b33d8b14693e69cd1b63c820 (patch)
tree	f9c9a2643a9f3afe1404b5aff6758d8e8da39b9b /libjava/java/util/Timer.java
parent	3852e8b8f21397fc719ef45ba404a58bed53a7d0 (diff)
download	gcc-d38ffc55428bbe33b33d8b14693e69cd1b63c820.zip gcc-d38ffc55428bbe33b33d8b14693e69cd1b63c820.tar.gz gcc-d38ffc55428bbe33b33d8b14693e69cd1b63c820.tar.bz2

basic-block.h (rediscover_loops_after_threading): Declare.

* basic-block.h (rediscover_loops_after_threading): Declare. * tree-ssa-dom.c: Include cfgloop.h. (tree_ssa_dominator_optimize): Discover loops and some basic properties. Remove forwarder blocks recreated by loop header canonicalization. Also mark backedges in the CFG. * tree-ssa-threadupdate.c: Include cfgloop.h (rediscover_loops_after_threading): Define. (struct local_info): New field, JUMP_THREADED. (prune_undesirable_thread_requests): New function. (redirect_edges): Clear EDGE_ABNORMAL. If edges were threaded then record that fact for the callers of redirct_edges. (thread_block): If BB has incoming backedges, then call prune_undesirable_thraed_requests. Note when we are going to have to rediscover loop information. Return a boolean indicating if any jumps were threaded. (thread_through_all_blocks): Bubble up boolean indicating if any jumps were threaded. * Makefile.in (tree-ssa-dom.o): Depend on cfgloop.h (tree-ssa-threadupdate.o): Similarly. From-SVN: r95903

Diffstat (limited to 'libjava/java/util/Timer.java')

0 files changed, 0 insertions, 0 deletions

#include "dtm.h" #include "riscv/debug_defines.h" #include <stdlib.h> #include <stdio.h> #include <string.h> #include <assert.h> #include <pthread.h> #include <stdexcept> #define RV_X(x, s, n) \ (((x) >> (s)) & ((1 << (n)) - 1)) #define ENCODE_ITYPE_IMM(x) \ (RV_X(x, 0, 12) << 20) #define ENCODE_STYPE_IMM(x) \ ((RV_X(x, 0, 5) << 7) | (RV_X(x, 5, 7) << 25)) #define ENCODE_SBTYPE_IMM(x) \ ((RV_X(x, 1, 4) << 8) | (RV_X(x, 5, 6) << 25) | (RV_X(x, 11, 1) << 7) | (RV_X(x, 12, 1) << 31)) #define ENCODE_UTYPE_IMM(x) \ (RV_X(x, 12, 20) << 12) #define ENCODE_UJTYPE_IMM(x) \ ((RV_X(x, 1, 10) << 21) | (RV_X(x, 11, 1) << 20) | (RV_X(x, 12, 8) << 12) | (RV_X(x, 20, 1) << 31)) #define LOAD(xlen, dst, base, imm) \ (((xlen) == 64 ? 0x00003003 : 0x00002003) \ | ((dst) << 7) | ((base) << 15) | (uint32_t)ENCODE_ITYPE_IMM(imm)) #define STORE(xlen, src, base, imm) \ (((xlen) == 64 ? 0x00003023 : 0x00002023) \ | ((src) << 20) | ((base) << 15) | (uint32_t)ENCODE_STYPE_IMM(imm)) #define JUMP(there, here) (0x6f | (uint32_t)ENCODE_UJTYPE_IMM((there) - (here))) #define BNE(r1, r2, there, here) (0x1063 | ((r1) << 15) | ((r2) << 20) | (uint32_t)ENCODE_SBTYPE_IMM((there) - (here))) #define ADDI(dst, src, imm) (0x13 | ((dst) << 7) | ((src) << 15) | (uint32_t)ENCODE_ITYPE_IMM(imm)) #define SRL(dst, src, sh) (0x5033 | ((dst) << 7) | ((src) << 15) | ((sh) << 20)) #define FENCE_I 0x100f #define EBREAK 0x00100073 #define X0 0 #define S0 8 #define S1 9 #define AC_AR_REGNO(x) ((0x1000 | x) << AC_ACCESS_REGISTER_REGNO_OFFSET) #define AC_AR_SIZE(x) (((x == 128)? 4 : (x == 64 ? 3 : 2)) << AC_ACCESS_REGISTER_AARSIZE_OFFSET) #define WRITE 1 #define SET 2 #define CLEAR 3 #define CSRRx(type, dst, csr, src) (0x73 | ((type) << 12) | ((dst) << 7) | ((src) << 15) | (uint32_t)((csr) << 20)) #define RUN_AC_OR_DIE(a, b, c, d, e) { \ uint32_t cmderr = run_abstract_command(a, b, c, d, e); \ if (cmderr) { \ die(cmderr); \ } \ } uint32_t dtm_t::do_command(dtm_t::req r) { req_buf = r; target->switch_to(); assert(resp_buf.resp == 0); return resp_buf.data; } uint32_t dtm_t::read(uint32_t addr) { return do_command((req){addr, 1, 0}); } uint32_t dtm_t::write(uint32_t addr, uint32_t data) { return do_command((req){addr, 2, data}); } void dtm_t::nop() { do_command((req){0, 0, 0}); } void dtm_t::select_hart(int hartsel) { int dmcontrol = read(DM_DMCONTROL); write (DM_DMCONTROL, set_field(dmcontrol, DM_DMCONTROL_HASEL, hartsel)); current_hart = hartsel; } int dtm_t::enumerate_harts() { int max_hart = (1 << DM_DMCONTROL_HASEL_LENGTH) - 1; write(DM_DMCONTROL, set_field(read(DM_DMCONTROL), DM_DMCONTROL_HASEL, max_hart)); read(DM_DMSTATUS); max_hart = get_field(read(DM_DMCONTROL), DM_DMCONTROL_HASEL); int hartsel; for (hartsel = 0; hartsel <= max_hart; hartsel++) { select_hart(hartsel); int dmstatus = read(DM_DMSTATUS); if (get_field(dmstatus, DM_DMSTATUS_ANYNONEXISTENT)) break; } return hartsel; } void dtm_t::halt(int hartsel) { if (running) { write(DM_DMCONTROL, DM_DMCONTROL_DMACTIVE); // Read dmstatus to avoid back-to-back writes to dmcontrol. read(DM_DMSTATUS); } int dmcontrol = DM_DMCONTROL_HALTREQ | DM_DMCONTROL_DMACTIVE; dmcontrol = set_field(dmcontrol, DM_DMCONTROL_HASEL, hartsel); write(DM_DMCONTROL, dmcontrol); int dmstatus; do { dmstatus = read(DM_DMSTATUS); } while(get_field(dmstatus, DM_DMSTATUS_ALLHALTED) == 0); dmcontrol &= ~DM_DMCONTROL_HALTREQ; write(DM_DMCONTROL, dmcontrol); // Read dmstatus to avoid back-to-back writes to dmcontrol. read(DM_DMSTATUS); current_hart = hartsel; } void dtm_t::resume(int hartsel) { int dmcontrol = DM_DMCONTROL_RESUMEREQ | DM_DMCONTROL_DMACTIVE; dmcontrol = set_field(dmcontrol, DM_DMCONTROL_HASEL, hartsel); write(DM_DMCONTROL, dmcontrol); int dmstatus; do { dmstatus = read(DM_DMSTATUS); } while (get_field(dmstatus, DM_DMSTATUS_ALLRESUMEACK) == 0); dmcontrol &= ~DM_DMCONTROL_RESUMEREQ; write(DM_DMCONTROL, dmcontrol); // Read dmstatus to avoid back-to-back writes to dmcontrol. read(DM_DMSTATUS); current_hart = hartsel; if (running) { write(DM_DMCONTROL, DM_DMCONTROL_DMACTIVE); // Read dmstatus to avoid back-to-back writes to dmcontrol. read(DM_DMSTATUS); } } uint64_t dtm_t::save_reg(unsigned regno) { uint32_t data[xlen/(8*4)]; uint32_t command = AC_ACCESS_REGISTER_TRANSFER | AC_AR_SIZE(xlen) | AC_AR_REGNO(regno); RUN_AC_OR_DIE(command, 0, 0, data, xlen / (8*4)); uint64_t result = data[0]; if (xlen > 32) { result |= ((uint64_t)data[1]) << 32; } return result; } void dtm_t::restore_reg(unsigned regno, uint64_t val) { uint32_t data[xlen/(8*4)]; data[0] = (uint32_t) val; if (xlen > 32) { data[1] = (uint32_t) (val >> 32); } uint32_t command = AC_ACCESS_REGISTER_TRANSFER | AC_ACCESS_REGISTER_WRITE | AC_AR_SIZE(xlen) | AC_AR_REGNO(regno); RUN_AC_OR_DIE(command, 0, 0, data, xlen / (8*4)); } uint32_t dtm_t::run_abstract_command(uint32_t command, const uint32_t program[], size_t program_n, uint32_t data[], size_t data_n) { assert(program_n <= ram_words); assert(data_n <= data_words); for (size_t i = 0; i < program_n; i++) { write(DM_PROGBUF0 + i, program[i]); } if (get_field(command, AC_ACCESS_REGISTER_WRITE) && get_field(command, AC_ACCESS_REGISTER_TRANSFER)) { for (size_t i = 0; i < data_n; i++) { write(DM_DATA0 + i, data[i]); } } write(DM_COMMAND, command); // Wait for not busy and then check for error. uint32_t abstractcs; do { abstractcs = read(DM_ABSTRACTCS); } while (abstractcs & DM_ABSTRACTCS_BUSY); if ((get_field(command, AC_ACCESS_REGISTER_WRITE) == 0) && get_field(command, AC_ACCESS_REGISTER_TRANSFER)) { for (size_t i = 0; i < data_n; i++){ data[i] = read(DM_DATA0 + i); } } return get_field(abstractcs, DM_ABSTRACTCS_CMDERR); } size_t dtm_t::chunk_align() { return xlen / 8; } void dtm_t::read_chunk(uint64_t taddr, size_t len, void* dst) { uint32_t prog[ram_words]; uint32_t data[data_words]; uint8_t * curr = (uint8_t*) dst; halt(current_hart); uint64_t s0 = save_reg(S0); uint64_t s1 = save_reg(S1); prog[0] = LOAD(xlen, S1, S0, 0); prog[1] = ADDI(S0, S0, xlen/8); prog[2] = EBREAK; data[0] = (uint32_t) taddr; if (xlen > 32) { data[1] = (uint32_t) (taddr >> 32); } // Write s0 with the address, then execute program buffer. // This will get S1 with the data and increment s0. uint32_t command = AC_ACCESS_REGISTER_TRANSFER | AC_ACCESS_REGISTER_WRITE | AC_ACCESS_REGISTER_POSTEXEC | AC_AR_SIZE(xlen) | AC_AR_REGNO(S0); RUN_AC_OR_DIE(command, prog, 3, data, xlen/(4*8)); // TODO: could use autoexec here. for (size_t i = 0; i < (len * 8 / xlen); i++){ command = AC_ACCESS_REGISTER_TRANSFER | AC_AR_SIZE(xlen) | AC_AR_REGNO(S1); if ((i + 1) < (len * 8 / xlen)) { command |= AC_ACCESS_REGISTER_POSTEXEC; } RUN_AC_OR_DIE(command, 0, 0, data, xlen/(4*8)); memcpy(curr, data, xlen/8); curr += xlen/8; } restore_reg(S0, s0); restore_reg(S1, s1); resume(current_hart); } void dtm_t::write_chunk(uint64_t taddr, size_t len, const void* src) { uint32_t prog[ram_words]; uint32_t data[data_words]; const uint8_t * curr = (const uint8_t*) src; halt(current_hart); uint64_t s0 = save_reg(S0); uint64_t s1 = save_reg(S1); prog[0] = STORE(xlen, S1, S0, 0); prog[1] = ADDI(S0, S0, xlen/8); prog[2] = EBREAK; data[0] = (uint32_t) taddr; if (xlen > 32) { data[1] = (uint32_t) (taddr >> 32); } // Write the program (not used yet). // Write s0 with the address. uint32_t command = AC_ACCESS_REGISTER_TRANSFER | AC_ACCESS_REGISTER_WRITE | AC_AR_SIZE(xlen) | AC_AR_REGNO(S0); RUN_AC_OR_DIE(command, prog, 3, data, xlen/(4*8)); // Use Autoexec for more than one word of transfer. // Write S1 with data, then execution stores S1 to // 0(S0) and increments S0. // Each time we write XLEN bits. memcpy(data, curr, xlen/8); curr += xlen/8; command = AC_ACCESS_REGISTER_TRANSFER | AC_ACCESS_REGISTER_POSTEXEC | AC_ACCESS_REGISTER_WRITE | AC_AR_SIZE(xlen) | AC_AR_REGNO(S1); RUN_AC_OR_DIE(command, 0, 0, data, xlen/(4*8)); uint32_t abstractcs; for (size_t i = 1; i < (len * 8 / xlen); i++){ if (i == 1) { write(DM_ABSTRACTAUTO, 1 << DM_ABSTRACTAUTO_AUTOEXECDATA_OFFSET); } memcpy(data, curr, xlen/8); curr += xlen/8; if (xlen == 64) { write(DM_DATA0 + 1, data[1]); } write(DM_DATA0, data[0]); //Triggers a command w/ autoexec. do { abstractcs = read(DM_ABSTRACTCS); } while (abstractcs & DM_ABSTRACTCS_BUSY); if ( get_field(abstractcs, DM_ABSTRACTCS_CMDERR)) { die(get_field(abstractcs, DM_ABSTRACTCS_CMDERR)); } } if ((len * 8 / xlen) > 1) { write(DM_ABSTRACTAUTO, 0); } restore_reg(S0, s0); restore_reg(S1, s1); resume(current_hart); } void dtm_t::die(uint32_t cmderr) { const char * codes[] = { "OK", "BUSY", "NOT_SUPPORTED", "EXCEPTION", "HALT/RESUME" }; const char * msg;


context:
space:
mode: