1 /** 2 * D header file for POSIX. 3 * 4 * Copyright: Copyright Sean Kelly 2005 - 2009. 5 * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). 6 * Authors: Sean Kelly 7 * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition 8 */ 9 10 /* Copyright Sean Kelly 2005 - 2009. 11 * Distributed under the Boost Software License, Version 1.0. 12 * (See accompanying file LICENSE or copy at 13 * http://www.boost.org/LICENSE_1_0.txt) 14 */ 15 module core.sys.posix.setjmp; 16 17 import core.sys.posix.config; 18 import core.sys.posix.signal; // for sigset_t 19 20 version (Posix): 21 extern (C) nothrow @nogc: 22 23 version (RISCV32) version = RISCV_Any; 24 version (RISCV64) version = RISCV_Any; 25 version (PPC) version = PPC_Any; 26 version (PPC64) version = PPC_Any; 27 28 // 29 // Required 30 // 31 /* 32 jmp_buf 33 34 int setjmp(ref jmp_buf); 35 void longjmp(ref jmp_buf, int); 36 */ 37 38 version (CRuntime_Glibc) 39 { 40 version (X86_64) 41 { 42 //enum JB_BX = 0; 43 //enum JB_BP = 1; 44 //enum JB_12 = 2; 45 //enum JB_13 = 3; 46 //enum JB_14 = 4; 47 //enum JB_15 = 5; 48 //enum JB_SP = 6; 49 //enum JB_PC = 7; 50 //enum JB_SIZE = 64; 51 52 alias long[8] __jmp_buf; 53 } 54 else version (X86) 55 { 56 //enum JB_BX = 0; 57 //enum JB_SI = 1; 58 //enum JB_DI = 2; 59 //enum JB_BP = 3; 60 //enum JB_SP = 4; 61 //enum JB_PC = 5; 62 //enum JB_SIZE = 24; 63 64 alias int[6] __jmp_buf; 65 } 66 else version (SPARC) 67 { 68 alias int[3] __jmp_buf; 69 } 70 else version (SPARC64) 71 { 72 alias __jmp_buf = ulong[22]; 73 } 74 else version (AArch64) 75 { 76 alias long[22] __jmp_buf; 77 } 78 else version (ARM) 79 { 80 alias int[64] __jmp_buf; 81 } 82 else version (HPPA) 83 { 84 struct __jmp_buf 85 { 86 int __r3; 87 int[15] __r4_r18; 88 int __r19; 89 int __r27; 90 int __sp; 91 int __rp; 92 int __pad1; 93 double[10] __fr12_fr21; 94 } 95 } 96 else version (PPC) 97 { 98 alias int[64 + (12*4)] __jmp_buf; 99 } 100 else version (PPC64) 101 { 102 alias long[64] __jmp_buf; 103 } 104 else version (MIPS32) 105 { 106 struct __jmp_buf 107 { 108 version (MIPS_O32) 109 { 110 void * __pc; 111 void * __sp; 112 int[8] __regs; 113 void * __fp; 114 void * __gp; 115 } 116 else 117 { 118 long __pc; 119 long __sp; 120 long[8] __regs; 121 long __fp; 122 long __gp; 123 } 124 int __fpc_csr; 125 version (MIPS_N64) 126 double[8] __fpregs; 127 else 128 double[6] __fpregs; 129 } 130 } 131 else version (MIPS64) 132 { 133 struct __jmp_buf 134 { 135 long __pc; 136 long __sp; 137 long[8] __regs; 138 long __fp; 139 long __gp; 140 int __fpc_csr; 141 version (MIPS_N64) 142 double[8] __fpregs; 143 else 144 double[6] __fpregs; 145 } 146 } 147 else version (RISCV_Any) 148 { 149 struct __riscv_jmp_buf 150 { 151 c_long __pc; 152 c_long[12] __regs; 153 c_long __sp; 154 static if (__traits(getTargetInfo, "floatAbi") == "double") 155 double[12] __fpregs; 156 } 157 alias __jmp_buf = __riscv_jmp_buf[1]; 158 } 159 else version (S390) 160 { 161 struct __s390_jmp_buf 162 { 163 c_long[10] __gregs; 164 c_long[4] __fpregs; 165 } 166 alias __jmp_buf = __s390_jmp_buf[1]; 167 } 168 else version (SystemZ) 169 { 170 struct __s390_jmp_buf 171 { 172 c_long[10] __gregs; 173 c_long[8] __fpregs; 174 } 175 alias __jmp_buf = __s390_jmp_buf[1]; 176 } 177 else version (LoongArch64) 178 { 179 struct __loongarch_jmp_buf 180 { 181 long __pc; 182 long __sp; 183 // reserved 184 long __r21; 185 long __fp; 186 long[9] __regs; 187 static if (__traits(getTargetInfo, "floatAbi") != "soft_float") 188 double[8] __fpregs; 189 } 190 alias __jmp_buf = __loongarch_jmp_buf[1]; 191 } 192 else 193 static assert(0, "unimplemented"); 194 195 struct __jmp_buf_tag 196 { 197 __jmp_buf __jmpbuf; 198 int __mask_was_saved; 199 sigset_t __saved_mask; 200 } 201 202 alias __jmp_buf_tag[1] jmp_buf; 203 204 alias _setjmp setjmp; // see XOpen block 205 void longjmp(ref jmp_buf, int); 206 } 207 else version (FreeBSD) 208 { 209 // <machine/setjmp.h> 210 version (X86) 211 { 212 enum _JBLEN = 11; 213 struct _jmp_buf { int[_JBLEN + 1] _jb; } 214 } 215 else version (X86_64) 216 { 217 enum _JBLEN = 12; 218 struct _jmp_buf { c_long[_JBLEN] _jb; } 219 } 220 else version (SPARC) 221 { 222 enum _JBLEN = 5; 223 struct _jmp_buf { c_long[_JBLEN + 1] _jb; } 224 } 225 else version (AArch64) 226 { 227 enum _JBLEN = 31; 228 // __int128_t 229 struct _jmp_buf { long[2][_JBLEN + 1] _jb; } 230 } 231 else version (PPC_Any) 232 { 233 enum _JBLEN = 100; 234 struct _jmp_buf { long[_JBLEN + 1] _jb; } 235 } 236 else 237 static assert(0); 238 alias _jmp_buf[1] jmp_buf; 239 240 int setjmp(ref jmp_buf); 241 void longjmp(ref jmp_buf, int); 242 } 243 else version (NetBSD) 244 { 245 // <machine/setjmp.h> 246 version (X86) 247 { 248 enum _JBLEN = 13; 249 struct _jmp_buf { int[_JBLEN + 1] _jb; } 250 } 251 else version (X86_64) 252 { 253 enum _JBLEN = 11; 254 struct _jmp_buf { c_long[_JBLEN] _jb; } 255 } 256 else 257 static assert(0); 258 alias _jmp_buf[_JBLEN] jmp_buf; 259 260 int setjmp(ref jmp_buf); 261 void longjmp(ref jmp_buf, int); 262 } 263 else version (OpenBSD) 264 { 265 // <machine/setjmp.h> 266 version (X86) 267 { 268 enum _JBLEN = 10; 269 } 270 else version (X86_64) 271 { 272 enum _JBLEN = 11; 273 } 274 else version (ARM) 275 { 276 enum _JBLEN = 64; 277 } 278 else version (AArch64) 279 { 280 enum _JBLEN = 64; 281 } 282 else version (PPC) 283 { 284 enum _JBLEN = 100; 285 } 286 else version (MIPS64) 287 { 288 enum _JBLEN = 83; 289 } 290 else version (SPARC) 291 { 292 enum _JBLEN = 10; 293 } 294 else version (SPARC64) 295 { 296 enum _JBLEN = 14; 297 } 298 else 299 static assert(0); 300 301 alias jmp_buf = c_long[_JBLEN]; 302 303 int setjmp(ref jmp_buf); 304 void longjmp(ref jmp_buf, int); 305 } 306 else version (DragonFlyBSD) 307 { 308 // <machine/setjmp.h> 309 version (X86_64) 310 { 311 enum _JBLEN = 12; 312 struct _jmp_buf { c_long[_JBLEN] _jb; } 313 } 314 else 315 static assert(0); 316 alias _jmp_buf[1] jmp_buf; 317 318 int setjmp(ref jmp_buf); 319 void longjmp(ref jmp_buf, int); 320 } 321 else version (CRuntime_Bionic) 322 { 323 // <machine/setjmp.h> 324 version (X86) 325 { 326 enum _JBLEN = 10; 327 } 328 else version (ARM) 329 { 330 enum _JBLEN = 64; 331 } 332 else version (AArch64) 333 { 334 enum _JBLEN = 32; 335 } 336 else version (X86_64) 337 { 338 enum _JBLEN = 11; 339 } 340 else 341 { 342 static assert(false, "Architecture not supported."); 343 } 344 345 alias c_long[_JBLEN] jmp_buf; 346 347 int setjmp(ref jmp_buf); 348 void longjmp(ref jmp_buf, int); 349 } 350 else version (CRuntime_UClibc) 351 { 352 version (X86_64) 353 { 354 alias long[8] __jmp_buf; 355 } 356 else version (ARM) 357 { 358 align(8) alias int[64] __jmp_buf; 359 } 360 else version (MIPS32) 361 { 362 struct __jmp_buf 363 { 364 version (MIPS_O32) 365 { 366 void * __pc; 367 void * __sp; 368 int[8] __regs; 369 void * __fp; 370 void * __gp; 371 } 372 else 373 { 374 long __pc; 375 long __sp; 376 long[8] __regs; 377 long __fp; 378 long __gp; 379 } 380 int __fpc_csr; 381 version (MIPS_N64) 382 double[8] __fpregs; 383 else 384 double[6] __fpregs; 385 } 386 } 387 else version (MIPS64) 388 { 389 struct __jmp_buf 390 { 391 long __pc; 392 long __sp; 393 long[8] __regs; 394 long __fp; 395 long __gp; 396 int __fpc_csr; 397 version (MIPS_N64) 398 double[8] __fpregs; 399 else 400 double[6] __fpregs; 401 } 402 } 403 else 404 static assert(0, "unimplemented"); 405 406 struct __jmp_buf_tag 407 { 408 __jmp_buf __jmpbuf; 409 int __mask_was_saved; 410 sigset_t __saved_mask; 411 } 412 413 alias __jmp_buf_tag[1] jmp_buf; 414 415 alias _setjmp setjmp; 416 void longjmp(ref jmp_buf, int); 417 } 418 419 // 420 // C Extension (CX) 421 // 422 /* 423 sigjmp_buf 424 425 int sigsetjmp(sigjmp_buf, int); 426 void siglongjmp(sigjmp_buf, int); 427 */ 428 429 version (CRuntime_Glibc) 430 { 431 alias jmp_buf sigjmp_buf; 432 433 int __sigsetjmp(sigjmp_buf, int); 434 alias __sigsetjmp sigsetjmp; 435 void siglongjmp(sigjmp_buf, int); 436 } 437 else version (FreeBSD) 438 { 439 // <machine/setjmp.h> 440 version (X86) 441 { 442 struct _sigjmp_buf { int[_JBLEN + 1] _ssjb; } 443 } 444 else version (X86_64) 445 { 446 struct _sigjmp_buf { c_long[_JBLEN] _sjb; } 447 } 448 else version (SPARC) 449 { 450 enum _JBLEN = 5; 451 enum _JB_FP = 0; 452 enum _JB_PC = 1; 453 enum _JB_SP = 2; 454 enum _JB_SIGMASK = 3; 455 enum _JB_SIGFLAG = 5; 456 struct _sigjmp_buf { c_long[_JBLEN + 1] _sjb; } 457 } 458 else version (AArch64) 459 { 460 // __int128_t 461 struct _sigjmp_buf { long[2][_JBLEN + 1] _jb; } 462 } 463 else version (PPC_Any) 464 { 465 struct _sigjmp_buf { long[_JBLEN + 1] _sjb; } 466 } 467 else 468 static assert(0); 469 alias _sigjmp_buf[1] sigjmp_buf; 470 471 int sigsetjmp(ref sigjmp_buf); 472 void siglongjmp(ref sigjmp_buf, int); 473 } 474 else version (NetBSD) 475 { 476 // <machine/setjmp.h> 477 version (X86) 478 { 479 struct _sigjmp_buf { int[_JBLEN + 1] _ssjb; } 480 } 481 else version (X86_64) 482 { 483 struct _sigjmp_buf { c_long[_JBLEN] _sjb; } 484 } 485 else 486 static assert(0); 487 alias _sigjmp_buf[_JBLEN + 1] sigjmp_buf; 488 489 int sigsetjmp(ref sigjmp_buf); 490 void siglongjmp(ref sigjmp_buf, int); 491 } 492 else version (OpenBSD) 493 { 494 alias sigjmp_buf = c_long[_JBLEN + 1]; 495 496 int sigsetjmp(ref sigjmp_buf); 497 void siglongjmp(ref sigjmp_buf, int); 498 } 499 else version (DragonFlyBSD) 500 { 501 // <machine/setjmp.h> 502 version (X86_64) 503 { 504 struct _sigjmp_buf { c_long[_JBLEN] _sjb; } 505 } 506 else 507 static assert(0); 508 alias _sigjmp_buf[1] sigjmp_buf; 509 510 int sigsetjmp(ref sigjmp_buf); 511 void siglongjmp(ref sigjmp_buf, int); 512 } 513 else version (CRuntime_Bionic) 514 { 515 alias c_long[_JBLEN + 1] sigjmp_buf; 516 517 int sigsetjmp(ref sigjmp_buf, int); 518 void siglongjmp(ref sigjmp_buf, int); 519 } 520 else version (CRuntime_UClibc) 521 { 522 alias jmp_buf sigjmp_buf; 523 524 int __sigsetjmp(ref sigjmp_buf, int); 525 alias __sigsetjmp sigsetjmp; 526 void siglongjmp(ref sigjmp_buf, int); 527 } 528 529 // 530 // XOpen (XSI) 531 // 532 /* 533 int _setjmp(jmp_buf); 534 void _longjmp(jmp_buf, int); 535 */ 536 537 version (CRuntime_Glibc) 538 { 539 int _setjmp(ref jmp_buf); 540 void _longjmp(ref jmp_buf, int); 541 } 542 else version (FreeBSD) 543 { 544 int _setjmp(ref jmp_buf); 545 void _longjmp(ref jmp_buf, int); 546 } 547 else version (NetBSD) 548 { 549 int _setjmp(ref jmp_buf); 550 void _longjmp(ref jmp_buf, int); 551 } 552 else version (OpenBSD) 553 { 554 int _setjmp(ref jmp_buf); 555 void _longjmp(ref jmp_buf, int); 556 } 557 else version (DragonFlyBSD) 558 { 559 int _setjmp(ref jmp_buf); 560 void _longjmp(ref jmp_buf, int); 561 } 562 else version (CRuntime_Bionic) 563 { 564 int _setjmp(ref jmp_buf); 565 void _longjmp(ref jmp_buf, int); 566 } 567 else version (CRuntime_UClibc) 568 { 569 int _setjmp(ref jmp_buf); 570 void _longjmp(ref jmp_buf, int); 571 }