1 2 /*--------------------------------------------------------------------*/ 3 /*--- Create/destroy signal delivery frames. ---*/ 4 /*--- sigframe-amd64-linux.c ---*/ 5 /*--------------------------------------------------------------------*/ 6 7 /* 8 This file is part of Valgrind, a dynamic binary instrumentation 9 framework. 10 11 Copyright (C) 2000-2015 Nicholas Nethercote 12 njn (at) valgrind.org 13 14 This program is free software; you can redistribute it and/or 15 modify it under the terms of the GNU General Public License as 16 published by the Free Software Foundation; either version 2 of the 17 License, or (at your option) any later version. 18 19 This program is distributed in the hope that it will be useful, but 20 WITHOUT ANY WARRANTY; without even the implied warranty of 21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 22 General Public License for more details. 23 24 You should have received a copy of the GNU General Public License 25 along with this program; if not, write to the Free Software 26 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 27 02111-1307, USA. 28 29 The GNU General Public License is contained in the file COPYING. 30 */ 31 32 #if defined(VGP_amd64_linux) 33 34 #include "pub_core_basics.h" 35 #include "pub_core_vki.h" 36 #include "pub_core_threadstate.h" 37 #include "pub_core_aspacemgr.h" 38 #include "pub_core_libcbase.h" 39 #include "pub_core_libcassert.h" 40 #include "pub_core_libcprint.h" 41 #include "pub_core_machine.h" 42 #include "pub_core_options.h" 43 #include "pub_core_signals.h" 44 #include "pub_core_tooliface.h" 45 #include "pub_core_trampoline.h" 46 #include "pub_core_sigframe.h" /* self */ 47 #include "priv_sigframe.h" 48 49 /* This module creates and removes signal frames for signal deliveries 50 on amd64-linux. 51 52 Note, this file contains kernel-specific knowledge in the form of 53 'struct rt_sigframe'. How does that relate to the vki kernel 54 interface stuff? 55 56 A 'struct rtsigframe' is pushed onto the client's stack. This 57 contains a subsidiary vki_ucontext. That holds the vcpu's state 58 across the signal, so that the sighandler can mess with the vcpu 59 state if it really wants. 60 61 FIXME: sigcontexting is basically broken for the moment. When 62 delivering a signal, the integer registers and %rflags are 63 correctly written into the sigcontext, however the FP and SSE state 64 is not. When returning from a signal, only the integer registers 65 are restored from the sigcontext; the rest of the CPU state is 66 restored to what it was before the signal. 67 68 This will be fixed. 69 */ 70 71 72 /*------------------------------------------------------------*/ 73 /*--- Signal frame layouts ---*/ 74 /*------------------------------------------------------------*/ 75 76 // A structure in which to save the application's registers 77 // during the execution of signal handlers. 78 79 // In theory, so long as we get the arguments to the handler function 80 // right, it doesn't matter what the exact layout of the rest of the 81 // frame is. Unfortunately, things like gcc's exception unwinding 82 // make assumptions about the locations of various parts of the frame, 83 // so we need to duplicate it exactly. 84 85 /* Valgrind-specific parts of the signal frame */ 86 struct vg_sigframe 87 { 88 /* Sanity check word. */ 89 UInt magicPI; 90 91 UInt handlerflags; /* flags for signal handler */ 92 93 94 /* Safely-saved version of sigNo, as described above. */ 95 Int sigNo_private; 96 97 /* XXX This is wrong. Surely we should store the shadow values 98 into the shadow memory behind the actual values? */ 99 VexGuestAMD64State vex_shadow1; 100 VexGuestAMD64State vex_shadow2; 101 102 /* HACK ALERT */ 103 VexGuestAMD64State vex; 104 /* end HACK ALERT */ 105 106 /* saved signal mask to be restored when handler returns */ 107 vki_sigset_t mask; 108 109 /* Sanity check word. Is the highest-addressed word; do not 110 move!*/ 111 UInt magicE; 112 }; 113 114 struct rt_sigframe 115 { 116 /* Sig handler's return address */ 117 Addr retaddr; 118 119 /* ucontext */ 120 struct vki_ucontext uContext; 121 122 /* siginfo */ 123 vki_siginfo_t sigInfo; 124 struct _vki_fpstate fpstate; 125 126 struct vg_sigframe vg; 127 }; 128 129 130 //:: /*------------------------------------------------------------*/ 131 //:: /*--- Signal operations ---*/ 132 //:: /*------------------------------------------------------------*/ 133 //:: 134 //:: /* 135 //:: Great gobs of FP state conversion taken wholesale from 136 //:: linux/arch/i386/kernel/i387.c 137 //:: */ 138 //:: 139 //:: /* 140 //:: * FXSR floating point environment conversions. 141 //:: */ 142 //:: #define X86_FXSR_MAGIC 0x0000 143 //:: 144 //:: /* 145 //:: * FPU tag word conversions. 146 //:: */ 147 //:: 148 //:: static inline unsigned short twd_i387_to_fxsr( unsigned short twd ) 149 //:: { 150 //:: unsigned int tmp; /* to avoid 16 bit prefixes in the code */ 151 //:: 152 //:: /* Transform each pair of bits into 01 (valid) or 00 (empty) */ 153 //:: tmp = ~twd; 154 //:: tmp = (tmp | (tmp>>1)) & 0x5555; /* 0V0V0V0V0V0V0V0V */ 155 //:: /* and move the valid bits to the lower byte. */ 156 //:: tmp = (tmp | (tmp >> 1)) & 0x3333; /* 00VV00VV00VV00VV */ 157 //:: tmp = (tmp | (tmp >> 2)) & 0x0f0f; /* 0000VVVV0000VVVV */ 158 //:: tmp = (tmp | (tmp >> 4)) & 0x00ff; /* 00000000VVVVVVVV */ 159 //:: return tmp; 160 //:: } 161 //:: 162 //:: static unsigned long twd_fxsr_to_i387( const struct i387_fxsave_struct *fxsave ) 163 //:: { 164 //:: struct _vki_fpxreg *st = NULL; 165 //:: unsigned long twd = (unsigned long) fxsave->twd; 166 //:: unsigned long tag; 167 //:: unsigned long ret = 0xffff0000u; 168 //:: int i; 169 //:: 170 //:: #define FPREG_ADDR(f, n) ((char *)&(f)->st_space + (n) * 16); 171 //:: 172 //:: for ( i = 0 ; i < 8 ; i++ ) { 173 //:: if ( twd & 0x1 ) { 174 //:: st = (struct _vki_fpxreg *) FPREG_ADDR( fxsave, i ); 175 //:: 176 //:: switch ( st->exponent & 0x7fff ) { 177 //:: case 0x7fff: 178 //:: tag = 2; /* Special */ 179 //:: break; 180 //:: case 0x0000: 181 //:: if ( !st->significand[0] && 182 //:: !st->significand[1] && 183 //:: !st->significand[2] && 184 //:: !st->significand[3] ) { 185 //:: tag = 1; /* Zero */ 186 //:: } else { 187 //:: tag = 2; /* Special */ 188 //:: } 189 //:: break; 190 //:: default: 191 //:: if ( st->significand[3] & 0x8000 ) { 192 //:: tag = 0; /* Valid */ 193 //:: } else { 194 //:: tag = 2; /* Special */ 195 //:: } 196 //:: break; 197 //:: } 198 //:: } else { 199 //:: tag = 3; /* Empty */ 200 //:: } 201 //:: ret |= (tag << (2 * i)); 202 //:: twd = twd >> 1; 203 //:: } 204 //:: return ret; 205 //:: } 206 //:: 207 //:: static void convert_fxsr_to_user( struct _vki_fpstate *buf, 208 //:: const struct i387_fxsave_struct *fxsave ) 209 //:: { 210 //:: unsigned long env[7]; 211 //:: struct _vki_fpreg *to; 212 //:: struct _vki_fpxreg *from; 213 //:: int i; 214 //:: 215 //:: env[0] = (unsigned long)fxsave->cwd | 0xffff0000ul; 216 //:: env[1] = (unsigned long)fxsave->swd | 0xffff0000ul; 217 //:: env[2] = twd_fxsr_to_i387(fxsave); 218 //:: env[3] = fxsave->fip; 219 //:: env[4] = fxsave->fcs | ((unsigned long)fxsave->fop << 16); 220 //:: env[5] = fxsave->foo; 221 //:: env[6] = fxsave->fos; 222 //:: 223 //:: VG_(memcpy)(buf, env, 7 * sizeof(unsigned long)); 224 //:: 225 //:: to = &buf->_st[0]; 226 //:: from = (struct _vki_fpxreg *) &fxsave->st_space[0]; 227 //:: for ( i = 0 ; i < 8 ; i++, to++, from++ ) { 228 //:: unsigned long __user *t = (unsigned long __user *)to; 229 //:: unsigned long *f = (unsigned long *)from; 230 //:: 231 //:: t[0] = f[0]; 232 //:: t[1] = f[1]; 233 //:: to->exponent = from->exponent; 234 //:: } 235 //:: } 236 //:: 237 //:: static void convert_fxsr_from_user( struct i387_fxsave_struct *fxsave, 238 //:: const struct _vki_fpstate *buf ) 239 //:: { 240 //:: unsigned long env[7]; 241 //:: struct _vki_fpxreg *to; 242 //:: const struct _vki_fpreg *from; 243 //:: int i; 244 //:: 245 //:: VG_(memcpy)(env, buf, 7 * sizeof(long)); 246 //:: 247 //:: fxsave->cwd = (unsigned short)(env[0] & 0xffff); 248 //:: fxsave->swd = (unsigned short)(env[1] & 0xffff); 249 //:: fxsave->twd = twd_i387_to_fxsr((unsigned short)(env[2] & 0xffff)); 250 //:: fxsave->fip = env[3]; 251 //:: fxsave->fop = (unsigned short)((env[4] & 0xffff0000ul) >> 16); 252 //:: fxsave->fcs = (env[4] & 0xffff); 253 //:: fxsave->foo = env[5]; 254 //:: fxsave->fos = env[6]; 255 //:: 256 //:: to = (struct _vki_fpxreg *) &fxsave->st_space[0]; 257 //:: from = &buf->_st[0]; 258 //:: for ( i = 0 ; i < 8 ; i++, to++, from++ ) { 259 //:: unsigned long *t = (unsigned long *)to; 260 //:: unsigned long __user *f = (unsigned long __user *)from; 261 //:: 262 //:: t[0] = f[0]; 263 //:: t[1] = f[1]; 264 //:: to->exponent = from->exponent; 265 //:: } 266 //:: } 267 //:: 268 //:: static inline void save_i387_fsave( arch_thread_t *regs, struct _vki_fpstate *buf ) 269 //:: { 270 //:: struct i387_fsave_struct *fs = ®s->m_sse.fsave; 271 //:: 272 //:: fs->status = fs->swd; 273 //:: VG_(memcpy)(buf, fs, sizeof(*fs)); 274 //:: } 275 //:: 276 //:: static void save_i387_fxsave( arch_thread_t *regs, struct _vki_fpstate *buf ) 277 //:: { 278 //:: const struct i387_fxsave_struct *fx = ®s->m_sse.fxsave; 279 //:: convert_fxsr_to_user( buf, fx ); 280 //:: 281 //:: buf->status = fx->swd; 282 //:: buf->magic = X86_FXSR_MAGIC; 283 //:: VG_(memcpy)(buf->_fxsr_env, fx, sizeof(struct i387_fxsave_struct)); 284 //:: } 285 //:: 286 //:: static void save_i387( arch_thread_t *regs, struct _vki_fpstate *buf ) 287 //:: { 288 //:: if ( VG_(have_ssestate) ) 289 //:: save_i387_fxsave( regs, buf ); 290 //:: else 291 //:: save_i387_fsave( regs, buf ); 292 //:: } 293 //:: 294 //:: static inline void restore_i387_fsave( arch_thread_t *regs, const struct _vki_fpstate __user *buf ) 295 //:: { 296 //:: VG_(memcpy)( ®s->m_sse.fsave, buf, sizeof(struct i387_fsave_struct) ); 297 //:: } 298 //:: 299 //:: static void restore_i387_fxsave( arch_thread_t *regs, const struct _vki_fpstate __user *buf ) 300 //:: { 301 //:: VG_(memcpy)(®s->m_sse.fxsave, &buf->_fxsr_env[0], 302 //:: sizeof(struct i387_fxsave_struct) ); 303 //:: /* mxcsr reserved bits must be masked to zero for security reasons */ 304 //:: regs->m_sse.fxsave.mxcsr &= 0xffbf; 305 //:: convert_fxsr_from_user( ®s->m_sse.fxsave, buf ); 306 //:: } 307 //:: 308 //:: static void restore_i387( arch_thread_t *regs, const struct _vki_fpstate __user *buf ) 309 //:: { 310 //:: if ( VG_(have_ssestate) ) { 311 //:: restore_i387_fxsave( regs, buf ); 312 //:: } else { 313 //:: restore_i387_fsave( regs, buf ); 314 //:: } 315 //:: } 316 317 318 /*------------------------------------------------------------*/ 319 /*--- Creating signal frames ---*/ 320 /*------------------------------------------------------------*/ 321 322 /* Create a plausible-looking sigcontext from the thread's 323 Vex guest state. NOTE: does not fill in the FP or SSE 324 bits of sigcontext at the moment. 325 */ 326 static 327 void synth_ucontext(ThreadId tid, const vki_siginfo_t *si, 328 UWord trapno, UWord err, const vki_sigset_t *set, 329 struct vki_ucontext *uc, struct _vki_fpstate *fpstate) 330 { 331 ThreadState *tst = VG_(get_ThreadState)(tid); 332 struct vki_sigcontext *sc = &uc->uc_mcontext; 333 334 VG_(memset)(uc, 0, sizeof(*uc)); 335 336 uc->uc_flags = 0; 337 uc->uc_link = 0; 338 uc->uc_sigmask = *set; 339 uc->uc_stack = tst->altstack; 340 sc->fpstate = fpstate; 341 342 // FIXME: save_i387(&tst->arch, fpstate); 343 344 # define SC2(reg,REG) sc->reg = tst->arch.vex.guest_##REG 345 SC2(r8,R8); 346 SC2(r9,R9); 347 SC2(r10,R10); 348 SC2(r11,R11); 349 SC2(r12,R12); 350 SC2(r13,R13); 351 SC2(r14,R14); 352 SC2(r15,R15); 353 SC2(rdi,RDI); 354 SC2(rsi,RSI); 355 SC2(rbp,RBP); 356 SC2(rbx,RBX); 357 SC2(rdx,RDX); 358 SC2(rax,RAX); 359 SC2(rcx,RCX); 360 SC2(rsp,RSP); 361 362 SC2(rip,RIP); 363 sc->eflags = LibVEX_GuestAMD64_get_rflags(&tst->arch.vex); 364 // FIXME: SC2(cs,CS); 365 // FIXME: SC2(gs,GS); 366 // FIXME: SC2(fs,FS); 367 sc->trapno = trapno; 368 sc->err = err; 369 # undef SC2 370 371 sc->cr2 = (UWord)si->_sifields._sigfault._addr; 372 } 373 374 375 /* Build the Valgrind-specific part of a signal frame. */ 376 377 static void build_vg_sigframe(struct vg_sigframe *frame, 378 ThreadState *tst, 379 const vki_sigset_t *mask, 380 UInt flags, 381 Int sigNo) 382 { 383 frame->sigNo_private = sigNo; 384 frame->magicPI = 0x31415927; 385 frame->vex_shadow1 = tst->arch.vex_shadow1; 386 frame->vex_shadow2 = tst->arch.vex_shadow2; 387 /* HACK ALERT */ 388 frame->vex = tst->arch.vex; 389 /* end HACK ALERT */ 390 frame->mask = tst->sig_mask; 391 frame->handlerflags = flags; 392 frame->magicE = 0x27182818; 393 } 394 395 396 static Addr build_rt_sigframe(ThreadState *tst, 397 Addr rsp_top_of_frame, 398 const vki_siginfo_t *siginfo, 399 const struct vki_ucontext *siguc, 400 void *handler, UInt flags, 401 const vki_sigset_t *mask, 402 void *restorer) 403 { 404 struct rt_sigframe *frame; 405 Addr rsp = rsp_top_of_frame; 406 Int sigNo = siginfo->si_signo; 407 UWord trapno; 408 UWord err; 409 410 rsp -= sizeof(*frame); 411 rsp = VG_ROUNDDN(rsp, 16) - 8; 412 frame = (struct rt_sigframe *)rsp; 413 414 if (! ML_(sf_maybe_extend_stack)(tst, rsp, sizeof(*frame), flags)) 415 return rsp_top_of_frame; 416 417 /* retaddr, siginfo, uContext fields are to be written */ 418 VG_TRACK( pre_mem_write, Vg_CoreSignal, tst->tid, "rt signal handler frame", 419 rsp, offsetof(struct rt_sigframe, vg) ); 420 421 if (flags & VKI_SA_RESTORER) 422 frame->retaddr = (Addr)restorer; 423 else 424 frame->retaddr = (Addr)&VG_(amd64_linux_SUBST_FOR_rt_sigreturn); 425 426 if (siguc) { 427 trapno = siguc->uc_mcontext.trapno; 428 err = siguc->uc_mcontext.err; 429 } else { 430 trapno = 0; 431 err = 0; 432 } 433 434 VG_(memcpy)(&frame->sigInfo, siginfo, sizeof(vki_siginfo_t)); 435 436 /* SIGILL defines addr to be the faulting address */ 437 if (sigNo == VKI_SIGILL && siginfo->si_code > 0) 438 frame->sigInfo._sifields._sigfault._addr 439 = (void*)tst->arch.vex.guest_RIP; 440 441 synth_ucontext(tst->tid, siginfo, trapno, err, mask, 442 &frame->uContext, &frame->fpstate); 443 444 VG_TRACK( post_mem_write, Vg_CoreSignal, tst->tid, 445 rsp, offsetof(struct rt_sigframe, vg) ); 446 447 build_vg_sigframe(&frame->vg, tst, mask, flags, sigNo); 448 449 return rsp; 450 } 451 452 453 void VG_(sigframe_create)( ThreadId tid, 454 Bool on_altstack, 455 Addr rsp_top_of_frame, 456 const vki_siginfo_t *siginfo, 457 const struct vki_ucontext *siguc, 458 void *handler, 459 UInt flags, 460 const vki_sigset_t *mask, 461 void *restorer ) 462 { 463 Addr rsp; 464 struct rt_sigframe *frame; 465 ThreadState* tst = VG_(get_ThreadState)(tid); 466 467 rsp = build_rt_sigframe(tst, rsp_top_of_frame, siginfo, siguc, 468 handler, flags, mask, restorer); 469 frame = (struct rt_sigframe *)rsp; 470 471 /* Set the thread so it will next run the handler. */ 472 /* tst->m_rsp = rsp; also notify the tool we've updated RSP */ 473 VG_(set_SP)(tid, rsp); 474 VG_TRACK( post_reg_write, Vg_CoreSignal, tid, VG_O_STACK_PTR, sizeof(Addr)); 475 476 //VG_(printf)("handler = %p\n", handler); 477 tst->arch.vex.guest_RIP = (Addr) handler; 478 tst->arch.vex.guest_RDI = (ULong) siginfo->si_signo; 479 tst->arch.vex.guest_RSI = (Addr) &frame->sigInfo; 480 tst->arch.vex.guest_RDX = (Addr) &frame->uContext; 481 /* And tell the tool that these registers have been written. */ 482 VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid, 483 offsetof(VexGuestAMD64State,guest_RIP), sizeof(UWord) ); 484 VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid, 485 offsetof(VexGuestAMD64State,guest_RDI), sizeof(UWord) ); 486 VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid, 487 offsetof(VexGuestAMD64State,guest_RSI), sizeof(UWord) ); 488 VG_TRACK( post_reg_write, Vg_CoreSignal, tst->tid, 489 offsetof(VexGuestAMD64State,guest_RDX), sizeof(UWord) ); 490 491 /* This thread needs to be marked runnable, but we leave that the 492 caller to do. */ 493 494 if (0) 495 VG_(printf)("pushed signal frame; %%RSP now = %#lx, " 496 "next %%RIP = %#llx, status=%d\n", 497 rsp, tst->arch.vex.guest_RIP, (Int)tst->status); 498 } 499 500 501 /*------------------------------------------------------------*/ 502 /*--- Destroying signal frames ---*/ 503 /*------------------------------------------------------------*/ 504 505 /* Return False and don't do anything, just set the client to take a 506 segfault, if it looks like the frame is corrupted. */ 507 static 508 Bool restore_vg_sigframe ( ThreadState *tst, 509 struct vg_sigframe *frame, Int *sigNo ) 510 { 511 if (frame->magicPI != 0x31415927 || 512 frame->magicE != 0x27182818) { 513 VG_(message)(Vg_UserMsg, "Thread %u return signal frame " 514 "corrupted. Killing process.\n", 515 tst->tid); 516 VG_(set_default_handler)(VKI_SIGSEGV); 517 VG_(synth_fault)(tst->tid); 518 *sigNo = VKI_SIGSEGV; 519 return False; 520 } 521 tst->sig_mask = frame->mask; 522 tst->tmp_sig_mask = frame->mask; 523 tst->arch.vex_shadow1 = frame->vex_shadow1; 524 tst->arch.vex_shadow2 = frame->vex_shadow2; 525 /* HACK ALERT */ 526 tst->arch.vex = frame->vex; 527 /* end HACK ALERT */ 528 *sigNo = frame->sigNo_private; 529 return True; 530 } 531 532 static 533 void restore_sigcontext( ThreadState *tst, 534 struct vki_sigcontext *sc, 535 struct _vki_fpstate *fpstate ) 536 { 537 tst->arch.vex.guest_RAX = sc->rax; 538 tst->arch.vex.guest_RCX = sc->rcx; 539 tst->arch.vex.guest_RDX = sc->rdx; 540 tst->arch.vex.guest_RBX = sc->rbx; 541 tst->arch.vex.guest_RBP = sc->rbp; 542 tst->arch.vex.guest_RSP = sc->rsp; 543 tst->arch.vex.guest_RSI = sc->rsi; 544 tst->arch.vex.guest_RDI = sc->rdi; 545 tst->arch.vex.guest_R8 = sc->r8; 546 tst->arch.vex.guest_R9 = sc->r9; 547 tst->arch.vex.guest_R10 = sc->r10; 548 tst->arch.vex.guest_R11 = sc->r11; 549 tst->arch.vex.guest_R12 = sc->r12; 550 tst->arch.vex.guest_R13 = sc->r13; 551 tst->arch.vex.guest_R14 = sc->r14; 552 tst->arch.vex.guest_R15 = sc->r15; 553 //:: tst->arch.vex.guest_rflags = sc->rflags; 554 tst->arch.vex.guest_RIP = sc->rip; 555 556 //:: tst->arch.vex.guest_CS = sc->cs; 557 //:: tst->arch.vex.guest_FS = sc->fs; 558 //:: tst->arch.vex.guest_GS = sc->gs; 559 560 //:: restore_i387(&tst->arch, fpstate); 561 } 562 563 564 static 565 SizeT restore_rt_sigframe ( ThreadState *tst, 566 struct rt_sigframe *frame, Int *sigNo ) 567 { 568 if (restore_vg_sigframe(tst, &frame->vg, sigNo)) 569 restore_sigcontext(tst, &frame->uContext.uc_mcontext, &frame->fpstate); 570 571 return sizeof(*frame); 572 } 573 574 575 void VG_(sigframe_destroy)( ThreadId tid, Bool isRT ) 576 { 577 Addr rsp; 578 ThreadState* tst; 579 SizeT size; 580 Int sigNo; 581 582 vg_assert(isRT); 583 584 tst = VG_(get_ThreadState)(tid); 585 586 /* Correctly reestablish the frame base address. */ 587 rsp = tst->arch.vex.guest_RSP; 588 589 size = restore_rt_sigframe(tst, (struct rt_sigframe *)rsp, &sigNo); 590 591 VG_TRACK( die_mem_stack_signal, rsp - VG_STACK_REDZONE_SZB, 592 size + VG_STACK_REDZONE_SZB ); 593 594 if (VG_(clo_trace_signals)) 595 VG_(message)( 596 Vg_DebugMsg, 597 "VG_(signal_return) (thread %u): isRT=%d valid magic; RIP=%#llx\n", 598 tid, isRT, tst->arch.vex.guest_RIP); 599 600 /* tell the tools */ 601 VG_TRACK( post_deliver_signal, tid, sigNo ); 602 } 603 604 #endif // defined(VGP_amd64_linux) 605 606 /*--------------------------------------------------------------------*/ 607 /*--- end ---*/ 608 /*--------------------------------------------------------------------*/ 609
