From 03febb677360b30c5d46688b668ac762771d0853 Mon Sep 17 00:00:00 2001 From: Rob Pike Date: Mon, 30 Jun 2008 15:30:47 -0700 Subject: [PATCH] clean up rearrangement of runtime functions in the source add isNaN, isInf, NaN, Inf SVN=125389 --- src/cmd/gc/sys.go | 10 +- src/cmd/gc/sysimport.c | 210 +++++++++-------- src/runtime/runtime.c | 461 ++++++++++++++++++++++++++++++++++++++ src/runtime/runtime_map.c | 429 ----------------------------------- 4 files changed, 585 insertions(+), 525 deletions(-) diff --git a/src/cmd/gc/sys.go b/src/cmd/gc/sys.go index 94d3b76c91..24f3a2c504 100644 --- a/src/cmd/gc/sys.go +++ b/src/cmd/gc/sys.go @@ -31,6 +31,10 @@ func envv(int32) string; func frexp(float64) (int32, float64); // break fp into exp,fract func ldexp(int32, float64) float64; // make fp from exp,fract func modf(float64) (float64, float64); // break fp into double.double +func isInf(float64, int32) bool; // test for infinity +func isNaN(float64) bool; // test for not-a-number +func Inf(int32) float64; // return signed Inf +func NaN() float64; // return a NaN func newmap(keysize uint32, valsize uint32, keyalg uint32, valalg uint32, @@ -42,7 +46,7 @@ func mapassign2(hmap *map[any]any, key any, val any, pres bool); func readfile(string) (string, bool); // read file into string; boolean status -func exit(int32); +func exit(int32); export mal @@ -75,6 +79,10 @@ export frexp ldexp modf + isInf, + isNaN, + Inf, + NaN, // op map newmap diff --git a/src/cmd/gc/sysimport.c b/src/cmd/gc/sysimport.c index e3d2581c15..c84005054c 100644 --- a/src/cmd/gc/sysimport.c +++ b/src/cmd/gc/sysimport.c @@ -3,10 +3,10 @@ char* sysimport = "type sys._e002 {}\n" "type sys.any 24\n" "type sys._e003 *sys.any\n" - "type sys._o214 {_e212 sys._e003}\n" + "type sys._o247 {_e245 sys._e003}\n" "type sys.uint32 6\n" - "type sys._i216 {_e213 sys.uint32}\n" - "type sys._e001 (sys._e002 sys._o214 sys._i216)\n" + "type sys._i249 {_e246 sys.uint32}\n" + "type sys._e001 (sys._e002 sys._o247 sys._i249)\n" "var !sys.mal sys._e001\n" "type sys._e005 {}\n" "type sys._e006 {}\n" @@ -16,161 +16,181 @@ char* sysimport = "type sys._e009 {}\n" "type sys._e010 {}\n" "type sys.int32 5\n" - "type sys._i222 {_e221 sys.int32}\n" - "type sys._e008 (sys._e009 sys._e010 sys._i222)\n" + "type sys._i255 {_e254 sys.int32}\n" + "type sys._e008 (sys._e009 sys._e010 sys._i255)\n" "var !sys.panicl sys._e008\n" "type sys._e012 {}\n" "type sys._e013 {}\n" "type sys.bool 12\n" - "type sys._i227 {_e226 sys.bool}\n" - "type sys._e011 (sys._e012 sys._e013 sys._i227)\n" + "type sys._i260 {_e259 sys.bool}\n" + "type sys._e011 (sys._e012 sys._e013 sys._i260)\n" "var !sys.printbool sys._e011\n" "type sys._e015 {}\n" "type sys._e016 {}\n" "type sys.float64 10\n" - "type sys._i232 {_e231 sys.float64}\n" - "type sys._e014 (sys._e015 sys._e016 sys._i232)\n" + "type sys._i265 {_e264 sys.float64}\n" + "type sys._e014 (sys._e015 sys._e016 sys._i265)\n" "var !sys.printfloat sys._e014\n" "type sys._e018 {}\n" "type sys._e019 {}\n" "type sys.int64 7\n" - "type sys._i237 {_e236 sys.int64}\n" - "type sys._e017 (sys._e018 sys._e019 sys._i237)\n" + "type sys._i270 {_e269 sys.int64}\n" + "type sys._e017 (sys._e018 sys._e019 sys._i270)\n" "var !sys.printint sys._e017\n" "type sys._e021 {}\n" "type sys._e022 {}\n" "type sys._e023 25\n" "type sys.string *sys._e023\n" - "type sys._i242 {_e241 sys.string}\n" - "type sys._e020 (sys._e021 sys._e022 sys._i242)\n" + "type sys._i275 {_e274 sys.string}\n" + "type sys._e020 (sys._e021 sys._e022 sys._i275)\n" "var !sys.printstring sys._e020\n" "type sys._e025 {}\n" "type sys._e026 {}\n" "type sys.uint8 2\n" "type sys._e027 *sys.uint8\n" - "type sys._i247 {_e246 sys._e027}\n" - "type sys._e024 (sys._e025 sys._e026 sys._i247)\n" + "type sys._i280 {_e279 sys._e027}\n" + "type sys._e024 (sys._e025 sys._e026 sys._i280)\n" "var !sys.printpointer sys._e024\n" "type sys._e029 {}\n" - "type sys._o254 {_e251 sys.string}\n" - "type sys._i256 {_e252 sys.string _e253 sys.string}\n" - "type sys._e028 (sys._e029 sys._o254 sys._i256)\n" + "type sys._o287 {_e284 sys.string}\n" + "type sys._i289 {_e285 sys.string _e286 sys.string}\n" + "type sys._e028 (sys._e029 sys._o287 sys._i289)\n" "var !sys.catstring sys._e028\n" "type sys._e031 {}\n" - "type sys._o264 {_e261 sys.int32}\n" - "type sys._i266 {_e262 sys.string _e263 sys.string}\n" - "type sys._e030 (sys._e031 sys._o264 sys._i266)\n" + "type sys._o297 {_e294 sys.int32}\n" + "type sys._i299 {_e295 sys.string _e296 sys.string}\n" + "type sys._e030 (sys._e031 sys._o297 sys._i299)\n" "var !sys.cmpstring sys._e030\n" "type sys._e033 {}\n" - "type sys._o275 {_e271 sys.string}\n" - "type sys._i277 {_e272 sys.string _e273 sys.int32 _e274 sys.int32}\n" - "type sys._e032 (sys._e033 sys._o275 sys._i277)\n" + "type sys._o308 {_e304 sys.string}\n" + "type sys._i310 {_e305 sys.string _e306 sys.int32 _e307 sys.int32}\n" + "type sys._e032 (sys._e033 sys._o308 sys._i310)\n" "var !sys.slicestring sys._e032\n" "type sys._e035 {}\n" - "type sys._o286 {_e283 sys.uint8}\n" - "type sys._i288 {_e284 sys.string _e285 sys.int32}\n" - "type sys._e034 (sys._e035 sys._o286 sys._i288)\n" + "type sys._o319 {_e316 sys.uint8}\n" + "type sys._i321 {_e317 sys.string _e318 sys.int32}\n" + "type sys._e034 (sys._e035 sys._o319 sys._i321)\n" "var !sys.indexstring sys._e034\n" "type sys._e037 {}\n" - "type sys._o295 {_e293 sys.string}\n" - "type sys._i297 {_e294 sys.int64}\n" - "type sys._e036 (sys._e037 sys._o295 sys._i297)\n" + "type sys._o328 {_e326 sys.string}\n" + "type sys._i330 {_e327 sys.int64}\n" + "type sys._e036 (sys._e037 sys._o328 sys._i330)\n" "var !sys.intstring sys._e036\n" "type sys._e039 {}\n" - "type sys._o304 {_e301 sys.string}\n" + "type sys._o337 {_e334 sys.string}\n" "type sys._e040 *sys.uint8\n" - "type sys._i306 {_e302 sys._e040 _e303 sys.int32}\n" - "type sys._e038 (sys._e039 sys._o304 sys._i306)\n" + "type sys._i339 {_e335 sys._e040 _e336 sys.int32}\n" + "type sys._e038 (sys._e039 sys._o337 sys._i339)\n" "var !sys.byteastring sys._e038\n" "type sys._e042 {}\n" "type sys._e043 <>\n" - "type sys._o315 {_e311 sys._e043}\n" + "type sys._o348 {_e344 sys._e043}\n" "type sys._e044 *sys.uint8\n" "type sys._e045 *sys.uint8\n" - "type sys._s322 {}\n" - "type sys._e046 *sys._s322\n" - "type sys._i317 {_e312 sys._e044 _e313 sys._e045 _e314 sys._e046}\n" - "type sys._e041 (sys._e042 sys._o315 sys._i317)\n" + "type sys._s355 {}\n" + "type sys._e046 *sys._s355\n" + "type sys._i350 {_e345 sys._e044 _e346 sys._e045 _e347 sys._e046}\n" + "type sys._e041 (sys._e042 sys._o348 sys._i350)\n" "var !sys.mkiface sys._e041\n" "type sys._e048 {}\n" - "type sys._o326 {_e325 sys.int32}\n" + "type sys._o359 {_e358 sys.int32}\n" "type sys._e049 {}\n" - "type sys._e047 (sys._e048 sys._o326 sys._e049)\n" + "type sys._e047 (sys._e048 sys._o359 sys._e049)\n" "var !sys.argc sys._e047\n" "type sys._e051 {}\n" - "type sys._o330 {_e329 sys.int32}\n" + "type sys._o363 {_e362 sys.int32}\n" "type sys._e052 {}\n" - "type sys._e050 (sys._e051 sys._o330 sys._e052)\n" + "type sys._e050 (sys._e051 sys._o363 sys._e052)\n" "var !sys.envc sys._e050\n" "type sys._e054 {}\n" - "type sys._o335 {_e333 sys.string}\n" - "type sys._i337 {_e334 sys.int32}\n" - "type sys._e053 (sys._e054 sys._o335 sys._i337)\n" + "type sys._o368 {_e366 sys.string}\n" + "type sys._i370 {_e367 sys.int32}\n" + "type sys._e053 (sys._e054 sys._o368 sys._i370)\n" "var !sys.argv sys._e053\n" "type sys._e056 {}\n" - "type sys._o343 {_e341 sys.string}\n" - "type sys._i345 {_e342 sys.int32}\n" - "type sys._e055 (sys._e056 sys._o343 sys._i345)\n" + "type sys._o376 {_e374 sys.string}\n" + "type sys._i378 {_e375 sys.int32}\n" + "type sys._e055 (sys._e056 sys._o376 sys._i378)\n" "var !sys.envv sys._e055\n" "type sys._e058 {}\n" - "type sys._o352 {_e349 sys.int32 _e350 sys.float64}\n" - "type sys._i354 {_e351 sys.float64}\n" - "type sys._e057 (sys._e058 sys._o352 sys._i354)\n" + "type sys._o385 {_e382 sys.int32 _e383 sys.float64}\n" + "type sys._i387 {_e384 sys.float64}\n" + "type sys._e057 (sys._e058 sys._o385 sys._i387)\n" "var !sys.frexp sys._e057\n" "type sys._e060 {}\n" - "type sys._o361 {_e358 sys.float64}\n" - "type sys._i363 {_e359 sys.int32 _e360 sys.float64}\n" - "type sys._e059 (sys._e060 sys._o361 sys._i363)\n" + "type sys._o394 {_e391 sys.float64}\n" + "type sys._i396 {_e392 sys.int32 _e393 sys.float64}\n" + "type sys._e059 (sys._e060 sys._o394 sys._i396)\n" "var !sys.ldexp sys._e059\n" "type sys._e062 {}\n" - "type sys._o371 {_e368 sys.float64 _e369 sys.float64}\n" - "type sys._i373 {_e370 sys.float64}\n" - "type sys._e061 (sys._e062 sys._o371 sys._i373)\n" + "type sys._o404 {_e401 sys.float64 _e402 sys.float64}\n" + "type sys._i406 {_e403 sys.float64}\n" + "type sys._e061 (sys._e062 sys._o404 sys._i406)\n" "var !sys.modf sys._e061\n" "type sys._e064 {}\n" - "type sys._e066 [sys.any] sys.any\n" - "type sys._e065 *sys._e066\n" - "type sys._o377 {hmap sys._e065}\n" - "type sys._i379 {keysize sys.uint32 valsize sys.uint32 keyalg sys.uint32 valalg sys.uint32 hint sys.uint32}\n" - "type sys._e063 (sys._e064 sys._o377 sys._i379)\n" - "var !sys.newmap sys._e063\n" + "type sys._o413 {_e410 sys.bool}\n" + "type sys._i415 {_e411 sys.float64 _e412 sys.int32}\n" + "type sys._e063 (sys._e064 sys._o413 sys._i415)\n" + "var !sys.isInf sys._e063\n" + "type sys._e066 {}\n" + "type sys._o422 {_e420 sys.bool}\n" + "type sys._i424 {_e421 sys.float64}\n" + "type sys._e065 (sys._e066 sys._o422 sys._i424)\n" + "var !sys.isNaN sys._e065\n" "type sys._e068 {}\n" - "type sys._o387 {val sys.any}\n" - "type sys._e070 [sys.any] sys.any\n" - "type sys._e069 *sys._e070\n" - "type sys._i389 {hmap sys._e069 key sys.any}\n" - "type sys._e067 (sys._e068 sys._o387 sys._i389)\n" - "var !sys.mapaccess1 sys._e067\n" - "type sys._e072 {}\n" - "type sys._o394 {val sys.any pres sys.bool}\n" - "type sys._e074 [sys.any] sys.any\n" - "type sys._e073 *sys._e074\n" - "type sys._i396 {hmap sys._e073 key sys.any}\n" - "type sys._e071 (sys._e072 sys._o394 sys._i396)\n" - "var !sys.mapaccess2 sys._e071\n" - "type sys._e076 {}\n" + "type sys._o430 {_e428 sys.float64}\n" + "type sys._i432 {_e429 sys.int32}\n" + "type sys._e067 (sys._e068 sys._o430 sys._i432)\n" + "var !sys.Inf sys._e067\n" + "type sys._e070 {}\n" + "type sys._o437 {_e436 sys.float64}\n" + "type sys._e071 {}\n" + "type sys._e069 (sys._e070 sys._o437 sys._e071)\n" + "var !sys.NaN sys._e069\n" + "type sys._e073 {}\n" + "type sys._e075 [sys.any] sys.any\n" + "type sys._e074 *sys._e075\n" + "type sys._o440 {hmap sys._e074}\n" + "type sys._i442 {keysize sys.uint32 valsize sys.uint32 keyalg sys.uint32 valalg sys.uint32 hint sys.uint32}\n" + "type sys._e072 (sys._e073 sys._o440 sys._i442)\n" + "var !sys.newmap sys._e072\n" "type sys._e077 {}\n" + "type sys._o450 {val sys.any}\n" "type sys._e079 [sys.any] sys.any\n" "type sys._e078 *sys._e079\n" - "type sys._i401 {hmap sys._e078 key sys.any val sys.any}\n" - "type sys._e075 (sys._e076 sys._e077 sys._i401)\n" - "var !sys.mapassign1 sys._e075\n" + "type sys._i452 {hmap sys._e078 key sys.any}\n" + "type sys._e076 (sys._e077 sys._o450 sys._i452)\n" + "var !sys.mapaccess1 sys._e076\n" "type sys._e081 {}\n" - "type sys._e082 {}\n" - "type sys._e084 [sys.any] sys.any\n" - "type sys._e083 *sys._e084\n" - "type sys._i407 {hmap sys._e083 key sys.any val sys.any pres sys.bool}\n" - "type sys._e080 (sys._e081 sys._e082 sys._i407)\n" - "var !sys.mapassign2 sys._e080\n" + "type sys._o457 {val sys.any pres sys.bool}\n" + "type sys._e083 [sys.any] sys.any\n" + "type sys._e082 *sys._e083\n" + "type sys._i459 {hmap sys._e082 key sys.any}\n" + "type sys._e080 (sys._e081 sys._o457 sys._i459)\n" + "var !sys.mapaccess2 sys._e080\n" + "type sys._e085 {}\n" "type sys._e086 {}\n" - "type sys._o417 {_e414 sys.string _e415 sys.bool}\n" - "type sys._i419 {_e416 sys.string}\n" - "type sys._e085 (sys._e086 sys._o417 sys._i419)\n" - "var !sys.readfile sys._e085\n" - "type sys._e088 {}\n" - "type sys._e089 {}\n" - "type sys._i424 {_e423 sys.int32}\n" - "type sys._e087 (sys._e088 sys._e089 sys._i424)\n" - "var !sys.exit sys._e087\n" + "type sys._e088 [sys.any] sys.any\n" + "type sys._e087 *sys._e088\n" + "type sys._i464 {hmap sys._e087 key sys.any val sys.any}\n" + "type sys._e084 (sys._e085 sys._e086 sys._i464)\n" + "var !sys.mapassign1 sys._e084\n" + "type sys._e090 {}\n" + "type sys._e091 {}\n" + "type sys._e093 [sys.any] sys.any\n" + "type sys._e092 *sys._e093\n" + "type sys._i470 {hmap sys._e092 key sys.any val sys.any pres sys.bool}\n" + "type sys._e089 (sys._e090 sys._e091 sys._i470)\n" + "var !sys.mapassign2 sys._e089\n" + "type sys._e095 {}\n" + "type sys._o480 {_e477 sys.string _e478 sys.bool}\n" + "type sys._i482 {_e479 sys.string}\n" + "type sys._e094 (sys._e095 sys._o480 sys._i482)\n" + "var !sys.readfile sys._e094\n" + "type sys._e097 {}\n" + "type sys._e098 {}\n" + "type sys._i487 {_e486 sys.int32}\n" + "type sys._e096 (sys._e097 sys._e098 sys._i487)\n" + "var !sys.exit sys._e096\n" "))\n" ; diff --git a/src/runtime/runtime.c b/src/runtime/runtime.c index 3f9e8c2741..1807e63f3f 100644 --- a/src/runtime/runtime.c +++ b/src/runtime/runtime.c @@ -109,3 +109,464 @@ sys·mal(uint32 n, uint8 *ret) ret = mal(n); FLUSH(&ret); } + +static Map* hash[1009]; + +static Map* +hashmap(Sigi *si, Sigs *ss) +{ + int32 ns, ni; + uint32 ihash, h; + byte *sname, *iname; + Map *m; + + h = ((uint32)si + (uint32)ss) % nelem(hash); + for(m=hash[h]; m!=nil; m=m->link) { + if(m->si == si && m->ss == ss) { + if(m->bad) { + throw("bad hashmap"); + m = nil; + } + // prints("old hashmap\n"); + return m; + } + } + + ni = si[0].offset; // first word has size + m = mal(sizeof(*m) + ni*sizeof(m->fun[0])); + m->si = si; + m->ss = ss; + + ni = 1; // skip first word + ns = 0; + +loop1: + // pick up next name from + // interface signature + iname = si[ni].name; + if(iname == nil) { + m->link = hash[h]; + hash[h] = m; + // prints("new hashmap\n"); + return m; + } + ihash = si[ni].hash; + +loop2: + // pick up and comapre next name + // from structure signature + sname = ss[ns].name; + if(sname == nil) { + prints((int8*)iname); + prints(": "); + throw("hashmap: failed to find method"); + m->bad = 1; + m->link = hash[h]; + hash[h] = m; + return nil; + } + if(ihash != ss[ns].hash || + strcmp(sname, iname) != 0) { + ns++; + goto loop2; + } + + m->fun[si[ni].offset] = ss[ns].fun; + ni++; + goto loop1; +} + +void +sys·ifaces2i(Sigi *si, Sigs *ss, Map *m, void *s) +{ + + if(debug) { + prints("s2i sigi="); + sys·printpointer(si); + prints(" sigs="); + sys·printpointer(ss); + prints(" s="); + sys·printpointer(s); + } + + if(s == nil) { + throw("ifaces2i: nil pointer"); + m = nil; + FLUSH(&m); + return; + } + + m = hashmap(si, ss); + + if(debug) { + prints(" returning m="); + sys·printpointer(m); + prints(" s="); + sys·printpointer(s); + prints("\n"); + dump((byte*)m, 64); + } + + FLUSH(&m); +} + +void +sys·ifacei2i(Sigi *si, Map *m, void *s) +{ + + if(debug) { + prints("i2i sigi="); + sys·printpointer(si); + prints(" m="); + sys·printpointer(m); + prints(" s="); + sys·printpointer(s); + } + + if(m == nil) { + throw("ifacei2i: nil map"); + s = nil; + FLUSH(&s); + return; + } + + if(m->si == nil) { + throw("ifacei2i: nil pointer"); + return; + } + + if(m->si != si) { + m = hashmap(si, m->ss); + FLUSH(&m); + } + + if(debug) { + prints(" returning m="); + sys·printpointer(m); + prints(" s="); + sys·printpointer(s); + prints("\n"); + dump((byte*)m, 64); + } +} + +void +sys·ifacei2s(Sigs *ss, Map *m, void *s) +{ + + if(debug) { + prints("i2s m="); + sys·printpointer(m); + prints(" s="); + sys·printpointer(s); + prints("\n"); + } + + if(m == nil) { + throw("ifacei2s: nil map"); + s = nil; + FLUSH(&s); + return; + } + + if(m->ss != ss) { + dump((byte*)m, 64); + throw("ifacei2s: wrong pointer"); + s = nil; + FLUSH(&s); + return; + } +} + +enum +{ + NANEXP = 2047<<20, + NANMASK = 2047<<20, + NANSIGN = 1<<31, +}; + +static uint64 uvnan = 0x7FF0000000000001; +static uint64 uvinf = 0x7FF0000000000000; +static uint64 uvneginf = 0xFFF0000000000000; + +static int32 +isInf(float64 d, int32 sign) +{ + uint64 x; + + x = *(uint64*)&d; + if(sign == 0) { + if(x == uvinf || x == uvneginf) + return 1; + return 0; + } + if(sign > 0) { + if(x == uvinf) + return 1; + return 0; + } + if(x == uvneginf) + return 1; + return 0; +} + +static float64 +NaN(void) +{ + return *(float64*)&uvnan; +} + +static int32 +isNaN(float64 d) +{ + uint64 x; + + x = *(uint64*)&d; + return ((uint32)x>>32)==0x7FF00000 && !isInf(d, 0); +} + +static float64 +Inf(int32 sign) +{ + if(sign < 0) + return *(float64*)&uvinf; + else + return *(float64*)&uvneginf; +} + +enum +{ + MASK = 0x7ffL, + SHIFT = 64-11-1, + BIAS = 1022L, +}; + +static float64 +frexp(float64 d, int32 *ep) +{ + uint64 x; + + if(d == 0) { + *ep = 0; + return 0; + } + x = *(uint64*)&d; + *ep = (int32)((x >> SHIFT) & MASK) - BIAS; + x &= ~((uint64)MASK << SHIFT); + x |= (uint64)BIAS << SHIFT; + return *(float64*)&x; +} + +static float64 +ldexp(float64 d, int32 e) +{ + uint64 x; + + if(d == 0) + return 0; + x = *(uint64*)&d; + e += (int32)(x >> SHIFT) & MASK; + if(e <= 0) + return 0; /* underflow */ + if(e >= MASK){ /* overflow */ + if(d < 0) + return Inf(-1); + return Inf(1); + } + x &= ~((uint64)MASK << SHIFT); + x |= (uint64)e << SHIFT; + return *(float64*)&x; +} + +static float64 +modf(float64 d, float64 *ip) +{ + float64 dd; + uint64 x; + int32 e; + + if(d < 1) { + if(d < 0) { + d = modf(-d, ip); + *ip = -*ip; + return -d; + } + *ip = 0; + return d; + } + + x = *(uint64*)&d; + e = (int32)((x >> SHIFT) & MASK) - BIAS; + + /* + * Keep the top 11+e bits; clear the rest. + */ + if(e <= 64-11) + x &= ~((uint64)1 << (64-11-e))-1; + dd = *(float64*)&x; + *ip = dd; + return d - dd; +} + +// func frexp(float64) (int32, float64); // break fp into exp,fract +void +sys·frexp(float64 din, int32 iou, float64 dou) +{ + dou = frexp(din, &iou); + FLUSH(&dou); +} + +//func ldexp(int32, float64) float64; // make fp from exp,fract +void +sys·ldexp(float64 din, int32 ein, float64 dou) +{ + dou = ldexp(din, ein); + FLUSH(&dou); +} + +//func modf(float64) (float64, float64); // break fp into double+double +float64 +sys·modf(float64 din, float64 dou1, float64 dou2) +{ + dou1 = modf(din, &dou2); + FLUSH(&dou2); +} + +//func isinf(float64, int32 sign) bool; // test for infinity +void +sys·isInf(float64 din, int32 signin, bool out) +{ + out = isInf(din, signin); + FLUSH(&out); +} + +//func isnan(float64) bool; // test for NaN +void +sys·isNaN(float64 din, bool out) +{ + out = isNaN(din); + FLUSH(&out); +} + +//func inf(int32 sign) float64; // signed infinity +void +sys·Inf(int32 signin, float64 out) +{ + out = Inf(signin); + FLUSH(&out); +} + +//func nan() float64; // NaN +void +sys·NaN(float64 out) +{ + out = NaN(); + FLUSH(&out); +} + +static int32 argc; +static uint8** argv; +static int32 envc; +static uint8** envv; + + +void +args(int32 c, uint8 **v) +{ + argc = c; + argv = v; + envv = v + argc + 1; // skip 0 at end of argv + for (envc = 0; envv[envc] != 0; envc++) + ; +} + +//func argc() int32; // return number of arguments +void +sys·argc(int32 v) +{ + v = argc; + FLUSH(&v); +} + +//func envc() int32; // return number of environment variables +void +sys·envc(int32 v) +{ + v = envc; + FLUSH(&v); +} + +//func argv(i) string; // return argument i +void +sys·argv(int32 i, string s) +{ + uint8* str; + int32 l; + + if(i < 0 || i >= argc) { + s = emptystring; + goto out; + } + + str = argv[i]; + l = findnull((int8*)str); + s = mal(sizeof(s->len)+l); + s->len = l; + mcpy(s->str, str, l); + +out: + FLUSH(&s); +} + +//func envv(i) string; // return argument i +void +sys·envv(int32 i, string s) +{ + uint8* str; + int32 l; + + if(i < 0 || i >= envc) { + s = emptystring; + goto out; + } + + str = envv[i]; + l = findnull((int8*)str); + s = mal(sizeof(s->len)+l); + s->len = l; + mcpy(s->str, str, l); + +out: + FLUSH(&s); +} + +check(void) +{ + int8 a; + uint8 b; + int16 c; + uint16 d; + int32 e; + uint32 f; + int64 g; + uint64 h; + float32 i; + float64 j; + void* k; + uint16* l; + + if(sizeof(a) != 1) throw("bad a"); + if(sizeof(b) != 1) throw("bad b"); + if(sizeof(c) != 2) throw("bad c"); + if(sizeof(d) != 2) throw("bad d"); + if(sizeof(e) != 4) throw("bad e"); + if(sizeof(f) != 4) throw("bad f"); + if(sizeof(g) != 8) throw("bad g"); + if(sizeof(h) != 8) throw("bad h"); + if(sizeof(i) != 4) throw("bad i"); + if(sizeof(j) != 8) throw("bad j"); + if(sizeof(k) != 8) throw("bad k"); + if(sizeof(l) != 8) throw("bad l"); +// prints(1"check ok\n"); + initsig(); +} diff --git a/src/runtime/runtime_map.c b/src/runtime/runtime_map.c index ba9ff37b65..0dd655b16e 100644 --- a/src/runtime/runtime_map.c +++ b/src/runtime/runtime_map.c @@ -4,435 +4,6 @@ #include "runtime.h" -static Map* hash[1009]; - -static Map* -hashmap(Sigi *si, Sigs *ss) -{ - int32 ns, ni; - uint32 ihash, h; - byte *sname, *iname; - Map *m; - - h = ((uint32)si + (uint32)ss) % nelem(hash); - for(m=hash[h]; m!=nil; m=m->link) { - if(m->si == si && m->ss == ss) { - if(m->bad) { - throw("bad hashmap"); - m = nil; - } - // prints("old hashmap\n"); - return m; - } - } - - ni = si[0].offset; // first word has size - m = mal(sizeof(*m) + ni*sizeof(m->fun[0])); - m->si = si; - m->ss = ss; - - ni = 1; // skip first word - ns = 0; - -loop1: - // pick up next name from - // interface signature - iname = si[ni].name; - if(iname == nil) { - m->link = hash[h]; - hash[h] = m; - // prints("new hashmap\n"); - return m; - } - ihash = si[ni].hash; - -loop2: - // pick up and comapre next name - // from structure signature - sname = ss[ns].name; - if(sname == nil) { - prints((int8*)iname); - prints(": "); - throw("hashmap: failed to find method"); - m->bad = 1; - m->link = hash[h]; - hash[h] = m; - return nil; - } - if(ihash != ss[ns].hash || - strcmp(sname, iname) != 0) { - ns++; - goto loop2; - } - - m->fun[si[ni].offset] = ss[ns].fun; - ni++; - goto loop1; -} - -void -sys·ifaces2i(Sigi *si, Sigs *ss, Map *m, void *s) -{ - - if(debug) { - prints("s2i sigi="); - sys·printpointer(si); - prints(" sigs="); - sys·printpointer(ss); - prints(" s="); - sys·printpointer(s); - } - - if(s == nil) { - throw("ifaces2i: nil pointer"); - m = nil; - FLUSH(&m); - return; - } - - m = hashmap(si, ss); - - if(debug) { - prints(" returning m="); - sys·printpointer(m); - prints(" s="); - sys·printpointer(s); - prints("\n"); - dump((byte*)m, 64); - } - - FLUSH(&m); -} - -void -sys·ifacei2i(Sigi *si, Map *m, void *s) -{ - - if(debug) { - prints("i2i sigi="); - sys·printpointer(si); - prints(" m="); - sys·printpointer(m); - prints(" s="); - sys·printpointer(s); - } - - if(m == nil) { - throw("ifacei2i: nil map"); - s = nil; - FLUSH(&s); - return; - } - - if(m->si == nil) { - throw("ifacei2i: nil pointer"); - return; - } - - if(m->si != si) { - m = hashmap(si, m->ss); - FLUSH(&m); - } - - if(debug) { - prints(" returning m="); - sys·printpointer(m); - prints(" s="); - sys·printpointer(s); - prints("\n"); - dump((byte*)m, 64); - } -} - -void -sys·ifacei2s(Sigs *ss, Map *m, void *s) -{ - - if(debug) { - prints("i2s m="); - sys·printpointer(m); - prints(" s="); - sys·printpointer(s); - prints("\n"); - } - - if(m == nil) { - throw("ifacei2s: nil map"); - s = nil; - FLUSH(&s); - return; - } - - if(m->ss != ss) { - dump((byte*)m, 64); - throw("ifacei2s: wrong pointer"); - s = nil; - FLUSH(&s); - return; - } -} - -enum -{ - NANEXP = 2047<<20, - NANMASK = 2047<<20, - NANSIGN = 1<<31, -}; - -static uint64 uvnan = 0x7FF0000000000001; -static uint64 uvinf = 0x7FF0000000000000; -static uint64 uvneginf = 0xFFF0000000000000; - -static int32 -isInf(float64 d, int32 sign) -{ - uint64 x; - - x = *(uint64*)&d; - if(sign == 0) { - if(x == uvinf || x == uvneginf) - return 1; - return 0; - } - if(sign > 0) { - if(x == uvinf) - return 1; - return 0; - } - if(x == uvneginf) - return 1; - return 0; -} - -static float64 -NaN(void) -{ - return *(float64*)&uvnan; -} - -static int32 -isNaN(float64 d) -{ - uint64 x; - - x = *(uint64*)&d; - return ((uint32)x>>32)==0x7FF00000 && !isInf(d, 0); -} - -static float64 -Inf(int32 sign) -{ - if(sign < 0) - return *(float64*)&uvinf; - else - return *(float64*)&uvneginf; -} - -enum -{ - MASK = 0x7ffL, - SHIFT = 64-11-1, - BIAS = 1022L, -}; - -static float64 -frexp(float64 d, int32 *ep) -{ - uint64 x; - - if(d == 0) { - *ep = 0; - return 0; - } - x = *(uint64*)&d; - *ep = (int32)((x >> SHIFT) & MASK) - BIAS; - x &= ~((uint64)MASK << SHIFT); - x |= (uint64)BIAS << SHIFT; - return *(float64*)&x; -} - -static float64 -ldexp(float64 d, int32 e) -{ - uint64 x; - - if(d == 0) - return 0; - x = *(uint64*)&d; - e += (int32)(x >> SHIFT) & MASK; - if(e <= 0) - return 0; /* underflow */ - if(e >= MASK){ /* overflow */ - if(d < 0) - return Inf(-1); - return Inf(1); - } - x &= ~((uint64)MASK << SHIFT); - x |= (uint64)e << SHIFT; - return *(float64*)&x; -} - -static float64 -modf(float64 d, float64 *ip) -{ - float64 dd; - uint64 x; - int32 e; - - if(d < 1) { - if(d < 0) { - d = modf(-d, ip); - *ip = -*ip; - return -d; - } - *ip = 0; - return d; - } - - x = *(uint64*)&d; - e = (int32)((x >> SHIFT) & MASK) - BIAS; - - /* - * Keep the top 11+e bits; clear the rest. - */ - if(e <= 64-11) - x &= ~((uint64)1 << (64-11-e))-1; - dd = *(float64*)&x; - *ip = dd; - return d - dd; -} - -// func frexp(float64) (int32, float64); // break fp into exp,fract -void -sys·frexp(float64 din, int32 iou, float64 dou) -{ - dou = frexp(din, &iou); - FLUSH(&dou); -} - -//func ldexp(int32, float64) float64; // make fp from exp,fract -void -sys·ldexp(float64 din, int32 ein, float64 dou) -{ - dou = ldexp(din, ein); - FLUSH(&dou); -} - -//func modf(float64) (float64, float64); // break fp into double+double -float64 -sys·modf(float64 din, float64 dou1, float64 dou2) -{ - dou1 = modf(din, &dou2); - FLUSH(&dou2); -} - -static int32 argc; -static uint8** argv; -static int32 envc; -static uint8** envv; - - -void -args(int32 c, uint8 **v) -{ - argc = c; - argv = v; - envv = v + argc + 1; // skip 0 at end of argv - for (envc = 0; envv[envc] != 0; envc++) - ; -} - -//func argc() int32; // return number of arguments -void -sys·argc(int32 v) -{ - v = argc; - FLUSH(&v); -} - -//func envc() int32; // return number of environment variables -void -sys·envc(int32 v) -{ - v = envc; - FLUSH(&v); -} - -//func argv(i) string; // return argument i -void -sys·argv(int32 i, string s) -{ - uint8* str; - int32 l; - - if(i < 0 || i >= argc) { - s = emptystring; - goto out; - } - - str = argv[i]; - l = findnull((int8*)str); - s = mal(sizeof(s->len)+l); - s->len = l; - mcpy(s->str, str, l); - -out: - FLUSH(&s); -} - -//func envv(i) string; // return argument i -void -sys·envv(int32 i, string s) -{ - uint8* str; - int32 l; - - if(i < 0 || i >= envc) { - s = emptystring; - goto out; - } - - str = envv[i]; - l = findnull((int8*)str); - s = mal(sizeof(s->len)+l); - s->len = l; - mcpy(s->str, str, l); - -out: - FLUSH(&s); -} - -check(void) -{ - int8 a; - uint8 b; - int16 c; - uint16 d; - int32 e; - uint32 f; - int64 g; - uint64 h; - float32 i; - float64 j; - void* k; - uint16* l; - - if(sizeof(a) != 1) throw("bad a"); - if(sizeof(b) != 1) throw("bad b"); - if(sizeof(c) != 2) throw("bad c"); - if(sizeof(d) != 2) throw("bad d"); - if(sizeof(e) != 4) throw("bad e"); - if(sizeof(f) != 4) throw("bad f"); - if(sizeof(g) != 8) throw("bad g"); - if(sizeof(h) != 8) throw("bad h"); - if(sizeof(i) != 4) throw("bad i"); - if(sizeof(j) != 8) throw("bad j"); - if(sizeof(k) != 8) throw("bad k"); - if(sizeof(l) != 8) throw("bad l"); -// prints(1"check ok\n"); - initsig(); -} - typedef struct Link Link; typedef struct Hmap Hmap; typedef struct Alg Alg; -- 2.48.1