@@ -854,6 +854,11 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
854
854
writetag (s -> s , jl_method_type );
855
855
jl_method_t * m = (jl_method_t * )v ;
856
856
union jl_typemap_t * tf = & m -> specializations ;
857
+ if (s -> mode == MODE_MODULE || s -> mode == MODE_MODULE_POSTWORK ) {
858
+ int external = !module_in_worklist (m -> module );
859
+ if (external )
860
+ jl_error ("support for serializing a direct reference to an external Method not implemented" );
861
+ }
857
862
if (tf -> unknown && tf -> unknown != jl_nothing ) {
858
863
// go through the t-func cache, replacing ASTs with just return
859
864
// types for abstract argument types. these ASTs are generally
@@ -879,6 +884,19 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
879
884
else if (jl_is_lambda_info (v )) {
880
885
writetag (s -> s , jl_lambda_info_type );
881
886
jl_lambda_info_t * li = (jl_lambda_info_t * )v ;
887
+ jl_serialize_value (s , (jl_value_t * )li -> specTypes );
888
+ write_int8 (s -> s , li -> inferred );
889
+ if (s -> mode == MODE_MODULE || s -> mode == MODE_MODULE_POSTWORK ) {
890
+ int external = li -> def && !module_in_worklist (li -> def -> module );
891
+ write_uint8 (s -> s , external );
892
+ if (external ) {
893
+ // also flag this in the backref table as special
894
+ uintptr_t * bp = (uintptr_t * )ptrhash_bp (& backref_table , v );
895
+ assert (* bp != (uintptr_t )HT_NOTFOUND );
896
+ * bp |= 1 ; assert (((uintptr_t )HT_NOTFOUND )|1 );
897
+ return ;
898
+ }
899
+ }
882
900
if (li -> jlcall_api == 2 )
883
901
jl_serialize_value (s , jl_nothing );
884
902
else
@@ -890,8 +908,6 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v)
890
908
jl_serialize_value (s , li -> rettype );
891
909
jl_serialize_value (s , (jl_value_t * )li -> sparam_syms );
892
910
jl_serialize_value (s , (jl_value_t * )li -> sparam_vals );
893
- jl_serialize_value (s , (jl_value_t * )li -> specTypes );
894
- write_int8 (s -> s , li -> inferred );
895
911
write_int8 (s -> s , li -> pure );
896
912
write_int8 (s -> s , li -> inlineable );
897
913
write_int8 (s -> s , li -> isva );
@@ -1389,7 +1405,7 @@ static jl_value_t *jl_deserialize_value_(jl_serializer_state *s, jl_value_t *vta
1389
1405
isunboxed = !(elsize >>15 );
1390
1406
elsize = elsize & 0x7fff ;
1391
1407
}
1392
- int pos = backref_list .len ;
1408
+ uintptr_t pos = backref_list .len ;
1393
1409
if (usetable )
1394
1410
arraylist_push (& backref_list , NULL );
1395
1411
size_t * dims = (size_t * )alloca (ndims * sizeof (size_t ));
@@ -1452,6 +1468,7 @@ static jl_value_t *jl_deserialize_value_(jl_serializer_state *s, jl_value_t *vta
1452
1468
jl_method_t * m =
1453
1469
(jl_method_t * )jl_gc_alloc (ptls , sizeof (jl_method_t ),
1454
1470
jl_method_type );
1471
+ memset (m , 0 , sizeof (jl_method_type ));
1455
1472
if (usetable )
1456
1473
arraylist_push (& backref_list , m );
1457
1474
m -> specializations .unknown = jl_deserialize_value (s , (jl_value_t * * )& m -> specializations );
@@ -1490,8 +1507,42 @@ static jl_value_t *jl_deserialize_value_(jl_serializer_state *s, jl_value_t *vta
1490
1507
jl_lambda_info_t * li =
1491
1508
(jl_lambda_info_t * )jl_gc_alloc (ptls , sizeof (jl_lambda_info_t ),
1492
1509
jl_lambda_info_type );
1510
+ memset (li , 0 , sizeof (jl_lambda_info_t ));
1511
+ uintptr_t pos = backref_list .len ;
1493
1512
if (usetable )
1494
1513
arraylist_push (& backref_list , li );
1514
+
1515
+ li -> specTypes = (jl_tupletype_t * )jl_deserialize_value (s , (jl_value_t * * )& li -> specTypes );
1516
+ if (li -> specTypes ) jl_gc_wb (li , li -> specTypes );
1517
+ int inferred = read_int8 (s -> s );
1518
+ li -> inferred = inferred ;
1519
+
1520
+ if (s -> mode == MODE_MODULE ) {
1521
+ int external = read_uint8 (s -> s );
1522
+ if (external ) {
1523
+ assert (loc != NULL );
1524
+ arraylist_push (& flagref_list , loc );
1525
+ arraylist_push (& flagref_list , (void * )pos );
1526
+ return (jl_value_t * )li ;
1527
+ }
1528
+ }
1529
+ if (s -> mode == MODE_MODULE_POSTWORK ) {
1530
+ int external = read_uint8 (s -> s );
1531
+ if (external ) {
1532
+ jl_datatype_t * ftype = jl_first_argument_datatype ((jl_value_t * )li -> specTypes );
1533
+ jl_methtable_t * mt = ftype -> name -> mt ;
1534
+ li = jl_method_lookup_by_type (mt , li -> specTypes , 1 , 0 , 0 );
1535
+ assert (li );
1536
+ backref_list .items [pos ] = li ;
1537
+ // if it can be inferred but isn't, encourage codegen to infer it
1538
+ if (inferred && !li -> inferred ) {
1539
+ jl_set_lambda_code_null (li );
1540
+ li -> inferred = 1 ;
1541
+ }
1542
+ return (jl_value_t * )li ;
1543
+ }
1544
+ }
1545
+
1495
1546
li -> code = jl_deserialize_value (s , & li -> code ); jl_gc_wb (li , li -> code );
1496
1547
li -> slotnames = (jl_array_t * )jl_deserialize_value (s , (jl_value_t * * )& li -> slotnames ); jl_gc_wb (li , li -> slotnames );
1497
1548
li -> slottypes = jl_deserialize_value (s , & li -> slottypes ); jl_gc_wb (li , li -> slottypes );
@@ -1503,10 +1554,7 @@ static jl_value_t *jl_deserialize_value_(jl_serializer_state *s, jl_value_t *vta
1503
1554
jl_gc_wb (li , li -> sparam_syms );
1504
1555
li -> sparam_vals = (jl_svec_t * )jl_deserialize_value (s , (jl_value_t * * )& li -> sparam_vals );
1505
1556
jl_gc_wb (li , li -> sparam_vals );
1506
- li -> specTypes = (jl_tupletype_t * )jl_deserialize_value (s , (jl_value_t * * )& li -> specTypes );
1507
- if (li -> specTypes ) jl_gc_wb (li , li -> specTypes );
1508
1557
li -> unspecialized_ducttape = NULL ;
1509
- li -> inferred = read_int8 (s -> s );
1510
1558
li -> pure = read_int8 (s -> s );
1511
1559
li -> inlineable = read_int8 (s -> s );
1512
1560
li -> isva = read_int8 (s -> s );
@@ -1530,7 +1578,7 @@ static jl_value_t *jl_deserialize_value_(jl_serializer_state *s, jl_value_t *vta
1530
1578
return (jl_value_t * )li ;
1531
1579
}
1532
1580
else if (vtag == (jl_value_t * )jl_module_type ) {
1533
- int pos = backref_list .len ;
1581
+ uintptr_t pos = backref_list .len ;
1534
1582
if (usetable )
1535
1583
arraylist_push (& backref_list , NULL );
1536
1584
jl_sym_t * mname = (jl_sym_t * )jl_deserialize_value (s , NULL );
@@ -1620,7 +1668,7 @@ static jl_value_t *jl_deserialize_value_(jl_serializer_state *s, jl_value_t *vta
1620
1668
else if (vtag == (jl_value_t * )jl_datatype_type || vtag == (jl_value_t * )SmallDataType_tag ) {
1621
1669
int32_t sz = (vtag == (jl_value_t * )SmallDataType_tag ? read_uint8 (s -> s ) : read_int32 (s -> s ));
1622
1670
jl_value_t * v = jl_gc_alloc (ptls , sz , NULL );
1623
- int pos = backref_list .len ;
1671
+ uintptr_t pos = backref_list .len ;
1624
1672
if (usetable )
1625
1673
arraylist_push (& backref_list , v );
1626
1674
jl_datatype_t * dt = (jl_datatype_t * )jl_deserialize_value (s , & jl_astaggedvalue (v )-> type );
@@ -2309,30 +2357,72 @@ static void jl_recache_types(void)
2309
2357
int offs = (int )(intptr_t )flagref_list .items [i ++ ];
2310
2358
jl_value_t * v , * o = loc ? * loc : (jl_value_t * )backref_list .items [offs ];
2311
2359
jl_datatype_t * dt , * t ;
2312
- if (jl_is_datatype (o )) {
2313
- dt = (jl_datatype_t * )o ;
2314
- v = dt -> instance ;
2315
- assert (dt -> uid == -1 );
2316
- t = jl_recache_type (dt , i , NULL );
2317
- }
2318
- else {
2319
- dt = (jl_datatype_t * )jl_typeof (o );
2360
+ if (jl_is_lambda_info (o )) {
2361
+ // lookup the real LambdaInfo based on the placeholder specTypes
2362
+ jl_lambda_info_t * li = (jl_lambda_info_t * )o ;
2363
+ int inferred = li -> inferred ;
2364
+ jl_datatype_t * argtypes = jl_recache_type (li -> specTypes , i , NULL );
2365
+ jl_datatype_t * ftype = jl_first_argument_datatype ((jl_value_t * )argtypes );
2366
+ jl_methtable_t * mt = ftype -> name -> mt ;
2367
+ jl_set_typeof (li , (void * )(intptr_t )0x30 ); // invalidate the old value to help catch errors
2368
+ li = jl_method_lookup_by_type (mt , argtypes , 1 , 0 , 0 );
2369
+ assert (li );
2370
+ // if it can be inferred but isn't, encourage codegen to infer it
2371
+ if (inferred && !li -> inferred ) {
2372
+ jl_set_lambda_code_null (li );
2373
+ li -> inferred = 1 ;
2374
+ }
2375
+ // update the backref list
2376
+ if (loc ) * loc = (jl_value_t * )li ;
2377
+ if (offs > 0 ) backref_list .items [offs ] = li ;
2320
2378
v = o ;
2321
- t = jl_recache_type (dt , i , v );
2322
- }
2323
- assert (dt );
2324
- if (t != dt ) {
2325
- jl_set_typeof (dt , (void * )(intptr_t )0x10 ); // invalidate the old value to help catch errors
2326
- if ((jl_value_t * )dt == o ) {
2327
- if (loc ) * loc = (jl_value_t * )t ;
2328
- if (offs > 0 ) backref_list .items [offs ] = t ;
2379
+ size_t j = i ;
2380
+ while (j < flagref_list .len ) {
2381
+ jl_value_t * * loc = (jl_value_t * * )flagref_list .items [j ];
2382
+ int offs = (int )(intptr_t )flagref_list .items [j + 1 ];
2383
+ jl_value_t * o = loc ? * loc : (jl_value_t * )backref_list .items [offs ];
2384
+ if ((jl_value_t * )v == o ) { // same item, update this entry
2385
+ if (loc ) * loc = (jl_value_t * )li ;
2386
+ if (offs > 0 ) backref_list .items [offs ] = li ;
2387
+ // delete this item from the flagref list, so it won't be re-encountered later
2388
+ flagref_list .len -= 2 ;
2389
+ if (j >= flagref_list .len )
2390
+ break ;
2391
+ flagref_list .items [j + 0 ] = flagref_list .items [flagref_list .len + 0 ];
2392
+ flagref_list .items [j + 1 ] = flagref_list .items [flagref_list .len + 1 ];
2393
+ }
2394
+ else {
2395
+ j += 2 ;
2396
+ }
2329
2397
}
2330
2398
}
2331
- if (t -> instance != v ) {
2332
- jl_set_typeof (v , (void * )(intptr_t )0x20 ); // invalidate the old value to help catch errors
2333
- if (v == o ) {
2334
- * loc = t -> instance ;
2335
- if (offs > 0 ) backref_list .items [offs ] = t -> instance ;
2399
+ else {
2400
+ if (jl_is_datatype (o )) {
2401
+ dt = (jl_datatype_t * )o ;
2402
+ v = dt -> instance ;
2403
+ assert (dt -> uid == -1 );
2404
+ t = jl_recache_type (dt , i , NULL );
2405
+ }
2406
+ else {
2407
+ dt = (jl_datatype_t * )jl_typeof (o );
2408
+ v = o ;
2409
+ assert (dt -> instance );
2410
+ t = jl_recache_type (dt , i , v );
2411
+ }
2412
+ assert (dt );
2413
+ if (t != dt ) {
2414
+ jl_set_typeof (dt , (void * )(intptr_t )0x10 ); // invalidate the old value to help catch errors
2415
+ if ((jl_value_t * )dt == o ) {
2416
+ if (loc ) * loc = (jl_value_t * )t ;
2417
+ if (offs > 0 ) backref_list .items [offs ] = t ;
2418
+ }
2419
+ }
2420
+ if (t -> instance != v ) {
2421
+ jl_set_typeof (v , (void * )(intptr_t )0x20 ); // invalidate the old value to help catch errors
2422
+ if (v == o ) {
2423
+ * loc = t -> instance ;
2424
+ if (offs > 0 ) backref_list .items [offs ] = t -> instance ;
2425
+ }
2336
2426
}
2337
2427
}
2338
2428
}
0 commit comments