1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy of the CDDL is also available via the Internet at 9 * http://www.illumos.org/license/CDDL. 10 */ 11 12 /* 13 * Copyright 2019, Joyent, Inc. 14 */ 15 16 #include <errno.h> 17 #include <libcustr.h> 18 #include <limits.h> 19 #include <string.h> 20 #include <sys/ctype.h> /* We want the C locale ISXXX() versions */ 21 #include <sys/debug.h> 22 #include <stdio.h> 23 #include <sys/sysmacros.h> 24 25 #include "strview.h" 26 #include "demangle_int.h" 27 28 /* 29 * Unfortunately, there is currently no official specification for the rust 30 * name mangling. This is an attempt to document the understanding of the 31 * mangling used here. It is based off examination of 32 * https://docs.rs/rustc-demangle/0.1.13/rustc_demangle/ 33 * 34 * A mangled rust name is: 35 * <prefix> <name> <hash> E 36 * 37 * <prefix> ::= _Z 38 * __Z 39 * 40 * <name> ::= <name-segment>+ 41 * 42 * <name-segment> ::= <len> <name-chars>{len} 43 * 44 * <len> ::= [1-9][0-9]+ 45 * 46 * <name-chars> ::= <[A-Za-z]> <[A-Za-z0-9]>* 47 * <separator> 48 * <special> 49 * 50 * <separator> ::= '..' # '::' 51 * 52 * <special> ::= $SP$ # ' ' 53 * $BP$ # '*' 54 * $RF$ # '&' 55 * $LT$ # '<' 56 * $GT$ # '>' 57 * $LP$ # '(' 58 * $RP$ # ')' 59 * $C$ # ',' 60 * $u7e$ # '~' 61 * $u20$ # ' ' 62 * $u27$ # '\'' 63 * $u3d$ # '=' 64 * $u5b$ # '[' 65 * $u5d$ # ']' 66 * $u7b$ # '{' 67 * $u7d$ # '}' 68 * $u3b$ # ';' 69 * $u2b$ # '+' 70 * $u22$ # '"' 71 * 72 * <hash> := <len> h <hex-digits>+ 73 * 74 * <hex-digits> := <[0-9a-f]> 75 */ 76 77 typedef struct rustdem_state { 78 const char *rds_str; 79 custr_t *rds_demangled; 80 sysdem_ops_t *rds_ops; 81 int rds_error; 82 } rustdem_state_t; 83 84 static const struct rust_charmap { 85 const char *ruc_seq; 86 char ruc_ch; 87 } rust_charmap[] = { 88 { "$SP$", '@' }, 89 { "$BP$", '*' }, 90 { "$RF$", '&' }, 91 { "$LT$", '<' }, 92 { "$GT$", '>' }, 93 { "$LP$", '(' }, 94 { "$RP$", ')' }, 95 { "$C$", ',' }, 96 { "$u7e$", '~' }, 97 { "$u20$", ' ' }, 98 { "$u27$", '\'' }, 99 { "$u3d$", '=' }, 100 { "$u5b$", '[' }, 101 { "$u5d$", ']' }, 102 { "$u7b$", '{' }, 103 { "$u7d$", '}' }, 104 { "$u3b$", ';' }, 105 { "$u2b$", '+' }, 106 { "$u22$", '"' } 107 }; 108 static const size_t rust_charmap_sz = ARRAY_SIZE(rust_charmap); 109 110 static void *rustdem_alloc(custr_alloc_t *, size_t); 111 static void rustdem_free(custr_alloc_t *, void *, size_t); 112 113 static boolean_t rustdem_append_c(rustdem_state_t *, char); 114 static boolean_t rustdem_all_ascii(const strview_t *); 115 116 static boolean_t rustdem_parse_prefix(rustdem_state_t *, strview_t *); 117 static boolean_t rustdem_parse_name(rustdem_state_t *, strview_t *); 118 static boolean_t rustdem_parse_hash(rustdem_state_t *, strview_t *); 119 static boolean_t rustdem_parse_num(rustdem_state_t *, strview_t *, uint64_t *); 120 static boolean_t rustdem_parse_special(rustdem_state_t *, strview_t *); 121 static boolean_t rustdem_add_sep(rustdem_state_t *); 122 123 char * 124 rust_demangle(const char *s, size_t slen, sysdem_ops_t *ops) 125 { 126 rustdem_state_t st = { 127 .rds_str = s, 128 .rds_ops = ops, 129 }; 130 custr_alloc_ops_t custr_ops = { 131 .custr_ao_alloc = rustdem_alloc, 132 .custr_ao_free = rustdem_free 133 }; 134 custr_alloc_t custr_alloc = { 135 .cua_version = CUSTR_VERSION 136 }; 137 strview_t sv; 138 int ret; 139 140 if (custr_alloc_init(&custr_alloc, &custr_ops) != 0) 141 return (NULL); 142 custr_alloc.cua_arg = &st; 143 144 sv_init_str(&sv, s, s + slen); 145 146 if (sv_remaining(&sv) < 1 || sv_peek(&sv, -1) != 'E') { 147 DEMDEBUG("ERROR: string is either too small or does not end " 148 "with 'E'"); 149 errno = EINVAL; 150 return (NULL); 151 } 152 153 if (!rustdem_parse_prefix(&st, &sv)) { 154 DEMDEBUG("ERROR: could not parse prefix"); 155 errno = EINVAL; 156 return (NULL); 157 } 158 DEMDEBUG("parsed prefix; remaining='%.*s'", SV_PRINT(&sv)); 159 160 if (!rustdem_all_ascii(&sv)) { 161 /* rustdem_all_ascii() provides debug output */ 162 errno = EINVAL; 163 return (NULL); 164 } 165 166 if ((ret = custr_xalloc(&st.rds_demangled, &custr_alloc)) != 0) 167 return (NULL); 168 169 while (sv_remaining(&sv) > 1) { 170 if (rustdem_parse_name(&st, &sv)) 171 continue; 172 if (st.rds_error != 0) 173 goto fail; 174 } 175 176 if (st.rds_error != 0 || !sv_consume_if_c(&sv, 'E')) 177 goto fail; 178 179 char *res = xstrdup(ops, custr_cstr(st.rds_demangled)); 180 if (res == NULL) { 181 st.rds_error = errno; 182 goto fail; 183 } 184 185 custr_free(st.rds_demangled); 186 DEMDEBUG("result = '%s'", res); 187 return (res); 188 189 fail: 190 custr_free(st.rds_demangled); 191 errno = st.rds_error; 192 return (NULL); 193 } 194 195 static boolean_t 196 rustdem_parse_prefix(rustdem_state_t *st, strview_t *svp) 197 { 198 strview_t pfx; 199 200 sv_init_sv(&pfx, svp); 201 202 DEMDEBUG("checking for '_ZN' or '__ZN' in '%.*s'", SV_PRINT(&pfx)); 203 204 if (st->rds_error != 0) 205 return (B_FALSE); 206 207 if (!sv_consume_if_c(&pfx, '_')) 208 return (B_FALSE); 209 210 (void) sv_consume_if_c(&pfx, '_'); 211 212 if (!sv_consume_if_c(&pfx, 'Z') || !sv_consume_if_c(&pfx, 'N')) 213 return (B_FALSE); 214 215 /* Update svp with new position */ 216 sv_init_sv(svp, &pfx); 217 return (B_TRUE); 218 } 219 220 static boolean_t 221 rustdem_parse_name_segment(rustdem_state_t *st, strview_t *svp, boolean_t first) 222 { 223 strview_t sv; 224 strview_t name; 225 uint64_t len; 226 size_t rem; 227 boolean_t last = B_FALSE; 228 229 if (st->rds_error != 0 || sv_remaining(svp) == 0) 230 return (B_FALSE); 231 232 sv_init_sv(&sv, svp); 233 234 if (!rustdem_parse_num(st, &sv, &len)) { 235 DEMDEBUG("ERROR: no leading length"); 236 st->rds_error = EINVAL; 237 return (B_FALSE); 238 } 239 240 rem = sv_remaining(&sv); 241 242 if (rem < len || len > SIZE_MAX) { 243 st->rds_error = EINVAL; 244 return (B_FALSE); 245 } 246 247 /* Is this the last segment before the terminating E? */ 248 if (rem == len + 1) { 249 VERIFY3U(sv_peek(&sv, -1), ==, 'E'); 250 last = B_TRUE; 251 } 252 253 if (!first && !rustdem_add_sep(st)) 254 return (B_FALSE); 255 256 /* Reduce length of seg to the length we parsed */ 257 (void) sv_init_sv_range(&name, &sv, len); 258 259 DEMDEBUG("%s: segment='%.*s'", __func__, SV_PRINT(&name)); 260 261 /* 262 * A rust hash starts with 'h', and is the last component of a name 263 * before the terminating 'E' 264 */ 265 if (sv_peek(&name, 0) == 'h' && last) { 266 if (!rustdem_parse_hash(st, &name)) 267 return (B_FALSE); 268 goto done; 269 } 270 271 while (sv_remaining(&name) > 0) { 272 switch (sv_peek(&name, 0)) { 273 case '$': 274 if (rustdem_parse_special(st, &name)) 275 continue; 276 break; 277 case '_': 278 if (sv_peek(&name, 1) == '$') { 279 /* 280 * Only consume/ignore '_'. Leave 281 * $ for next round. 282 */ 283 sv_consume_n(&name, 1); 284 continue; 285 } 286 break; 287 case '.': 288 /* Convert '..' to '::' */ 289 if (sv_peek(&name, 1) != '.') 290 break; 291 292 if (!rustdem_add_sep(st)) 293 return (B_FALSE); 294 295 sv_consume_n(&name, 2); 296 continue; 297 default: 298 break; 299 } 300 301 if (custr_appendc(st->rds_demangled, 302 sv_consume_c(&name)) != 0) { 303 st->rds_error = ENOMEM; 304 return (B_FALSE); 305 } 306 } 307 308 done: 309 DEMDEBUG("%s: consumed '%.*s'", __func__, (int)len, svp->sv_first); 310 sv_consume_n(&sv, len); 311 sv_init_sv(svp, &sv); 312 return (B_TRUE); 313 } 314 315 static boolean_t 316 rustdem_parse_name(rustdem_state_t *st, strview_t *svp) 317 { 318 strview_t name; 319 boolean_t first = B_TRUE; 320 321 if (st->rds_error != 0) 322 return (B_FALSE); 323 324 sv_init_sv(&name, svp); 325 326 if (sv_remaining(&name) == 0) 327 return (B_FALSE); 328 329 while (sv_remaining(&name) > 0 && sv_peek(&name, 0) != 'E') { 330 if (!rustdem_parse_name_segment(st, &name, first)) 331 return (B_FALSE); 332 first = B_FALSE; 333 } 334 335 sv_init_sv(svp, &name); 336 return (B_TRUE); 337 } 338 339 static boolean_t 340 rustdem_parse_hash(rustdem_state_t *st, strview_t *svp) 341 { 342 strview_t sv; 343 344 sv_init_sv(&sv, svp); 345 346 VERIFY(sv_consume_if_c(&sv, 'h')); 347 if (!rustdem_append_c(st, 'h')) 348 return (B_FALSE); 349 350 while (sv_remaining(&sv) > 0) { 351 char c = sv_consume_c(&sv); 352 353 switch (c) { 354 /* 355 * The upper-case hex digits (A-F) are excluded as valid 356 * hash values for several reasons: 357 * 358 * 1. It would result in two different possible names for 359 * the same function, leading to ambiguity in linking (among 360 * other things). 361 * 362 * 2. It would cause potential ambiguity in parsing -- is a 363 * trailing 'E' part of the hash, or the terminating character 364 * in the mangled name? 365 * 366 * 3. No examples were able to be found in the wild where 367 * uppercase digits are used, and other rust demanglers all 368 * seem to assume the hash must contain lower-case hex digits. 369 */ 370 case '0': case '1': case '2': case '3': 371 case '4': case '5': case '6': case '7': 372 case '8': case '9': case 'a': case 'b': 373 case 'c': case 'd': case 'e': case 'f': 374 if (!rustdem_append_c(st, c)) 375 return (B_FALSE); 376 break; 377 default: 378 return (B_FALSE); 379 } 380 } 381 382 sv_init_sv(svp, &sv); 383 return (B_TRUE); 384 } 385 386 /* 387 * A 10 digit value would imply a name 1Gb or larger in size. It seems 388 * unlikely to the point of absurdity any such value could every possibly 389 * be valid (or even have compiled properly). This also prevents the 390 * uint64_t conversion from possibly overflowing since the value must always 391 * be below 10 * UINT32_MAX. 392 */ 393 #define MAX_DIGITS 10 394 395 static boolean_t 396 rustdem_parse_num(rustdem_state_t *restrict st, strview_t *restrict svp, 397 uint64_t *restrict valp) 398 { 399 strview_t snum; 400 uint64_t v = 0; 401 size_t ndigits = 0; 402 char c; 403 404 if (st->rds_error != 0) 405 return (B_FALSE); 406 407 sv_init_sv(&snum, svp); 408 409 DEMDEBUG("%s: str='%.*s'", __func__, SV_PRINT(&snum)); 410 411 c = sv_peek(&snum, 0); 412 if (!ISDIGIT(c)) { 413 DEMDEBUG("%s: ERROR no digits in str\n", __func__); 414 st->rds_error = EINVAL; 415 return (B_FALSE); 416 } 417 418 /* 419 * Since there is currently no official specification on rust name 420 * mangling, only that it has been stated that rust follows what 421 * C++ mangling does. In the Itanium C++ ABI (what practically 422 * every non-Windows C++ implementation uses these days), it 423 * explicitly disallows leading 0s in numeric values (except for 424 * substition and template indexes, which aren't relevant here). 425 * We enforce the same restriction -- if a rust implementation allowed 426 * leading zeros in numbers (basically segment lengths) it'd 427 * cause all sorts of ambiguity problems with names that likely lead 428 * to much bigger problems with linking and such, so this seems 429 * reasonable. 430 */ 431 if (c == '0') { 432 DEMDEBUG("%s: ERROR number starts with leading 0\n", __func__); 433 st->rds_error = EINVAL; 434 return (B_FALSE); 435 } 436 437 while (sv_remaining(&snum) > 0 && ndigits <= MAX_DIGITS) { 438 c = sv_consume_c(&snum); 439 440 if (!ISDIGIT(c)) 441 break; 442 443 v *= 10; 444 v += c - '0'; 445 ndigits++; 446 } 447 448 if (ndigits > MAX_DIGITS) { 449 DEMDEBUG("%s: value %llu is too large\n", __func__, v); 450 st->rds_error = ERANGE; 451 return (B_FALSE); 452 } 453 454 DEMDEBUG("%s: num=%llu", __func__, v); 455 456 *valp = v; 457 sv_consume_n(svp, ndigits); 458 return (B_TRUE); 459 } 460 461 static boolean_t 462 rustdem_parse_special(rustdem_state_t *restrict st, strview_t *restrict svp) 463 { 464 if (st->rds_error != 0) 465 return (B_FALSE); 466 467 if (sv_peek(svp, 0) != '$') 468 return (B_FALSE); 469 470 for (size_t i = 0; i < rust_charmap_sz; i++) { 471 if (sv_consume_if(svp, rust_charmap[i].ruc_seq)) { 472 if (!rustdem_append_c(st, rust_charmap[i].ruc_ch)) 473 return (B_FALSE); 474 return (B_TRUE); 475 } 476 } 477 return (B_FALSE); 478 } 479 480 static boolean_t 481 rustdem_add_sep(rustdem_state_t *st) 482 { 483 if (st->rds_error != 0) 484 return (B_FALSE); 485 486 if (!rustdem_append_c(st, ':') || 487 !rustdem_append_c(st, ':')) 488 return (B_FALSE); 489 490 return (B_TRUE); 491 } 492 493 static boolean_t 494 rustdem_append_c(rustdem_state_t *st, char c) 495 { 496 if (st->rds_error != 0) 497 return (B_FALSE); 498 499 if (custr_appendc(st->rds_demangled, c) == 0) 500 return (B_TRUE); 501 502 st->rds_error = errno; 503 return (B_FALSE); 504 } 505 506 static boolean_t 507 rustdem_all_ascii(const strview_t *svp) 508 { 509 strview_t p; 510 511 sv_init_sv(&p, svp); 512 513 while (sv_remaining(&p) > 0) { 514 char c = sv_consume_c(&p); 515 516 /* 517 * #including <sys/ctype.h> conflicts with <ctype.h>. Since 518 * we want the C locale macros (ISDIGIT, etc), it also means 519 * we can't use isascii(3C). 520 */ 521 if ((c & 0x80) != 0) { 522 DEMDEBUG("%s: found non-ascii character 0x%02hhx at " 523 "offset %tu", __func__, c, 524 (ptrdiff_t)(p.sv_first - svp->sv_first)); 525 return (B_FALSE); 526 } 527 } 528 return (B_TRUE); 529 } 530 531 static void * 532 rustdem_alloc(custr_alloc_t *cao, size_t len) 533 { 534 rustdem_state_t *st = cao->cua_arg; 535 return (zalloc(st->rds_ops, len)); 536 } 537 538 static void 539 rustdem_free(custr_alloc_t *cao, void *p, size_t len) 540 { 541 rustdem_state_t *st = cao->cua_arg; 542 xfree(st->rds_ops, p, len); 543 } 544