sewardj | c97096c | 2004-06-30 09:28:04 +0000 | [diff] [blame] | 1 | |
| 2 | /*---------------------------------------------------------------*/ |
| 3 | /*--- ---*/ |
| 4 | /*--- This file (host_regs.c) is ---*/ |
| 5 | /*--- Copyright (c) 2004 OpenWorks LLP. All rights reserved. ---*/ |
| 6 | /*--- ---*/ |
| 7 | /*---------------------------------------------------------------*/ |
| 8 | |
| 9 | #include <stdio.h> |
sewardj | 2cd80dc | 2004-07-02 15:20:40 +0000 | [diff] [blame] | 10 | #include <malloc.h> |
sewardj | c97096c | 2004-06-30 09:28:04 +0000 | [diff] [blame] | 11 | |
| 12 | #include "basictypes.h" |
| 13 | #include "host_regs.h" |
| 14 | |
| 15 | |
| 16 | HReg mkHReg ( UInt regno, HRegClass rc, Bool virtual ) |
| 17 | { |
sewardj | af5a522 | 2004-07-01 23:14:42 +0000 | [diff] [blame] | 18 | UInt r24 = regno & 0x00FFFFFF; |
| 19 | /* This is critical. The register number field may only |
| 20 | occupy 24 bits. */ |
| 21 | if (r24 != regno) |
| 22 | panic("mkHReg: regno exceeds 2^24"); |
| 23 | return regno | (((UInt)rc) << 28) | (virtual ? (1<<24) : 0); |
sewardj | c97096c | 2004-06-30 09:28:04 +0000 | [diff] [blame] | 24 | } |
| 25 | |
| 26 | HRegClass hregClass ( HReg r ) |
| 27 | { |
sewardj | af5a522 | 2004-07-01 23:14:42 +0000 | [diff] [blame] | 28 | UInt rc = r; |
| 29 | rc = (rc >> 28) & 0x0F; |
sewardj | 6f37cce | 2004-07-03 19:44:54 +0000 | [diff] [blame^] | 30 | assert(rc == HRcInt || rc == HRcFloat || rc == HRcVector |
| 31 | || rc == HRcInt64 || rc == HRcVector128); |
sewardj | c97096c | 2004-06-30 09:28:04 +0000 | [diff] [blame] | 32 | return (HRegClass)rc; |
| 33 | } |
| 34 | |
| 35 | Bool hregIsVirtual ( HReg r ) |
| 36 | { |
sewardj | af5a522 | 2004-07-01 23:14:42 +0000 | [diff] [blame] | 37 | return (((UInt)r) & (1<<24)) ? True : False; |
sewardj | c97096c | 2004-06-30 09:28:04 +0000 | [diff] [blame] | 38 | } |
| 39 | |
| 40 | UInt hregNumber ( HReg r ) |
| 41 | { |
sewardj | af5a522 | 2004-07-01 23:14:42 +0000 | [diff] [blame] | 42 | return ((UInt)r) & 0x00FFFFFF; |
sewardj | c97096c | 2004-06-30 09:28:04 +0000 | [diff] [blame] | 43 | } |
| 44 | |
sewardj | b3d4ce7 | 2004-07-02 07:09:23 +0000 | [diff] [blame] | 45 | void ppHRegClass ( FILE* f, HRegClass hrc ) |
| 46 | { |
| 47 | switch (hrc) { |
| 48 | case HRcInt: fprintf(f, "HRcInt32"); break; |
| 49 | case HRcInt64: fprintf(f, "HRcInt64"); break; |
| 50 | case HRcFloat: fprintf(f, "HRcFloat"); break; |
| 51 | case HRcVector: fprintf(f, "HRcVector64"); break; |
| 52 | case HRcVector128: fprintf(f, "HRcVector128"); break; |
| 53 | default: panic("ppHRegClass"); |
| 54 | } |
| 55 | } |
sewardj | c97096c | 2004-06-30 09:28:04 +0000 | [diff] [blame] | 56 | |
| 57 | /* Generic printing for registers. */ |
| 58 | void ppHReg ( FILE* f, HReg r ) |
| 59 | { |
| 60 | Char* maybe_v = hregIsVirtual(r) ? "v" : ""; |
| 61 | Int regNo = hregNumber(r); |
| 62 | switch (hregClass(r)) { |
sewardj | 6f37cce | 2004-07-03 19:44:54 +0000 | [diff] [blame^] | 63 | case HRcInt: fprintf(f, "%%%sr%d", maybe_v, regNo); return; |
| 64 | case HRcInt64: fprintf(f, "%%%sR%d", maybe_v, regNo); return; |
| 65 | case HRcFloat: fprintf(f, "%%%sf%d", maybe_v, regNo); return; |
| 66 | case HRcVector: fprintf(f, "%%%sv%d", maybe_v, regNo); return; |
| 67 | case HRcVector128: fprintf(f, "%%%sV%d", maybe_v, regNo); return; |
sewardj | c97096c | 2004-06-30 09:28:04 +0000 | [diff] [blame] | 68 | default: panic("ppHReg"); |
| 69 | } |
| 70 | } |
| 71 | |
sewardj | 8bc26ee | 2004-07-01 18:30:32 +0000 | [diff] [blame] | 72 | |
| 73 | /*---------------------------------------------------------*/ |
| 74 | /*--- Helpers for recording reg usage (for reg-alloc) ---*/ |
| 75 | /*---------------------------------------------------------*/ |
| 76 | |
| 77 | void ppHRegUsage ( FILE* f, HRegUsage* tab ) |
| 78 | { |
| 79 | Int i; |
| 80 | Char* str; |
| 81 | fprintf(f, "HRegUsage {\n"); |
| 82 | for (i = 0; i < tab->n_used; i++) { |
| 83 | switch (tab->mode[i]) { |
| 84 | case HRmRead: str = "Read "; break; |
| 85 | case HRmWrite: str = "Write "; break; |
| 86 | case HRmModify: str = "Modify "; break; |
| 87 | default: panic("ppHRegUsage"); |
| 88 | } |
| 89 | fprintf(f, " %s ", str); |
| 90 | ppHReg(f, tab->hreg[i]); |
| 91 | fprintf(f, "\n"); |
| 92 | } |
| 93 | fprintf(f, "}\n"); |
| 94 | } |
| 95 | |
| 96 | |
| 97 | void initHRegUsage ( HRegUsage* tab ) |
| 98 | { |
| 99 | tab->n_used = 0; |
| 100 | } |
| 101 | |
| 102 | |
| 103 | /* Add a register to a usage table. Combine incoming read uses with |
| 104 | existing write uses into a modify use, and vice versa. Do not |
| 105 | create duplicate entries -- each reg should only be mentioned once. |
| 106 | */ |
sewardj | 53f85a9 | 2004-07-02 13:45:17 +0000 | [diff] [blame] | 107 | void addHRegUse ( HRegUsage* tab, HRegMode mode, HReg reg ) |
sewardj | 8bc26ee | 2004-07-01 18:30:32 +0000 | [diff] [blame] | 108 | { |
| 109 | Int i; |
| 110 | /* Find it ... */ |
| 111 | for (i = 0; i < tab->n_used; i++) |
| 112 | if (tab->hreg[i] == reg) |
| 113 | break; |
| 114 | if (i == tab->n_used) { |
| 115 | /* Not found, add new entry. */ |
| 116 | assert(tab->n_used+1 < N_HREG_USAGE); |
| 117 | tab->hreg[tab->n_used] = reg; |
| 118 | tab->mode[tab->n_used] = mode; |
| 119 | tab->n_used++; |
| 120 | } else { |
| 121 | /* Found: combine or ignore. */ |
| 122 | if (tab->mode[i] == mode) |
| 123 | return; /* duplicate, ignore */ |
| 124 | if (mode == HRmModify) { |
| 125 | tab->mode[i] = HRmModify; |
| 126 | return; /* modify mode makes previous mode irrelevant */ |
| 127 | } |
| 128 | assert( (mode == HRmRead && tab->mode[i] == HRmWrite) |
| 129 | || (mode == HRmWrite && tab->mode[i] == HRmRead) ); |
| 130 | tab->mode[i] = HRmModify; |
| 131 | } |
| 132 | } |
| 133 | |
| 134 | |
| 135 | /*---------------------------------------------------------*/ |
| 136 | /*--- Indicating register remappings (for reg-alloc) ---*/ |
| 137 | /*---------------------------------------------------------*/ |
| 138 | |
| 139 | void ppHRegRemap ( FILE* f, HRegRemap* map ) |
| 140 | { |
| 141 | Int i; |
| 142 | fprintf(f, "HRegRemap {\n"); |
| 143 | for (i = 0; i < map->n_used; i++) { |
| 144 | fprintf(f, " "); |
sewardj | af5a522 | 2004-07-01 23:14:42 +0000 | [diff] [blame] | 145 | ppHReg(f, map->orig[i]); |
sewardj | 8bc26ee | 2004-07-01 18:30:32 +0000 | [diff] [blame] | 146 | fprintf(f, " --> "); |
sewardj | af5a522 | 2004-07-01 23:14:42 +0000 | [diff] [blame] | 147 | ppHReg(f, map->replacement[i]); |
sewardj | 8bc26ee | 2004-07-01 18:30:32 +0000 | [diff] [blame] | 148 | fprintf(f, "\n"); |
| 149 | } |
| 150 | fprintf(f, "}\n"); |
| 151 | } |
| 152 | |
| 153 | |
| 154 | void initHRegRemap ( HRegRemap* map ) |
| 155 | { |
| 156 | map->n_used = 0; |
| 157 | } |
| 158 | |
| 159 | |
| 160 | void addToHRegRemap ( HRegRemap* map, HReg orig, HReg replacement ) |
| 161 | { |
| 162 | Int i; |
| 163 | for (i = 0; i < map->n_used; i++) |
| 164 | if (map->orig[i] == orig) |
| 165 | panic("addToHRegMap: duplicate entry"); |
sewardj | 0ec3325 | 2004-07-03 13:30:00 +0000 | [diff] [blame] | 166 | if (!hregIsVirtual(orig)) |
| 167 | panic("addToHRegMap: orig is not a vreg"); |
| 168 | if (hregIsVirtual(replacement)) |
| 169 | panic("addToHRegMap: replacement is not a vreg"); |
| 170 | |
sewardj | 8bc26ee | 2004-07-01 18:30:32 +0000 | [diff] [blame] | 171 | assert(map->n_used+1 < N_HREG_REMAP); |
| 172 | map->orig[map->n_used] = orig; |
| 173 | map->replacement[map->n_used] = replacement; |
| 174 | map->n_used++; |
| 175 | } |
| 176 | |
| 177 | |
| 178 | HReg lookupHRegRemap ( HRegRemap* map, HReg orig ) |
| 179 | { |
| 180 | Int i; |
sewardj | 0ec3325 | 2004-07-03 13:30:00 +0000 | [diff] [blame] | 181 | if (!hregIsVirtual(orig)) |
| 182 | return orig; |
sewardj | 8bc26ee | 2004-07-01 18:30:32 +0000 | [diff] [blame] | 183 | for (i = 0; i < map->n_used; i++) |
| 184 | if (map->orig[i] == orig) |
| 185 | return map->replacement[i]; |
| 186 | panic("lookupHRegRemap: not found"); |
| 187 | } |
| 188 | |
sewardj | 2cd80dc | 2004-07-02 15:20:40 +0000 | [diff] [blame] | 189 | /*---------------------------------------------------------*/ |
| 190 | /*--- Abstract instructions ---*/ |
| 191 | /*---------------------------------------------------------*/ |
| 192 | |
| 193 | HInstrArray* newHInstrArray ( void ) |
| 194 | { |
| 195 | HInstrArray* ha = malloc(sizeof(HInstrArray)); |
| 196 | ha->arr_size = 4; |
| 197 | ha->arr_used = 0; |
sewardj | 194d54a | 2004-07-03 19:08:18 +0000 | [diff] [blame] | 198 | ha->arr = malloc(ha->arr_size * sizeof(HInstr*)); |
| 199 | ha->n_vregs = 0; |
sewardj | 2cd80dc | 2004-07-02 15:20:40 +0000 | [diff] [blame] | 200 | return ha; |
| 201 | } |
| 202 | |
| 203 | void deleteHInstrArray ( HInstrArray* ha ) |
| 204 | { |
| 205 | free(ha->arr); |
| 206 | free(ha); |
| 207 | } |
| 208 | |
| 209 | void addHInstr ( HInstrArray* ha, HInstr* instr ) |
| 210 | { |
| 211 | assert(ha->arr_used <= ha->arr_size); |
| 212 | if (ha->arr_used < ha->arr_size) { |
| 213 | ha->arr[ha->arr_used] = instr; |
| 214 | ha->arr_used++; |
| 215 | } else { |
| 216 | Int i; |
| 217 | HInstr** arr2 = malloc(ha->arr_size * 2 * sizeof(HInstr*)); |
| 218 | for (i = 0; i < ha->arr_size; i++) |
| 219 | arr2[i] = ha->arr[i]; |
| 220 | ha->arr_size *= 2; |
| 221 | free(ha->arr); |
| 222 | ha->arr = arr2; |
| 223 | addHInstr(ha, instr); |
| 224 | } |
| 225 | } |
| 226 | |
| 227 | |
sewardj | 8bc26ee | 2004-07-01 18:30:32 +0000 | [diff] [blame] | 228 | /*---------------------------------------------------------------*/ |
| 229 | /*--- host_regs.c ---*/ |
| 230 | /*---------------------------------------------------------------*/ |