API tools faq
paste
Guest User

Untitled

a guest
Sep 21st, 2018
95
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 18.43 KB | None | 0 0
raw download clone embed print report
  1. diff --git a/libphobos/libdruntime/core/runtime.d b/libphobos/libdruntime/core/runtime.d
  2. index 42e09ac..cc426dd 100644
  3. --- a/libphobos/libdruntime/core/runtime.d
  4. +++ b/libphobos/libdruntime/core/runtime.d
  5. @@ -42,11 +42,14 @@ private
  6.  
  7. version(GNU)
  8. {
  9. - import gcc.unwind;
  10. - import core.demangle;
  11. - import core.stdc.stdio : snprintf, printf;
  12. - import core.stdc.string : strlen;
  13. - import core.sys.posix.signal; // segv handler
  14. + version(Posix)
  15. + {
  16. + import gcc.unwind;
  17. + import core.demangle;
  18. + import core.stdc.stdio : snprintf, printf;
  19. + import core.stdc.string : strlen;
  20. + import core.sys.posix.signal; // segv handler
  21. + }
  22. }
  23.  
  24. version(Android)
  25. @@ -363,60 +366,63 @@ extern (C) bool runModuleUnitTests()
  26. }
  27. else version(GNU)
  28. {
  29. - /*
  30. - * core.demangle may allocate, so no demangling here
  31. - *
  32. - * FIXME: At least on ARM this prints only the signal handler's
  33. - * stack. This is of course useless..
  34. - */
  35. - static extern (C) void unittestSegvHandler( int signum, siginfo_t* info, void* ptr )
  36. + version(Posix)
  37. {
  38. - gdcBacktraceData stackframe = gdcBacktrace();
  39. - btSymbolData syms = gdcBacktraceSymbols(stackframe);
  40. -
  41. - for(size_t i = 0; i < syms.entries; i++)
  42. + /*
  43. + * core.demangle may allocate, so no demangling here
  44. + *
  45. + * FIXME: At least on ARM this prints only the signal handler's
  46. + * stack. This is of course useless..
  47. + */
  48. + static extern (C) void unittestSegvHandler( int signum, siginfo_t* info, void* ptr )
  49. {
  50. - auto sym = syms.symbols[i];
  51. - if(sym.fileName)
  52. - {
  53. - if(sym.name)
  54. - {
  55. - printf("%s(%s+%#x) [%p]\n", sym.fileName, sym.name,
  56. - sym.offset, sym.address);
  57. - }
  58. - else
  59. - {
  60. - printf("%s() [%p]\n", sym.fileName, sym.address);
  61. - }
  62. - }
  63. - else
  64. + gdcBacktraceData stackframe = gdcBacktrace();
  65. + btSymbolData syms = gdcBacktraceSymbols(stackframe);
  66. +
  67. + for(size_t i = 0; i < syms.entries; i++)
  68. {
  69. - if(sym.name)
  70. + auto sym = syms.symbols[i];
  71. + if(sym.fileName)
  72. {
  73. - printf("(%s+%#x) [%p]\n", sym.name, sym.offset, sym.address);
  74. + if(sym.name)
  75. + {
  76. + printf("%s(%s+%#x) [%p]\n", sym.fileName, sym.name,
  77. + sym.offset, sym.address);
  78. + }
  79. + else
  80. + {
  81. + printf("%s() [%p]\n", sym.fileName, sym.address);
  82. + }
  83. }
  84. else
  85. {
  86. - printf("() [%p]\n", sym.address);
  87. + if(sym.name)
  88. + {
  89. + printf("(%s+%#x) [%p]\n", sym.name, sym.offset, sym.address);
  90. + }
  91. + else
  92. + {
  93. + printf("() [%p]\n", sym.address);
  94. + }
  95. }
  96. }
  97. }
  98. - }
  99. -
  100. - sigaction_t action = void;
  101. - sigaction_t oldseg = void;
  102. - sigaction_t oldbus = void;
  103. -
  104. - (cast(byte*) &action)[0 .. action.sizeof] = 0;
  105. - sigfillset( &action.sa_mask ); // block other signals
  106. - action.sa_flags = SA_SIGINFO | SA_RESETHAND;
  107. - action.sa_sigaction = &unittestSegvHandler;
  108. - sigaction( SIGSEGV, &action, &oldseg );
  109. - sigaction( SIGBUS, &action, &oldbus );
  110. - scope( exit )
  111. - {
  112. - sigaction( SIGSEGV, &oldseg, null );
  113. - sigaction( SIGBUS, &oldbus, null );
  114. +
  115. + sigaction_t action = void;
  116. + sigaction_t oldseg = void;
  117. + sigaction_t oldbus = void;
  118. +
  119. + (cast(byte*) &action)[0 .. action.sizeof] = 0;
  120. + sigfillset( &action.sa_mask ); // block other signals
  121. + action.sa_flags = SA_SIGINFO | SA_RESETHAND;
  122. + action.sa_sigaction = &unittestSegvHandler;
  123. + sigaction( SIGSEGV, &action, &oldseg );
  124. + sigaction( SIGBUS, &action, &oldbus );
  125. + scope( exit )
  126. + {
  127. + sigaction( SIGSEGV, &oldseg, null );
  128. + sigaction( SIGBUS, &oldbus, null );
  129. + }
  130. }
  131. }
  132.  
  133. @@ -650,131 +656,138 @@ Throwable.TraceInfo defaultTraceHandler( void* ptr = null )
  134. }
  135. else version(GNU)
  136. {
  137. - class DefaultTraceInfo : Throwable.TraceInfo
  138. + version(Posix)
  139. {
  140. - this()
  141. + class DefaultTraceInfo : Throwable.TraceInfo
  142. {
  143. - callstack = gdcBacktrace();
  144. - framelist = gdcBacktraceSymbols(callstack);
  145. - }
  146. -
  147. - override int opApply( scope int delegate(ref char[]) dg )
  148. - {
  149. - return opApply( (ref size_t, ref char[] buf)
  150. - {
  151. - return dg( buf );
  152. - } );
  153. - }
  154. -
  155. - override int opApply( scope int delegate(ref size_t, ref char[]) dg )
  156. - {
  157. - version( Posix )
  158. + this()
  159. {
  160. - // NOTE: The first 5 frames with the current implementation are
  161. - // inside core.runtime and the object code, so eliminate
  162. - // these for readability. The alternative would be to
  163. - // exclude the first N frames that are in a list of
  164. - // mangled function names.
  165. - static enum FIRSTFRAME = 5;
  166. + callstack = gdcBacktrace();
  167. + framelist = gdcBacktraceSymbols(callstack);
  168. }
  169. - else
  170. - {
  171. - // NOTE: On Windows, the number of frames to exclude is based on
  172. - // whether the exception is user or system-generated, so
  173. - // it may be necessary to exclude a list of function names
  174. - // instead.
  175. - static enum FIRSTFRAME = 0;
  176. - }
  177. - int ret = 0;
  178. -
  179. - for( int i = FIRSTFRAME; i < framelist.entries; ++i )
  180. +
  181. + override int opApply( scope int delegate(ref char[]) dg )
  182. {
  183. - auto pos = cast(size_t)(i - FIRSTFRAME);
  184. - auto buf = formatLine(framelist.symbols[i]);
  185. - ret = dg( pos, buf );
  186. - if( ret )
  187. - break;
  188. + return opApply( (ref size_t, ref char[] buf)
  189. + {
  190. + return dg( buf );
  191. + } );
  192. }
  193. - return ret;
  194. - }
  195. -
  196. - override string toString()
  197. - {
  198. - string buf;
  199. - foreach( i, line; this )
  200. - buf ~= i ? "\n" ~ line : line;
  201. - return buf;
  202. - }
  203. -
  204. - private:
  205. - btSymbolData framelist;
  206. - gdcBacktraceData callstack;
  207. -
  208. - private:
  209. - char[4096] fixbuf;
  210. -
  211. - /*Do not put \n at end of line!*/
  212. - char[] formatLine(backtraceSymbol sym)
  213. - {
  214. - int ret;
  215. -
  216. - if(sym.fileName)
  217. +
  218. + override int opApply( scope int delegate(ref size_t, ref char[]) dg )
  219. {
  220. - if(sym.name)
  221. + version( Posix )
  222. {
  223. - ret = snprintf(fixbuf.ptr, fixbuf.sizeof,
  224. - "%s(", sym.fileName);
  225. - if(ret >= fixbuf.sizeof)
  226. - return fixbuf[];
  227. -
  228. - auto demangled = demangle(sym.name[0 .. strlen(sym.name)],
  229. - fixbuf[ret .. $]);
  230. -
  231. - ret += demangled.length;
  232. - if(ret >= fixbuf.sizeof)
  233. - return fixbuf[];
  234. -
  235. - ret += snprintf(fixbuf.ptr + ret, fixbuf.sizeof - ret,
  236. - "+%#x) [%p]", sym.offset, sym.address);
  237. + // NOTE: The first 5 frames with the current implementation are
  238. + // inside core.runtime and the object code, so eliminate
  239. + // these for readability. The alternative would be to
  240. + // exclude the first N frames that are in a list of
  241. + // mangled function names.
  242. + static enum FIRSTFRAME = 5;
  243. }
  244. else
  245. {
  246. - ret = snprintf(fixbuf.ptr, fixbuf.sizeof,
  247. - "%s() [%p]", sym.fileName, sym.address);
  248. + // NOTE: On Windows, the number of frames to exclude is based on
  249. + // whether the exception is user or system-generated, so
  250. + // it may be necessary to exclude a list of function names
  251. + // instead.
  252. + static enum FIRSTFRAME = 0;
  253. }
  254. + int ret = 0;
  255. +
  256. + for( int i = FIRSTFRAME; i < framelist.entries; ++i )
  257. + {
  258. + auto pos = cast(size_t)(i - FIRSTFRAME);
  259. + auto buf = formatLine(framelist.symbols[i]);
  260. + ret = dg( pos, buf );
  261. + if( ret )
  262. + break;
  263. + }
  264. + return ret;
  265. }
  266. - else
  267. +
  268. + override string toString()
  269. {
  270. - if(sym.name)
  271. + string buf;
  272. + foreach( i, line; this )
  273. + buf ~= i ? "\n" ~ line : line;
  274. + return buf;
  275. + }
  276. +
  277. + private:
  278. + btSymbolData framelist;
  279. + gdcBacktraceData callstack;
  280. +
  281. + private:
  282. + char[4096] fixbuf;
  283. +
  284. + /*Do not put \n at end of line!*/
  285. + char[] formatLine(backtraceSymbol sym)
  286. + {
  287. + int ret;
  288. +
  289. + if(sym.fileName)
  290. {
  291. - fixbuf[0] = '(';
  292. - ret = 1;
  293. -
  294. - auto demangled = demangle(sym.name[0 .. strlen(sym.name)],
  295. - fixbuf[ret .. $]);
  296. -
  297. - ret += demangled.length;
  298. - if(ret >= fixbuf.sizeof)
  299. - return fixbuf[];
  300. -
  301. - ret += snprintf(fixbuf.ptr + ret, fixbuf.sizeof - ret,
  302. - "+%#x) [%p]", sym.offset, sym.address);
  303. + if(sym.name)
  304. + {
  305. + ret = snprintf(fixbuf.ptr, fixbuf.sizeof,
  306. + "%s(", sym.fileName);
  307. + if(ret >= fixbuf.sizeof)
  308. + return fixbuf[];
  309. +
  310. + auto demangled = demangle(sym.name[0 .. strlen(sym.name)],
  311. + fixbuf[ret .. $]);
  312. +
  313. + ret += demangled.length;
  314. + if(ret >= fixbuf.sizeof)
  315. + return fixbuf[];
  316. +
  317. + ret += snprintf(fixbuf.ptr + ret, fixbuf.sizeof - ret,
  318. + "+%#x) [%p]", sym.offset, sym.address);
  319. + }
  320. + else
  321. + {
  322. + ret = snprintf(fixbuf.ptr, fixbuf.sizeof,
  323. + "%s() [%p]", sym.fileName, sym.address);
  324. + }
  325. }
  326. else
  327. {
  328. - ret = snprintf(fixbuf.ptr, fixbuf.sizeof, "() [%p]",
  329. - sym.address);
  330. + if(sym.name)
  331. + {
  332. + fixbuf[0] = '(';
  333. + ret = 1;
  334. +
  335. + auto demangled = demangle(sym.name[0 .. strlen(sym.name)],
  336. + fixbuf[ret .. $]);
  337. +
  338. + ret += demangled.length;
  339. + if(ret >= fixbuf.sizeof)
  340. + return fixbuf[];
  341. +
  342. + ret += snprintf(fixbuf.ptr + ret, fixbuf.sizeof - ret,
  343. + "+%#x) [%p]", sym.offset, sym.address);
  344. + }
  345. + else
  346. + {
  347. + ret = snprintf(fixbuf.ptr, fixbuf.sizeof, "() [%p]",
  348. + sym.address);
  349. + }
  350. }
  351. +
  352. + if(ret >= fixbuf.sizeof)
  353. + return fixbuf[];
  354. + else
  355. + return fixbuf[0 .. ret];
  356. }
  357. -
  358. - if(ret >= fixbuf.sizeof)
  359. - return fixbuf[];
  360. - else
  361. - return fixbuf[0 .. ret];
  362. }
  363. +
  364. + return new DefaultTraceInfo;
  365. + }
  366. + else
  367. + {
  368. + return null;
  369. }
  370. -
  371. - return new DefaultTraceInfo;
  372. }
  373. else
  374. {
  375. @@ -784,69 +797,77 @@ Throwable.TraceInfo defaultTraceHandler( void* ptr = null )
  376.  
  377. version(GNU)
  378. {
  379. - import gcc.unwind;
  380. -
  381. - static enum MAXFRAMES = 128;
  382. -
  383. - struct gdcBacktraceData
  384. - {
  385. - void*[MAXFRAMES] callstack;
  386. - int numframes = 0;
  387. - }
  388. -
  389. - struct backtraceSymbol
  390. - {
  391. - const(char)* name, fileName;
  392. - size_t offset;
  393. - void* address;
  394. - }
  395. -
  396. - struct btSymbolData
  397. + version(Posix)
  398. {
  399. - size_t entries;
  400. - backtraceSymbol[MAXFRAMES] symbols;
  401. - }
  402. + import gcc.unwind;
  403.  
  404. - static extern (C) _Unwind_Reason_Code unwindCB(_Unwind_Context *ctx, void *d)
  405. - {
  406. - gdcBacktraceData* bt = cast(gdcBacktraceData*)d;
  407. - if(bt.numframes >= MAXFRAMES)
  408. + static enum MAXFRAMES = 128;
  409. +
  410. + struct gdcBacktraceData
  411. + {
  412. + void*[MAXFRAMES] callstack;
  413. + int numframes = 0;
  414. + }
  415. +
  416. + struct backtraceSymbol
  417. + {
  418. + const(char)* name, fileName;
  419. + size_t offset;
  420. + void* address;
  421. + }
  422. +
  423. + struct btSymbolData
  424. + {
  425. + size_t entries;
  426. + backtraceSymbol[MAXFRAMES] symbols;
  427. + }
  428. +
  429. + static extern (C) _Unwind_Reason_Code unwindCB(_Unwind_Context *ctx, void *d)
  430. + {
  431. + gdcBacktraceData* bt = cast(gdcBacktraceData*)d;
  432. + if(bt.numframes >= MAXFRAMES)
  433. + return _URC_NO_REASON;
  434. +
  435. + bt.callstack[bt.numframes] = cast(void*)_Unwind_GetIP(ctx);
  436. + bt.numframes++;
  437. return _URC_NO_REASON;
  438. -
  439. - bt.callstack[bt.numframes] = cast(void*)_Unwind_GetIP(ctx);
  440. - bt.numframes++;
  441. - return _URC_NO_REASON;
  442. - }
  443. -
  444. - gdcBacktraceData gdcBacktrace()
  445. - {
  446. - gdcBacktraceData stackframe;
  447. - _Unwind_Backtrace(&unwindCB, &stackframe);
  448. - return stackframe;
  449. - }
  450. -
  451. - btSymbolData gdcBacktraceSymbols(gdcBacktraceData data)
  452. - {
  453. - btSymbolData symData;
  454. -
  455. - for(auto i = 0; i < data.numframes; i++)
  456. + }
  457. +
  458. + gdcBacktraceData gdcBacktrace()
  459. + {
  460. + gdcBacktraceData stackframe;
  461. + _Unwind_Backtrace(&unwindCB, &stackframe);
  462. + return stackframe;
  463. + }
  464. +
  465. + btSymbolData gdcBacktraceSymbols(gdcBacktraceData data)
  466. {
  467. - version(haveDLADDR)
  468. + btSymbolData symData;
  469. +
  470. + for(auto i = 0; i < data.numframes; i++)
  471. {
  472. - Dl_info funcInfo;
  473. -
  474. - if(data.callstack[i] !is null && dladdr(data.callstack[i], &funcInfo) != 0)
  475. + version(haveDLADDR)
  476. {
  477. - symData.symbols[symData.entries].name = funcInfo.dli_sname;
  478. - symData.symbols[symData.entries].fileName = funcInfo.dli_fname;
  479. -
  480. - if(funcInfo.dli_saddr is null)
  481. - symData.symbols[symData.entries].offset = 0;
  482. + Dl_info funcInfo;
  483. +
  484. + if(data.callstack[i] !is null && dladdr(data.callstack[i], &funcInfo) != 0)
  485. + {
  486. + symData.symbols[symData.entries].name = funcInfo.dli_sname;
  487. + symData.symbols[symData.entries].fileName = funcInfo.dli_fname;
  488. +
  489. + if(funcInfo.dli_saddr is null)
  490. + symData.symbols[symData.entries].offset = 0;
  491. + else
  492. + symData.symbols[symData.entries].offset = data.callstack[i] - funcInfo.dli_saddr;
  493. +
  494. + symData.symbols[symData.entries].address = data.callstack[i];
  495. + symData.entries++;
  496. + }
  497. else
  498. - symData.symbols[symData.entries].offset = data.callstack[i] - funcInfo.dli_saddr;
  499. -
  500. - symData.symbols[symData.entries].address = data.callstack[i];
  501. - symData.entries++;
  502. + {
  503. + symData.symbols[symData.entries].address = data.callstack[i];
  504. + symData.entries++;
  505. + }
  506. }
  507. else
  508. {
  509. @@ -854,13 +875,8 @@ version(GNU)
  510. symData.entries++;
  511. }
  512. }
  513. - else
  514. - {
  515. - symData.symbols[symData.entries].address = data.callstack[i];
  516. - symData.entries++;
  517. - }
  518. +
  519. + return symData;
  520. }
  521. -
  522. - return symData;
  523. }
  524. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!