├── .clang-format ├── .editorconfig ├── CMakeLists.txt ├── README.md ├── bin └── dbghelp.dll ├── example ├── CMakeLists.txt └── example.cpp └── src ├── CrashHandler.cpp ├── CrashHandler.h ├── CrashRpt.cpp ├── CrashRpt.h ├── DbgHlp.cpp ├── Dbghlp.h ├── Report.cpp ├── Report.h ├── Utility.cpp ├── Utility.h └── cvconst.h /.clang-format: -------------------------------------------------------------------------------- 1 | --- 2 | Language: Cpp 3 | BasedOnStyle: Microsoft 4 | 5 | ColumnLimit: 120 6 | TabWidth: 4 7 | 8 | SortIncludes: false 9 | PointerAlignment: Left 10 | DerivePointerAlignment: false 11 | AllowShortLambdasOnASingleLine: Empty 12 | 13 | -------------------------------------------------------------------------------- /.editorconfig: -------------------------------------------------------------------------------- 1 | # EditorConfig is awesome: https://EditorConfig.org 2 | 3 | root = true 4 | 5 | [*] 6 | charset = utf-8 7 | end_of_line = crlf 8 | trim_trailing_whitespace = true 9 | insert_final_newline = true 10 | indent_style = space 11 | indent_size = 4 12 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.0) 2 | 3 | project(calmdump) 4 | 5 | set(PROJECT_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}) 6 | 7 | include_directories( 8 | src 9 | ) 10 | 11 | add_definitions( 12 | -DNOMINMAX 13 | -DWIN32_LEAN_AND_MEAN 14 | -D_WIN32_WINNT=0x0502 15 | -D_CRT_SECURE_NO_WARNINGS 16 | -D_SCL_SECURE_NO_WARNINGS 17 | ) 18 | 19 | file(GLOB_RECURSE LIB_HEADER_FILES src/*.h) 20 | file(GLOB_RECURSE LIB_SOURCE_FILES src/*.cpp) 21 | 22 | set_property(GLOBAL PROPERTY USE_FOLDERS ON) 23 | 24 | macro(SOURCE_GROUP_BY_DIR source_files) 25 | foreach(FILE ${SRCS}) 26 | # Get the directory of the source file 27 | get_filename_component(PARENT_DIR "${FILE}" DIRECTORY) 28 | 29 | # Remove common directory prefix to make the group 30 | string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}" "" GROUP "${PARENT_DIR}") 31 | 32 | # Make sure we are using windows slashes 33 | string(REPLACE "/" "\\" GROUP "${GROUP}") 34 | 35 | # Group into "Source Files" and "Header Files" 36 | if ("${FILE}" MATCHES ".*\\.cpp") 37 | set(GROUP "Source Files${GROUP}") 38 | elseif("${FILE}" MATCHES ".*\\.h") 39 | set(GROUP "Header Files${GROUP}") 40 | endif() 41 | 42 | source_group("${GROUP}" FILES "${FILE}") 43 | endforeach() 44 | endmacro(SOURCE_GROUP_BY_DIR) 45 | 46 | SOURCE_GROUP_BY_DIR(LIB_HEADER_FILES) 47 | SOURCE_GROUP_BY_DIR(LIB_SOURCE_FILES) 48 | 49 | add_library(calmdump ${LIB_HEADER_FILES} ${LIB_SOURCE_FILES}) 50 | 51 | add_subdirectory(example) 52 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # calmdump 2 | 3 | calmdump是用于Windows C++服务端的crash report组件，从[crashrpt](http://crashrpt.sourceforge.net/)里面提取出核心的异常处理代码，并增加了异常堆栈打印。 4 | 5 | [calmdump](https://github.com/ichenq/calmdump) takes the core exception handling code in [crashrpt](http://crashrpt.sourceforge.net/), but no client-only feature(screen capturing, file compression, video recording etc). 6 | on collect the minidump file and print stack information to a specified file. 7 | 8 | 9 | 10 | ## API 11 | 12 | ```cpp 13 | #include 14 | #include 15 | 16 | int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR lpCmdLine, int nCmdShow) 17 | { 18 | crInstall(); // this API handles everything 19 | 20 | // do your own job 21 | } 22 | ``` 23 | 24 | 25 | ## 如何构建本项目 26 | 27 | * Obtain [CMake](https://cmake.org/download/) 28 | * `mkdir build && cd build && cmake ..` 29 | 30 | 31 | 32 | ## 扩展阅读 33 | 34 | [A Crash Course on the Depths of Win32™ Structured Exception Handling](http://www.microsoft.com/msj/0197/exception/exception.aspx) 35 | 36 | [Vectored Exception Handling](http://msdn.microsoft.com/en-us/magazine/cc301714.aspx) 37 | 38 | [Programming against the x64 exception handling support](http://www.nynaeve.net/?p=99) 39 | 40 | [Structure Exception Handling in Windows NT](http://www.longene.org/techdoc/0031255001224576939.html) 41 | 42 | -------------------------------------------------------------------------------- /bin/dbghelp.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qi7chen/calmdump/de8224a43bd95584007f92b36b9f62a9e555e97d/bin/dbghelp.dll -------------------------------------------------------------------------------- /example/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | project(example) 2 | 3 | file(GLOB PROJECT_HEADER_FILES *.h) 4 | file(GLOB PROJECT_SOURCE_FILES *.cpp) 5 | 6 | set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SUBSYSTEM:CONSOLE") 7 | add_executable(example WIN32 ${PROJECT_HEADER_FILES} ${PROJECT_SOURCE_FILES}) 8 | 9 | target_link_libraries(example calmdump) 10 | -------------------------------------------------------------------------------- /example/example.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qi7chen/calmdump/de8224a43bd95584007f92b36b9f62a9e555e97d/example/example.cpp -------------------------------------------------------------------------------- /src/CrashHandler.cpp: -------------------------------------------------------------------------------- 1 | /************************************************************************************* 2 | This file is a part of CrashRpt library. 3 | Copyright (c) 2003-2013 The CrashRpt project authors. All Rights Reserved. 4 | 5 | Use of this source code is governed by a BSD-style license 6 | that can be found in the License.txt file in the root of the source 7 | tree. All contributing project authors may 8 | be found in the Authors.txt file in the root of the source tree. 9 | ***************************************************************************************/ 10 | 11 | // File: CrashHandler.cpp 12 | // Description: Exception handling and report generation functionality. 13 | // Authors: mikecarruth, zexspectrum 14 | // Date: 15 | 16 | 17 | 18 | #include "CrashHandler.h" 19 | #include 20 | #include 21 | #include "Report.h" 22 | #include "Dbghlp.h" 23 | 24 | #pragma warning(disable: 4996) 25 | 26 | 27 | // Get crash handlers of current process 28 | CurrentProcessCrashHandler* GetCurrentProcessCrashHandler() 29 | { 30 | static CurrentProcessCrashHandler instance; 31 | return &instance; 32 | } 33 | 34 | 35 | #define LOCK_HANDLER() GetCurrentProcessCrashHandler()->critsec.Enter() 36 | #define UNLOCK_HANDLER() GetCurrentProcessCrashHandler()->critsec.Leave() 37 | 38 | ////////////////////////////////////////////////////////////////////////// 39 | // 40 | // Exception handler functions. 41 | // 42 | 43 | 44 | static DWORD WINAPI StackOverflowThreadFunction(LPVOID lpParameter) 45 | { 46 | PEXCEPTION_POINTERS pExceptionPtrs = reinterpret_cast(lpParameter); 47 | 48 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 49 | LOCK_HANDLER(); 50 | 51 | // Treat this type of crash critical by default 52 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 53 | 54 | // Generate error report. 55 | CR_EXCEPTION_INFO ei = {}; 56 | ei.cb = sizeof(CR_EXCEPTION_INFO); 57 | ei.exctype = CR_SEH_EXCEPTION; 58 | ei.pexcptrs = pExceptionPtrs; 59 | GenerateErrorReport(&ei); 60 | 61 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 62 | { 63 | // Terminate process 64 | TerminateProcess(GetCurrentProcess(), 1); 65 | } 66 | 67 | // We do not unlock, because process is to be terminated. 68 | UNLOCK_HANDLER(); 69 | 70 | return 0; 71 | } 72 | 73 | // Structured exception handler (SEH handler) 74 | static LONG WINAPI SehHandler(__in PEXCEPTION_POINTERS pExceptionPtrs) 75 | { 76 | // Handle stack overflow in a separate thread. 77 | // Vojtech: Based on martin.bis...@gmail.com comment in 78 | // http://groups.google.com/group/crashrpt/browse_thread/thread/a1dbcc56acb58b27/fbd0151dd8e26daf?lnk=gst&q=stack+overflow#fbd0151dd8e26daf 79 | if (pExceptionPtrs != 0 && pExceptionPtrs->ExceptionRecord != 0 && 80 | pExceptionPtrs->ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW) 81 | { 82 | // Special case to handle the stack overflow exception. 83 | // The dump will be realized from another thread. 84 | // Create another thread that will do the dump. 85 | HANDLE thread = ::CreateThread(0, 0, 86 | &StackOverflowThreadFunction, pExceptionPtrs, 0, 0); 87 | ::WaitForSingleObject(thread, INFINITE); 88 | ::CloseHandle(thread); 89 | // Terminate process 90 | TerminateProcess(GetCurrentProcess(), 1); 91 | } 92 | else 93 | { 94 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 95 | LOCK_HANDLER(); 96 | 97 | // Treat this type of crash critical by default 98 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 99 | 100 | // Generate error report. 101 | CR_EXCEPTION_INFO ei = {}; 102 | ei.cb = sizeof(CR_EXCEPTION_INFO); 103 | ei.exctype = CR_SEH_EXCEPTION; 104 | ei.pexcptrs = pExceptionPtrs; 105 | GenerateErrorReport(&ei); 106 | 107 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 108 | { 109 | // Terminate process 110 | TerminateProcess(GetCurrentProcess(), 1); 111 | } 112 | 113 | // We do not unlock, because process is to be terminated. 114 | UNLOCK_HANDLER(); 115 | } 116 | return EXCEPTION_EXECUTE_HANDLER; 117 | } 118 | 119 | 120 | // C++ terminate handler 121 | static void TerminateHandler() 122 | { 123 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 124 | LOCK_HANDLER(); 125 | 126 | // Treat this type of crash critical by default 127 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 128 | 129 | // Generate error report. 130 | CR_EXCEPTION_INFO ei = {}; 131 | ei.cb = sizeof(CR_EXCEPTION_INFO); 132 | ei.exctype = CR_CPP_TERMINATE_CALL; 133 | GenerateErrorReport(&ei); 134 | 135 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 136 | { 137 | // Terminate process 138 | TerminateProcess(GetCurrentProcess(), 1); 139 | } 140 | 141 | // We do not unlock, because process is to be terminated. 142 | UNLOCK_HANDLER(); 143 | } 144 | 145 | // C++ unexpected handler 146 | static void UnexpectedHandler() 147 | { 148 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 149 | LOCK_HANDLER(); 150 | 151 | // Treat this type of crash critical by default 152 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 153 | 154 | // Fill in the exception info 155 | CR_EXCEPTION_INFO ei = {}; 156 | ei.cb = sizeof(CR_EXCEPTION_INFO); 157 | ei.exctype = CR_CPP_UNEXPECTED_CALL; 158 | 159 | // Generate crash report 160 | GenerateErrorReport(&ei); 161 | 162 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 163 | { 164 | // Terminate process 165 | TerminateProcess(GetCurrentProcess(), 1); 166 | } 167 | 168 | // We do not unlock, because process is to be terminated. 169 | UNLOCK_HANDLER(); 170 | } 171 | 172 | #if _MSC_VER >= 1300 173 | // C++ pure virtual call handler 174 | static void PureCallHandler() 175 | { 176 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 177 | LOCK_HANDLER(); 178 | 179 | // Treat this type of crash critical by default 180 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 181 | 182 | // Fill in the exception info 183 | CR_EXCEPTION_INFO ei = {}; 184 | ei.cb = sizeof(CR_EXCEPTION_INFO); 185 | ei.exctype = CR_CPP_PURE_CALL; 186 | 187 | // Generate crash report 188 | GenerateErrorReport(&ei); 189 | 190 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 191 | { 192 | // Terminate process 193 | TerminateProcess(GetCurrentProcess(), 1); 194 | } 195 | 196 | // We do not unlock, because process is to be terminated. 197 | UNLOCK_HANDLER(); 198 | } 199 | #endif 200 | 201 | #if _MSC_VER >= 1300 && _MSC_VER < 1400 202 | // Buffer overrun handler (deprecated in newest versions of Visual C++). 203 | static void SecurityHandler(int code, void *x) 204 | { 205 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 206 | LOCK_HANDLER(); 207 | 208 | // Treat this type of crash critical by default 209 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 210 | 211 | // Fill in the exception info 212 | CR_EXCEPTION_INFO ei = {}; 213 | ei.cb = sizeof(CR_EXCEPTION_INFO); 214 | ei.exctype = CR_CPP_SECURITY_ERROR; 215 | 216 | // Generate crash report 217 | GenerateErrorReport(&ei); 218 | 219 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 220 | { 221 | // Terminate process 222 | TerminateProcess(GetCurrentProcess(), 1); 223 | } 224 | 225 | // We do not unlock, because process is to be terminated. 226 | UNLOCK_HANDLER(); 227 | } 228 | #endif 229 | 230 | #if _MSC_VER >= 1400 231 | // C++ Invalid parameter handler. 232 | static void InvalidParameterHandler(const wchar_t* expression, 233 | const wchar_t* function, 234 | const wchar_t* file, 235 | unsigned int line, 236 | uintptr_t pReserved) 237 | { 238 | UNREFERENCED_PARAMETER(pReserved); 239 | 240 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 241 | LOCK_HANDLER(); 242 | 243 | // Treat this type of crash critical by default 244 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 245 | 246 | // Fill in the exception info 247 | CR_EXCEPTION_INFO ei = {}; 248 | ei.cb = sizeof(CR_EXCEPTION_INFO); 249 | ei.exctype = CR_CPP_INVALID_PARAMETER; 250 | ei.expression = expression; 251 | ei.function = function; 252 | ei.file = file; 253 | ei.line = line; 254 | 255 | // Generate crash report 256 | GenerateErrorReport(&ei); 257 | 258 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 259 | { 260 | // Terminate process 261 | TerminateProcess(GetCurrentProcess(), 1); 262 | } 263 | 264 | // We do not unlock, because process is to be terminated. 265 | UNLOCK_HANDLER(); 266 | } 267 | #endif 268 | 269 | #if _MSC_VER >= 1300 270 | // C++ new operator fault (memory exhaustion) handler 271 | static int NewHandler(size_t) 272 | { 273 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 274 | LOCK_HANDLER(); 275 | 276 | // Treat this type of crash critical by default 277 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 278 | 279 | // Fill in the exception info 280 | CR_EXCEPTION_INFO ei = {}; 281 | ei.cb = sizeof(CR_EXCEPTION_INFO); 282 | ei.exctype = CR_CPP_NEW_OPERATOR_ERROR; 283 | 284 | // Generate crash report 285 | GenerateErrorReport(&ei); 286 | 287 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 288 | { 289 | // Terminate process 290 | TerminateProcess(GetCurrentProcess(), 1); 291 | } 292 | 293 | // We do not unlock, because process is to be terminated. 294 | UNLOCK_HANDLER(); 295 | 296 | // Unreacheable code 297 | return 0; 298 | } 299 | #endif 300 | 301 | // Signal handlers 302 | static void SigabrtHandler(int) 303 | { 304 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 305 | LOCK_HANDLER(); 306 | 307 | // Treat this type of crash critical by default 308 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 309 | 310 | // Fill in the exception info 311 | CR_EXCEPTION_INFO ei = {}; 312 | ei.cb = sizeof(CR_EXCEPTION_INFO); 313 | ei.exctype = CR_CPP_SIGABRT; 314 | 315 | // Generate crash report 316 | GenerateErrorReport(&ei); 317 | 318 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 319 | { 320 | // Terminate process 321 | TerminateProcess(GetCurrentProcess(), 1); 322 | } 323 | 324 | // We do not unlock, because process is to be terminated. 325 | UNLOCK_HANDLER(); 326 | } 327 | 328 | static void SigfpeHandler(int code, int subcode) 329 | { 330 | UNREFERENCED_PARAMETER(code); 331 | 332 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 333 | LOCK_HANDLER(); 334 | 335 | // Treat this type of crash critical by default 336 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 337 | 338 | // Fill in the exception info 339 | CR_EXCEPTION_INFO ei = {}; 340 | ei.cb = sizeof(CR_EXCEPTION_INFO); 341 | ei.exctype = CR_CPP_SIGFPE; 342 | ei.pexcptrs = (PEXCEPTION_POINTERS)_pxcptinfoptrs; 343 | ei.fpe_subcode = subcode; 344 | 345 | // Generate crash report 346 | GenerateErrorReport(&ei); 347 | 348 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 349 | { 350 | // Terminate process 351 | TerminateProcess(GetCurrentProcess(), 1); 352 | } 353 | 354 | // We do not unlock, because process is to be terminated. 355 | UNLOCK_HANDLER(); 356 | } 357 | 358 | static void SigintHandler(int) 359 | { 360 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 361 | LOCK_HANDLER(); 362 | 363 | // Treat this type of crash critical by default 364 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 365 | 366 | // Fill in the exception info 367 | CR_EXCEPTION_INFO ei = {}; 368 | ei.cb = sizeof(CR_EXCEPTION_INFO); 369 | ei.exctype = CR_CPP_SIGINT; 370 | 371 | // Generate crash report 372 | GenerateErrorReport(&ei); 373 | 374 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 375 | { 376 | // Terminate process 377 | TerminateProcess(GetCurrentProcess(), 1); 378 | } 379 | 380 | // We do not unlock, because process is to be terminated. 381 | UNLOCK_HANDLER(); 382 | } 383 | 384 | static void SigillHandler(int) 385 | { 386 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 387 | LOCK_HANDLER(); 388 | 389 | // Treat this type of crash critical by default 390 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 391 | 392 | // Fill in the exception info 393 | CR_EXCEPTION_INFO ei = {}; 394 | ei.cb = sizeof(CR_EXCEPTION_INFO); 395 | ei.exctype = CR_CPP_SIGILL; 396 | 397 | // Generate crash report 398 | GenerateErrorReport(&ei); 399 | 400 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 401 | { 402 | // Terminate process 403 | TerminateProcess(GetCurrentProcess(), 1); 404 | } 405 | 406 | // We do not unlock, because process is to be terminated. 407 | UNLOCK_HANDLER(); 408 | } 409 | 410 | static void SigsegvHandler(int) 411 | { 412 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 413 | LOCK_HANDLER(); 414 | 415 | // Treat this type of crash critical by default 416 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 417 | 418 | // Fill in the exception info 419 | CR_EXCEPTION_INFO ei = {}; 420 | ei.cb = sizeof(CR_EXCEPTION_INFO); 421 | ei.exctype = CR_CPP_SIGSEGV; 422 | ei.pexcptrs = (PEXCEPTION_POINTERS)_pxcptinfoptrs; 423 | 424 | // Generate crash report 425 | GenerateErrorReport(&ei); 426 | 427 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 428 | { 429 | // Terminate process 430 | TerminateProcess(GetCurrentProcess(), 1); 431 | } 432 | 433 | // We do not unlock, because process is to be terminated. 434 | UNLOCK_HANDLER(); 435 | } 436 | 437 | static void SigtermHandler(int) 438 | { 439 | // Acquire lock to avoid other threads (if exist) to crash while we are inside 440 | LOCK_HANDLER(); 441 | 442 | // Treat this type of crash critical by default 443 | GetCurrentProcessCrashHandler()->bContinueExecution = FALSE; 444 | 445 | // Fill in the exception info 446 | CR_EXCEPTION_INFO ei = {}; 447 | ei.cb = sizeof(CR_EXCEPTION_INFO); 448 | ei.exctype = CR_CPP_SIGTERM; 449 | 450 | // Generate crash report 451 | GenerateErrorReport(&ei); 452 | 453 | if(!GetCurrentProcessCrashHandler()->bContinueExecution) 454 | { 455 | // Terminate process 456 | TerminateProcess(GetCurrentProcess(), 1); 457 | } 458 | 459 | // We do not unlock, because process is to be terminated. 460 | UNLOCK_HANDLER(); 461 | } 462 | 463 | ////////////////////////////////////////////////////////////////////////// 464 | 465 | // Create Minidump file 466 | static bool CreateMiniDump(EXCEPTION_POINTERS* ep) 467 | { 468 | MINIDUMP_EXCEPTION_INFORMATION mei = {}; 469 | mei.ThreadId = ::GetCurrentThreadId(); 470 | mei.ExceptionPointers = ep; 471 | mei.ClientPointers = TRUE; 472 | 473 | // Make a name 474 | char szFileName[MAX_PATH]; 475 | const std::string& strModule = GetAppName(); 476 | time_t now = time(NULL); 477 | tm thisDate = *localtime(&now); 478 | sprintf_s(szFileName, MAX_PATH, ("%s_%4d%02d%02d-%02d%02d%02d.dmp"), strModule.c_str(), 479 | thisDate.tm_year+1900, thisDate.tm_mon+1, thisDate.tm_mday, thisDate.tm_hour, 480 | thisDate.tm_min, thisDate.tm_sec); 481 | 482 | // Create Minidump file 483 | HANDLE hFile = ::CreateFile(szFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 484 | FILE_ATTRIBUTE_NORMAL, NULL); 485 | if (hFile != INVALID_HANDLE_VALUE) 486 | { 487 | GetDbghelpDll().MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), 488 | hFile, MiniDumpNormal, &mei, NULL, NULL); 489 | CloseHandle(hFile); 490 | return true; 491 | } 492 | else 493 | { 494 | LogLastError(); 495 | return false; 496 | } 497 | } 498 | 499 | 500 | int GenerateErrorReport(PCR_EXCEPTION_INFO pExceptionInfo /*= NULL*/) 501 | { 502 | // Only handle first chance exception in current thread 503 | static int excpt_chance = 0; 504 | if (++excpt_chance == 2) 505 | { 506 | return 1; 507 | } 508 | 509 | // Allocate memory in stack for storing exception pointers. 510 | EXCEPTION_RECORD ExceptionRecord = {}; 511 | CONTEXT ContextRecord = {}; 512 | EXCEPTION_POINTERS excptr = {}; 513 | ZeroMemory(&excptr, sizeof(excptr)); 514 | excptr.ExceptionRecord = &ExceptionRecord; 515 | excptr.ContextRecord = &ContextRecord; 516 | 517 | // Get exception pointers if they were not provided by the caller. 518 | if(pExceptionInfo->pexcptrs==NULL) 519 | { 520 | GetExceptionPointers(pExceptionInfo->code, &excptr); 521 | pExceptionInfo->pexcptrs = &excptr; 522 | } 523 | 524 | CreateMiniDump(&excptr); 525 | CreateReport(&excptr); 526 | 527 | return 0; 528 | } 529 | 530 | ////////////////////////////////////////////////////////////////////////// 531 | int SetProcessExceptionHanlders(DWORD dwFlags) 532 | { 533 | ProcessExceptHandlder prevHandlers = {}; 534 | 535 | // If 0 is specified as dwFlags, assume all handlers should be 536 | // installed 537 | if((dwFlags & CR_INST_ALL_POSSIBLE_HANDLERS) == 0) 538 | { 539 | dwFlags |= CR_INST_ALL_POSSIBLE_HANDLERS; 540 | } 541 | 542 | if(dwFlags & CR_INST_STRUCTURED_EXCEPTION_HANDLER) 543 | { 544 | // Install top-level SEH handler 545 | prevHandlers.pfnSehHandler = SetUnhandledExceptionFilter(SehHandler); 546 | } 547 | 548 | _set_error_mode(_OUT_TO_STDERR); 549 | 550 | #if _MSC_VER >= 1300 551 | if(dwFlags & CR_INST_PURE_CALL_HANDLER) 552 | { 553 | // Catch pure virtual function calls. 554 | // Because there is one _purecall_handler for the whole process, 555 | // calling this function immediately impacts all threads. The last 556 | // caller on any thread sets the handler. 557 | // http://msdn.microsoft.com/en-us/library/t296ys27.aspx 558 | prevHandlers.pfnPurec = _set_purecall_handler(PureCallHandler); 559 | } 560 | 561 | if(dwFlags & CR_INST_NEW_OPERATOR_ERROR_HANDLER) 562 | { 563 | // Catch new operator memory allocation exceptions 564 | _set_new_mode(1); // Force malloc() to call new handler too 565 | prevHandlers.pfnNewHandler = _set_new_handler(NewHandler); 566 | } 567 | #endif 568 | 569 | #if _MSC_VER >= 1400 570 | if(dwFlags & CR_INST_INVALID_PARAMETER_HANDLER) 571 | { 572 | // Catch invalid parameter exceptions. 573 | prevHandlers.pfnInvpar = _set_invalid_parameter_handler(InvalidParameterHandler); 574 | } 575 | #endif 576 | 577 | #if _MSC_VER >= 1300 && _MSC_VER < 1400 578 | if(dwFlags & CR_INST_SECURITY_ERROR_HANDLER) 579 | { 580 | // Catch buffer overrun exceptions 581 | // The _set_security_error_handler is deprecated in VC8 C++ run time library 582 | prevHandlers.pfnvSec = _set_security_error_handler(SecurityHandler); 583 | } 584 | #endif 585 | 586 | // Set up C++ signal handlers 587 | if(dwFlags & CR_INST_SIGABRT_HANDLER) 588 | { 589 | #if _MSC_VER >= 1400 590 | _set_abort_behavior(_CALL_REPORTFAULT, _CALL_REPORTFAULT); 591 | #endif 592 | // Catch an abnormal program termination 593 | prevHandlers.pfnSigabrtHandler = signal(SIGABRT, SigabrtHandler); 594 | } 595 | 596 | if(dwFlags & CR_INST_SIGINT_HANDLER) 597 | { 598 | // Catch illegal instruction handler 599 | prevHandlers.pfnSigintHandler = signal(SIGINT, SigintHandler); 600 | } 601 | 602 | if(dwFlags & CR_INST_TERMINATE_HANDLER) 603 | { 604 | // Catch a termination request 605 | prevHandlers.pfnSigtermHandler = signal(SIGTERM, SigtermHandler); 606 | } 607 | 608 | if(dwFlags & CR_INST_SIGFPE_HANDLER) 609 | { 610 | // Catch a floating point error 611 | typedef void (*sigh)(int); 612 | typedef void (*sigfpe)(int,int); 613 | prevHandlers.pfnSigfpeHandler = (sigfpe)signal(SIGFPE, (sigh)SigfpeHandler); 614 | } 615 | 616 | 617 | if(dwFlags & CR_INST_SIGILL_HANDLER) 618 | { 619 | // Catch an illegal instruction 620 | prevHandlers.pfnSigillHandler = signal(SIGILL, SigillHandler); 621 | } 622 | 623 | if(dwFlags & CR_INST_SIGSEGV_HANDLER) 624 | { 625 | // Catch illegal storage access errors 626 | prevHandlers.pfnSigsegvHandler = signal(SIGSEGV, SigsegvHandler); 627 | } 628 | 629 | if(dwFlags & CR_INST_TERMINATE_HANDLER) 630 | { 631 | // Catch terminate() calls. 632 | // In a multithreaded environment, terminate functions are maintained 633 | // separately for each thread. Each new thread needs to install its own 634 | // terminate function. Thus, each thread is in charge of its own termination handling. 635 | // http://msdn.microsoft.com/en-us/library/t6fk7h29.aspx 636 | prevHandlers.pfnTerminateHandler = set_terminate(TerminateHandler); 637 | } 638 | 639 | if(dwFlags & CR_INST_UNEXPECTED_HANDLER) 640 | { 641 | // Catch unexpected() calls. 642 | // In a multithreaded environment, unexpected functions are maintained 643 | // separately for each thread. Each new thread needs to install its own 644 | // unexpected function. Thus, each thread is in charge of its own unexpected handling. 645 | // http://msdn.microsoft.com/en-us/library/h46t5b69.aspx 646 | prevHandlers.pfnUnexpectedHandler = set_unexpected(UnexpectedHandler); 647 | } 648 | 649 | return TRUE; 650 | } 651 | 652 | -------------------------------------------------------------------------------- /src/CrashHandler.h: -------------------------------------------------------------------------------- 1 | /************************************************************************************* 2 | This file is a part of CrashRpt library. 3 | Copyright (c) 2003-2013 The CrashRpt project authors. All Rights Reserved. 4 | 5 | Use of this source code is governed by a BSD-style license 6 | that can be found in the License.txt file in the root of the source 7 | tree. All contributing project authors may 8 | be found in the Authors.txt file in the root of the source tree. 9 | ***************************************************************************************/ 10 | 11 | // File: CrashHandler.h 12 | // Description: Exception handling functionality. 13 | // Authors: mikecarruth, zexspectrum 14 | // Date: 2009 15 | 16 | 17 | #pragma once 18 | 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include "CrashRpt.h" 25 | #include "Utility.h" 26 | 27 | 28 | /* This structure contains pointer to the exception handlers for a process.*/ 29 | struct ProcessExceptHandlder 30 | { 31 | // Previous SEH exception filter. 32 | LPTOP_LEVEL_EXCEPTION_FILTER pfnSehHandler; 33 | 34 | // C++ terminate handler 35 | terminate_function pfnTerminateHandler; 36 | 37 | // C++ unexpected handler 38 | unexpected_function pfnUnexpectedHandler; 39 | 40 | #if _MSC_VER >= 1300 41 | _purecall_handler pfnPurec; // Pure virtual call exception filter. 42 | _PNH pfnNewHandler; // New operator exception filter. 43 | #endif 44 | 45 | #if _MSC_VER >= 1400 46 | _invalid_parameter_handler pfnInvpar; // Invalid parameter exception filter. 47 | #endif 48 | 49 | #if _MSC_VER >= 1300 && _MSC_VER < 1400 50 | _secerr_handler_func pfnvSec; // security exception filter. 51 | #endif 52 | 53 | // Signal handlers 54 | void (*pfnSigabrtHandler)(int); // SIGABRT signal handler 55 | void (*pfnSigfpeHandler)(int, int); // FPE handler 56 | void (*pfnSigintHandler)(int); // Illegal instruction handler 57 | void (*pfnSigillHandler)(int); // SIGILL handler 58 | void (*pfnSigsegvHandler)(int); // Illegal storage access handler 59 | void (*pfnSigtermHandler)(int); // Termination request handler 60 | }; 61 | 62 | 63 | 64 | struct CurrentProcessCrashHandler 65 | { 66 | // Avoid other threads (if exist) to crash while we are inside. 67 | ATL::CCriticalSection critsec; 68 | 69 | // Previous process exception handlers 70 | ProcessExceptHandlder prevHandlers; 71 | 72 | // Whether to terminate process (the default) or to continue execution after crash. 73 | BOOL bContinueExecution; 74 | }; 75 | 76 | 77 | // Generates error report 78 | int GenerateErrorReport(PCR_EXCEPTION_INFO pExceptionInfo); 79 | 80 | int SetProcessExceptionHanlders(DWORD dwFlags = 0); 81 | -------------------------------------------------------------------------------- /src/CrashRpt.cpp: -------------------------------------------------------------------------------- 1 | /************************************************************************************* 2 | This file is a part of CrashRpt library. 3 | Copyright (c) 2003-2013 The CrashRpt project authors. All Rights Reserved. 4 | 5 | Use of this source code is governed by a BSD-style license 6 | that can be found in the License.txt file in the root of the source 7 | tree. All contributing project authors may 8 | be found in the Authors.txt file in the root of the source tree. 9 | ***************************************************************************************/ 10 | 11 | // File: CrashRpt.cpp 12 | // Description: CrashRpt API implementation. 13 | // Authors: mikecarruth, zexspectrum 14 | // Date: 15 | 16 | // Copyright (C) 2015 prototyped.cn All rights reserved. 17 | // Distributed under the terms and conditions of the Apache License. 18 | // See accompanying files LICENSE. 19 | 20 | #include "CrashRpt.h" 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | #include 28 | #include "CrashHandler.h" 29 | 30 | int crInstall() 31 | { 32 | SetProcessExceptionHanlders(); 33 | return 0; 34 | } 35 | 36 | int crUninstall() 37 | { 38 | return 0; 39 | } 40 | 41 | int crExceptionFilter(unsigned int code, struct _EXCEPTION_POINTERS* ep) 42 | { 43 | CR_EXCEPTION_INFO ei; 44 | memset(&ei, 0, sizeof(CR_EXCEPTION_INFO)); 45 | ei.cb = sizeof(CR_EXCEPTION_INFO); 46 | ei.exctype = CR_SEH_EXCEPTION; 47 | ei.pexcptrs = ep; 48 | ei.code = code; 49 | 50 | int res = GenerateErrorReport(&ei); 51 | if(res!=0) 52 | { 53 | // If goes here than GenerateErrorReport() failed 54 | return EXCEPTION_CONTINUE_SEARCH; 55 | } 56 | 57 | return EXCEPTION_EXECUTE_HANDLER; 58 | } 59 | 60 | //----------------------------------------------------------------------------------------------- 61 | // Below crEmulateCrash() related stuff goes 62 | 63 | 64 | class CDerived; 65 | class CBase 66 | { 67 | public: 68 | CBase(CDerived *derived): m_pDerived(derived) {}; 69 | ~CBase(); 70 | virtual void function(void) = 0; 71 | 72 | CDerived * m_pDerived; 73 | }; 74 | 75 | class CDerived : public CBase 76 | { 77 | public: 78 | CDerived() : CBase(this) {}; // C4355 79 | virtual void function(void) {}; 80 | }; 81 | 82 | CBase::~CBase() 83 | { 84 | m_pDerived->function(); 85 | } 86 | 87 | 88 | void sigfpe_test() 89 | { 90 | // Code taken from http://www.devx.com/cplus/Article/34993/1954 91 | 92 | //Set the x86 floating-point control word according to what 93 | //exceptions you want to trap. 94 | _clearfp(); //Always call _clearfp before setting the control 95 | //word 96 | //Because the second parameter in the following call is 0, it 97 | //only returns the floating-point control word 98 | unsigned int cw; 99 | #if _MSC_VER<1400 100 | cw = _controlfp(0, 0); //Get the default control 101 | #else 102 | _controlfp_s(&cw, 0, 0); //Get the default control 103 | #endif 104 | //word 105 | //Set the exception masks off for exceptions that you want to 106 | //trap. When a mask bit is set, the corresponding floating-point 107 | //exception is //blocked from being generating. 108 | cw &=~(EM_OVERFLOW|EM_UNDERFLOW|EM_ZERODIVIDE| 109 | EM_DENORMAL|EM_INVALID); 110 | //For any bit in the second parameter (mask) that is 1, the 111 | //corresponding bit in the first parameter is used to update 112 | //the control word. 113 | unsigned int cwOriginal = 0; 114 | #if _MSC_VER<1400 115 | cwOriginal = _controlfp(cw, MCW_EM); //Set it. 116 | #else 117 | _controlfp_s(&cwOriginal, cw, MCW_EM); //Set it. 118 | #endif 119 | //MCW_EM is defined in float.h. 120 | 121 | // Divide by zero 122 | 123 | float a = 1.0f; 124 | float b = 0.0f; 125 | float c = a/b; 126 | c; 127 | 128 | //Restore the original value when done: 129 | //_controlfp_s(cwOriginal, MCW_EM); 130 | } 131 | 132 | #define BIG_NUMBER 0x1fffffff 133 | //#define BIG_NUMBER 0xf 134 | #pragma warning(disable: 4717) // avoid C4717 warning 135 | int RecurseAlloc() 136 | { 137 | int *pi = NULL; 138 | for(;;) 139 | pi = new int[BIG_NUMBER]; 140 | return 0; 141 | } 142 | 143 | // Vulnerable function 144 | #pragma warning(disable : 4996) // for strcpy use 145 | #pragma warning(disable : 6255) // warning C6255: _alloca indicates failure by raising a stack overflow exception. Consider using _malloca instead 146 | #pragma warning(disable : 6204) // warning C6204: Possible buffer overrun in call to 'strcpy': use of unchecked parameter 'str' 147 | void test_buffer_overrun(const char *str) 148 | { 149 | char* buffer = (char*)_alloca(10); 150 | strcpy(buffer, str); // overrun buffer !!! 151 | 152 | // use a secure CRT function to help prevent buffer overruns 153 | // truncate string to fit a 10 byte buffer 154 | // strncpy_s(buffer, _countof(buffer), str, _TRUNCATE); 155 | } 156 | #pragma warning(default : 4996) 157 | #pragma warning(default : 6255) 158 | #pragma warning(default : 6204) 159 | 160 | // Stack overflow function 161 | struct DisableTailOptimization 162 | { 163 | ~DisableTailOptimization() { 164 | ++ v; 165 | } 166 | static int v; 167 | }; 168 | 169 | int DisableTailOptimization::v = 0; 170 | 171 | static void CauseStackOverflow() 172 | { 173 | DisableTailOptimization v; 174 | CauseStackOverflow(); 175 | } 176 | 177 | int crEmulateCrash(unsigned ExceptionType) 178 | { 179 | switch(ExceptionType) 180 | { 181 | case CR_SEH_EXCEPTION: 182 | { 183 | // Access violation 184 | int *p = 0; 185 | #pragma warning(disable : 6011) // warning C6011: Dereferencing NULL pointer 'p' 186 | *p = 0; 187 | #pragma warning(default : 6011) 188 | } 189 | break; 190 | case CR_CPP_TERMINATE_CALL: 191 | { 192 | // Call terminate 193 | terminate(); 194 | } 195 | break; 196 | case CR_CPP_UNEXPECTED_CALL: 197 | { 198 | // Call unexpected 199 | unexpected(); 200 | } 201 | break; 202 | case CR_CPP_PURE_CALL: 203 | { 204 | // pure virtual method call 205 | CDerived derived; 206 | } 207 | break; 208 | case CR_CPP_SECURITY_ERROR: 209 | { 210 | // Cause buffer overrun (/GS compiler option) 211 | 212 | // declare buffer that is bigger than expected 213 | char large_buffer[] = "This string is longer than 10 characters!!"; 214 | test_buffer_overrun(large_buffer); 215 | } 216 | break; 217 | case CR_CPP_INVALID_PARAMETER: 218 | { 219 | char* formatString; 220 | // Call printf_s with invalid parameters. 221 | formatString = NULL; 222 | // warning C6387: 'argument 1' might be '0': this does not adhere to the specification for the function 'printf' 223 | #pragma warning(disable : 6387) 224 | printf(formatString); 225 | #pragma warning(default : 6387) 226 | 227 | } 228 | break; 229 | case CR_CPP_NEW_OPERATOR_ERROR: 230 | { 231 | // Cause memory allocation error 232 | RecurseAlloc(); 233 | } 234 | break; 235 | case CR_CPP_SIGABRT: 236 | { 237 | // Call abort 238 | abort(); 239 | } 240 | break; 241 | case CR_CPP_SIGFPE: 242 | { 243 | // floating point exception ( /fp:except compiler option) 244 | sigfpe_test(); 245 | return 1; 246 | } 247 | case CR_CPP_SIGILL: 248 | { 249 | int result = raise(SIGILL); 250 | assert(result==0); 251 | return result; 252 | } 253 | case CR_CPP_SIGINT: 254 | { 255 | int result = raise(SIGINT); 256 | assert(result==0); 257 | return result; 258 | } 259 | case CR_CPP_SIGSEGV: 260 | { 261 | int result = raise(SIGSEGV); 262 | assert(result==0); 263 | return result; 264 | } 265 | case CR_CPP_SIGTERM: 266 | { 267 | int result = raise(SIGTERM); 268 | assert(result==0); 269 | return result; 270 | } 271 | case CR_NONCONTINUABLE_EXCEPTION: 272 | { 273 | // Raise noncontinuable software exception 274 | RaiseException(123, EXCEPTION_NONCONTINUABLE, 0, NULL); 275 | } 276 | break; 277 | case CR_THROW: 278 | { 279 | // Throw typed C++ exception. 280 | throw 13; 281 | } 282 | break; 283 | case CR_STACK_OVERFLOW: 284 | { 285 | // Infinite recursion and stack overflow. 286 | CauseStackOverflow(); 287 | } 288 | default: 289 | break; 290 | } 291 | 292 | return 1; 293 | } 294 | 295 | -------------------------------------------------------------------------------- /src/CrashRpt.h: -------------------------------------------------------------------------------- 1 | /************************************************************************************* 2 | This file is a part of CrashRpt library. 3 | 4 | Copyright (c) 2003, Michael Carruth 5 | All rights reserved. 6 | 7 | Redistribution and use in source and binary forms, with or without modification, 8 | are permitted provided that the following conditions are met: 9 | 10 | * Redistributions of source code must retain the above copyright notice, this 11 | list of conditions and the following disclaimer. 12 | 13 | * Redistributions in binary form must reproduce the above copyright notice, 14 | this list of conditions and the following disclaimer in the documentation 15 | and/or other materials provided with the distribution. 16 | 17 | * Neither the name of the author nor the names of its contributors 18 | may be used to endorse or promote products derived from this software without 19 | specific prior written permission. 20 | 21 | 22 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 23 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 25 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 27 | TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 28 | BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 29 | STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 30 | OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 | ***************************************************************************************/ 32 | 33 | /*! \file CrashRpt.h 34 | * \brief Defines the interface for the CrashRpt.DLL. 35 | * \date 2003-2011 36 | * \author Michael Carruth 37 | * \author zeXspectrum 38 | */ 39 | 40 | // Copyright (C) 2015 prototyped.cn All rights reserved. 41 | // Distributed under the terms and conditions of the Apache License. 42 | // See accompanying files LICENSE. 43 | 44 | #pragma once 45 | 46 | #include 47 | 48 | 49 | // Define SAL macros to be empty if some old Visual Studio used 50 | #ifndef __reserved 51 | #define __reserved 52 | #endif 53 | #ifndef __in 54 | #define __in 55 | #endif 56 | #ifndef __in_opt 57 | #define __in_opt 58 | #endif 59 | #ifndef __out_ecount_z 60 | #define __out_ecount_z(x) 61 | #endif 62 | 63 | #ifdef __cplusplus 64 | #define CRASHRPT_EXTERNC extern "C" 65 | #else 66 | #define CRASHRPT_EXTERNC 67 | #endif 68 | 69 | #define CRASHRPTAPI(rettype) CRASHRPT_EXTERNC rettype WINAPI 70 | 71 | 72 | // Flags for CR_INSTALL_INFO::dwFlags 73 | #define CR_INST_STRUCTURED_EXCEPTION_HANDLER 0x1 //!< Install SEH handler (deprecated name, use \ref CR_INST_SEH_EXCEPTION_HANDLER instead). 74 | #define CR_INST_SEH_EXCEPTION_HANDLER 0x1 //!< Install SEH handler. 75 | #define CR_INST_TERMINATE_HANDLER 0x2 //!< Install terminate handler. 76 | #define CR_INST_UNEXPECTED_HANDLER 0x4 //!< Install unexpected handler. 77 | #define CR_INST_PURE_CALL_HANDLER 0x8 //!< Install pure call handler (VS .NET and later). 78 | #define CR_INST_NEW_OPERATOR_ERROR_HANDLER 0x10 //!< Install new operator error handler (VS .NET and later). 79 | #define CR_INST_SECURITY_ERROR_HANDLER 0x20 //!< Install security error handler (VS .NET and later). 80 | #define CR_INST_INVALID_PARAMETER_HANDLER 0x40 //!< Install invalid parameter handler (VS 2005 and later). 81 | #define CR_INST_SIGABRT_HANDLER 0x80 //!< Install SIGABRT signal handler. 82 | #define CR_INST_SIGFPE_HANDLER 0x100 //!< Install SIGFPE signal handler. 83 | #define CR_INST_SIGILL_HANDLER 0x200 //!< Install SIGILL signal handler. 84 | #define CR_INST_SIGINT_HANDLER 0x400 //!< Install SIGINT signal handler. 85 | #define CR_INST_SIGSEGV_HANDLER 0x800 //!< Install SIGSEGV signal handler. 86 | #define CR_INST_SIGTERM_HANDLER 0x1000 //!< Install SIGTERM signal handler. 87 | 88 | #define CR_INST_ALL_POSSIBLE_HANDLERS 0x1FFF //!< Install all possible exception handlers. 89 | #define CR_INST_CRT_EXCEPTION_HANDLERS 0x1FFE //!< Install exception handlers for the linked CRT module. 90 | 91 | #define CR_INST_NO_GUI 0x2000 //!< Do not show GUI, send report silently (use for non-GUI apps only). 92 | #define CR_INST_HTTP_BINARY_ENCODING 0x4000 //!< Deprecated, do not use. 93 | #define CR_INST_DONT_SEND_REPORT 0x8000 //!< Don't send error report immediately, just save it locally. 94 | #define CR_INST_APP_RESTART 0x10000 //!< Restart the application on crash. 95 | #define CR_INST_NO_MINIDUMP 0x20000 //!< Do not include minidump file to crash report. 96 | #define CR_INST_SEND_QUEUED_REPORTS 0x40000 //!< CrashRpt should send error reports that are waiting to be delivered. 97 | #define CR_INST_STORE_ZIP_ARCHIVES 0x80000 //!< CrashRpt should store both uncompressed error report files and ZIP archives. 98 | #define CR_INST_SEND_MANDATORY 0x100000 //!< This flag removes the "Close" and "Other actions" buttons from Error Report dialog, thus making the sending procedure mandatory for user. 99 | #define CR_INST_SHOW_ADDITIONAL_INFO_FIELDS 0x200000 //!< Makes "Your E-mail" and "Describe what you were doing when the problem occurred" fields of Error Report dialog always visible. 100 | #define CR_INST_ALLOW_ATTACH_MORE_FILES 0x400000 //!< Adds an ability for user to attach more files to crash report by clicking "Attach More File(s)" item from context menu of Error Report Details dialog. 101 | #define CR_INST_AUTO_THREAD_HANDLERS 0x800000 //!< If this flag is set, installs exception handlers for newly created threads automatically. 102 | 103 | 104 | /*! \ingroup CrashRptAPI 105 | * \brief Installs exception handlers for the caller process. 106 | * 107 | * 108 | * \remarks 109 | * This function installs unhandled exception filter for the caller process. 110 | * It also installs various CRT exception/error handlers that function for all threads of the caller process. 111 | * For more information, see \ref exception_handling 112 | * 113 | * Below is the list of installed handlers: 114 | * - Top-level SEH exception filter [ \c SetUnhandledExceptionFilter() ] 115 | * - C++ pure virtual call handler (Visual Studio .NET 2003 and later) [ \c _set_purecall_handler() ] 116 | * - C++ invalid parameter handler (Visual Studio .NET 2005 and later) [ \c _set_invalid_parameter_handler() ] 117 | * - C++ new operator error handler (Visual Studio .NET 2003 and later) [ \c _set_new_handler() ] 118 | * - C++ buffer overrun handler (Visual Studio .NET 2003 only) [ \c _set_security_error_handler() ] 119 | * - C++ abort handler [ \c signal(SIGABRT) ] 120 | * - C++ illegal instruction handler [ \c signal(SIGINT) ] 121 | * - C++ termination request [ \c signal(SIGTERM) ] 122 | * 123 | * In a multithreaded program, additionally use crInstallToCurrentThread2() function for each execution 124 | * thread, except the main one. 125 | * 126 | */ 127 | int crInstall(); 128 | 129 | 130 | /*! \ingroup CrashRptAPI 131 | * \brief Unsinstalls exception handlers previously installed with crInstall(). 132 | * 133 | * \return 134 | * This function returns zero if succeeded. 135 | * 136 | * \remarks 137 | * 138 | * Call this function on application exit to uninstall exception 139 | * handlers previously installed with crInstall(). After function call, the exception handlers 140 | * are restored to states they had before calling crInstall(). 141 | * 142 | * This function fails if crInstall() wasn't previously called in context of the 143 | * caller process. 144 | * 145 | * When this function fails, use crGetLastErrorMsg() to retrieve the error message. 146 | * 147 | * \sa crInstallW(), crInstallA(), crInstall(), crUninstall(), 148 | * CrAutoInstallHelper 149 | */ 150 | int crUninstall(); 151 | 152 | 153 | /*! \ingroup CrashRptAPI 154 | * \brief Installs exception handlers to the caller thread. 155 | * \return This function returns zero if succeeded. 156 | * \param[in] dwFlags Flags. 157 | * 158 | * \remarks 159 | * 160 | * This function is available since v.1.1.2. 161 | * 162 | * The function sets exception handlers for the caller thread. If you have 163 | * several execution threads, you ought to call the function for each thread, 164 | * except the main one. 165 | * 166 | * \a dwFlags defines what exception handlers to install. Use zero value 167 | * to install all possible exception handlers. Or use a combination of the following constants: 168 | * 169 | * - \ref CR_INST_TERMINATE_HANDLER Install terminate handler 170 | * - \ref CR_INST_UNEXPECTED_HANDLER Install unexpected handler 171 | * - \ref CR_INST_SIGFPE_HANDLER Install SIGFPE signal handler 172 | * - \ref CR_INST_SIGILL_HANDLER Install SIGILL signal handler 173 | * - \ref CR_INST_SIGSEGV_HANDLER Install SIGSEGV signal handler 174 | * 175 | * Example: 176 | * 177 | * \code 178 | * DWORD WINAPI ThreadProc(LPVOID lpParam) 179 | * { 180 | * // Install exception handlers 181 | * crInstallToCurrentThread2(0); 182 | * 183 | * // Your code... 184 | * 185 | * // Uninstall exception handlers 186 | * crUninstallFromCurrentThread(); 187 | * 188 | * return 0; 189 | * } 190 | * \endcode 191 | * 192 | * \sa 193 | * crInstall() 194 | */ 195 | int crInstallToCurrentThread2(DWORD dwFlags); 196 | 197 | /*! \ingroup CrashRptAPI 198 | * \brief Uninstalls C++ exception handlers from the current thread. 199 | * \return This function returns zero if succeeded. 200 | * 201 | * \remarks 202 | * 203 | * This function unsets exception handlers from the caller thread. If you have 204 | * several execution threads, you ought to call the function for each thread. 205 | * After calling this function, the exception handlers for current thread are 206 | * replaced with the handlers that were before call of crInstallToCurrentThread2(). 207 | * 208 | * This function fails if crInstallToCurrentThread2() wasn't called for current thread. 209 | * 210 | * When this function fails, use crGetLastErrorMsg() to retrieve the error message. 211 | * 212 | * No need to call this function for the main execution thread. The crUninstall() 213 | * will automatically uninstall C++ exception handlers for the main thread. 214 | * 215 | * \sa crInstallToCurrentThread2(), 216 | * crUninstallFromCurrentThread(), CrThreadAutoInstallHelper 217 | */ 218 | 219 | int crUninstallFromCurrentThread(); 220 | 221 | // Exception types 222 | #define CR_WIN32_STRUCTURED_EXCEPTION 0 //!< SEH exception (deprecated name, use \ref CR_SEH_EXCEPTION instead). 223 | #define CR_SEH_EXCEPTION 0 //!< SEH exception. 224 | #define CR_CPP_TERMINATE_CALL 1 //!< C++ terminate() call. 225 | #define CR_CPP_UNEXPECTED_CALL 2 //!< C++ unexpected() call. 226 | #define CR_CPP_PURE_CALL 3 //!< C++ pure virtual function call (VS .NET and later). 227 | #define CR_CPP_NEW_OPERATOR_ERROR 4 //!< C++ new operator fault (VS .NET and later). 228 | #define CR_CPP_SECURITY_ERROR 5 //!< Buffer overrun error (VS .NET only). 229 | #define CR_CPP_INVALID_PARAMETER 6 //!< Invalid parameter exception (VS 2005 and later). 230 | #define CR_CPP_SIGABRT 7 //!< C++ SIGABRT signal (abort). 231 | #define CR_CPP_SIGFPE 8 //!< C++ SIGFPE signal (flotating point exception). 232 | #define CR_CPP_SIGILL 9 //!< C++ SIGILL signal (illegal instruction). 233 | #define CR_CPP_SIGINT 10 //!< C++ SIGINT signal (CTRL+C). 234 | #define CR_CPP_SIGSEGV 11 //!< C++ SIGSEGV signal (invalid storage access). 235 | #define CR_CPP_SIGTERM 12 //!< C++ SIGTERM signal (termination request). 236 | 237 | 238 | /*! \ingroup CrashRptStructs 239 | * 240 | * This structure defines the information needed to generate crash minidump file and 241 | * provide the developer with other information about the error. This structure is used by 242 | * the crGenerateErrorReport() function. 243 | * 244 | * \b cb [in] 245 | * 246 | * This must contain the size of this structure in bytes. 247 | * 248 | * \b pexcptrs [in, optional] 249 | * 250 | * Should contain the exception pointers. If this parameter is NULL, 251 | * the current CPU state is used to generate exception pointers. 252 | * 253 | * \b exctype [in] 254 | * 255 | * The type of exception. This parameter may be one of the following: 256 | * - \ref CR_SEH_EXCEPTION SEH (Structured Exception Handling) exception 257 | * - \ref CR_CPP_TERMINATE_CALL C++ terminate() function call 258 | * - \ref CR_CPP_UNEXPECTED_CALL C++ unexpected() function call 259 | * - \ref CR_CPP_PURE_CALL Pure virtual method call (Visual Studio .NET 2003 and later) 260 | * - \ref CR_CPP_NEW_OPERATOR_ERROR C++ 'new' operator error (Visual Studio .NET 2003 and later) 261 | * - \ref CR_CPP_SECURITY_ERROR Buffer overrun (Visual Studio .NET 2003 only) 262 | * - \ref CR_CPP_INVALID_PARAMETER Invalid parameter error (Visual Studio 2005 and later) 263 | * - \ref CR_CPP_SIGABRT C++ SIGABRT signal 264 | * - \ref CR_CPP_SIGFPE C++ floating point exception 265 | * - \ref CR_CPP_SIGILL C++ illegal instruction 266 | * - \ref CR_CPP_SIGINT C++ SIGINT signal 267 | * - \ref CR_CPP_SIGSEGV C++ invalid storage access 268 | * - \ref CR_CPP_SIGTERM C++ termination request 269 | * 270 | * \b code [in, optional] 271 | * 272 | * Used if \a exctype is \ref CR_SEH_EXCEPTION and represents the SEH exception code. 273 | * If \a pexptrs is NULL, this value is used when generating exception information for initializing 274 | * \c pexptrs->ExceptionRecord->ExceptionCode member, otherwise it is ignored. 275 | * 276 | * \b fpe_subcode [in, optional] 277 | * 278 | * Used if \a exctype is equal to \ref CR_CPP_SIGFPE. It defines the floating point 279 | * exception subcode (see \c signal() function ducumentation in MSDN). 280 | * 281 | * \b expression, \b function, \b file and \b line [in, optional] 282 | * 283 | * These parameters are used when \a exctype is \ref CR_CPP_INVALID_PARAMETER. 284 | * These members are typically non-zero when using debug version of CRT. 285 | * 286 | * \b bManual [in] 287 | * 288 | * Since v.1.2.4, \a bManual parameter should be equal to TRUE if the report is generated manually. 289 | * The value of \a bManual parameter affects the automatic application restart behavior. If the application 290 | * restart is requested by the \ref CR_INST_APP_RESTART flag of CR_INSTALL_INFO::dwFlags structure member, 291 | * and if \a bManual is FALSE, the application will be 292 | * restarted after error report generation. If \a bManual is TRUE, the application won't be restarted. 293 | * 294 | * \b hSenderProcess [out] 295 | * 296 | * As of v.1.2.8, \a hSenderProcess parameter will contain the handle to the CrashSender.exe process when 297 | * \ref crGenerateErrorReport function returns. The caller may use this handle to wait until CrashSender.exe 298 | * process exits and check the exit code. 299 | */ 300 | 301 | typedef struct tagCR_EXCEPTION_INFO 302 | { 303 | WORD cb; //!< Size of this structure in bytes; should be initialized before using. 304 | PEXCEPTION_POINTERS pexcptrs; //!< Exception pointers. 305 | int exctype; //!< Exception type. 306 | DWORD code; //!< Code of SEH exception. 307 | unsigned int fpe_subcode; //!< Floating point exception subcode. 308 | const wchar_t* expression; //!< Assertion expression. 309 | const wchar_t* function; //!< Function in which assertion happened. 310 | const wchar_t* file; //!< File in which assertion happened. 311 | unsigned int line; //!< Line number. 312 | BOOL bManual; //!< Flag telling if the error report is generated manually or not. 313 | HANDLE hSenderProcess; //!< Handle to the CrashSender.exe process. 314 | } 315 | CR_EXCEPTION_INFO; 316 | 317 | typedef CR_EXCEPTION_INFO *PCR_EXCEPTION_INFO; 318 | 319 | 320 | /*! \ingroup DeprecatedAPI 321 | * \brief Can be used as a SEH exception filter. 322 | * 323 | * \return This function returns \c EXCEPTION_EXECUTE_HANDLER if succeeds, else \c EXCEPTION_CONTINUE_SEARCH. 324 | * 325 | * \param[in] code Exception code. 326 | * \param[in] ep Exception pointers. 327 | * 328 | * \remarks 329 | * 330 | * As of v.1.2.8, this function is declared deprecated. It may be removed in one of the future releases. 331 | * 332 | * This function can be called instead of a SEH exception filter 333 | * inside of __try{}__except(Expression){} statement. The function generates a error report 334 | * and returns control to the exception handler block. 335 | * 336 | * The exception code is usually retrieved with \b GetExceptionCode() intrinsic function 337 | * and the exception pointers are retrieved with \b GetExceptionInformation() intrinsic 338 | * function. 339 | * 340 | * If an error occurs, this function returns \c EXCEPTION_CONTINUE_SEARCH. 341 | * Use crGetLastErrorMsg() to retrieve the error message on fail. 342 | * 343 | * The following example shows how to use crExceptionFilter(). 344 | * 345 | * \code 346 | * int* p = NULL; // pointer to NULL 347 | * __try 348 | * { 349 | * *p = 13; // causes an access violation exception; 350 | * } 351 | * __except(crExceptionFilter(GetExceptionCode(), GetExceptionInformation())) 352 | * { 353 | * // Terminate program 354 | * ExitProcess(1); 355 | * } 356 | * 357 | * \endcode 358 | */ 359 | int crExceptionFilter(unsigned int code, struct _EXCEPTION_POINTERS* ep); 360 | 361 | // Flags used by crEmulateCrash() function 362 | #define CR_NONCONTINUABLE_EXCEPTION 32 //!< Non continuable sofware exception. 363 | #define CR_THROW 33 //!< Throw C++ typed exception. 364 | #define CR_STACK_OVERFLOW 34 //!< Stack overflow. 365 | 366 | /*! \ingroup CrashRptAPI 367 | * \brief Emulates a predefined crash situation. 368 | * 369 | * \return This function doesn't return if succeded. If failed, returns non-zero value. Call crGetLastErrorMsg() 370 | * to get the last error message. 371 | * 372 | * \param[in] ExceptionType Type of crash. 373 | * 374 | * \remarks 375 | * 376 | * This function uses some a priori incorrect or vulnerable code or raises a C++ signal or raises an uncontinuable 377 | * software exception to cause crash. 378 | * 379 | * This function can be used to test if CrashRpt handles a crash situation correctly. 380 | * 381 | * CrashRpt will intercept an error or exception if crInstall() and/or crInstallToCurrentThread2() 382 | * were previously called. crInstall() installs exception handlers that function on per-process basis. 383 | * crInstallToCurrentThread2() installs exception handlers that function on per-thread basis. 384 | * 385 | * \a ExceptionType can be one of the following constants: 386 | * - \ref CR_SEH_EXCEPTION This will generate a null pointer exception. 387 | * - \ref CR_CPP_TERMINATE_CALL This results in call of terminate() C++ function. 388 | * - \ref CR_CPP_UNEXPECTED_CALL This results in call of unexpected() C++ function. 389 | * - \ref CR_CPP_PURE_CALL This emulates a call of pure virtual method call of a C++ class instance (Visual Studio .NET 2003 and later). 390 | * - \ref CR_CPP_NEW_OPERATOR_ERROR This emulates C++ new operator failure (Visual Studio .NET 2003 and later). 391 | * - \ref CR_CPP_SECURITY_ERROR This emulates copy of large amount of data to a small buffer (Visual Studio .NET 2003 only). 392 | * - \ref CR_CPP_INVALID_PARAMETER This emulates an invalid parameter C++ exception (Visual Studio 2005 and later). 393 | * - \ref CR_CPP_SIGABRT This raises SIGABRT signal (abnormal program termination). 394 | * - \ref CR_CPP_SIGFPE This causes floating point exception. 395 | * - \ref CR_CPP_SIGILL This raises SIGILL signal (illegal instruction signal). 396 | * - \ref CR_CPP_SIGINT This raises SIGINT signal. 397 | * - \ref CR_CPP_SIGSEGV This raises SIGSEGV signal. 398 | * - \ref CR_CPP_SIGTERM This raises SIGTERM signal (program termination request). 399 | * - \ref CR_NONCONTINUABLE_EXCEPTION This raises a noncontinuable software exception (expected result 400 | * is the same as in \ref CR_SEH_EXCEPTION). 401 | * - \ref CR_THROW This throws a C++ typed exception (expected result is the same as in \ref CR_CPP_TERMINATE_CALL). 402 | * 403 | * The \ref CR_SEH_EXCEPTION uses null pointer write operation to cause the access violation. 404 | * 405 | * The \ref CR_NONCONTINUABLE_EXCEPTION has the same effect as \ref CR_SEH_EXCEPTION, but it uses 406 | * \b RaiseException() WinAPI function to raise noncontinuable software exception. 407 | * 408 | * The following example shows how to use crEmulateCrash() function. 409 | * 410 | * \code 411 | * // emulate null pointer exception (access violation) 412 | * crEmulateCrash(CR_SEH_EXCEPTION); 413 | * \endcode 414 | * 415 | */ 416 | int crEmulateCrash(unsigned ExceptionType) throw (...); 417 | 418 | 419 | 420 | 421 | //// Helper wrapper classes 422 | 423 | #ifndef _CRASHRPT_NO_WRAPPERS 424 | 425 | /*! \class CrAutoInstallHelper 426 | * \ingroup CrashRptWrappers 427 | * \brief Installs exception handlers in constructor and uninstalls in destructor. 428 | * \remarks 429 | * Use this class to easily install/uninstall exception handlers in you \b main() 430 | * or \b WinMain() function. 431 | * 432 | * This wrapper class calls crInstall() in its constructor and calls crUninstall() in 433 | * its destructor. 434 | * 435 | * Use CrAutoInstallHelper::m_nInstallStatus member to check the return status of crInstall(). 436 | * 437 | */ 438 | 439 | class CrAutoInstallHelper 440 | { 441 | public: 442 | 443 | //! Installs exception handlers to the caller process 444 | CrAutoInstallHelper() 445 | { 446 | m_nInstallStatus = crInstall(); 447 | } 448 | 449 | 450 | //! Uninstalls exception handlers from the caller process 451 | ~CrAutoInstallHelper() 452 | { 453 | crUninstall(); 454 | } 455 | 456 | //! Install status 457 | int m_nInstallStatus; 458 | }; 459 | 460 | 461 | #endif //!_CRASHRPT_NO_WRAPPERS 462 | 463 | 464 | 465 | 466 | -------------------------------------------------------------------------------- /src/DbgHlp.cpp: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2013-present prototyped.cn All rights reserved. 2 | // Distributed under the terms and conditions of the Apache License. 3 | // See accompanying files LICENSE. 4 | 5 | #include "Dbghlp.h" 6 | 7 | 8 | // ctor 9 | DbghlpDll::DbghlpDll() 10 | : DllHandle(("dbghelp.dll")) 11 | { 12 | if (handle_ && init()) 13 | { 14 | // turn on default options 15 | DWORD dwOptions = this->SymGetOptions(); 16 | dwOptions |= SYMOPT_DEFERRED_LOADS | SYMOPT_UNDNAME | SYMOPT_DEBUG; 17 | this->SymSetOptions(dwOptions); 18 | } 19 | else 20 | { 21 | LogLastError(); 22 | } 23 | } 24 | 25 | // dctor 26 | DbghlpDll::~DbghlpDll() 27 | { 28 | this->SymCleanup(GetCurrentProcess()); 29 | } 30 | 31 | BOOL DbghlpDll::init() 32 | { 33 | SymGetOptions = (SymGetOptions_t)GetFuncAddress(("SymGetOptions")); 34 | SymSetOptions = (SymSetOptions_t)GetFuncAddress(("SymSetOptions")); 35 | SymInitialize = (SymInitialize_t)GetFuncAddress(("SymInitialize")); 36 | SymCleanup = (SymCleanup_t)GetFuncAddress(("SymCleanup")); 37 | StackWalk = (StackWalk_t)GetFuncAddress(("StackWalk")); 38 | SymFromAddr = (SymFromAddr_t)GetFuncAddress(("SymFromAddr")); 39 | SymFunctionTableAccess = (SymFunctionTableAccess_t)GetFuncAddress(("SymFunctionTableAccess")); 40 | SymGetModuleBase = (SymGetModuleBase_t)GetFuncAddress(("SymGetModuleBase")); 41 | SymGetLineFromAddr = (SymGetLineFromAddr_t)GetFuncAddress(("SymGetLineFromAddr")); 42 | SymSetContext = (SymSetContext_t)GetFuncAddress(("SymSetContext")); 43 | SymEnumSymbols = (SymEnumSymbols_t)GetFuncAddress(("SymEnumSymbols")); 44 | SymGetTypeInfo = (SymGetTypeInfo_t)GetFuncAddress(("SymGetTypeInfo")); 45 | EnumerateLoadedModules = (EnumerateLoadedModules_t)GetFuncAddress(("EnumerateLoadedModules")); 46 | MiniDumpWriteDump = (MiniDumpWriteDump_t)GetFuncAddress(("MiniDumpWriteDump")); 47 | 48 | return (SymGetOptions && SymSetOptions && SymInitialize && SymCleanup 49 | && StackWalk && SymFromAddr && SymFunctionTableAccess && SymGetModuleBase 50 | && SymGetLineFromAddr && SymSetContext && SymEnumSymbols 51 | && SymGetTypeInfo && EnumerateLoadedModules && MiniDumpWriteDump); 52 | } 53 | 54 | // DbgHelp dll wrapper object 55 | DbghlpDll& GetDbghelpDll() 56 | { 57 | static DbghlpDll instance; 58 | return instance; 59 | } 60 | -------------------------------------------------------------------------------- /src/Dbghlp.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2013-present prototyped.cn All rights reserved. 2 | // Distributed under the terms and conditions of the Apache License. 3 | // See accompanying files LICENSE. 4 | 5 | 6 | #pragma once 7 | 8 | #include "Utility.h" 9 | 10 | // function types 11 | typedef DWORD(WINAPI* SymGetOptions_t)(); 12 | typedef DWORD(WINAPI* SymSetOptions_t)(DWORD); 13 | typedef BOOL(WINAPI* SymInitialize_t)(HANDLE, LPSTR, BOOL); 14 | typedef BOOL(WINAPI* StackWalk_t)(DWORD, HANDLE, HANDLE, LPSTACKFRAME, 15 | LPVOID, PREAD_PROCESS_MEMORY_ROUTINE, 16 | PFUNCTION_TABLE_ACCESS_ROUTINE, 17 | PGET_MODULE_BASE_ROUTINE, 18 | PTRANSLATE_ADDRESS_ROUTINE); 19 | typedef BOOL(WINAPI* SymFromAddr_t)(HANDLE, DWORD64, PDWORD64, PSYMBOL_INFO); 20 | typedef LPVOID(WINAPI* SymFunctionTableAccess_t)(HANDLE, DWORD_PTR); 21 | typedef DWORD_PTR(WINAPI* SymGetModuleBase_t)(HANDLE, DWORD_PTR); 22 | typedef BOOL(WINAPI* SymGetLineFromAddr_t)(HANDLE, DWORD_PTR, 23 | PDWORD, PIMAGEHLP_LINE); 24 | typedef BOOL(WINAPI* SymSetContext_t)(HANDLE, PIMAGEHLP_STACK_FRAME, PIMAGEHLP_CONTEXT); 25 | typedef BOOL(WINAPI* SymEnumSymbols_t)(HANDLE, ULONG64, PCSTR, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID); 26 | typedef BOOL(WINAPI* SymGetTypeInfo_t)(HANDLE, DWORD64, ULONG, IMAGEHLP_SYMBOL_TYPE_INFO, PVOID); 27 | typedef BOOL(WINAPI* SymCleanup_t)(HANDLE); 28 | typedef BOOL(WINAPI* EnumerateLoadedModules_t)(HANDLE, PENUMLOADED_MODULES_CALLBACK, PVOID); 29 | typedef BOOL(WINAPI* MiniDumpWriteDump_t)(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, 30 | CONST PMINIDUMP_EXCEPTION_INFORMATION, 31 | CONST PMINIDUMP_USER_STREAM_INFORMATION, 32 | CONST PMINIDUMP_CALLBACK_INFORMATION); 33 | 34 | // wrapper class for dbghelp.dll 35 | struct DbghlpDll : public DllHandle 36 | { 37 | DbghlpDll(); 38 | ~DbghlpDll(); 39 | 40 | BOOL init(); 41 | 42 | SymGetOptions_t SymGetOptions; 43 | SymSetOptions_t SymSetOptions; 44 | SymInitialize_t SymInitialize; 45 | SymCleanup_t SymCleanup; 46 | StackWalk_t StackWalk; 47 | SymFromAddr_t SymFromAddr; 48 | SymFunctionTableAccess_t SymFunctionTableAccess; 49 | SymGetModuleBase_t SymGetModuleBase; 50 | SymGetLineFromAddr_t SymGetLineFromAddr; 51 | SymSetContext_t SymSetContext; 52 | SymEnumSymbols_t SymEnumSymbols; 53 | SymGetTypeInfo_t SymGetTypeInfo; 54 | EnumerateLoadedModules_t EnumerateLoadedModules; 55 | MiniDumpWriteDump_t MiniDumpWriteDump; 56 | }; 57 | 58 | // DbgHelp dll wrapper object 59 | DbghlpDll& GetDbghelpDll(); 60 | -------------------------------------------------------------------------------- /src/Report.cpp: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2013-present prototyped.cn All rights reserved. 2 | // Distributed under the terms and conditions of the Apache License. 3 | // See accompanying files LICENSE. 4 | 5 | #include "Report.h" 6 | #include "Dbghlp.h" 7 | #include "cvconst.h" 8 | #include 9 | #include 10 | #include 11 | 12 | #pragma warning(disable: 4996) 13 | 14 | // Print system information 15 | static void PrintSystemInfo(); 16 | 17 | // Callback pro to numerate symbols 18 | static BOOL CALLBACK EnumSymbolsProcCallback(PSYMBOL_INFO pSymInfo, ULONG SymSize, PVOID data); 19 | 20 | static bool FormatSymbolValue(PSYMBOL_INFO pSym, STACKFRAME* sf, char* pszBuffer, unsigned cbBuffer); 21 | 22 | static char* FormatOutputValue(char* pszCurrBuffer, BasicType basicType, DWORD64 length, PVOID pAddress); 23 | 24 | static BasicType GetBasicType(DWORD typeIndex, DWORD64 modBase); 25 | 26 | static char* DumpTypeIndex(char* pszCurrBuffer, DWORD64 modBase, DWORD dwTypeIndex, 27 | unsigned nestingLevel, DWORD_PTR offset, bool & bHandled, char* Name); 28 | 29 | 30 | // Add log text to file 31 | static void AddToReport(const char* fmt, ...) 32 | { 33 | std::string text; 34 | va_list ap; 35 | va_start(ap, fmt); 36 | StringAppendV(&text, fmt, ap); 37 | va_end(ap); 38 | WriteTextToFile(GetAppName(), text); 39 | } 40 | 41 | 42 | // Given an exception code, returns a pointer to a static string with a 43 | // description of the exception 44 | std::string GetExceptionString(DWORD dwCode) 45 | { 46 | #define EXCEPTION( x ) case EXCEPTION_##x: return (#x); 47 | switch ( dwCode ) 48 | { 49 | EXCEPTION( ACCESS_VIOLATION ) 50 | EXCEPTION( DATATYPE_MISALIGNMENT ) 51 | EXCEPTION( BREAKPOINT ) 52 | EXCEPTION( SINGLE_STEP ) 53 | EXCEPTION( ARRAY_BOUNDS_EXCEEDED ) 54 | EXCEPTION( FLT_DENORMAL_OPERAND ) 55 | EXCEPTION( FLT_DIVIDE_BY_ZERO ) 56 | EXCEPTION( FLT_INEXACT_RESULT ) 57 | EXCEPTION( FLT_INVALID_OPERATION ) 58 | EXCEPTION( FLT_OVERFLOW ) 59 | EXCEPTION( FLT_STACK_CHECK ) 60 | EXCEPTION( FLT_UNDERFLOW ) 61 | EXCEPTION( INT_DIVIDE_BY_ZERO ) 62 | EXCEPTION( INT_OVERFLOW ) 63 | EXCEPTION( PRIV_INSTRUCTION ) 64 | EXCEPTION( IN_PAGE_ERROR ) 65 | EXCEPTION( ILLEGAL_INSTRUCTION ) 66 | EXCEPTION( NONCONTINUABLE_EXCEPTION ) 67 | EXCEPTION( STACK_OVERFLOW ) 68 | EXCEPTION( INVALID_DISPOSITION ) 69 | EXCEPTION( GUARD_PAGE ) 70 | EXCEPTION( INVALID_HANDLE ) 71 | } 72 | 73 | // If not one of the "known" exceptions, try to get the string 74 | // from NTDLL.DLL's message table. 75 | 76 | char szBuffer[512] = { 0 }; 77 | FormatMessage( FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_HMODULE, 78 | GetModuleHandle( ("NTDLL.DLL") ), 79 | dwCode, 0, szBuffer, sizeof( szBuffer ), 0 ); 80 | 81 | return std::string(szBuffer); 82 | } 83 | 84 | static void DumpSymbolName(DWORD dwLevel, const STACKFRAME& sf) 85 | { 86 | DWORD64 dwAddress = sf.AddrPC.Offset; 87 | BYTE symbolBuffer[sizeof(SYMBOL_INFO) + MAX_NAME_LEN] = {}; 88 | PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)symbolBuffer; 89 | pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO); 90 | pSymbol->MaxNameLen = MAX_NAME_LEN; 91 | DWORD64 symDisplacement = 0; 92 | if (!GetDbghelpDll().SymFromAddr(::GetCurrentProcess(), dwAddress, 93 | &symDisplacement, pSymbol)) 94 | { 95 | //LOG_LAST_ERROR(); 96 | return ; 97 | } 98 | 99 | IMAGEHLP_LINE line = {sizeof(IMAGEHLP_LINE)}; 100 | DWORD dwLineDisplacement = 0; 101 | if (!GetDbghelpDll().SymGetLineFromAddr( 102 | ::GetCurrentProcess(), 103 | dwAddress, 104 | &dwLineDisplacement, 105 | &line)) 106 | { 107 | // it is normal that we don't have source info for some symbols, 108 | // notably all the ones from the system DLLs... 109 | return; 110 | } 111 | 112 | AddToReport(("%02d. (0x%08I64x) %s() %s [%u]\n"), dwLevel, pSymbol->Address, 113 | pSymbol->Name, line.FileName, line.LineNumber); 114 | } 115 | 116 | 117 | static void DumpSymbolParam(const STACKFRAME& sf ) 118 | { 119 | DWORD64 dwSymAddr = sf.AddrPC.Offset; 120 | DWORD64 dwAddrFrame = sf.AddrFrame.Offset; 121 | 122 | // use SymSetContext to get just the locals/params for this frame 123 | IMAGEHLP_STACK_FRAME imagehlpStackFrame = {}; 124 | imagehlpStackFrame.InstructionOffset = dwSymAddr; 125 | if (!GetDbghelpDll().SymSetContext(::GetCurrentProcess(), &imagehlpStackFrame, 0)) 126 | { 127 | // for symbols from kernel DLL we might not have access to their 128 | // address, this is not a real error 129 | return ; 130 | } 131 | 132 | if (!GetDbghelpDll().SymEnumSymbols( 133 | ::GetCurrentProcess(), 134 | NULL, // DLL base: use current context 135 | NULL, // no mask, get all symbols 136 | EnumSymbolsProcCallback, 137 | (PVOID)&sf)) // data parameter for this callback 138 | { 139 | LogLastError(); 140 | } 141 | } 142 | 143 | static void WalkStack(const CONTEXT* pContext, size_t skip, size_t maxDepth) 144 | { 145 | CONTEXT ctx = *pContext; // will be modified by dbghelp StackWalk() 146 | DWORD dwMachineType; 147 | // initialize the initial frame: currently we can do it for x86 only 148 | STACKFRAME sf = {}; 149 | #if defined(_M_AMD64) 150 | sf.AddrPC.Offset = ctx.Rip; 151 | sf.AddrPC.Mode = AddrModeFlat; 152 | sf.AddrStack.Offset = ctx.Rsp; 153 | sf.AddrStack.Mode = AddrModeFlat; 154 | sf.AddrFrame.Offset = ctx.Rbp; 155 | sf.AddrFrame.Mode = AddrModeFlat; 156 | 157 | dwMachineType = IMAGE_FILE_MACHINE_AMD64; 158 | #elif defined(_M_IX86) 159 | sf.AddrPC.Offset = ctx.Eip; 160 | sf.AddrPC.Mode = AddrModeFlat; 161 | sf.AddrStack.Offset = ctx.Esp; 162 | sf.AddrStack.Mode = AddrModeFlat; 163 | sf.AddrFrame.Offset = ctx.Ebp; 164 | sf.AddrFrame.Mode = AddrModeFlat; 165 | 166 | dwMachineType = IMAGE_FILE_MACHINE_I386; 167 | #else 168 | #error "Need to initialize STACKFRAME on non x86" 169 | #endif // _M_IX86 170 | 171 | // iterate over all stack frames 172 | for ( size_t nLevel = 0; nLevel < maxDepth; nLevel++) 173 | { 174 | if (!GetDbghelpDll().StackWalk( 175 | dwMachineType, 176 | ::GetCurrentProcess(), 177 | ::GetCurrentThread(), 178 | &sf, 179 | &ctx, 180 | NULL, // read memory function (default) 181 | GetDbghelpDll().SymFunctionTableAccess, 182 | GetDbghelpDll().SymGetModuleBase, 183 | NULL)) // address translator for 16 bit 184 | { 185 | break; 186 | } 187 | //Invalid frame 188 | if (!sf.AddrFrame.Offset) 189 | { 190 | break; 191 | } 192 | 193 | // don't show this frame itself in the output 194 | if (nLevel >= skip) 195 | { 196 | DumpSymbolName((DWORD)(nLevel - skip), sf); 197 | DumpSymbolParam(sf); 198 | AddToReport(("\n")); 199 | } 200 | } 201 | } 202 | 203 | static void PrintExceptInfo(EXCEPTION_POINTERS* ep) 204 | { 205 | AddToReport(("\r\n*** Exception ***\r\n")); 206 | MEMORY_BASIC_INFORMATION mbi; 207 | char szModule[MAX_PATH]; 208 | DWORD dwExceptCode = ep->ExceptionRecord->ExceptionCode; 209 | PVOID ExceptionAddress = ep->ExceptionRecord->ExceptionAddress; 210 | if (VirtualQuery(ExceptionAddress, &mbi, sizeof(mbi))) 211 | { 212 | PVOID hMod = (PVOID)mbi.AllocationBase; 213 | if (GetModuleFileName((HMODULE)hMod, szModule, MAX_PATH)) 214 | { 215 | AddToReport(("Module: %s\r\n"), szModule); 216 | } 217 | } 218 | 219 | AddToReport(("Fault address: 0x%08x, Thread ID: %d\r\n"), ExceptionAddress, GetCurrentThreadId()); 220 | if (dwExceptCode == EXCEPTION_ACCESS_VIOLATION) 221 | { 222 | ULONG_PTR* exceptinfo = ep->ExceptionRecord->ExceptionInformation; 223 | const char* szOperation = (exceptinfo[0] ? ("write") : ("read")); 224 | AddToReport(("Failed to %d address 0x%08x\r\n"), szOperation, exceptinfo[1]); 225 | } 226 | std::string code = GetExceptionString(dwExceptCode); 227 | AddToReport(("Exception code: 0x%08x %s\r\n\r\n"), dwExceptCode, code.c_str()); 228 | } 229 | 230 | // Create stack frame log of this exception 231 | void CreateReport(EXCEPTION_POINTERS* ep) 232 | { 233 | assert(ep); 234 | 235 | time_t now = time(NULL); 236 | AddToReport(("\nException report created at %s"), ctime(&now)); 237 | 238 | PrintExceptInfo(ep); 239 | 240 | // according to MSDN, the first parameter should be just a unique value and 241 | // not process handle (although the parameter is prototyped as "HANDLE 242 | // hProcess") and actually it advises to use the process id and not handle 243 | // for Win9x, but then we need to use the same value in StackWalk() call 244 | // below which should be a real handle... so this is what we use 245 | const HANDLE hProcess = ::GetCurrentProcess(); 246 | if (!GetDbghelpDll().SymInitialize(hProcess, NULL, TRUE)) 247 | { 248 | LogLastError(); 249 | return ; 250 | } 251 | 252 | AddToReport(("\r\nCall stack:\r\n---------------------------\r\n")); 253 | AddToReport(("Level Address Function SourceFile\r\n")); 254 | 255 | // enumerate stack frames from the given context 256 | WalkStack(ep->ContextRecord, 0, MAX_DUMP_DEPTH); 257 | 258 | PrintSystemInfo(); 259 | 260 | if (!GetDbghelpDll().SymCleanup(::GetCurrentProcess())) 261 | { 262 | LogLastError(); 263 | } 264 | } 265 | 266 | 267 | BOOL CALLBACK EnumSymbolsProcCallback(PSYMBOL_INFO pSymInfo, ULONG SymSize, PVOID userContext) 268 | { 269 | STACKFRAME* sf = (STACKFRAME*)userContext; 270 | 271 | // we're only interested in parameters and local variables 272 | if ( pSymInfo->Flags & SYMF_PARAMETER || pSymInfo->Flags & SYMF_LOCAL) 273 | { 274 | char szBuffer[2048]; 275 | __try 276 | { 277 | if (FormatSymbolValue(pSymInfo, sf, szBuffer, _countof(szBuffer))) 278 | { 279 | AddToReport("\t%s\r\n", szBuffer); 280 | } 281 | } 282 | __except(EXCEPTION_EXECUTE_HANDLER) 283 | { 284 | } 285 | } 286 | 287 | // return true to continue enumeration, false would have stopped it 288 | return TRUE; 289 | } 290 | 291 | 292 | // Given a SYMBOL_INFO representing a particular variable, displays its 293 | // contents. If it's a user defined type, display the members and their 294 | // values. 295 | bool FormatSymbolValue(PSYMBOL_INFO pSym, STACKFRAME* sf, char* pszBuffer, unsigned cbBuffer) 296 | { 297 | char* pszCurrBuffer = pszBuffer; 298 | 299 | // Indicate if the variable is a local or parameter 300 | if (pSym->Flags & IMAGEHLP_SYMBOL_INFO_PARAMETER) 301 | pszCurrBuffer += sprintf(pszCurrBuffer, "Parameter "); 302 | else if (pSym->Flags & IMAGEHLP_SYMBOL_INFO_LOCAL) 303 | pszCurrBuffer += sprintf(pszCurrBuffer, "Local "); 304 | 305 | // If it's a function, don't do anything. 306 | if (pSym->Tag == 5) // SymTagFunction from CVCONST.H from the DIA SDK 307 | return false; 308 | 309 | DWORD_PTR pVariable = 0; // Will point to the variable's data in memory 310 | 311 | if (pSym->Flags & IMAGEHLP_SYMBOL_INFO_REGRELATIVE) 312 | { 313 | // if ( pSym->Register == 8 ) // EBP is the value 8 (in DBGHELP 5.1) 314 | { // This may change!!! 315 | pVariable = sf->AddrFrame.Offset; 316 | pVariable += (DWORD_PTR)pSym->Address; 317 | } 318 | // else 319 | // return false; 320 | } 321 | else if (pSym->Flags & IMAGEHLP_SYMBOL_INFO_REGISTER) 322 | { 323 | return false; // Don't try to report register variable 324 | } 325 | else 326 | { 327 | pVariable = (DWORD_PTR)pSym->Address; // It must be a global variable 328 | } 329 | 330 | // Determine if the variable is a user defined type (UDT). IF so, bHandled 331 | // will return true. 332 | bool bHandled; 333 | pszCurrBuffer = DumpTypeIndex(pszCurrBuffer, pSym->ModBase, pSym->TypeIndex, 334 | 0, pVariable, bHandled, pSym->Name); 335 | 336 | if (!bHandled) 337 | { 338 | // The symbol wasn't a UDT, so do basic, stupid formatting of the 339 | // variable. Based on the size, we're assuming it's a char, WORD, or 340 | // DWORD. 341 | BasicType basicType = GetBasicType(pSym->TypeIndex, pSym->ModBase); 342 | pszCurrBuffer += sprintf(pszCurrBuffer, rgBaseType[basicType]); 343 | 344 | // Emit the variable name 345 | pszCurrBuffer += sprintf(pszCurrBuffer, "\'%s\'", pSym->Name); 346 | 347 | pszCurrBuffer = FormatOutputValue(pszCurrBuffer, basicType, pSym->Size, 348 | (PVOID)pVariable); 349 | } 350 | 351 | return true; 352 | } 353 | 354 | char* FormatOutputValue(char* pszCurrBuffer, BasicType basicType, DWORD64 length, PVOID pAddress) 355 | { 356 | // Format appropriately (assuming it's a 1, 2, or 4 bytes (!!!) 357 | if (length == 1) 358 | pszCurrBuffer += sprintf(pszCurrBuffer, " = %X", *(PBYTE)pAddress); 359 | else if (length == 2) 360 | pszCurrBuffer += sprintf(pszCurrBuffer, " = %X", *(PWORD)pAddress); 361 | else if (length == 4) 362 | { 363 | if (basicType == btFloat) 364 | { 365 | pszCurrBuffer += sprintf(pszCurrBuffer, " = %f", *(PFLOAT)pAddress); 366 | } 367 | else if (basicType == btChar) 368 | { 369 | if (!IsBadStringPtr(*(PSTR*)pAddress, 32)) 370 | { 371 | pszCurrBuffer += sprintf(pszCurrBuffer, " = \"%.31s\"", *(PSTR*)pAddress); 372 | } 373 | else 374 | pszCurrBuffer += sprintf(pszCurrBuffer, " = %X", 375 | *(PDWORD)pAddress); 376 | } 377 | else 378 | pszCurrBuffer += sprintf(pszCurrBuffer, " = %X", *(PDWORD)pAddress); 379 | } 380 | else if (length == 8) 381 | { 382 | if (basicType == btFloat) 383 | { 384 | pszCurrBuffer += sprintf(pszCurrBuffer, " = %lf", 385 | *(double *)pAddress); 386 | } 387 | else 388 | pszCurrBuffer += sprintf(pszCurrBuffer, " = %I64X", 389 | *(DWORD64*)pAddress); 390 | } 391 | 392 | return pszCurrBuffer; 393 | } 394 | 395 | 396 | // If it's a user defined type (UDT), recurse through its members until we're 397 | // at fundamental types. When he hit fundamental types, return 398 | // bHandled = false, so that FormatSymbolValue() will format them. 399 | char* DumpTypeIndex(char* pszCurrBuffer, DWORD64 modBase, DWORD dwTypeIndex, 400 | unsigned nestingLevel, DWORD_PTR offset, bool & bHandled, char* Name) 401 | { 402 | bHandled = false; 403 | 404 | // Get the name of the symbol. This will either be a Type name (if a UDT), 405 | // or the structure member name. 406 | WCHAR * pwszTypeName; 407 | if (GetDbghelpDll().SymGetTypeInfo(GetCurrentProcess(), modBase, dwTypeIndex, TI_GET_SYMNAME, 408 | &pwszTypeName)) 409 | { 410 | pszCurrBuffer += sprintf(pszCurrBuffer, " %ls", pwszTypeName); 411 | LocalFree(pwszTypeName); 412 | } 413 | 414 | // Determine how many children this type has. 415 | DWORD dwChildrenCount = 0; 416 | GetDbghelpDll().SymGetTypeInfo(GetCurrentProcess(), modBase, dwTypeIndex, TI_GET_CHILDRENCOUNT, 417 | &dwChildrenCount); 418 | 419 | if (!dwChildrenCount) // If no children, we're done 420 | return pszCurrBuffer; 421 | 422 | // Prepare to get an array of "TypeIds", representing each of the children. 423 | // SymGetTypeInfo(TI_FINDCHILDREN) expects more memory than just a 424 | // TI_FINDCHILDREN_PARAMS struct has. Use derivation to accomplish this. 425 | struct FINDCHILDREN : TI_FINDCHILDREN_PARAMS 426 | { 427 | ULONG MoreChildIds[1024]; 428 | FINDCHILDREN(){ Count = sizeof(MoreChildIds) / sizeof(MoreChildIds[0]); } 429 | } children; 430 | 431 | children.Count = dwChildrenCount; 432 | children.Start = 0; 433 | 434 | // Get the array of TypeIds, one for each child type 435 | if (!GetDbghelpDll().SymGetTypeInfo(GetCurrentProcess(), modBase, dwTypeIndex, TI_FINDCHILDREN, 436 | &children)) 437 | { 438 | return pszCurrBuffer; 439 | } 440 | 441 | // Append a line feed 442 | pszCurrBuffer += sprintf(pszCurrBuffer, "\r\n"); 443 | 444 | // Iterate through each of the children 445 | for (unsigned i = 0; i < dwChildrenCount; i++) 446 | { 447 | // Add appropriate indentation level (since this routine is recursive) 448 | for (unsigned j = 0; j <= nestingLevel + 1; j++) 449 | pszCurrBuffer += sprintf(pszCurrBuffer, "\t"); 450 | 451 | // Recurse for each of the child types 452 | bool bHandled2; 453 | BasicType basicType = GetBasicType(children.ChildId[i], modBase); 454 | pszCurrBuffer += sprintf(pszCurrBuffer, rgBaseType[basicType]); 455 | 456 | pszCurrBuffer = DumpTypeIndex(pszCurrBuffer, modBase, 457 | children.ChildId[i], nestingLevel + 1, 458 | offset, bHandled2, ""/*Name */); 459 | 460 | // If the child wasn't a UDT, format it appropriately 461 | if (!bHandled2) 462 | { 463 | // Get the offset of the child member, relative to its parent 464 | DWORD dwMemberOffset; 465 | GetDbghelpDll().SymGetTypeInfo(GetCurrentProcess(), modBase, children.ChildId[i], 466 | TI_GET_OFFSET, &dwMemberOffset); 467 | 468 | // Get the real "TypeId" of the child. We need this for the 469 | // SymGetTypeInfo( TI_GET_TYPEID ) call below. 470 | DWORD typeId; 471 | GetDbghelpDll().SymGetTypeInfo(GetCurrentProcess(), modBase, children.ChildId[i], 472 | TI_GET_TYPEID, &typeId); 473 | 474 | // Get the size of the child member 475 | ULONG64 length; 476 | GetDbghelpDll().SymGetTypeInfo(GetCurrentProcess(), modBase, typeId, TI_GET_LENGTH, &length); 477 | 478 | // Calculate the address of the member 479 | DWORD_PTR dwFinalOffset = offset + dwMemberOffset; 480 | pszCurrBuffer = FormatOutputValue(pszCurrBuffer, basicType, 481 | length, (PVOID)dwFinalOffset); 482 | 483 | pszCurrBuffer += sprintf(pszCurrBuffer, "\r\n"); 484 | } 485 | } 486 | 487 | bHandled = true; 488 | return pszCurrBuffer; 489 | } 490 | 491 | BasicType GetBasicType(DWORD typeIndex, DWORD64 modBase) 492 | { 493 | BasicType basicType; 494 | if (GetDbghelpDll().SymGetTypeInfo(GetCurrentProcess(), modBase, typeIndex, 495 | TI_GET_BASETYPE, &basicType)) 496 | { 497 | return basicType; 498 | } 499 | 500 | // Get the real "TypeId" of the child. We need this for the 501 | // SymGetTypeInfo( TI_GET_TYPEID ) call below. 502 | DWORD typeId; 503 | if (GetDbghelpDll().SymGetTypeInfo(GetCurrentProcess(), modBase, typeIndex, TI_GET_TYPEID, &typeId)) 504 | { 505 | if (GetDbghelpDll().SymGetTypeInfo(GetCurrentProcess(), modBase, typeId, TI_GET_BASETYPE, 506 | &basicType)) 507 | { 508 | return basicType; 509 | } 510 | } 511 | 512 | return btNoType; 513 | } 514 | 515 | bool GetProcessorName(char* sProcessorName, DWORD maxcount) 516 | { 517 | assert(sProcessorName); 518 | HKEY hKey; 519 | LONG lRet = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, ("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"), 520 | 0, KEY_QUERY_VALUE, &hKey); 521 | if (lRet != ERROR_SUCCESS) 522 | { 523 | return false; 524 | } 525 | char szTmp[2048]; 526 | DWORD cntBytes = sizeof(szTmp); 527 | lRet = ::RegQueryValueEx(hKey, ("ProcessorNameString"), NULL, NULL, 528 | (LPBYTE)szTmp, &cntBytes); 529 | if (lRet != ERROR_SUCCESS) 530 | { 531 | return false; 532 | } 533 | ::RegCloseKey(hKey); 534 | sProcessorName[0] = '\0'; 535 | // Skip spaces 536 | char* psz = szTmp; 537 | while (isspace(*psz)) 538 | { 539 | ++psz; 540 | } 541 | strncpy(sProcessorName, psz, maxcount); 542 | return true; 543 | } 544 | 545 | typedef void (WINAPI* PGNSI)(LPSYSTEM_INFO); 546 | typedef BOOL (WINAPI* PGPI)(DWORD, DWORD, DWORD, DWORD, PDWORD); 547 | 548 | BOOL GetWindowsVersion(char* szVersion, DWORD cntMax) 549 | { 550 | OSVERSIONINFOEX osvi; 551 | SYSTEM_INFO si; 552 | PGNSI pGNSI; 553 | PGPI pGPI; 554 | BOOL bOsVersionInfoEx; 555 | DWORD dwType; 556 | 557 | ZeroMemory(&si, sizeof(SYSTEM_INFO)); 558 | ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX)); 559 | 560 | osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); 561 | bOsVersionInfoEx = GetVersionEx((OSVERSIONINFO*) &osvi); 562 | 563 | // Call GetNativeSystemInfo if supported or GetSystemInfo otherwise. 564 | pGNSI = (PGNSI) GetProcAddress( 565 | GetModuleHandle(TEXT("kernel32.dll")), 566 | "GetNativeSystemInfo"); 567 | if(NULL != pGNSI) 568 | { 569 | pGNSI(&si); 570 | } 571 | else 572 | { 573 | GetSystemInfo(&si); 574 | } 575 | 576 | if ( VER_PLATFORM_WIN32_NT == osvi.dwPlatformId && 577 | osvi.dwMajorVersion > 4 ) 578 | { 579 | strcpy_s(szVersion, cntMax, TEXT("Microsoft ")); 580 | 581 | // Test for the specific product. 582 | 583 | if ( osvi.dwMajorVersion == 6 ) 584 | { 585 | if( osvi.dwMinorVersion == 0 ) 586 | { 587 | if( osvi.wProductType == VER_NT_WORKSTATION ) 588 | { 589 | strcat_s(szVersion, cntMax, TEXT("Windows Vista ")); 590 | } 591 | else 592 | { 593 | strcat_s(szVersion, cntMax, TEXT("Windows Server 2008 " )); 594 | } 595 | } 596 | else if ( osvi.dwMinorVersion == 1 ) 597 | { 598 | if( osvi.wProductType == VER_NT_WORKSTATION ) 599 | { 600 | strcat_s(szVersion, cntMax, TEXT("Windows 7 ")); 601 | } 602 | else 603 | { 604 | strcat_s(szVersion, cntMax, TEXT("Windows Server 2008 R2 " )); 605 | } 606 | } 607 | else if ( osvi.dwMinorVersion == 2 ) 608 | { 609 | if( osvi.wProductType == VER_NT_WORKSTATION ) 610 | { 611 | strcat_s(szVersion, cntMax, TEXT("Windows 8 ")); 612 | } 613 | else 614 | { 615 | strcat_s(szVersion, cntMax, TEXT("Windows Server 2012 " )); 616 | } 617 | } 618 | 619 | pGPI = (PGPI) GetProcAddress( 620 | GetModuleHandle(TEXT("kernel32.dll")), 621 | "GetProductInfo"); 622 | 623 | pGPI( osvi.dwMajorVersion, osvi.dwMinorVersion, 0, 0, &dwType); 624 | switch( dwType ) 625 | { 626 | case PRODUCT_ULTIMATE: 627 | strcat_s(szVersion, cntMax, TEXT("Ultimate Edition" )); 628 | break; 629 | case PRODUCT_PROFESSIONAL: 630 | strcat_s(szVersion, cntMax, TEXT("Professional" )); 631 | break; 632 | case PRODUCT_HOME_PREMIUM: 633 | strcat_s(szVersion, cntMax, TEXT("Home Premium Edition" )); 634 | break; 635 | case PRODUCT_HOME_BASIC: 636 | strcat_s(szVersion, cntMax, TEXT("Home Basic Edition" )); 637 | break; 638 | case PRODUCT_ENTERPRISE: 639 | strcat_s(szVersion, cntMax, TEXT("Enterprise Edition" )); 640 | break; 641 | case PRODUCT_BUSINESS: 642 | strcat_s(szVersion, cntMax, TEXT("Business Edition" )); 643 | break; 644 | case PRODUCT_STARTER: 645 | strcat_s(szVersion, cntMax, TEXT("Starter Edition" )); 646 | break; 647 | case PRODUCT_CLUSTER_SERVER: 648 | strcat_s(szVersion, cntMax, TEXT("Cluster Server Edition" )); 649 | break; 650 | case PRODUCT_DATACENTER_SERVER: 651 | strcat_s(szVersion, cntMax, TEXT("Datacenter Edition" )); 652 | break; 653 | case PRODUCT_DATACENTER_SERVER_CORE: 654 | strcat_s(szVersion, cntMax, TEXT("Datacenter Edition (core installation)" )); 655 | break; 656 | case PRODUCT_ENTERPRISE_SERVER: 657 | strcat_s(szVersion, cntMax, TEXT("Enterprise Edition" )); 658 | break; 659 | case PRODUCT_ENTERPRISE_SERVER_CORE: 660 | strcat_s(szVersion, cntMax, TEXT("Enterprise Edition (core installation)" )); 661 | break; 662 | case PRODUCT_ENTERPRISE_SERVER_IA64: 663 | strcat_s(szVersion, cntMax, TEXT("Enterprise Edition for Itanium-based Systems" )); 664 | break; 665 | case PRODUCT_SMALLBUSINESS_SERVER: 666 | strcat_s(szVersion, cntMax, TEXT("Small Business Server" )); 667 | break; 668 | case PRODUCT_SMALLBUSINESS_SERVER_PREMIUM: 669 | strcat_s(szVersion, cntMax, TEXT("Small Business Server Premium Edition" )); 670 | break; 671 | case PRODUCT_STANDARD_SERVER: 672 | strcat_s(szVersion, cntMax, TEXT("Standard Edition" )); 673 | break; 674 | case PRODUCT_STANDARD_SERVER_CORE: 675 | strcat_s(szVersion, cntMax, TEXT("Standard Edition (core installation)" )); 676 | break; 677 | case PRODUCT_WEB_SERVER: 678 | strcat_s(szVersion, cntMax, TEXT("Web Server Edition" )); 679 | break; 680 | } 681 | } 682 | 683 | if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 ) 684 | { 685 | if( GetSystemMetrics(SM_SERVERR2) ) 686 | { 687 | strcat_s(szVersion, cntMax, TEXT( "Windows Server 2003 R2, ")); 688 | } 689 | else if ( osvi.wSuiteMask & VER_SUITE_STORAGE_SERVER ) 690 | { 691 | strcat_s(szVersion, cntMax, TEXT( "Windows Storage Server 2003")); 692 | } 693 | else if ( osvi.wSuiteMask & VER_SUITE_WH_SERVER ) 694 | { 695 | strcat_s(szVersion, cntMax, TEXT( "Windows Home Server")); 696 | } 697 | else if( osvi.wProductType == VER_NT_WORKSTATION && 698 | si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) 699 | { 700 | strcat_s(szVersion, cntMax, TEXT( "Windows XP Professional x64 Edition")); 701 | } 702 | else 703 | { 704 | strcat_s(szVersion, cntMax, TEXT("Windows Server 2003, ")); 705 | } 706 | 707 | // Test for the server type. 708 | if ( osvi.wProductType != VER_NT_WORKSTATION ) 709 | { 710 | if ( si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64 ) 711 | { 712 | if( osvi.wSuiteMask & VER_SUITE_DATACENTER ) 713 | { 714 | strcat_s(szVersion, cntMax, TEXT( "Datacenter Edition for Itanium-based Systems" )); 715 | } 716 | else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE ) 717 | { 718 | strcat_s(szVersion, cntMax, TEXT( "Enterprise Edition for Itanium-based Systems" )); 719 | } 720 | } 721 | else if ( si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 ) 722 | { 723 | if( osvi.wSuiteMask & VER_SUITE_DATACENTER ) 724 | { 725 | strcat_s(szVersion, cntMax, TEXT( "Datacenter x64 Edition" )); 726 | } 727 | else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE ) 728 | { 729 | strcat_s(szVersion, cntMax, TEXT( "Enterprise x64 Edition" )); 730 | } 731 | else 732 | { 733 | strcat_s(szVersion, cntMax, TEXT( "Standard x64 Edition" )); 734 | } 735 | } 736 | else 737 | { 738 | if ( osvi.wSuiteMask & VER_SUITE_COMPUTE_SERVER ) 739 | { 740 | strcat_s(szVersion, cntMax, TEXT( "Compute Cluster Edition" )); 741 | } 742 | else if( osvi.wSuiteMask & VER_SUITE_DATACENTER ) 743 | { 744 | strcat_s(szVersion, cntMax, TEXT( "Datacenter Edition" )); 745 | } 746 | else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE ) 747 | { 748 | strcat_s(szVersion, cntMax, TEXT( "Enterprise Edition" )); 749 | } 750 | else if ( osvi.wSuiteMask & VER_SUITE_BLADE ) 751 | { 752 | strcat_s(szVersion, cntMax, TEXT( "Web Edition" )); 753 | } 754 | else 755 | { 756 | strcat_s(szVersion, cntMax, TEXT( "Standard Edition" )); 757 | } 758 | } 759 | } 760 | } 761 | if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 ) 762 | { 763 | strcat_s(szVersion, cntMax, TEXT("Windows XP ")); 764 | if( osvi.wSuiteMask & VER_SUITE_PERSONAL ) 765 | { 766 | strcat_s(szVersion, cntMax, TEXT( "Home Edition" )); 767 | } 768 | else 769 | { 770 | strcat_s(szVersion, cntMax, TEXT( "Professional" )); 771 | } 772 | } 773 | 774 | if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 ) 775 | { 776 | strcat_s(szVersion, cntMax, TEXT("Windows 2000 ")); 777 | 778 | if ( osvi.wProductType == VER_NT_WORKSTATION ) 779 | { 780 | strcat_s(szVersion, cntMax, TEXT( "Professional" )); 781 | } 782 | else 783 | { 784 | if( osvi.wSuiteMask & VER_SUITE_DATACENTER ) 785 | { 786 | strcat_s(szVersion, cntMax, TEXT( "Datacenter Server" )); 787 | } 788 | else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE ) 789 | { 790 | strcat_s(szVersion, cntMax, TEXT( "Advanced Server" )); 791 | } 792 | else 793 | { 794 | strcat_s(szVersion, cntMax, TEXT( "Server" )); 795 | } 796 | } 797 | } 798 | 799 | // Include service pack (if any) and build number. 800 | if( strlen(osvi.szCSDVersion) > 0 ) 801 | { 802 | strcat_s(szVersion, cntMax, TEXT(" ") ); 803 | strcat_s(szVersion, cntMax, osvi.szCSDVersion); 804 | } 805 | 806 | TCHAR buf[80]; 807 | sprintf_s( buf, 80, TEXT(" (build %d)"), osvi.dwBuildNumber); 808 | strcat_s(szVersion, cntMax, buf); 809 | 810 | if ( osvi.dwMajorVersion >= 6 ) 811 | { 812 | if ( si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 ) 813 | { 814 | strcat_s(szVersion, cntMax, TEXT( ", 64-bit" )); 815 | } 816 | else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL ) 817 | { 818 | strcat_s(szVersion, cntMax, TEXT(", 32-bit")); 819 | } 820 | } 821 | return TRUE; 822 | } 823 | else 824 | { 825 | strcat_s(szVersion, cntMax, "This application does not support this version of Windows.\n"); 826 | return FALSE; 827 | } 828 | 829 | return TRUE; 830 | } 831 | 832 | void PrintSystemInfo() 833 | { 834 | SYSTEM_INFO SystemInfo; 835 | ::GetSystemInfo(&SystemInfo); 836 | 837 | MEMORYSTATUS MemoryStatus; 838 | MemoryStatus.dwLength = sizeof (MEMORYSTATUS); 839 | ::GlobalMemoryStatus(&MemoryStatus); 840 | 841 | TCHAR sString[1024]; 842 | AddToReport(("=====================================================\r\n")); 843 | if (GetProcessorName(sString, _countof(sString))) 844 | { 845 | AddToReport(("*** Hardware ***\r\nProcessor: %s\r\nNumber Of Processors: %d\r\n" 846 | "Physical Memory: %s (Available: %s)\r\nCommit Charge Limit: %s\r\n"), 847 | sString, SystemInfo.dwNumberOfProcessors, FileSizeToStr(MemoryStatus.dwTotalPhys).c_str(), 848 | FileSizeToStr(MemoryStatus.dwAvailPhys).c_str(), FileSizeToStr(MemoryStatus.dwTotalPageFile).c_str()); 849 | } 850 | else 851 | { 852 | AddToReport(("*** Hardware ***\r\nProcessor: \r\nNumber Of Processors: %d\r\n" 853 | "Physical Memory: %s (Available: %s)\r\nCommit Charge Limit: %s\r\n"), 854 | SystemInfo.dwNumberOfProcessors, FileSizeToStr(MemoryStatus.dwTotalPhys).c_str(), 855 | FileSizeToStr(MemoryStatus.dwAvailPhys).c_str(), FileSizeToStr(MemoryStatus.dwTotalPageFile).c_str()); 856 | } 857 | 858 | if(GetWindowsVersion(sString, _countof(sString))) 859 | { 860 | AddToReport(("\r\n*** Operation System ***\r\n%s\r\n"), sString); 861 | } 862 | else 863 | { 864 | AddToReport(("\r\n*** Operation System:\r\n\r\n")); 865 | } 866 | } 867 | -------------------------------------------------------------------------------- /src/Report.h: -------------------------------------------------------------------------------- 1 | // Copyright (C) 2013-present prototyped.cn All rights reserved. 2 | // Distributed under the terms and conditions of the Apache License. 3 | // See accompanying files LICENSE. 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | enum 10 | { 11 | // Max symbol name length 12 | MAX_NAME_LEN = 1024, 13 | 14 | // To prevent recursion which could result from corrupted data we limit 15 | // ourselves to that many levels of embedded fields inside structs 16 | MAX_DUMP_DEPTH = 20, 17 | 18 | // Max buffer length 19 | MAX_BUF_SIZE = 4 * 1024, 20 | }; 21 | 22 | 23 | static const char* const rgBaseType[] = 24 | { 25 | " ", // btNoType = 0, 26 | " void ", // btVoid = 1, 27 | " char* ", // btChar = 2, 28 | " wchar_t* ", // btWChar = 3, 29 | " signed char ", 30 | " unsigned char ", 31 | " int ", // btInt = 6, 32 | " unsigned int ", // btUInt = 7, 33 | " float ", // btFloat = 8, 34 | " ", // btBCD = 9, 35 | " bool ", // btBool = 10, 36 | " short ", 37 | " unsigned short ", 38 | " long ", // btLong = 13, 39 | " unsigned long ", // btULong = 14, 40 | " __int8 ", 41 | " __int16 ", 42 | " __int32 ", 43 | " __int64 ", 44 | " __int128 ", 45 | " unsigned __int8 ", 46 | " unsigned __int16 ", 47 | " unsigned __int32 ", 48 | " unsigned __int64 ", 49 | " unsigned __int128 ", 50 | " ", // btCurrency = 25, 51 | " ", // btDate = 26, 52 | " VARIANT ", // btVariant = 27, 53 | " ", // btComplex = 28, 54 | " ", // btBit = 29, 55 | " BSTR ", // btBSTR = 30, 56 | " HRESULT " // btHresult = 31 57 | }; 58 | 59 | 60 | // Create stack frame log of this exception 61 | void CreateReport(EXCEPTION_POINTERS* ep); 62 | -------------------------------------------------------------------------------- /src/Utility.cpp: -------------------------------------------------------------------------------- 1 | /************************************************************************************* 2 | This file is a part of CrashRpt library. 3 | Copyright (c) 2003-2013 The CrashRpt project authors. All Rights Reserved. 4 | 5 | Use of this source code is governed by a BSD-style license 6 | that can be found in the License.txt file in the root of the source 7 | tree. All contributing project authors may 8 | be found in the Authors.txt file in the root of the source tree. 9 | ***************************************************************************************/ 10 | 11 | // File: Utility.cpp 12 | // Description: Miscellaneous helper functions 13 | // Authors: mikecarruth, zexspectrum 14 | // Date: 15 | 16 | 17 | #include "Utility.h" 18 | #include 19 | #include 20 | #include 21 | #include 22 | 23 | 24 | #pragma warning(disable: 4996) 25 | 26 | #ifndef va_copy 27 | // This is a hack, assuming va_list is simply a pointer into the stack and is safe to copy. 28 | #define va_copy(dest, src) ((dest) = (src)) 29 | #endif 30 | 31 | void StringAppendV(std::string* dst, const char* format, va_list ap) 32 | { 33 | // First try with a small fixed size buffer 34 | static const int kSpaceLength = 1024; 35 | char space[kSpaceLength]; 36 | 37 | // It's possible for methods that use a va_list to invalidate 38 | // the data in it upon use. The fix is to make a copy 39 | // of the structure before using it and use that copy instead. 40 | va_list backup_ap; 41 | va_copy(backup_ap, ap); 42 | int result = vsnprintf(space, kSpaceLength, format, backup_ap); 43 | va_end(backup_ap); 44 | 45 | if (result < kSpaceLength) 46 | { 47 | if (result >= 0) { 48 | // Normal case -- everything fit. 49 | dst->append(space, result); 50 | return; 51 | } 52 | 53 | // Error or MSVC running out of space. MSVC 8.0 and higher 54 | // can be asked about space needed with the special idiom below: 55 | va_copy(backup_ap, ap); 56 | result = vsnprintf(NULL, 0, format, backup_ap); 57 | va_end(backup_ap); 58 | 59 | if (result < 0) 60 | { 61 | // Just an error. 62 | return; 63 | } 64 | } 65 | 66 | // Increase the buffer size to the size requested by vsnprintf, 67 | // plus one for the closing \0. 68 | int length = result + 1; 69 | char* buf = new char[length]; 70 | 71 | // Restore the va_list before we use it again 72 | va_copy(backup_ap, ap); 73 | result = vsnprintf(buf, length, format, backup_ap); 74 | va_end(backup_ap); 75 | 76 | if (result >= 0 && result < length) 77 | { 78 | // It fit 79 | dst->append(buf, result); 80 | } 81 | delete[] buf; 82 | } 83 | 84 | std::string StringPrintf(const char* format, ...) 85 | { 86 | va_list ap; 87 | va_start(ap, format); 88 | std::string result; 89 | StringAppendV(&result, format, ap); 90 | va_end(ap); 91 | return result; 92 | } 93 | 94 | // Returns mudule name of the launched current process. 95 | std::string GetModuleName(HMODULE hModule) 96 | { 97 | char szFileName[MAX_PATH]; 98 | GetModuleFileNameA(hModule, szFileName, _MAX_FNAME); 99 | std::string sAppName = szFileName; 100 | size_t start = sAppName.find_last_of('\\') + 1; 101 | return sAppName.substr(start); 102 | } 103 | 104 | // Returns base name of the EXE file that launched current process. 105 | std::string GetAppName() 106 | { 107 | const std::string& sAppName = GetModuleName(NULL); 108 | size_t end = sAppName.find_last_of('.'); 109 | return sAppName.substr(0, end); 110 | } 111 | 112 | 113 | // Formats a string of file size 114 | std::string FileSizeToStr(ULONG64 uFileSize) 115 | { 116 | char szSize[MAX_PATH]; 117 | if (uFileSize == 0) 118 | { 119 | return "0 KB"; 120 | } 121 | else if (uFileSize < 1024) 122 | { 123 | float fSizeKbytes = (float)uFileSize / 1024.0f; 124 | sprintf_s(szSize, MAX_PATH, ("%0.1f KB"), fSizeKbytes); 125 | } 126 | else if (uFileSize < 1024*1024) 127 | { 128 | sprintf_s(szSize, MAX_PATH, ("%I64u KB"), uFileSize / 1024); 129 | } 130 | else 131 | { 132 | float fSizeMbytes = (float)uFileSize / (float)(1024*1024); 133 | sprintf_s(szSize, MAX_PATH, ("%0.1f MB"), fSizeMbytes); 134 | } 135 | return szSize; 136 | } 137 | 138 | // Description of calling thread's last error code 139 | std::string GetErrorMessage(DWORD dwError) 140 | { 141 | char szbuffer[BUFSIZ]; 142 | DWORD dwLen = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, 143 | dwError, 0, szbuffer, BUFSIZ-1, NULL); 144 | if (dwLen == 0) 145 | { 146 | return ("?"); 147 | } 148 | return std::string(szbuffer, dwLen); 149 | } 150 | 151 | void WriteTextToFile(const std::string& module, const std::string& message) 152 | { 153 | char filename[MAX_PATH]; 154 | time_t now = time(NULL); 155 | tm date = *localtime(&now); 156 | int r = sprintf_s(filename, MAX_PATH, "%s_%d-%02d-%02d.log", module.c_str(), date.tm_year + 1900, 157 | date.tm_mon + 1, date.tm_mday); 158 | if (r <= 0) 159 | { 160 | return; 161 | } 162 | FILE* fp = fopen(filename, "a+"); 163 | if (fp) 164 | { 165 | fwrite(message.c_str(), 1, message.size(), fp); 166 | fclose(fp); 167 | } 168 | } 169 | 170 | 171 | #ifndef _AddressOfReturnAddress 172 | 173 | // Taken from: http://msdn.microsoft.com/en-us/library/s975zw7k(VS.71).aspx 174 | #ifdef __cplusplus 175 | #define EXTERNC extern "C" 176 | #else 177 | #define EXTERNC 178 | #endif 179 | 180 | // _ReturnAddress and _AddressOfReturnAddress should be prototyped before use 181 | EXTERNC void * _AddressOfReturnAddress(void); 182 | EXTERNC void * _ReturnAddress(void); 183 | 184 | #endif 185 | 186 | 187 | // The following code gets exception pointers using a workaround found in CRT code. 188 | void GetExceptionPointers(DWORD dwExceptionCode, EXCEPTION_POINTERS* pExceptionPointers) 189 | { 190 | // The following code was taken from VC++ 8.0 CRT (invarg.c: line 104) 191 | CONTEXT ContextRecord; 192 | memset(&ContextRecord, 0, sizeof(CONTEXT)); 193 | 194 | #ifdef _X86_ 195 | __asm { 196 | mov dword ptr [ContextRecord.Eax], eax 197 | mov dword ptr [ContextRecord.Ecx], ecx 198 | mov dword ptr [ContextRecord.Edx], edx 199 | mov dword ptr [ContextRecord.Ebx], ebx 200 | mov dword ptr [ContextRecord.Esi], esi 201 | mov dword ptr [ContextRecord.Edi], edi 202 | mov word ptr [ContextRecord.SegSs], ss 203 | mov word ptr [ContextRecord.SegCs], cs 204 | mov word ptr [ContextRecord.SegDs], ds 205 | mov word ptr [ContextRecord.SegEs], es 206 | mov word ptr [ContextRecord.SegFs], fs 207 | mov word ptr [ContextRecord.SegGs], gs 208 | pushfd 209 | pop [ContextRecord.EFlags] 210 | } 211 | 212 | ContextRecord.ContextFlags = CONTEXT_CONTROL; 213 | #pragma warning(push) 214 | #pragma warning(disable:4311) 215 | ContextRecord.Eip = (ULONG)_ReturnAddress(); 216 | ContextRecord.Esp = (ULONG)_AddressOfReturnAddress(); 217 | #pragma warning(pop) 218 | ContextRecord.Ebp = *((ULONG *)_AddressOfReturnAddress()-1); 219 | 220 | #elif defined (_IA64_) || defined (_AMD64_) 221 | 222 | /* Need to fill up the Context in IA64 and AMD64. */ 223 | RtlCaptureContext(&ContextRecord); 224 | 225 | #else /* defined (_IA64_) || defined (_AMD64_) */ 226 | 227 | ZeroMemory(&ContextRecord, sizeof(ContextRecord)); 228 | 229 | #endif /* defined (_IA64_) || defined (_AMD64_) */ 230 | 231 | memcpy(pExceptionPointers->ContextRecord, &ContextRecord, sizeof(CONTEXT)); 232 | 233 | ZeroMemory(pExceptionPointers->ExceptionRecord, sizeof(EXCEPTION_RECORD)); 234 | 235 | pExceptionPointers->ExceptionRecord->ExceptionCode = dwExceptionCode; 236 | pExceptionPointers->ExceptionRecord->ExceptionAddress = _ReturnAddress(); 237 | } 238 | -------------------------------------------------------------------------------- /src/Utility.h: -------------------------------------------------------------------------------- 1 | /************************************************************************************* 2 | This file is a part of CrashRpt library. 3 | Copyright (c) 2003-2013 The CrashRpt project authors. All Rights Reserved. 4 | 5 | Use of this source code is governed by a BSD-style license 6 | that can be found in the License.txt file in the root of the source 7 | tree. All contributing project authors may 8 | be found in the Authors.txt file in the root of the source tree. 9 | ***************************************************************************************/ 10 | 11 | // File: Utility.h 12 | // Description: Miscellaneous helper functions 13 | // Authors: mikecarruth, zexspectrum 14 | // Date: 15 | 16 | 17 | #pragma once 18 | 19 | #include 20 | #include // For va_list and related operations 21 | #include 22 | #include 23 | #include 24 | 25 | #pragma warning(disable: 4127) 26 | 27 | // Formats a string of file size 28 | std::string FileSizeToStr(ULONG64 uFileSize); 29 | 30 | // Printf-like, but std::string as return value 31 | std::string StringPrintf(const char* format, ...); 32 | 33 | // Lower-level routine that takes a va_list and appends to a specified 34 | // string. All other routines are just convenience wrappers around it. 35 | void StringAppendV(std::string* dst, const char* format, va_list ap); 36 | 37 | // Returns mudule name of the launched current process. 38 | std::string GetModuleName(HMODULE hModule); 39 | 40 | 41 | // Returns base name of the EXE file that launched current process. 42 | std::string GetAppName(); 43 | 44 | 45 | // Description of calling thread's last error code 46 | std::string GetErrorMessage(DWORD dwError); 47 | 48 | 49 | // Write text string to file 50 | void WriteTextToFile(const std::string& module, const std::string& message); 51 | 52 | 53 | // Get exception pointers 54 | void GetExceptionPointers(DWORD dwExceptionCode, EXCEPTION_POINTERS* pExceptionPointers); 55 | 56 | 57 | #define LogLastError() do { \ 58 | std::string msg = GetErrorMessage(::GetLastError()); \ 59 | WriteTextToFile("FATAL", StringPrintf("%s()[Line: %d][Error: 0x%x]\n%s\r\n", \ 60 | __FUNCTION__, __LINE__, ::GetLastError(), msg.c_str())); \ 61 | } while (false); 62 | 63 | 64 | // Auto free dll handle wrapper 65 | struct DllHandle 66 | { 67 | explicit DllHandle(const char* path) 68 | : handle_(::LoadLibraryA(path)) 69 | { 70 | assert(handle_); 71 | } 72 | 73 | ~DllHandle() 74 | { 75 | if (handle_ != NULL) 76 | { 77 | ::FreeLibrary(handle_); 78 | handle_ = NULL; 79 | } 80 | } 81 | 82 | FARPROC GetFuncAddress(const char* funcname) 83 | { 84 | assert(handle_ && funcname); 85 | return ::GetProcAddress(handle_, funcname); 86 | } 87 | 88 | HMODULE handle_; 89 | }; 90 | -------------------------------------------------------------------------------- /src/cvconst.h: -------------------------------------------------------------------------------- 1 | // cvconst.h - codeview constant definitions 2 | //----------------------------------------------------------------- 3 | // 4 | // Copyright Microsoft Corporation. All Rights Reserved. 5 | // 6 | //--------------------------------------------------------------- 7 | #ifndef _CVCONST_H_ 8 | #define _CVCONST_H_ 9 | 10 | 11 | 12 | // Enumeration for function call type 13 | 14 | 15 | typedef enum CV_call_e { 16 | CV_CALL_NEAR_C = 0x00, // near right to left push, caller pops stack 17 | CV_CALL_FAR_C = 0x01, // far right to left push, caller pops stack 18 | CV_CALL_NEAR_PASCAL = 0x02, // near left to right push, callee pops stack 19 | CV_CALL_FAR_PASCAL = 0x03, // far left to right push, callee pops stack 20 | CV_CALL_NEAR_FAST = 0x04, // near left to right push with regs, callee pops stack 21 | CV_CALL_FAR_FAST = 0x05, // far left to right push with regs, callee pops stack 22 | CV_CALL_SKIPPED = 0x06, // skipped (unused) call index 23 | CV_CALL_NEAR_STD = 0x07, // near standard call 24 | CV_CALL_FAR_STD = 0x08, // far standard call 25 | CV_CALL_NEAR_SYS = 0x09, // near sys call 26 | CV_CALL_FAR_SYS = 0x0a, // far sys call 27 | CV_CALL_THISCALL = 0x0b, // this call (this passed in register) 28 | CV_CALL_MIPSCALL = 0x0c, // Mips call 29 | CV_CALL_GENERIC = 0x0d, // Generic call sequence 30 | CV_CALL_ALPHACALL = 0x0e, // Alpha call 31 | CV_CALL_PPCCALL = 0x0f, // PPC call 32 | CV_CALL_SHCALL = 0x10, // Hitachi SuperH call 33 | CV_CALL_ARMCALL = 0x11, // ARM call 34 | CV_CALL_AM33CALL = 0x12, // AM33 call 35 | CV_CALL_TRICALL = 0x13, // TriCore Call 36 | CV_CALL_SH5CALL = 0x14, // Hitachi SuperH-5 call 37 | CV_CALL_M32RCALL = 0x15, // M32R Call 38 | CV_CALL_CLRCALL = 0x16, // clr call 39 | CV_CALL_INLINE = 0x17, // Marker for routines always inlined and thus lacking a convention 40 | CV_CALL_RESERVED = 0x18 // first unused call enumeration 41 | 42 | // Do NOT add any more machine specific conventions. This is to be used for 43 | // calling conventions in the source only (e.g. __cdecl, __stdcall). 44 | } CV_call_e; 45 | 46 | 47 | // Values for the access protection of class attributes 48 | 49 | 50 | typedef enum CV_access_e { 51 | CV_private = 1, 52 | CV_protected = 2, 53 | CV_public = 3 54 | } CV_access_e; 55 | 56 | typedef enum THUNK_ORDINAL { 57 | THUNK_ORDINAL_NOTYPE, // standard thunk 58 | THUNK_ORDINAL_ADJUSTOR, // "this" adjustor thunk 59 | THUNK_ORDINAL_VCALL, // virtual call thunk 60 | THUNK_ORDINAL_PCODE, // pcode thunk 61 | THUNK_ORDINAL_LOAD, // thunk which loads the address to jump to 62 | // via unknown means... 63 | 64 | // trampoline thunk ordinals - only for use in Trampoline thunk symbols 65 | THUNK_ORDINAL_TRAMP_INCREMENTAL, 66 | THUNK_ORDINAL_TRAMP_BRANCHISLAND, 67 | 68 | } THUNK_ORDINAL; 69 | 70 | 71 | enum CV_SourceChksum_t { 72 | CHKSUM_TYPE_NONE = 0, // indicates no checksum is available 73 | CHKSUM_TYPE_MD5, 74 | CHKSUM_TYPE_SHA1 75 | }; 76 | 77 | // 78 | // DIA enums 79 | // 80 | 81 | enum SymTagEnum 82 | { 83 | SymTagNull, 84 | SymTagExe, 85 | SymTagCompiland, 86 | SymTagCompilandDetails, 87 | SymTagCompilandEnv, 88 | SymTagFunction, 89 | SymTagBlock, 90 | SymTagData, 91 | SymTagAnnotation, 92 | SymTagLabel, 93 | SymTagPublicSymbol, 94 | SymTagUDT, 95 | SymTagEnum, 96 | SymTagFunctionType, 97 | SymTagPointerType, 98 | SymTagArrayType, 99 | SymTagBaseType, 100 | SymTagTypedef, 101 | SymTagBaseClass, 102 | SymTagFriend, 103 | SymTagFunctionArgType, 104 | SymTagFuncDebugStart, 105 | SymTagFuncDebugEnd, 106 | SymTagUsingNamespace, 107 | SymTagVTableShape, 108 | SymTagVTable, 109 | SymTagCustom, 110 | SymTagThunk, 111 | SymTagCustomType, 112 | SymTagManagedType, 113 | SymTagDimension, 114 | SymTagCallSite, 115 | SymTagInlineSite, 116 | SymTagBaseInterface, 117 | SymTagVectorType, 118 | SymTagMatrixType, 119 | SymTagHLSLType, 120 | SymTagMax 121 | }; 122 | 123 | enum LocationType 124 | { 125 | LocIsNull, 126 | LocIsStatic, 127 | LocIsTLS, 128 | LocIsRegRel, 129 | LocIsThisRel, 130 | LocIsEnregistered, 131 | LocIsBitField, 132 | LocIsSlot, 133 | LocIsIlRel, 134 | LocInMetaData, 135 | LocIsConstant, 136 | LocTypeMax 137 | }; 138 | 139 | enum DataKind 140 | { 141 | DataIsUnknown, 142 | DataIsLocal, 143 | DataIsStaticLocal, 144 | DataIsParam, 145 | DataIsObjectPtr, 146 | DataIsFileStatic, 147 | DataIsGlobal, 148 | DataIsMember, 149 | DataIsStaticMember, 150 | DataIsConstant 151 | }; 152 | 153 | enum UdtKind 154 | { 155 | UdtStruct, 156 | UdtClass, 157 | UdtUnion, 158 | UdtInterface 159 | }; 160 | 161 | enum BasicType 162 | { 163 | btNoType = 0, 164 | btVoid = 1, 165 | btChar = 2, 166 | btWChar = 3, 167 | btInt = 6, 168 | btUInt = 7, 169 | btFloat = 8, 170 | btBCD = 9, 171 | btBool = 10, 172 | btLong = 13, 173 | btULong = 14, 174 | btCurrency = 25, 175 | btDate = 26, 176 | btVariant = 27, 177 | btComplex = 28, 178 | btBit = 29, 179 | btBSTR = 30, 180 | btHresult = 31 181 | }; 182 | 183 | 184 | // enumeration for type modifier values 185 | 186 | typedef enum CV_modifier_e { 187 | // 0x0000 - 0x01ff - Reserved. 188 | 189 | CV_MOD_INVALID = 0x0000, 190 | 191 | // Standard modifiers. 192 | 193 | CV_MOD_CONST = 0x0001, 194 | CV_MOD_VOLATILE = 0x0002, 195 | CV_MOD_UNALIGNED = 0x0003, 196 | 197 | // 0x0200 - 0x03ff - HLSL modifiers. 198 | 199 | CV_MOD_HLSL_UNIFORM = 0x0200, 200 | CV_MOD_HLSL_LINE = 0x0201, 201 | CV_MOD_HLSL_TRIANGLE = 0x0202, 202 | CV_MOD_HLSL_LINEADJ = 0x0203, 203 | CV_MOD_HLSL_TRIANGLEADJ = 0x0204, 204 | CV_MOD_HLSL_LINEAR = 0x0205, 205 | CV_MOD_HLSL_CENTROID = 0x0206, 206 | CV_MOD_HLSL_CONSTINTERP = 0x0207, 207 | CV_MOD_HLSL_NOPERSPECTIVE = 0x0208, 208 | CV_MOD_HLSL_SAMPLE = 0x0209, 209 | CV_MOD_HLSL_CENTER = 0x020a, 210 | CV_MOD_HLSL_SNORM = 0x020b, 211 | CV_MOD_HLSL_UNORM = 0x020c, 212 | CV_MOD_HLSL_PRECISE = 0x020d, 213 | CV_MOD_HLSL_UAV_GLOBALLY_COHERENT = 0x020e, 214 | 215 | // 0x0400 - 0xffff - Unused. 216 | 217 | } CV_modifier_e; 218 | 219 | 220 | // built-in type kinds 221 | 222 | 223 | typedef enum CV_builtin_e { 224 | 225 | // 0x0000 - 0x01ff - Reserved. 226 | CV_BI_INVALID = 0x0000, 227 | 228 | // 0x0200 - 0x03ff - HLSL types. 229 | 230 | CV_BI_HLSL_INTERFACE_POINTER = 0x0200, 231 | CV_BI_HLSL_TEXTURE1D = 0x0201, 232 | CV_BI_HLSL_TEXTURE1D_ARRAY = 0x0202, 233 | CV_BI_HLSL_TEXTURE2D = 0x0203, 234 | CV_BI_HLSL_TEXTURE2D_ARRAY = 0x0204, 235 | CV_BI_HLSL_TEXTURE3D = 0x0205, 236 | CV_BI_HLSL_TEXTURECUBE = 0x0206, 237 | CV_BI_HLSL_TEXTURECUBE_ARRAY = 0x0207, 238 | CV_BI_HLSL_TEXTURE2DMS = 0x0208, 239 | CV_BI_HLSL_TEXTURE2DMS_ARRAY = 0x0209, 240 | CV_BI_HLSL_SAMPLER = 0x020a, 241 | CV_BI_HLSL_SAMPLERCOMPARISON = 0x020b, 242 | CV_BI_HLSL_BUFFER = 0x020c, 243 | CV_BI_HLSL_POINTSTREAM = 0x020d, 244 | CV_BI_HLSL_LINESTREAM = 0x020e, 245 | CV_BI_HLSL_TRIANGLESTREAM = 0x020f, 246 | CV_BI_HLSL_INPUTPATCH = 0x0210, 247 | CV_BI_HLSL_OUTPUTPATCH = 0x0211, 248 | CV_BI_HLSL_RWTEXTURE1D = 0x0212, 249 | CV_BI_HLSL_RWTEXTURE1D_ARRAY = 0x0213, 250 | CV_BI_HLSL_RWTEXTURE2D = 0x0214, 251 | CV_BI_HLSL_RWTEXTURE2D_ARRAY = 0x0215, 252 | CV_BI_HLSL_RWTEXTURE3D = 0x0216, 253 | CV_BI_HLSL_RWBUFFER = 0x0217, 254 | CV_BI_HLSL_BYTEADDRESS_BUFFER = 0x0218, 255 | CV_BI_HLSL_RWBYTEADDRESS_BUFFER = 0x0219, 256 | CV_BI_HLSL_STRUCTURED_BUFFER = 0x021a, 257 | CV_BI_HLSL_RWSTRUCTURED_BUFFER = 0x021b, 258 | CV_BI_HLSL_APPEND_STRUCTURED_BUFFER = 0x021c, 259 | CV_BI_HLSL_CONSUME_STRUCTURED_BUFFER= 0x021d, 260 | CV_BI_HLSL_MIN8FLOAT = 0x021e, 261 | CV_BI_HLSL_MIN10FLOAT = 0x021f, 262 | CV_BI_HLSL_MIN16FLOAT = 0x0220, 263 | CV_BI_HLSL_MIN12INT = 0x0221, 264 | CV_BI_HLSL_MIN16INT = 0x0222, 265 | CV_BI_HLSL_MIN16UINT = 0x0223, 266 | 267 | // 0x0400 - 0xffff - Unused. 268 | 269 | } CV_builtin_e; 270 | 271 | 272 | // enum describing the compile flag source language 273 | 274 | 275 | typedef enum CV_CFL_LANG { 276 | CV_CFL_C = 0x00, 277 | CV_CFL_CXX = 0x01, 278 | CV_CFL_FORTRAN = 0x02, 279 | CV_CFL_MASM = 0x03, 280 | CV_CFL_PASCAL = 0x04, 281 | CV_CFL_BASIC = 0x05, 282 | CV_CFL_COBOL = 0x06, 283 | CV_CFL_LINK = 0x07, 284 | CV_CFL_CVTRES = 0x08, 285 | CV_CFL_CVTPGD = 0x09, 286 | CV_CFL_CSHARP = 0x0A, // C# 287 | CV_CFL_VB = 0x0B, // Visual Basic 288 | CV_CFL_ILASM = 0x0C, // IL (as in CLR) ASM 289 | CV_CFL_JAVA = 0x0D, 290 | CV_CFL_JSCRIPT = 0x0E, 291 | CV_CFL_MSIL = 0x0F, // Unknown MSIL (LTCG of .NETMODULE) 292 | CV_CFL_HLSL = 0x10, // High Level Shader Language 293 | } CV_CFL_LANG; 294 | 295 | 296 | // enum describing target processor 297 | 298 | 299 | typedef enum CV_CPU_TYPE_e { 300 | CV_CFL_8080 = 0x00, 301 | CV_CFL_8086 = 0x01, 302 | CV_CFL_80286 = 0x02, 303 | CV_CFL_80386 = 0x03, 304 | CV_CFL_80486 = 0x04, 305 | CV_CFL_PENTIUM = 0x05, 306 | CV_CFL_PENTIUMII = 0x06, 307 | CV_CFL_PENTIUMPRO = CV_CFL_PENTIUMII, 308 | CV_CFL_PENTIUMIII = 0x07, 309 | CV_CFL_MIPS = 0x10, 310 | CV_CFL_MIPSR4000 = CV_CFL_MIPS, // don't break current code 311 | CV_CFL_MIPS16 = 0x11, 312 | CV_CFL_MIPS32 = 0x12, 313 | CV_CFL_MIPS64 = 0x13, 314 | CV_CFL_MIPSI = 0x14, 315 | CV_CFL_MIPSII = 0x15, 316 | CV_CFL_MIPSIII = 0x16, 317 | CV_CFL_MIPSIV = 0x17, 318 | CV_CFL_MIPSV = 0x18, 319 | CV_CFL_M68000 = 0x20, 320 | CV_CFL_M68010 = 0x21, 321 | CV_CFL_M68020 = 0x22, 322 | CV_CFL_M68030 = 0x23, 323 | CV_CFL_M68040 = 0x24, 324 | CV_CFL_ALPHA = 0x30, 325 | CV_CFL_ALPHA_21064 = 0x30, 326 | CV_CFL_ALPHA_21164 = 0x31, 327 | CV_CFL_ALPHA_21164A = 0x32, 328 | CV_CFL_ALPHA_21264 = 0x33, 329 | CV_CFL_ALPHA_21364 = 0x34, 330 | CV_CFL_PPC601 = 0x40, 331 | CV_CFL_PPC603 = 0x41, 332 | CV_CFL_PPC604 = 0x42, 333 | CV_CFL_PPC620 = 0x43, 334 | CV_CFL_PPCFP = 0x44, 335 | CV_CFL_PPCBE = 0x45, 336 | CV_CFL_SH3 = 0x50, 337 | CV_CFL_SH3E = 0x51, 338 | CV_CFL_SH3DSP = 0x52, 339 | CV_CFL_SH4 = 0x53, 340 | CV_CFL_SHMEDIA = 0x54, 341 | CV_CFL_ARM3 = 0x60, 342 | CV_CFL_ARM4 = 0x61, 343 | CV_CFL_ARM4T = 0x62, 344 | CV_CFL_ARM5 = 0x63, 345 | CV_CFL_ARM5T = 0x64, 346 | CV_CFL_ARM6 = 0x65, 347 | CV_CFL_ARM_XMAC = 0x66, 348 | CV_CFL_ARM_WMMX = 0x67, 349 | CV_CFL_ARM7 = 0x68, 350 | CV_CFL_OMNI = 0x70, 351 | CV_CFL_IA64 = 0x80, 352 | CV_CFL_IA64_1 = 0x80, 353 | CV_CFL_IA64_2 = 0x81, 354 | CV_CFL_CEE = 0x90, 355 | CV_CFL_AM33 = 0xA0, 356 | CV_CFL_M32R = 0xB0, 357 | CV_CFL_TRICORE = 0xC0, 358 | CV_CFL_X64 = 0xD0, 359 | CV_CFL_AMD64 = CV_CFL_X64, 360 | CV_CFL_EBC = 0xE0, 361 | CV_CFL_THUMB = 0xF0, 362 | CV_CFL_ARMNT = 0xF4, 363 | CV_CFL_D3D11_SHADER = 0x100, 364 | } CV_CPU_TYPE_e; 365 | 366 | typedef enum CV_HREG_e { 367 | // Register subset shared by all processor types, 368 | // must not overlap with any of the ranges below, hence the high values 369 | 370 | CV_ALLREG_ERR = 30000, 371 | CV_ALLREG_TEB = 30001, 372 | CV_ALLREG_TIMER = 30002, 373 | CV_ALLREG_EFAD1 = 30003, 374 | CV_ALLREG_EFAD2 = 30004, 375 | CV_ALLREG_EFAD3 = 30005, 376 | CV_ALLREG_VFRAME= 30006, 377 | CV_ALLREG_HANDLE= 30007, 378 | CV_ALLREG_PARAMS= 30008, 379 | CV_ALLREG_LOCALS= 30009, 380 | CV_ALLREG_TID = 30010, 381 | CV_ALLREG_ENV = 30011, 382 | CV_ALLREG_CMDLN = 30012, 383 | 384 | 385 | // Register set for the Intel 80x86 and ix86 processor series 386 | // (plus PCODE registers) 387 | 388 | CV_REG_NONE = 0, 389 | CV_REG_AL = 1, 390 | CV_REG_CL = 2, 391 | CV_REG_DL = 3, 392 | CV_REG_BL = 4, 393 | CV_REG_AH = 5, 394 | CV_REG_CH = 6, 395 | CV_REG_DH = 7, 396 | CV_REG_BH = 8, 397 | CV_REG_AX = 9, 398 | CV_REG_CX = 10, 399 | CV_REG_DX = 11, 400 | CV_REG_BX = 12, 401 | CV_REG_SP = 13, 402 | CV_REG_BP = 14, 403 | CV_REG_SI = 15, 404 | CV_REG_DI = 16, 405 | CV_REG_EAX = 17, 406 | CV_REG_ECX = 18, 407 | CV_REG_EDX = 19, 408 | CV_REG_EBX = 20, 409 | CV_REG_ESP = 21, 410 | CV_REG_EBP = 22, 411 | CV_REG_ESI = 23, 412 | CV_REG_EDI = 24, 413 | CV_REG_ES = 25, 414 | CV_REG_CS = 26, 415 | CV_REG_SS = 27, 416 | CV_REG_DS = 28, 417 | CV_REG_FS = 29, 418 | CV_REG_GS = 30, 419 | CV_REG_IP = 31, 420 | CV_REG_FLAGS = 32, 421 | CV_REG_EIP = 33, 422 | CV_REG_EFLAGS = 34, 423 | CV_REG_TEMP = 40, // PCODE Temp 424 | CV_REG_TEMPH = 41, // PCODE TempH 425 | CV_REG_QUOTE = 42, // PCODE Quote 426 | CV_REG_PCDR3 = 43, // PCODE reserved 427 | CV_REG_PCDR4 = 44, // PCODE reserved 428 | CV_REG_PCDR5 = 45, // PCODE reserved 429 | CV_REG_PCDR6 = 46, // PCODE reserved 430 | CV_REG_PCDR7 = 47, // PCODE reserved 431 | CV_REG_CR0 = 80, // CR0 -- control registers 432 | CV_REG_CR1 = 81, 433 | CV_REG_CR2 = 82, 434 | CV_REG_CR3 = 83, 435 | CV_REG_CR4 = 84, // Pentium 436 | CV_REG_DR0 = 90, // Debug register 437 | CV_REG_DR1 = 91, 438 | CV_REG_DR2 = 92, 439 | CV_REG_DR3 = 93, 440 | CV_REG_DR4 = 94, 441 | CV_REG_DR5 = 95, 442 | CV_REG_DR6 = 96, 443 | CV_REG_DR7 = 97, 444 | CV_REG_GDTR = 110, 445 | CV_REG_GDTL = 111, 446 | CV_REG_IDTR = 112, 447 | CV_REG_IDTL = 113, 448 | CV_REG_LDTR = 114, 449 | CV_REG_TR = 115, 450 | 451 | CV_REG_PSEUDO1 = 116, 452 | CV_REG_PSEUDO2 = 117, 453 | CV_REG_PSEUDO3 = 118, 454 | CV_REG_PSEUDO4 = 119, 455 | CV_REG_PSEUDO5 = 120, 456 | CV_REG_PSEUDO6 = 121, 457 | CV_REG_PSEUDO7 = 122, 458 | CV_REG_PSEUDO8 = 123, 459 | CV_REG_PSEUDO9 = 124, 460 | 461 | CV_REG_ST0 = 128, 462 | CV_REG_ST1 = 129, 463 | CV_REG_ST2 = 130, 464 | CV_REG_ST3 = 131, 465 | CV_REG_ST4 = 132, 466 | CV_REG_ST5 = 133, 467 | CV_REG_ST6 = 134, 468 | CV_REG_ST7 = 135, 469 | CV_REG_CTRL = 136, 470 | CV_REG_STAT = 137, 471 | CV_REG_TAG = 138, 472 | CV_REG_FPIP = 139, 473 | CV_REG_FPCS = 140, 474 | CV_REG_FPDO = 141, 475 | CV_REG_FPDS = 142, 476 | CV_REG_ISEM = 143, 477 | CV_REG_FPEIP = 144, 478 | CV_REG_FPEDO = 145, 479 | 480 | CV_REG_MM0 = 146, 481 | CV_REG_MM1 = 147, 482 | CV_REG_MM2 = 148, 483 | CV_REG_MM3 = 149, 484 | CV_REG_MM4 = 150, 485 | CV_REG_MM5 = 151, 486 | CV_REG_MM6 = 152, 487 | CV_REG_MM7 = 153, 488 | 489 | CV_REG_XMM0 = 154, // KATMAI registers 490 | CV_REG_XMM1 = 155, 491 | CV_REG_XMM2 = 156, 492 | CV_REG_XMM3 = 157, 493 | CV_REG_XMM4 = 158, 494 | CV_REG_XMM5 = 159, 495 | CV_REG_XMM6 = 160, 496 | CV_REG_XMM7 = 161, 497 | 498 | CV_REG_XMM00 = 162, // KATMAI sub-registers 499 | CV_REG_XMM01 = 163, 500 | CV_REG_XMM02 = 164, 501 | CV_REG_XMM03 = 165, 502 | CV_REG_XMM10 = 166, 503 | CV_REG_XMM11 = 167, 504 | CV_REG_XMM12 = 168, 505 | CV_REG_XMM13 = 169, 506 | CV_REG_XMM20 = 170, 507 | CV_REG_XMM21 = 171, 508 | CV_REG_XMM22 = 172, 509 | CV_REG_XMM23 = 173, 510 | CV_REG_XMM30 = 174, 511 | CV_REG_XMM31 = 175, 512 | CV_REG_XMM32 = 176, 513 | CV_REG_XMM33 = 177, 514 | CV_REG_XMM40 = 178, 515 | CV_REG_XMM41 = 179, 516 | CV_REG_XMM42 = 180, 517 | CV_REG_XMM43 = 181, 518 | CV_REG_XMM50 = 182, 519 | CV_REG_XMM51 = 183, 520 | CV_REG_XMM52 = 184, 521 | CV_REG_XMM53 = 185, 522 | CV_REG_XMM60 = 186, 523 | CV_REG_XMM61 = 187, 524 | CV_REG_XMM62 = 188, 525 | CV_REG_XMM63 = 189, 526 | CV_REG_XMM70 = 190, 527 | CV_REG_XMM71 = 191, 528 | CV_REG_XMM72 = 192, 529 | CV_REG_XMM73 = 193, 530 | 531 | CV_REG_XMM0L = 194, 532 | CV_REG_XMM1L = 195, 533 | CV_REG_XMM2L = 196, 534 | CV_REG_XMM3L = 197, 535 | CV_REG_XMM4L = 198, 536 | CV_REG_XMM5L = 199, 537 | CV_REG_XMM6L = 200, 538 | CV_REG_XMM7L = 201, 539 | 540 | CV_REG_XMM0H = 202, 541 | CV_REG_XMM1H = 203, 542 | CV_REG_XMM2H = 204, 543 | CV_REG_XMM3H = 205, 544 | CV_REG_XMM4H = 206, 545 | CV_REG_XMM5H = 207, 546 | CV_REG_XMM6H = 208, 547 | CV_REG_XMM7H = 209, 548 | 549 | CV_REG_MXCSR = 211, // XMM status register 550 | 551 | CV_REG_EDXEAX = 212, // EDX:EAX pair 552 | 553 | CV_REG_EMM0L = 220, // XMM sub-registers (WNI integer) 554 | CV_REG_EMM1L = 221, 555 | CV_REG_EMM2L = 222, 556 | CV_REG_EMM3L = 223, 557 | CV_REG_EMM4L = 224, 558 | CV_REG_EMM5L = 225, 559 | CV_REG_EMM6L = 226, 560 | CV_REG_EMM7L = 227, 561 | 562 | CV_REG_EMM0H = 228, 563 | CV_REG_EMM1H = 229, 564 | CV_REG_EMM2H = 230, 565 | CV_REG_EMM3H = 231, 566 | CV_REG_EMM4H = 232, 567 | CV_REG_EMM5H = 233, 568 | CV_REG_EMM6H = 234, 569 | CV_REG_EMM7H = 235, 570 | 571 | // do not change the order of these regs, first one must be even too 572 | CV_REG_MM00 = 236, 573 | CV_REG_MM01 = 237, 574 | CV_REG_MM10 = 238, 575 | CV_REG_MM11 = 239, 576 | CV_REG_MM20 = 240, 577 | CV_REG_MM21 = 241, 578 | CV_REG_MM30 = 242, 579 | CV_REG_MM31 = 243, 580 | CV_REG_MM40 = 244, 581 | CV_REG_MM41 = 245, 582 | CV_REG_MM50 = 246, 583 | CV_REG_MM51 = 247, 584 | CV_REG_MM60 = 248, 585 | CV_REG_MM61 = 249, 586 | CV_REG_MM70 = 250, 587 | CV_REG_MM71 = 251, 588 | 589 | CV_REG_YMM0 = 252, // AVX registers 590 | CV_REG_YMM1 = 253, 591 | CV_REG_YMM2 = 254, 592 | CV_REG_YMM3 = 255, 593 | CV_REG_YMM4 = 256, 594 | CV_REG_YMM5 = 257, 595 | CV_REG_YMM6 = 258, 596 | CV_REG_YMM7 = 259, 597 | 598 | CV_REG_YMM0H = 260, 599 | CV_REG_YMM1H = 261, 600 | CV_REG_YMM2H = 262, 601 | CV_REG_YMM3H = 263, 602 | CV_REG_YMM4H = 264, 603 | CV_REG_YMM5H = 265, 604 | CV_REG_YMM6H = 266, 605 | CV_REG_YMM7H = 267, 606 | 607 | CV_REG_YMM0I0 = 268, // AVX integer registers 608 | CV_REG_YMM0I1 = 269, 609 | CV_REG_YMM0I2 = 270, 610 | CV_REG_YMM0I3 = 271, 611 | CV_REG_YMM1I0 = 272, 612 | CV_REG_YMM1I1 = 273, 613 | CV_REG_YMM1I2 = 274, 614 | CV_REG_YMM1I3 = 275, 615 | CV_REG_YMM2I0 = 276, 616 | CV_REG_YMM2I1 = 277, 617 | CV_REG_YMM2I2 = 278, 618 | CV_REG_YMM2I3 = 279, 619 | CV_REG_YMM3I0 = 280, 620 | CV_REG_YMM3I1 = 281, 621 | CV_REG_YMM3I2 = 282, 622 | CV_REG_YMM3I3 = 283, 623 | CV_REG_YMM4I0 = 284, 624 | CV_REG_YMM4I1 = 285, 625 | CV_REG_YMM4I2 = 286, 626 | CV_REG_YMM4I3 = 287, 627 | CV_REG_YMM5I0 = 288, 628 | CV_REG_YMM5I1 = 289, 629 | CV_REG_YMM5I2 = 290, 630 | CV_REG_YMM5I3 = 291, 631 | CV_REG_YMM6I0 = 292, 632 | CV_REG_YMM6I1 = 293, 633 | CV_REG_YMM6I2 = 294, 634 | CV_REG_YMM6I3 = 295, 635 | CV_REG_YMM7I0 = 296, 636 | CV_REG_YMM7I1 = 297, 637 | CV_REG_YMM7I2 = 298, 638 | CV_REG_YMM7I3 = 299, 639 | 640 | CV_REG_YMM0F0 = 300, // AVX floating-point single precise registers 641 | CV_REG_YMM0F1 = 301, 642 | CV_REG_YMM0F2 = 302, 643 | CV_REG_YMM0F3 = 303, 644 | CV_REG_YMM0F4 = 304, 645 | CV_REG_YMM0F5 = 305, 646 | CV_REG_YMM0F6 = 306, 647 | CV_REG_YMM0F7 = 307, 648 | CV_REG_YMM1F0 = 308, 649 | CV_REG_YMM1F1 = 309, 650 | CV_REG_YMM1F2 = 310, 651 | CV_REG_YMM1F3 = 311, 652 | CV_REG_YMM1F4 = 312, 653 | CV_REG_YMM1F5 = 313, 654 | CV_REG_YMM1F6 = 314, 655 | CV_REG_YMM1F7 = 315, 656 | CV_REG_YMM2F0 = 316, 657 | CV_REG_YMM2F1 = 317, 658 | CV_REG_YMM2F2 = 318, 659 | CV_REG_YMM2F3 = 319, 660 | CV_REG_YMM2F4 = 320, 661 | CV_REG_YMM2F5 = 321, 662 | CV_REG_YMM2F6 = 322, 663 | CV_REG_YMM2F7 = 323, 664 | CV_REG_YMM3F0 = 324, 665 | CV_REG_YMM3F1 = 325, 666 | CV_REG_YMM3F2 = 326, 667 | CV_REG_YMM3F3 = 327, 668 | CV_REG_YMM3F4 = 328, 669 | CV_REG_YMM3F5 = 329, 670 | CV_REG_YMM3F6 = 330, 671 | CV_REG_YMM3F7 = 331, 672 | CV_REG_YMM4F0 = 332, 673 | CV_REG_YMM4F1 = 333, 674 | CV_REG_YMM4F2 = 334, 675 | CV_REG_YMM4F3 = 335, 676 | CV_REG_YMM4F4 = 336, 677 | CV_REG_YMM4F5 = 337, 678 | CV_REG_YMM4F6 = 338, 679 | CV_REG_YMM4F7 = 339, 680 | CV_REG_YMM5F0 = 340, 681 | CV_REG_YMM5F1 = 341, 682 | CV_REG_YMM5F2 = 342, 683 | CV_REG_YMM5F3 = 343, 684 | CV_REG_YMM5F4 = 344, 685 | CV_REG_YMM5F5 = 345, 686 | CV_REG_YMM5F6 = 346, 687 | CV_REG_YMM5F7 = 347, 688 | CV_REG_YMM6F0 = 348, 689 | CV_REG_YMM6F1 = 349, 690 | CV_REG_YMM6F2 = 350, 691 | CV_REG_YMM6F3 = 351, 692 | CV_REG_YMM6F4 = 352, 693 | CV_REG_YMM6F5 = 353, 694 | CV_REG_YMM6F6 = 354, 695 | CV_REG_YMM6F7 = 355, 696 | CV_REG_YMM7F0 = 356, 697 | CV_REG_YMM7F1 = 357, 698 | CV_REG_YMM7F2 = 358, 699 | CV_REG_YMM7F3 = 359, 700 | CV_REG_YMM7F4 = 360, 701 | CV_REG_YMM7F5 = 361, 702 | CV_REG_YMM7F6 = 362, 703 | CV_REG_YMM7F7 = 363, 704 | 705 | CV_REG_YMM0D0 = 364, // AVX floating-point double precise registers 706 | CV_REG_YMM0D1 = 365, 707 | CV_REG_YMM0D2 = 366, 708 | CV_REG_YMM0D3 = 367, 709 | CV_REG_YMM1D0 = 368, 710 | CV_REG_YMM1D1 = 369, 711 | CV_REG_YMM1D2 = 370, 712 | CV_REG_YMM1D3 = 371, 713 | CV_REG_YMM2D0 = 372, 714 | CV_REG_YMM2D1 = 373, 715 | CV_REG_YMM2D2 = 374, 716 | CV_REG_YMM2D3 = 375, 717 | CV_REG_YMM3D0 = 376, 718 | CV_REG_YMM3D1 = 377, 719 | CV_REG_YMM3D2 = 378, 720 | CV_REG_YMM3D3 = 379, 721 | CV_REG_YMM4D0 = 380, 722 | CV_REG_YMM4D1 = 381, 723 | CV_REG_YMM4D2 = 382, 724 | CV_REG_YMM4D3 = 383, 725 | CV_REG_YMM5D0 = 384, 726 | CV_REG_YMM5D1 = 385, 727 | CV_REG_YMM5D2 = 386, 728 | CV_REG_YMM5D3 = 387, 729 | CV_REG_YMM6D0 = 388, 730 | CV_REG_YMM6D1 = 389, 731 | CV_REG_YMM6D2 = 390, 732 | CV_REG_YMM6D3 = 391, 733 | CV_REG_YMM7D0 = 392, 734 | CV_REG_YMM7D1 = 393, 735 | CV_REG_YMM7D2 = 394, 736 | CV_REG_YMM7D3 = 395, 737 | 738 | // registers for the 68K processors 739 | 740 | CV_R68_D0 = 0, 741 | CV_R68_D1 = 1, 742 | CV_R68_D2 = 2, 743 | CV_R68_D3 = 3, 744 | CV_R68_D4 = 4, 745 | CV_R68_D5 = 5, 746 | CV_R68_D6 = 6, 747 | CV_R68_D7 = 7, 748 | CV_R68_A0 = 8, 749 | CV_R68_A1 = 9, 750 | CV_R68_A2 = 10, 751 | CV_R68_A3 = 11, 752 | CV_R68_A4 = 12, 753 | CV_R68_A5 = 13, 754 | CV_R68_A6 = 14, 755 | CV_R68_A7 = 15, 756 | CV_R68_CCR = 16, 757 | CV_R68_SR = 17, 758 | CV_R68_USP = 18, 759 | CV_R68_MSP = 19, 760 | CV_R68_SFC = 20, 761 | CV_R68_DFC = 21, 762 | CV_R68_CACR = 22, 763 | CV_R68_VBR = 23, 764 | CV_R68_CAAR = 24, 765 | CV_R68_ISP = 25, 766 | CV_R68_PC = 26, 767 | //reserved 27 768 | CV_R68_FPCR = 28, 769 | CV_R68_FPSR = 29, 770 | CV_R68_FPIAR = 30, 771 | //reserved 31 772 | CV_R68_FP0 = 32, 773 | CV_R68_FP1 = 33, 774 | CV_R68_FP2 = 34, 775 | CV_R68_FP3 = 35, 776 | CV_R68_FP4 = 36, 777 | CV_R68_FP5 = 37, 778 | CV_R68_FP6 = 38, 779 | CV_R68_FP7 = 39, 780 | //reserved 40 781 | CV_R68_MMUSR030 = 41, 782 | CV_R68_MMUSR = 42, 783 | CV_R68_URP = 43, 784 | CV_R68_DTT0 = 44, 785 | CV_R68_DTT1 = 45, 786 | CV_R68_ITT0 = 46, 787 | CV_R68_ITT1 = 47, 788 | //reserved 50 789 | CV_R68_PSR = 51, 790 | CV_R68_PCSR = 52, 791 | CV_R68_VAL = 53, 792 | CV_R68_CRP = 54, 793 | CV_R68_SRP = 55, 794 | CV_R68_DRP = 56, 795 | CV_R68_TC = 57, 796 | CV_R68_AC = 58, 797 | CV_R68_SCC = 59, 798 | CV_R68_CAL = 60, 799 | CV_R68_TT0 = 61, 800 | CV_R68_TT1 = 62, 801 | //reserved 63 802 | CV_R68_BAD0 = 64, 803 | CV_R68_BAD1 = 65, 804 | CV_R68_BAD2 = 66, 805 | CV_R68_BAD3 = 67, 806 | CV_R68_BAD4 = 68, 807 | CV_R68_BAD5 = 69, 808 | CV_R68_BAD6 = 70, 809 | CV_R68_BAD7 = 71, 810 | CV_R68_BAC0 = 72, 811 | CV_R68_BAC1 = 73, 812 | CV_R68_BAC2 = 74, 813 | CV_R68_BAC3 = 75, 814 | CV_R68_BAC4 = 76, 815 | CV_R68_BAC5 = 77, 816 | CV_R68_BAC6 = 78, 817 | CV_R68_BAC7 = 79, 818 | 819 | // Register set for the MIPS 4000 820 | 821 | CV_M4_NOREG = CV_REG_NONE, 822 | 823 | CV_M4_IntZERO = 10, /* CPU REGISTER */ 824 | CV_M4_IntAT = 11, 825 | CV_M4_IntV0 = 12, 826 | CV_M4_IntV1 = 13, 827 | CV_M4_IntA0 = 14, 828 | CV_M4_IntA1 = 15, 829 | CV_M4_IntA2 = 16, 830 | CV_M4_IntA3 = 17, 831 | CV_M4_IntT0 = 18, 832 | CV_M4_IntT1 = 19, 833 | CV_M4_IntT2 = 20, 834 | CV_M4_IntT3 = 21, 835 | CV_M4_IntT4 = 22, 836 | CV_M4_IntT5 = 23, 837 | CV_M4_IntT6 = 24, 838 | CV_M4_IntT7 = 25, 839 | CV_M4_IntS0 = 26, 840 | CV_M4_IntS1 = 27, 841 | CV_M4_IntS2 = 28, 842 | CV_M4_IntS3 = 29, 843 | CV_M4_IntS4 = 30, 844 | CV_M4_IntS5 = 31, 845 | CV_M4_IntS6 = 32, 846 | CV_M4_IntS7 = 33, 847 | CV_M4_IntT8 = 34, 848 | CV_M4_IntT9 = 35, 849 | CV_M4_IntKT0 = 36, 850 | CV_M4_IntKT1 = 37, 851 | CV_M4_IntGP = 38, 852 | CV_M4_IntSP = 39, 853 | CV_M4_IntS8 = 40, 854 | CV_M4_IntRA = 41, 855 | CV_M4_IntLO = 42, 856 | CV_M4_IntHI = 43, 857 | 858 | CV_M4_Fir = 50, 859 | CV_M4_Psr = 51, 860 | 861 | CV_M4_FltF0 = 60, /* Floating point registers */ 862 | CV_M4_FltF1 = 61, 863 | CV_M4_FltF2 = 62, 864 | CV_M4_FltF3 = 63, 865 | CV_M4_FltF4 = 64, 866 | CV_M4_FltF5 = 65, 867 | CV_M4_FltF6 = 66, 868 | CV_M4_FltF7 = 67, 869 | CV_M4_FltF8 = 68, 870 | CV_M4_FltF9 = 69, 871 | CV_M4_FltF10 = 70, 872 | CV_M4_FltF11 = 71, 873 | CV_M4_FltF12 = 72, 874 | CV_M4_FltF13 = 73, 875 | CV_M4_FltF14 = 74, 876 | CV_M4_FltF15 = 75, 877 | CV_M4_FltF16 = 76, 878 | CV_M4_FltF17 = 77, 879 | CV_M4_FltF18 = 78, 880 | CV_M4_FltF19 = 79, 881 | CV_M4_FltF20 = 80, 882 | CV_M4_FltF21 = 81, 883 | CV_M4_FltF22 = 82, 884 | CV_M4_FltF23 = 83, 885 | CV_M4_FltF24 = 84, 886 | CV_M4_FltF25 = 85, 887 | CV_M4_FltF26 = 86, 888 | CV_M4_FltF27 = 87, 889 | CV_M4_FltF28 = 88, 890 | CV_M4_FltF29 = 89, 891 | CV_M4_FltF30 = 90, 892 | CV_M4_FltF31 = 91, 893 | CV_M4_FltFsr = 92, 894 | 895 | 896 | // Register set for the ALPHA AXP 897 | 898 | CV_ALPHA_NOREG = CV_REG_NONE, 899 | 900 | CV_ALPHA_FltF0 = 10, // Floating point registers 901 | CV_ALPHA_FltF1 = 11, 902 | CV_ALPHA_FltF2 = 12, 903 | CV_ALPHA_FltF3 = 13, 904 | CV_ALPHA_FltF4 = 14, 905 | CV_ALPHA_FltF5 = 15, 906 | CV_ALPHA_FltF6 = 16, 907 | CV_ALPHA_FltF7 = 17, 908 | CV_ALPHA_FltF8 = 18, 909 | CV_ALPHA_FltF9 = 19, 910 | CV_ALPHA_FltF10 = 20, 911 | CV_ALPHA_FltF11 = 21, 912 | CV_ALPHA_FltF12 = 22, 913 | CV_ALPHA_FltF13 = 23, 914 | CV_ALPHA_FltF14 = 24, 915 | CV_ALPHA_FltF15 = 25, 916 | CV_ALPHA_FltF16 = 26, 917 | CV_ALPHA_FltF17 = 27, 918 | CV_ALPHA_FltF18 = 28, 919 | CV_ALPHA_FltF19 = 29, 920 | CV_ALPHA_FltF20 = 30, 921 | CV_ALPHA_FltF21 = 31, 922 | CV_ALPHA_FltF22 = 32, 923 | CV_ALPHA_FltF23 = 33, 924 | CV_ALPHA_FltF24 = 34, 925 | CV_ALPHA_FltF25 = 35, 926 | CV_ALPHA_FltF26 = 36, 927 | CV_ALPHA_FltF27 = 37, 928 | CV_ALPHA_FltF28 = 38, 929 | CV_ALPHA_FltF29 = 39, 930 | CV_ALPHA_FltF30 = 40, 931 | CV_ALPHA_FltF31 = 41, 932 | 933 | CV_ALPHA_IntV0 = 42, // Integer registers 934 | CV_ALPHA_IntT0 = 43, 935 | CV_ALPHA_IntT1 = 44, 936 | CV_ALPHA_IntT2 = 45, 937 | CV_ALPHA_IntT3 = 46, 938 | CV_ALPHA_IntT4 = 47, 939 | CV_ALPHA_IntT5 = 48, 940 | CV_ALPHA_IntT6 = 49, 941 | CV_ALPHA_IntT7 = 50, 942 | CV_ALPHA_IntS0 = 51, 943 | CV_ALPHA_IntS1 = 52, 944 | CV_ALPHA_IntS2 = 53, 945 | CV_ALPHA_IntS3 = 54, 946 | CV_ALPHA_IntS4 = 55, 947 | CV_ALPHA_IntS5 = 56, 948 | CV_ALPHA_IntFP = 57, 949 | CV_ALPHA_IntA0 = 58, 950 | CV_ALPHA_IntA1 = 59, 951 | CV_ALPHA_IntA2 = 60, 952 | CV_ALPHA_IntA3 = 61, 953 | CV_ALPHA_IntA4 = 62, 954 | CV_ALPHA_IntA5 = 63, 955 | CV_ALPHA_IntT8 = 64, 956 | CV_ALPHA_IntT9 = 65, 957 | CV_ALPHA_IntT10 = 66, 958 | CV_ALPHA_IntT11 = 67, 959 | CV_ALPHA_IntRA = 68, 960 | CV_ALPHA_IntT12 = 69, 961 | CV_ALPHA_IntAT = 70, 962 | CV_ALPHA_IntGP = 71, 963 | CV_ALPHA_IntSP = 72, 964 | CV_ALPHA_IntZERO = 73, 965 | 966 | 967 | CV_ALPHA_Fpcr = 74, // Control registers 968 | CV_ALPHA_Fir = 75, 969 | CV_ALPHA_Psr = 76, 970 | CV_ALPHA_FltFsr = 77, 971 | CV_ALPHA_SoftFpcr = 78, 972 | 973 | // Register Set for Motorola/IBM PowerPC 974 | 975 | /* 976 | ** PowerPC General Registers ( User Level ) 977 | */ 978 | CV_PPC_GPR0 = 1, 979 | CV_PPC_GPR1 = 2, 980 | CV_PPC_GPR2 = 3, 981 | CV_PPC_GPR3 = 4, 982 | CV_PPC_GPR4 = 5, 983 | CV_PPC_GPR5 = 6, 984 | CV_PPC_GPR6 = 7, 985 | CV_PPC_GPR7 = 8, 986 | CV_PPC_GPR8 = 9, 987 | CV_PPC_GPR9 = 10, 988 | CV_PPC_GPR10 = 11, 989 | CV_PPC_GPR11 = 12, 990 | CV_PPC_GPR12 = 13, 991 | CV_PPC_GPR13 = 14, 992 | CV_PPC_GPR14 = 15, 993 | CV_PPC_GPR15 = 16, 994 | CV_PPC_GPR16 = 17, 995 | CV_PPC_GPR17 = 18, 996 | CV_PPC_GPR18 = 19, 997 | CV_PPC_GPR19 = 20, 998 | CV_PPC_GPR20 = 21, 999 | CV_PPC_GPR21 = 22, 1000 | CV_PPC_GPR22 = 23, 1001 | CV_PPC_GPR23 = 24, 1002 | CV_PPC_GPR24 = 25, 1003 | CV_PPC_GPR25 = 26, 1004 | CV_PPC_GPR26 = 27, 1005 | CV_PPC_GPR27 = 28, 1006 | CV_PPC_GPR28 = 29, 1007 | CV_PPC_GPR29 = 30, 1008 | CV_PPC_GPR30 = 31, 1009 | CV_PPC_GPR31 = 32, 1010 | 1011 | /* 1012 | ** PowerPC Condition Register ( User Level ) 1013 | */ 1014 | CV_PPC_CR = 33, 1015 | CV_PPC_CR0 = 34, 1016 | CV_PPC_CR1 = 35, 1017 | CV_PPC_CR2 = 36, 1018 | CV_PPC_CR3 = 37, 1019 | CV_PPC_CR4 = 38, 1020 | CV_PPC_CR5 = 39, 1021 | CV_PPC_CR6 = 40, 1022 | CV_PPC_CR7 = 41, 1023 | 1024 | /* 1025 | ** PowerPC Floating Point Registers ( User Level ) 1026 | */ 1027 | CV_PPC_FPR0 = 42, 1028 | CV_PPC_FPR1 = 43, 1029 | CV_PPC_FPR2 = 44, 1030 | CV_PPC_FPR3 = 45, 1031 | CV_PPC_FPR4 = 46, 1032 | CV_PPC_FPR5 = 47, 1033 | CV_PPC_FPR6 = 48, 1034 | CV_PPC_FPR7 = 49, 1035 | CV_PPC_FPR8 = 50, 1036 | CV_PPC_FPR9 = 51, 1037 | CV_PPC_FPR10 = 52, 1038 | CV_PPC_FPR11 = 53, 1039 | CV_PPC_FPR12 = 54, 1040 | CV_PPC_FPR13 = 55, 1041 | CV_PPC_FPR14 = 56, 1042 | CV_PPC_FPR15 = 57, 1043 | CV_PPC_FPR16 = 58, 1044 | CV_PPC_FPR17 = 59, 1045 | CV_PPC_FPR18 = 60, 1046 | CV_PPC_FPR19 = 61, 1047 | CV_PPC_FPR20 = 62, 1048 | CV_PPC_FPR21 = 63, 1049 | CV_PPC_FPR22 = 64, 1050 | CV_PPC_FPR23 = 65, 1051 | CV_PPC_FPR24 = 66, 1052 | CV_PPC_FPR25 = 67, 1053 | CV_PPC_FPR26 = 68, 1054 | CV_PPC_FPR27 = 69, 1055 | CV_PPC_FPR28 = 70, 1056 | CV_PPC_FPR29 = 71, 1057 | CV_PPC_FPR30 = 72, 1058 | CV_PPC_FPR31 = 73, 1059 | 1060 | /* 1061 | ** PowerPC Floating Point Status and Control Register ( User Level ) 1062 | */ 1063 | CV_PPC_FPSCR = 74, 1064 | 1065 | /* 1066 | ** PowerPC Machine State Register ( Supervisor Level ) 1067 | */ 1068 | CV_PPC_MSR = 75, 1069 | 1070 | /* 1071 | ** PowerPC Segment Registers ( Supervisor Level ) 1072 | */ 1073 | CV_PPC_SR0 = 76, 1074 | CV_PPC_SR1 = 77, 1075 | CV_PPC_SR2 = 78, 1076 | CV_PPC_SR3 = 79, 1077 | CV_PPC_SR4 = 80, 1078 | CV_PPC_SR5 = 81, 1079 | CV_PPC_SR6 = 82, 1080 | CV_PPC_SR7 = 83, 1081 | CV_PPC_SR8 = 84, 1082 | CV_PPC_SR9 = 85, 1083 | CV_PPC_SR10 = 86, 1084 | CV_PPC_SR11 = 87, 1085 | CV_PPC_SR12 = 88, 1086 | CV_PPC_SR13 = 89, 1087 | CV_PPC_SR14 = 90, 1088 | CV_PPC_SR15 = 91, 1089 | 1090 | /* 1091 | ** For all of the special purpose registers add 100 to the SPR# that the 1092 | ** Motorola/IBM documentation gives with the exception of any imaginary 1093 | ** registers. 1094 | */ 1095 | 1096 | /* 1097 | ** PowerPC Special Purpose Registers ( User Level ) 1098 | */ 1099 | CV_PPC_PC = 99, // PC (imaginary register) 1100 | 1101 | CV_PPC_MQ = 100, // MPC601 1102 | CV_PPC_XER = 101, 1103 | CV_PPC_RTCU = 104, // MPC601 1104 | CV_PPC_RTCL = 105, // MPC601 1105 | CV_PPC_LR = 108, 1106 | CV_PPC_CTR = 109, 1107 | 1108 | CV_PPC_COMPARE = 110, // part of XER (internal to the debugger only) 1109 | CV_PPC_COUNT = 111, // part of XER (internal to the debugger only) 1110 | 1111 | /* 1112 | ** PowerPC Special Purpose Registers ( Supervisor Level ) 1113 | */ 1114 | CV_PPC_DSISR = 118, 1115 | CV_PPC_DAR = 119, 1116 | CV_PPC_DEC = 122, 1117 | CV_PPC_SDR1 = 125, 1118 | CV_PPC_SRR0 = 126, 1119 | CV_PPC_SRR1 = 127, 1120 | CV_PPC_SPRG0 = 372, 1121 | CV_PPC_SPRG1 = 373, 1122 | CV_PPC_SPRG2 = 374, 1123 | CV_PPC_SPRG3 = 375, 1124 | CV_PPC_ASR = 280, // 64-bit implementations only 1125 | CV_PPC_EAR = 382, 1126 | CV_PPC_PVR = 287, 1127 | CV_PPC_BAT0U = 628, 1128 | CV_PPC_BAT0L = 629, 1129 | CV_PPC_BAT1U = 630, 1130 | CV_PPC_BAT1L = 631, 1131 | CV_PPC_BAT2U = 632, 1132 | CV_PPC_BAT2L = 633, 1133 | CV_PPC_BAT3U = 634, 1134 | CV_PPC_BAT3L = 635, 1135 | CV_PPC_DBAT0U = 636, 1136 | CV_PPC_DBAT0L = 637, 1137 | CV_PPC_DBAT1U = 638, 1138 | CV_PPC_DBAT1L = 639, 1139 | CV_PPC_DBAT2U = 640, 1140 | CV_PPC_DBAT2L = 641, 1141 | CV_PPC_DBAT3U = 642, 1142 | CV_PPC_DBAT3L = 643, 1143 | 1144 | /* 1145 | ** PowerPC Special Purpose Registers Implementation Dependent ( Supervisor Level ) 1146 | */ 1147 | 1148 | /* 1149 | ** Doesn't appear that IBM/Motorola has finished defining these. 1150 | */ 1151 | 1152 | CV_PPC_PMR0 = 1044, // MPC620, 1153 | CV_PPC_PMR1 = 1045, // MPC620, 1154 | CV_PPC_PMR2 = 1046, // MPC620, 1155 | CV_PPC_PMR3 = 1047, // MPC620, 1156 | CV_PPC_PMR4 = 1048, // MPC620, 1157 | CV_PPC_PMR5 = 1049, // MPC620, 1158 | CV_PPC_PMR6 = 1050, // MPC620, 1159 | CV_PPC_PMR7 = 1051, // MPC620, 1160 | CV_PPC_PMR8 = 1052, // MPC620, 1161 | CV_PPC_PMR9 = 1053, // MPC620, 1162 | CV_PPC_PMR10 = 1054, // MPC620, 1163 | CV_PPC_PMR11 = 1055, // MPC620, 1164 | CV_PPC_PMR12 = 1056, // MPC620, 1165 | CV_PPC_PMR13 = 1057, // MPC620, 1166 | CV_PPC_PMR14 = 1058, // MPC620, 1167 | CV_PPC_PMR15 = 1059, // MPC620, 1168 | 1169 | CV_PPC_DMISS = 1076, // MPC603 1170 | CV_PPC_DCMP = 1077, // MPC603 1171 | CV_PPC_HASH1 = 1078, // MPC603 1172 | CV_PPC_HASH2 = 1079, // MPC603 1173 | CV_PPC_IMISS = 1080, // MPC603 1174 | CV_PPC_ICMP = 1081, // MPC603 1175 | CV_PPC_RPA = 1082, // MPC603 1176 | 1177 | CV_PPC_HID0 = 1108, // MPC601, MPC603, MPC620 1178 | CV_PPC_HID1 = 1109, // MPC601 1179 | CV_PPC_HID2 = 1110, // MPC601, MPC603, MPC620 ( IABR ) 1180 | CV_PPC_HID3 = 1111, // Not Defined 1181 | CV_PPC_HID4 = 1112, // Not Defined 1182 | CV_PPC_HID5 = 1113, // MPC601, MPC604, MPC620 ( DABR ) 1183 | CV_PPC_HID6 = 1114, // Not Defined 1184 | CV_PPC_HID7 = 1115, // Not Defined 1185 | CV_PPC_HID8 = 1116, // MPC620 ( BUSCSR ) 1186 | CV_PPC_HID9 = 1117, // MPC620 ( L2CSR ) 1187 | CV_PPC_HID10 = 1118, // Not Defined 1188 | CV_PPC_HID11 = 1119, // Not Defined 1189 | CV_PPC_HID12 = 1120, // Not Defined 1190 | CV_PPC_HID13 = 1121, // MPC604 ( HCR ) 1191 | CV_PPC_HID14 = 1122, // Not Defined 1192 | CV_PPC_HID15 = 1123, // MPC601, MPC604, MPC620 ( PIR ) 1193 | 1194 | // 1195 | // JAVA VM registers 1196 | // 1197 | 1198 | CV_JAVA_PC = 1, 1199 | 1200 | // 1201 | // Register set for the Hitachi SH3 1202 | // 1203 | 1204 | CV_SH3_NOREG = CV_REG_NONE, 1205 | 1206 | CV_SH3_IntR0 = 10, // CPU REGISTER 1207 | CV_SH3_IntR1 = 11, 1208 | CV_SH3_IntR2 = 12, 1209 | CV_SH3_IntR3 = 13, 1210 | CV_SH3_IntR4 = 14, 1211 | CV_SH3_IntR5 = 15, 1212 | CV_SH3_IntR6 = 16, 1213 | CV_SH3_IntR7 = 17, 1214 | CV_SH3_IntR8 = 18, 1215 | CV_SH3_IntR9 = 19, 1216 | CV_SH3_IntR10 = 20, 1217 | CV_SH3_IntR11 = 21, 1218 | CV_SH3_IntR12 = 22, 1219 | CV_SH3_IntR13 = 23, 1220 | CV_SH3_IntFp = 24, 1221 | CV_SH3_IntSp = 25, 1222 | CV_SH3_Gbr = 38, 1223 | CV_SH3_Pr = 39, 1224 | CV_SH3_Mach = 40, 1225 | CV_SH3_Macl = 41, 1226 | 1227 | CV_SH3_Pc = 50, 1228 | CV_SH3_Sr = 51, 1229 | 1230 | CV_SH3_BarA = 60, 1231 | CV_SH3_BasrA = 61, 1232 | CV_SH3_BamrA = 62, 1233 | CV_SH3_BbrA = 63, 1234 | CV_SH3_BarB = 64, 1235 | CV_SH3_BasrB = 65, 1236 | CV_SH3_BamrB = 66, 1237 | CV_SH3_BbrB = 67, 1238 | CV_SH3_BdrB = 68, 1239 | CV_SH3_BdmrB = 69, 1240 | CV_SH3_Brcr = 70, 1241 | 1242 | // 1243 | // Additional registers for Hitachi SH processors 1244 | // 1245 | 1246 | CV_SH_Fpscr = 75, // floating point status/control register 1247 | CV_SH_Fpul = 76, // floating point communication register 1248 | 1249 | CV_SH_FpR0 = 80, // Floating point registers 1250 | CV_SH_FpR1 = 81, 1251 | CV_SH_FpR2 = 82, 1252 | CV_SH_FpR3 = 83, 1253 | CV_SH_FpR4 = 84, 1254 | CV_SH_FpR5 = 85, 1255 | CV_SH_FpR6 = 86, 1256 | CV_SH_FpR7 = 87, 1257 | CV_SH_FpR8 = 88, 1258 | CV_SH_FpR9 = 89, 1259 | CV_SH_FpR10 = 90, 1260 | CV_SH_FpR11 = 91, 1261 | CV_SH_FpR12 = 92, 1262 | CV_SH_FpR13 = 93, 1263 | CV_SH_FpR14 = 94, 1264 | CV_SH_FpR15 = 95, 1265 | 1266 | CV_SH_XFpR0 = 96, 1267 | CV_SH_XFpR1 = 97, 1268 | CV_SH_XFpR2 = 98, 1269 | CV_SH_XFpR3 = 99, 1270 | CV_SH_XFpR4 = 100, 1271 | CV_SH_XFpR5 = 101, 1272 | CV_SH_XFpR6 = 102, 1273 | CV_SH_XFpR7 = 103, 1274 | CV_SH_XFpR8 = 104, 1275 | CV_SH_XFpR9 = 105, 1276 | CV_SH_XFpR10 = 106, 1277 | CV_SH_XFpR11 = 107, 1278 | CV_SH_XFpR12 = 108, 1279 | CV_SH_XFpR13 = 109, 1280 | CV_SH_XFpR14 = 110, 1281 | CV_SH_XFpR15 = 111, 1282 | 1283 | // 1284 | // Register set for the ARM processor. 1285 | // 1286 | 1287 | CV_ARM_NOREG = CV_REG_NONE, 1288 | 1289 | CV_ARM_R0 = 10, 1290 | CV_ARM_R1 = 11, 1291 | CV_ARM_R2 = 12, 1292 | CV_ARM_R3 = 13, 1293 | CV_ARM_R4 = 14, 1294 | CV_ARM_R5 = 15, 1295 | CV_ARM_R6 = 16, 1296 | CV_ARM_R7 = 17, 1297 | CV_ARM_R8 = 18, 1298 | CV_ARM_R9 = 19, 1299 | CV_ARM_R10 = 20, 1300 | CV_ARM_R11 = 21, // Frame pointer, if allocated 1301 | CV_ARM_R12 = 22, 1302 | CV_ARM_SP = 23, // Stack pointer 1303 | CV_ARM_LR = 24, // Link Register 1304 | CV_ARM_PC = 25, // Program counter 1305 | CV_ARM_CPSR = 26, // Current program status register 1306 | 1307 | CV_ARM_ACC0 = 27, // DSP co-processor 0 40 bit accumulator 1308 | 1309 | // 1310 | // Registers for ARM VFP10 support 1311 | // 1312 | 1313 | CV_ARM_FPSCR = 40, 1314 | CV_ARM_FPEXC = 41, 1315 | 1316 | CV_ARM_FS0 = 50, 1317 | CV_ARM_FS1 = 51, 1318 | CV_ARM_FS2 = 52, 1319 | CV_ARM_FS3 = 53, 1320 | CV_ARM_FS4 = 54, 1321 | CV_ARM_FS5 = 55, 1322 | CV_ARM_FS6 = 56, 1323 | CV_ARM_FS7 = 57, 1324 | CV_ARM_FS8 = 58, 1325 | CV_ARM_FS9 = 59, 1326 | CV_ARM_FS10 = 60, 1327 | CV_ARM_FS11 = 61, 1328 | CV_ARM_FS12 = 62, 1329 | CV_ARM_FS13 = 63, 1330 | CV_ARM_FS14 = 64, 1331 | CV_ARM_FS15 = 65, 1332 | CV_ARM_FS16 = 66, 1333 | CV_ARM_FS17 = 67, 1334 | CV_ARM_FS18 = 68, 1335 | CV_ARM_FS19 = 69, 1336 | CV_ARM_FS20 = 70, 1337 | CV_ARM_FS21 = 71, 1338 | CV_ARM_FS22 = 72, 1339 | CV_ARM_FS23 = 73, 1340 | CV_ARM_FS24 = 74, 1341 | CV_ARM_FS25 = 75, 1342 | CV_ARM_FS26 = 76, 1343 | CV_ARM_FS27 = 77, 1344 | CV_ARM_FS28 = 78, 1345 | CV_ARM_FS29 = 79, 1346 | CV_ARM_FS30 = 80, 1347 | CV_ARM_FS31 = 81, 1348 | 1349 | // 1350 | // ARM VFP Floating Point Extra control registers 1351 | // 1352 | 1353 | CV_ARM_FPEXTRA0 = 90, 1354 | CV_ARM_FPEXTRA1 = 91, 1355 | CV_ARM_FPEXTRA2 = 92, 1356 | CV_ARM_FPEXTRA3 = 93, 1357 | CV_ARM_FPEXTRA4 = 94, 1358 | CV_ARM_FPEXTRA5 = 95, 1359 | CV_ARM_FPEXTRA6 = 96, 1360 | CV_ARM_FPEXTRA7 = 97, 1361 | 1362 | // XSCALE Concan co-processor registers 1363 | CV_ARM_WR0 = 128, 1364 | CV_ARM_WR1 = 129, 1365 | CV_ARM_WR2 = 130, 1366 | CV_ARM_WR3 = 131, 1367 | CV_ARM_WR4 = 132, 1368 | CV_ARM_WR5 = 133, 1369 | CV_ARM_WR6 = 134, 1370 | CV_ARM_WR7 = 135, 1371 | CV_ARM_WR8 = 136, 1372 | CV_ARM_WR9 = 137, 1373 | CV_ARM_WR10 = 138, 1374 | CV_ARM_WR11 = 139, 1375 | CV_ARM_WR12 = 140, 1376 | CV_ARM_WR13 = 141, 1377 | CV_ARM_WR14 = 142, 1378 | CV_ARM_WR15 = 143, 1379 | 1380 | // XSCALE Concan co-processor control registers 1381 | CV_ARM_WCID = 144, 1382 | CV_ARM_WCON = 145, 1383 | CV_ARM_WCSSF = 146, 1384 | CV_ARM_WCASF = 147, 1385 | CV_ARM_WC4 = 148, 1386 | CV_ARM_WC5 = 149, 1387 | CV_ARM_WC6 = 150, 1388 | CV_ARM_WC7 = 151, 1389 | CV_ARM_WCGR0 = 152, 1390 | CV_ARM_WCGR1 = 153, 1391 | CV_ARM_WCGR2 = 154, 1392 | CV_ARM_WCGR3 = 155, 1393 | CV_ARM_WC12 = 156, 1394 | CV_ARM_WC13 = 157, 1395 | CV_ARM_WC14 = 158, 1396 | CV_ARM_WC15 = 159, 1397 | 1398 | // 1399 | // ARM VFPv3/Neon extended floating Point 1400 | // 1401 | 1402 | CV_ARM_FS32 = 200, 1403 | CV_ARM_FS33 = 201, 1404 | CV_ARM_FS34 = 202, 1405 | CV_ARM_FS35 = 203, 1406 | CV_ARM_FS36 = 204, 1407 | CV_ARM_FS37 = 205, 1408 | CV_ARM_FS38 = 206, 1409 | CV_ARM_FS39 = 207, 1410 | CV_ARM_FS40 = 208, 1411 | CV_ARM_FS41 = 209, 1412 | CV_ARM_FS42 = 210, 1413 | CV_ARM_FS43 = 211, 1414 | CV_ARM_FS44 = 212, 1415 | CV_ARM_FS45 = 213, 1416 | CV_ARM_FS46 = 214, 1417 | CV_ARM_FS47 = 215, 1418 | CV_ARM_FS48 = 216, 1419 | CV_ARM_FS49 = 217, 1420 | CV_ARM_FS50 = 218, 1421 | CV_ARM_FS51 = 219, 1422 | CV_ARM_FS52 = 220, 1423 | CV_ARM_FS53 = 221, 1424 | CV_ARM_FS54 = 222, 1425 | CV_ARM_FS55 = 223, 1426 | CV_ARM_FS56 = 224, 1427 | CV_ARM_FS57 = 225, 1428 | CV_ARM_FS58 = 226, 1429 | CV_ARM_FS59 = 227, 1430 | CV_ARM_FS60 = 228, 1431 | CV_ARM_FS61 = 229, 1432 | CV_ARM_FS62 = 230, 1433 | CV_ARM_FS63 = 231, 1434 | 1435 | // ARM double-precision floating point 1436 | 1437 | CV_ARM_ND0 = 300, 1438 | CV_ARM_ND1 = 301, 1439 | CV_ARM_ND2 = 302, 1440 | CV_ARM_ND3 = 303, 1441 | CV_ARM_ND4 = 304, 1442 | CV_ARM_ND5 = 305, 1443 | CV_ARM_ND6 = 306, 1444 | CV_ARM_ND7 = 307, 1445 | CV_ARM_ND8 = 308, 1446 | CV_ARM_ND9 = 309, 1447 | CV_ARM_ND10 = 310, 1448 | CV_ARM_ND11 = 311, 1449 | CV_ARM_ND12 = 312, 1450 | CV_ARM_ND13 = 313, 1451 | CV_ARM_ND14 = 314, 1452 | CV_ARM_ND15 = 315, 1453 | CV_ARM_ND16 = 316, 1454 | CV_ARM_ND17 = 317, 1455 | CV_ARM_ND18 = 318, 1456 | CV_ARM_ND19 = 319, 1457 | CV_ARM_ND20 = 320, 1458 | CV_ARM_ND21 = 321, 1459 | CV_ARM_ND22 = 322, 1460 | CV_ARM_ND23 = 323, 1461 | CV_ARM_ND24 = 324, 1462 | CV_ARM_ND25 = 325, 1463 | CV_ARM_ND26 = 326, 1464 | CV_ARM_ND27 = 327, 1465 | CV_ARM_ND28 = 328, 1466 | CV_ARM_ND29 = 329, 1467 | CV_ARM_ND30 = 330, 1468 | CV_ARM_ND31 = 331, 1469 | 1470 | // ARM extended precision floating point 1471 | 1472 | CV_ARM_NQ0 = 400, 1473 | CV_ARM_NQ1 = 401, 1474 | CV_ARM_NQ2 = 402, 1475 | CV_ARM_NQ3 = 403, 1476 | CV_ARM_NQ4 = 404, 1477 | CV_ARM_NQ5 = 405, 1478 | CV_ARM_NQ6 = 406, 1479 | CV_ARM_NQ7 = 407, 1480 | CV_ARM_NQ8 = 408, 1481 | CV_ARM_NQ9 = 409, 1482 | CV_ARM_NQ10 = 410, 1483 | CV_ARM_NQ11 = 411, 1484 | CV_ARM_NQ12 = 412, 1485 | CV_ARM_NQ13 = 413, 1486 | CV_ARM_NQ14 = 414, 1487 | CV_ARM_NQ15 = 415, 1488 | 1489 | // 1490 | // Register set for Intel IA64 1491 | // 1492 | 1493 | CV_IA64_NOREG = CV_REG_NONE, 1494 | 1495 | // Branch Registers 1496 | 1497 | CV_IA64_Br0 = 512, 1498 | CV_IA64_Br1 = 513, 1499 | CV_IA64_Br2 = 514, 1500 | CV_IA64_Br3 = 515, 1501 | CV_IA64_Br4 = 516, 1502 | CV_IA64_Br5 = 517, 1503 | CV_IA64_Br6 = 518, 1504 | CV_IA64_Br7 = 519, 1505 | 1506 | // Predicate Registers 1507 | 1508 | CV_IA64_P0 = 704, 1509 | CV_IA64_P1 = 705, 1510 | CV_IA64_P2 = 706, 1511 | CV_IA64_P3 = 707, 1512 | CV_IA64_P4 = 708, 1513 | CV_IA64_P5 = 709, 1514 | CV_IA64_P6 = 710, 1515 | CV_IA64_P7 = 711, 1516 | CV_IA64_P8 = 712, 1517 | CV_IA64_P9 = 713, 1518 | CV_IA64_P10 = 714, 1519 | CV_IA64_P11 = 715, 1520 | CV_IA64_P12 = 716, 1521 | CV_IA64_P13 = 717, 1522 | CV_IA64_P14 = 718, 1523 | CV_IA64_P15 = 719, 1524 | CV_IA64_P16 = 720, 1525 | CV_IA64_P17 = 721, 1526 | CV_IA64_P18 = 722, 1527 | CV_IA64_P19 = 723, 1528 | CV_IA64_P20 = 724, 1529 | CV_IA64_P21 = 725, 1530 | CV_IA64_P22 = 726, 1531 | CV_IA64_P23 = 727, 1532 | CV_IA64_P24 = 728, 1533 | CV_IA64_P25 = 729, 1534 | CV_IA64_P26 = 730, 1535 | CV_IA64_P27 = 731, 1536 | CV_IA64_P28 = 732, 1537 | CV_IA64_P29 = 733, 1538 | CV_IA64_P30 = 734, 1539 | CV_IA64_P31 = 735, 1540 | CV_IA64_P32 = 736, 1541 | CV_IA64_P33 = 737, 1542 | CV_IA64_P34 = 738, 1543 | CV_IA64_P35 = 739, 1544 | CV_IA64_P36 = 740, 1545 | CV_IA64_P37 = 741, 1546 | CV_IA64_P38 = 742, 1547 | CV_IA64_P39 = 743, 1548 | CV_IA64_P40 = 744, 1549 | CV_IA64_P41 = 745, 1550 | CV_IA64_P42 = 746, 1551 | CV_IA64_P43 = 747, 1552 | CV_IA64_P44 = 748, 1553 | CV_IA64_P45 = 749, 1554 | CV_IA64_P46 = 750, 1555 | CV_IA64_P47 = 751, 1556 | CV_IA64_P48 = 752, 1557 | CV_IA64_P49 = 753, 1558 | CV_IA64_P50 = 754, 1559 | CV_IA64_P51 = 755, 1560 | CV_IA64_P52 = 756, 1561 | CV_IA64_P53 = 757, 1562 | CV_IA64_P54 = 758, 1563 | CV_IA64_P55 = 759, 1564 | CV_IA64_P56 = 760, 1565 | CV_IA64_P57 = 761, 1566 | CV_IA64_P58 = 762, 1567 | CV_IA64_P59 = 763, 1568 | CV_IA64_P60 = 764, 1569 | CV_IA64_P61 = 765, 1570 | CV_IA64_P62 = 766, 1571 | CV_IA64_P63 = 767, 1572 | 1573 | CV_IA64_Preds = 768, 1574 | 1575 | // Banked General Registers 1576 | 1577 | CV_IA64_IntH0 = 832, 1578 | CV_IA64_IntH1 = 833, 1579 | CV_IA64_IntH2 = 834, 1580 | CV_IA64_IntH3 = 835, 1581 | CV_IA64_IntH4 = 836, 1582 | CV_IA64_IntH5 = 837, 1583 | CV_IA64_IntH6 = 838, 1584 | CV_IA64_IntH7 = 839, 1585 | CV_IA64_IntH8 = 840, 1586 | CV_IA64_IntH9 = 841, 1587 | CV_IA64_IntH10 = 842, 1588 | CV_IA64_IntH11 = 843, 1589 | CV_IA64_IntH12 = 844, 1590 | CV_IA64_IntH13 = 845, 1591 | CV_IA64_IntH14 = 846, 1592 | CV_IA64_IntH15 = 847, 1593 | 1594 | // Special Registers 1595 | 1596 | CV_IA64_Ip = 1016, 1597 | CV_IA64_Umask = 1017, 1598 | CV_IA64_Cfm = 1018, 1599 | CV_IA64_Psr = 1019, 1600 | 1601 | // Banked General Registers 1602 | 1603 | CV_IA64_Nats = 1020, 1604 | CV_IA64_Nats2 = 1021, 1605 | CV_IA64_Nats3 = 1022, 1606 | 1607 | // General-Purpose Registers 1608 | 1609 | // Integer registers 1610 | CV_IA64_IntR0 = 1024, 1611 | CV_IA64_IntR1 = 1025, 1612 | CV_IA64_IntR2 = 1026, 1613 | CV_IA64_IntR3 = 1027, 1614 | CV_IA64_IntR4 = 1028, 1615 | CV_IA64_IntR5 = 1029, 1616 | CV_IA64_IntR6 = 1030, 1617 | CV_IA64_IntR7 = 1031, 1618 | CV_IA64_IntR8 = 1032, 1619 | CV_IA64_IntR9 = 1033, 1620 | CV_IA64_IntR10 = 1034, 1621 | CV_IA64_IntR11 = 1035, 1622 | CV_IA64_IntR12 = 1036, 1623 | CV_IA64_IntR13 = 1037, 1624 | CV_IA64_IntR14 = 1038, 1625 | CV_IA64_IntR15 = 1039, 1626 | CV_IA64_IntR16 = 1040, 1627 | CV_IA64_IntR17 = 1041, 1628 | CV_IA64_IntR18 = 1042, 1629 | CV_IA64_IntR19 = 1043, 1630 | CV_IA64_IntR20 = 1044, 1631 | CV_IA64_IntR21 = 1045, 1632 | CV_IA64_IntR22 = 1046, 1633 | CV_IA64_IntR23 = 1047, 1634 | CV_IA64_IntR24 = 1048, 1635 | CV_IA64_IntR25 = 1049, 1636 | CV_IA64_IntR26 = 1050, 1637 | CV_IA64_IntR27 = 1051, 1638 | CV_IA64_IntR28 = 1052, 1639 | CV_IA64_IntR29 = 1053, 1640 | CV_IA64_IntR30 = 1054, 1641 | CV_IA64_IntR31 = 1055, 1642 | 1643 | // Register Stack 1644 | CV_IA64_IntR32 = 1056, 1645 | CV_IA64_IntR33 = 1057, 1646 | CV_IA64_IntR34 = 1058, 1647 | CV_IA64_IntR35 = 1059, 1648 | CV_IA64_IntR36 = 1060, 1649 | CV_IA64_IntR37 = 1061, 1650 | CV_IA64_IntR38 = 1062, 1651 | CV_IA64_IntR39 = 1063, 1652 | CV_IA64_IntR40 = 1064, 1653 | CV_IA64_IntR41 = 1065, 1654 | CV_IA64_IntR42 = 1066, 1655 | CV_IA64_IntR43 = 1067, 1656 | CV_IA64_IntR44 = 1068, 1657 | CV_IA64_IntR45 = 1069, 1658 | CV_IA64_IntR46 = 1070, 1659 | CV_IA64_IntR47 = 1071, 1660 | CV_IA64_IntR48 = 1072, 1661 | CV_IA64_IntR49 = 1073, 1662 | CV_IA64_IntR50 = 1074, 1663 | CV_IA64_IntR51 = 1075, 1664 | CV_IA64_IntR52 = 1076, 1665 | CV_IA64_IntR53 = 1077, 1666 | CV_IA64_IntR54 = 1078, 1667 | CV_IA64_IntR55 = 1079, 1668 | CV_IA64_IntR56 = 1080, 1669 | CV_IA64_IntR57 = 1081, 1670 | CV_IA64_IntR58 = 1082, 1671 | CV_IA64_IntR59 = 1083, 1672 | CV_IA64_IntR60 = 1084, 1673 | CV_IA64_IntR61 = 1085, 1674 | CV_IA64_IntR62 = 1086, 1675 | CV_IA64_IntR63 = 1087, 1676 | CV_IA64_IntR64 = 1088, 1677 | CV_IA64_IntR65 = 1089, 1678 | CV_IA64_IntR66 = 1090, 1679 | CV_IA64_IntR67 = 1091, 1680 | CV_IA64_IntR68 = 1092, 1681 | CV_IA64_IntR69 = 1093, 1682 | CV_IA64_IntR70 = 1094, 1683 | CV_IA64_IntR71 = 1095, 1684 | CV_IA64_IntR72 = 1096, 1685 | CV_IA64_IntR73 = 1097, 1686 | CV_IA64_IntR74 = 1098, 1687 | CV_IA64_IntR75 = 1099, 1688 | CV_IA64_IntR76 = 1100, 1689 | CV_IA64_IntR77 = 1101, 1690 | CV_IA64_IntR78 = 1102, 1691 | CV_IA64_IntR79 = 1103, 1692 | CV_IA64_IntR80 = 1104, 1693 | CV_IA64_IntR81 = 1105, 1694 | CV_IA64_IntR82 = 1106, 1695 | CV_IA64_IntR83 = 1107, 1696 | CV_IA64_IntR84 = 1108, 1697 | CV_IA64_IntR85 = 1109, 1698 | CV_IA64_IntR86 = 1110, 1699 | CV_IA64_IntR87 = 1111, 1700 | CV_IA64_IntR88 = 1112, 1701 | CV_IA64_IntR89 = 1113, 1702 | CV_IA64_IntR90 = 1114, 1703 | CV_IA64_IntR91 = 1115, 1704 | CV_IA64_IntR92 = 1116, 1705 | CV_IA64_IntR93 = 1117, 1706 | CV_IA64_IntR94 = 1118, 1707 | CV_IA64_IntR95 = 1119, 1708 | CV_IA64_IntR96 = 1120, 1709 | CV_IA64_IntR97 = 1121, 1710 | CV_IA64_IntR98 = 1122, 1711 | CV_IA64_IntR99 = 1123, 1712 | CV_IA64_IntR100 = 1124, 1713 | CV_IA64_IntR101 = 1125, 1714 | CV_IA64_IntR102 = 1126, 1715 | CV_IA64_IntR103 = 1127, 1716 | CV_IA64_IntR104 = 1128, 1717 | CV_IA64_IntR105 = 1129, 1718 | CV_IA64_IntR106 = 1130, 1719 | CV_IA64_IntR107 = 1131, 1720 | CV_IA64_IntR108 = 1132, 1721 | CV_IA64_IntR109 = 1133, 1722 | CV_IA64_IntR110 = 1134, 1723 | CV_IA64_IntR111 = 1135, 1724 | CV_IA64_IntR112 = 1136, 1725 | CV_IA64_IntR113 = 1137, 1726 | CV_IA64_IntR114 = 1138, 1727 | CV_IA64_IntR115 = 1139, 1728 | CV_IA64_IntR116 = 1140, 1729 | CV_IA64_IntR117 = 1141, 1730 | CV_IA64_IntR118 = 1142, 1731 | CV_IA64_IntR119 = 1143, 1732 | CV_IA64_IntR120 = 1144, 1733 | CV_IA64_IntR121 = 1145, 1734 | CV_IA64_IntR122 = 1146, 1735 | CV_IA64_IntR123 = 1147, 1736 | CV_IA64_IntR124 = 1148, 1737 | CV_IA64_IntR125 = 1149, 1738 | CV_IA64_IntR126 = 1150, 1739 | CV_IA64_IntR127 = 1151, 1740 | 1741 | // Floating-Point Registers 1742 | 1743 | // Low Floating Point Registers 1744 | CV_IA64_FltF0 = 2048, 1745 | CV_IA64_FltF1 = 2049, 1746 | CV_IA64_FltF2 = 2050, 1747 | CV_IA64_FltF3 = 2051, 1748 | CV_IA64_FltF4 = 2052, 1749 | CV_IA64_FltF5 = 2053, 1750 | CV_IA64_FltF6 = 2054, 1751 | CV_IA64_FltF7 = 2055, 1752 | CV_IA64_FltF8 = 2056, 1753 | CV_IA64_FltF9 = 2057, 1754 | CV_IA64_FltF10 = 2058, 1755 | CV_IA64_FltF11 = 2059, 1756 | CV_IA64_FltF12 = 2060, 1757 | CV_IA64_FltF13 = 2061, 1758 | CV_IA64_FltF14 = 2062, 1759 | CV_IA64_FltF15 = 2063, 1760 | CV_IA64_FltF16 = 2064, 1761 | CV_IA64_FltF17 = 2065, 1762 | CV_IA64_FltF18 = 2066, 1763 | CV_IA64_FltF19 = 2067, 1764 | CV_IA64_FltF20 = 2068, 1765 | CV_IA64_FltF21 = 2069, 1766 | CV_IA64_FltF22 = 2070, 1767 | CV_IA64_FltF23 = 2071, 1768 | CV_IA64_FltF24 = 2072, 1769 | CV_IA64_FltF25 = 2073, 1770 | CV_IA64_FltF26 = 2074, 1771 | CV_IA64_FltF27 = 2075, 1772 | CV_IA64_FltF28 = 2076, 1773 | CV_IA64_FltF29 = 2077, 1774 | CV_IA64_FltF30 = 2078, 1775 | CV_IA64_FltF31 = 2079, 1776 | 1777 | // High Floating Point Registers 1778 | CV_IA64_FltF32 = 2080, 1779 | CV_IA64_FltF33 = 2081, 1780 | CV_IA64_FltF34 = 2082, 1781 | CV_IA64_FltF35 = 2083, 1782 | CV_IA64_FltF36 = 2084, 1783 | CV_IA64_FltF37 = 2085, 1784 | CV_IA64_FltF38 = 2086, 1785 | CV_IA64_FltF39 = 2087, 1786 | CV_IA64_FltF40 = 2088, 1787 | CV_IA64_FltF41 = 2089, 1788 | CV_IA64_FltF42 = 2090, 1789 | CV_IA64_FltF43 = 2091, 1790 | CV_IA64_FltF44 = 2092, 1791 | CV_IA64_FltF45 = 2093, 1792 | CV_IA64_FltF46 = 2094, 1793 | CV_IA64_FltF47 = 2095, 1794 | CV_IA64_FltF48 = 2096, 1795 | CV_IA64_FltF49 = 2097, 1796 | CV_IA64_FltF50 = 2098, 1797 | CV_IA64_FltF51 = 2099, 1798 | CV_IA64_FltF52 = 2100, 1799 | CV_IA64_FltF53 = 2101, 1800 | CV_IA64_FltF54 = 2102, 1801 | CV_IA64_FltF55 = 2103, 1802 | CV_IA64_FltF56 = 2104, 1803 | CV_IA64_FltF57 = 2105, 1804 | CV_IA64_FltF58 = 2106, 1805 | CV_IA64_FltF59 = 2107, 1806 | CV_IA64_FltF60 = 2108, 1807 | CV_IA64_FltF61 = 2109, 1808 | CV_IA64_FltF62 = 2110, 1809 | CV_IA64_FltF63 = 2111, 1810 | CV_IA64_FltF64 = 2112, 1811 | CV_IA64_FltF65 = 2113, 1812 | CV_IA64_FltF66 = 2114, 1813 | CV_IA64_FltF67 = 2115, 1814 | CV_IA64_FltF68 = 2116, 1815 | CV_IA64_FltF69 = 2117, 1816 | CV_IA64_FltF70 = 2118, 1817 | CV_IA64_FltF71 = 2119, 1818 | CV_IA64_FltF72 = 2120, 1819 | CV_IA64_FltF73 = 2121, 1820 | CV_IA64_FltF74 = 2122, 1821 | CV_IA64_FltF75 = 2123, 1822 | CV_IA64_FltF76 = 2124, 1823 | CV_IA64_FltF77 = 2125, 1824 | CV_IA64_FltF78 = 2126, 1825 | CV_IA64_FltF79 = 2127, 1826 | CV_IA64_FltF80 = 2128, 1827 | CV_IA64_FltF81 = 2129, 1828 | CV_IA64_FltF82 = 2130, 1829 | CV_IA64_FltF83 = 2131, 1830 | CV_IA64_FltF84 = 2132, 1831 | CV_IA64_FltF85 = 2133, 1832 | CV_IA64_FltF86 = 2134, 1833 | CV_IA64_FltF87 = 2135, 1834 | CV_IA64_FltF88 = 2136, 1835 | CV_IA64_FltF89 = 2137, 1836 | CV_IA64_FltF90 = 2138, 1837 | CV_IA64_FltF91 = 2139, 1838 | CV_IA64_FltF92 = 2140, 1839 | CV_IA64_FltF93 = 2141, 1840 | CV_IA64_FltF94 = 2142, 1841 | CV_IA64_FltF95 = 2143, 1842 | CV_IA64_FltF96 = 2144, 1843 | CV_IA64_FltF97 = 2145, 1844 | CV_IA64_FltF98 = 2146, 1845 | CV_IA64_FltF99 = 2147, 1846 | CV_IA64_FltF100 = 2148, 1847 | CV_IA64_FltF101 = 2149, 1848 | CV_IA64_FltF102 = 2150, 1849 | CV_IA64_FltF103 = 2151, 1850 | CV_IA64_FltF104 = 2152, 1851 | CV_IA64_FltF105 = 2153, 1852 | CV_IA64_FltF106 = 2154, 1853 | CV_IA64_FltF107 = 2155, 1854 | CV_IA64_FltF108 = 2156, 1855 | CV_IA64_FltF109 = 2157, 1856 | CV_IA64_FltF110 = 2158, 1857 | CV_IA64_FltF111 = 2159, 1858 | CV_IA64_FltF112 = 2160, 1859 | CV_IA64_FltF113 = 2161, 1860 | CV_IA64_FltF114 = 2162, 1861 | CV_IA64_FltF115 = 2163, 1862 | CV_IA64_FltF116 = 2164, 1863 | CV_IA64_FltF117 = 2165, 1864 | CV_IA64_FltF118 = 2166, 1865 | CV_IA64_FltF119 = 2167, 1866 | CV_IA64_FltF120 = 2168, 1867 | CV_IA64_FltF121 = 2169, 1868 | CV_IA64_FltF122 = 2170, 1869 | CV_IA64_FltF123 = 2171, 1870 | CV_IA64_FltF124 = 2172, 1871 | CV_IA64_FltF125 = 2173, 1872 | CV_IA64_FltF126 = 2174, 1873 | CV_IA64_FltF127 = 2175, 1874 | 1875 | // Application Registers 1876 | 1877 | CV_IA64_ApKR0 = 3072, 1878 | CV_IA64_ApKR1 = 3073, 1879 | CV_IA64_ApKR2 = 3074, 1880 | CV_IA64_ApKR3 = 3075, 1881 | CV_IA64_ApKR4 = 3076, 1882 | CV_IA64_ApKR5 = 3077, 1883 | CV_IA64_ApKR6 = 3078, 1884 | CV_IA64_ApKR7 = 3079, 1885 | CV_IA64_AR8 = 3080, 1886 | CV_IA64_AR9 = 3081, 1887 | CV_IA64_AR10 = 3082, 1888 | CV_IA64_AR11 = 3083, 1889 | CV_IA64_AR12 = 3084, 1890 | CV_IA64_AR13 = 3085, 1891 | CV_IA64_AR14 = 3086, 1892 | CV_IA64_AR15 = 3087, 1893 | CV_IA64_RsRSC = 3088, 1894 | CV_IA64_RsBSP = 3089, 1895 | CV_IA64_RsBSPSTORE = 3090, 1896 | CV_IA64_RsRNAT = 3091, 1897 | CV_IA64_AR20 = 3092, 1898 | CV_IA64_StFCR = 3093, 1899 | CV_IA64_AR22 = 3094, 1900 | CV_IA64_AR23 = 3095, 1901 | CV_IA64_EFLAG = 3096, 1902 | CV_IA64_CSD = 3097, 1903 | CV_IA64_SSD = 3098, 1904 | CV_IA64_CFLG = 3099, 1905 | CV_IA64_StFSR = 3100, 1906 | CV_IA64_StFIR = 3101, 1907 | CV_IA64_StFDR = 3102, 1908 | CV_IA64_AR31 = 3103, 1909 | CV_IA64_ApCCV = 3104, 1910 | CV_IA64_AR33 = 3105, 1911 | CV_IA64_AR34 = 3106, 1912 | CV_IA64_AR35 = 3107, 1913 | CV_IA64_ApUNAT = 3108, 1914 | CV_IA64_AR37 = 3109, 1915 | CV_IA64_AR38 = 3110, 1916 | CV_IA64_AR39 = 3111, 1917 | CV_IA64_StFPSR = 3112, 1918 | CV_IA64_AR41 = 3113, 1919 | CV_IA64_AR42 = 3114, 1920 | CV_IA64_AR43 = 3115, 1921 | CV_IA64_ApITC = 3116, 1922 | CV_IA64_AR45 = 3117, 1923 | CV_IA64_AR46 = 3118, 1924 | CV_IA64_AR47 = 3119, 1925 | CV_IA64_AR48 = 3120, 1926 | CV_IA64_AR49 = 3121, 1927 | CV_IA64_AR50 = 3122, 1928 | CV_IA64_AR51 = 3123, 1929 | CV_IA64_AR52 = 3124, 1930 | CV_IA64_AR53 = 3125, 1931 | CV_IA64_AR54 = 3126, 1932 | CV_IA64_AR55 = 3127, 1933 | CV_IA64_AR56 = 3128, 1934 | CV_IA64_AR57 = 3129, 1935 | CV_IA64_AR58 = 3130, 1936 | CV_IA64_AR59 = 3131, 1937 | CV_IA64_AR60 = 3132, 1938 | CV_IA64_AR61 = 3133, 1939 | CV_IA64_AR62 = 3134, 1940 | CV_IA64_AR63 = 3135, 1941 | CV_IA64_RsPFS = 3136, 1942 | CV_IA64_ApLC = 3137, 1943 | CV_IA64_ApEC = 3138, 1944 | CV_IA64_AR67 = 3139, 1945 | CV_IA64_AR68 = 3140, 1946 | CV_IA64_AR69 = 3141, 1947 | CV_IA64_AR70 = 3142, 1948 | CV_IA64_AR71 = 3143, 1949 | CV_IA64_AR72 = 3144, 1950 | CV_IA64_AR73 = 3145, 1951 | CV_IA64_AR74 = 3146, 1952 | CV_IA64_AR75 = 3147, 1953 | CV_IA64_AR76 = 3148, 1954 | CV_IA64_AR77 = 3149, 1955 | CV_IA64_AR78 = 3150, 1956 | CV_IA64_AR79 = 3151, 1957 | CV_IA64_AR80 = 3152, 1958 | CV_IA64_AR81 = 3153, 1959 | CV_IA64_AR82 = 3154, 1960 | CV_IA64_AR83 = 3155, 1961 | CV_IA64_AR84 = 3156, 1962 | CV_IA64_AR85 = 3157, 1963 | CV_IA64_AR86 = 3158, 1964 | CV_IA64_AR87 = 3159, 1965 | CV_IA64_AR88 = 3160, 1966 | CV_IA64_AR89 = 3161, 1967 | CV_IA64_AR90 = 3162, 1968 | CV_IA64_AR91 = 3163, 1969 | CV_IA64_AR92 = 3164, 1970 | CV_IA64_AR93 = 3165, 1971 | CV_IA64_AR94 = 3166, 1972 | CV_IA64_AR95 = 3167, 1973 | CV_IA64_AR96 = 3168, 1974 | CV_IA64_AR97 = 3169, 1975 | CV_IA64_AR98 = 3170, 1976 | CV_IA64_AR99 = 3171, 1977 | CV_IA64_AR100 = 3172, 1978 | CV_IA64_AR101 = 3173, 1979 | CV_IA64_AR102 = 3174, 1980 | CV_IA64_AR103 = 3175, 1981 | CV_IA64_AR104 = 3176, 1982 | CV_IA64_AR105 = 3177, 1983 | CV_IA64_AR106 = 3178, 1984 | CV_IA64_AR107 = 3179, 1985 | CV_IA64_AR108 = 3180, 1986 | CV_IA64_AR109 = 3181, 1987 | CV_IA64_AR110 = 3182, 1988 | CV_IA64_AR111 = 3183, 1989 | CV_IA64_AR112 = 3184, 1990 | CV_IA64_AR113 = 3185, 1991 | CV_IA64_AR114 = 3186, 1992 | CV_IA64_AR115 = 3187, 1993 | CV_IA64_AR116 = 3188, 1994 | CV_IA64_AR117 = 3189, 1995 | CV_IA64_AR118 = 3190, 1996 | CV_IA64_AR119 = 3191, 1997 | CV_IA64_AR120 = 3192, 1998 | CV_IA64_AR121 = 3193, 1999 | CV_IA64_AR122 = 3194, 2000 | CV_IA64_AR123 = 3195, 2001 | CV_IA64_AR124 = 3196, 2002 | CV_IA64_AR125 = 3197, 2003 | CV_IA64_AR126 = 3198, 2004 | CV_IA64_AR127 = 3199, 2005 | 2006 | // CPUID Registers 2007 | 2008 | CV_IA64_CPUID0 = 3328, 2009 | CV_IA64_CPUID1 = 3329, 2010 | CV_IA64_CPUID2 = 3330, 2011 | CV_IA64_CPUID3 = 3331, 2012 | CV_IA64_CPUID4 = 3332, 2013 | 2014 | // Control Registers 2015 | 2016 | CV_IA64_ApDCR = 4096, 2017 | CV_IA64_ApITM = 4097, 2018 | CV_IA64_ApIVA = 4098, 2019 | CV_IA64_CR3 = 4099, 2020 | CV_IA64_CR4 = 4100, 2021 | CV_IA64_CR5 = 4101, 2022 | CV_IA64_CR6 = 4102, 2023 | CV_IA64_CR7 = 4103, 2024 | CV_IA64_ApPTA = 4104, 2025 | CV_IA64_ApGPTA = 4105, 2026 | CV_IA64_CR10 = 4106, 2027 | CV_IA64_CR11 = 4107, 2028 | CV_IA64_CR12 = 4108, 2029 | CV_IA64_CR13 = 4109, 2030 | CV_IA64_CR14 = 4110, 2031 | CV_IA64_CR15 = 4111, 2032 | CV_IA64_StIPSR = 4112, 2033 | CV_IA64_StISR = 4113, 2034 | CV_IA64_CR18 = 4114, 2035 | CV_IA64_StIIP = 4115, 2036 | CV_IA64_StIFA = 4116, 2037 | CV_IA64_StITIR = 4117, 2038 | CV_IA64_StIIPA = 4118, 2039 | CV_IA64_StIFS = 4119, 2040 | CV_IA64_StIIM = 4120, 2041 | CV_IA64_StIHA = 4121, 2042 | CV_IA64_CR26 = 4122, 2043 | CV_IA64_CR27 = 4123, 2044 | CV_IA64_CR28 = 4124, 2045 | CV_IA64_CR29 = 4125, 2046 | CV_IA64_CR30 = 4126, 2047 | CV_IA64_CR31 = 4127, 2048 | CV_IA64_CR32 = 4128, 2049 | CV_IA64_CR33 = 4129, 2050 | CV_IA64_CR34 = 4130, 2051 | CV_IA64_CR35 = 4131, 2052 | CV_IA64_CR36 = 4132, 2053 | CV_IA64_CR37 = 4133, 2054 | CV_IA64_CR38 = 4134, 2055 | CV_IA64_CR39 = 4135, 2056 | CV_IA64_CR40 = 4136, 2057 | CV_IA64_CR41 = 4137, 2058 | CV_IA64_CR42 = 4138, 2059 | CV_IA64_CR43 = 4139, 2060 | CV_IA64_CR44 = 4140, 2061 | CV_IA64_CR45 = 4141, 2062 | CV_IA64_CR46 = 4142, 2063 | CV_IA64_CR47 = 4143, 2064 | CV_IA64_CR48 = 4144, 2065 | CV_IA64_CR49 = 4145, 2066 | CV_IA64_CR50 = 4146, 2067 | CV_IA64_CR51 = 4147, 2068 | CV_IA64_CR52 = 4148, 2069 | CV_IA64_CR53 = 4149, 2070 | CV_IA64_CR54 = 4150, 2071 | CV_IA64_CR55 = 4151, 2072 | CV_IA64_CR56 = 4152, 2073 | CV_IA64_CR57 = 4153, 2074 | CV_IA64_CR58 = 4154, 2075 | CV_IA64_CR59 = 4155, 2076 | CV_IA64_CR60 = 4156, 2077 | CV_IA64_CR61 = 4157, 2078 | CV_IA64_CR62 = 4158, 2079 | CV_IA64_CR63 = 4159, 2080 | CV_IA64_SaLID = 4160, 2081 | CV_IA64_SaIVR = 4161, 2082 | CV_IA64_SaTPR = 4162, 2083 | CV_IA64_SaEOI = 4163, 2084 | CV_IA64_SaIRR0 = 4164, 2085 | CV_IA64_SaIRR1 = 4165, 2086 | CV_IA64_SaIRR2 = 4166, 2087 | CV_IA64_SaIRR3 = 4167, 2088 | CV_IA64_SaITV = 4168, 2089 | CV_IA64_SaPMV = 4169, 2090 | CV_IA64_SaCMCV = 4170, 2091 | CV_IA64_CR75 = 4171, 2092 | CV_IA64_CR76 = 4172, 2093 | CV_IA64_CR77 = 4173, 2094 | CV_IA64_CR78 = 4174, 2095 | CV_IA64_CR79 = 4175, 2096 | CV_IA64_SaLRR0 = 4176, 2097 | CV_IA64_SaLRR1 = 4177, 2098 | CV_IA64_CR82 = 4178, 2099 | CV_IA64_CR83 = 4179, 2100 | CV_IA64_CR84 = 4180, 2101 | CV_IA64_CR85 = 4181, 2102 | CV_IA64_CR86 = 4182, 2103 | CV_IA64_CR87 = 4183, 2104 | CV_IA64_CR88 = 4184, 2105 | CV_IA64_CR89 = 4185, 2106 | CV_IA64_CR90 = 4186, 2107 | CV_IA64_CR91 = 4187, 2108 | CV_IA64_CR92 = 4188, 2109 | CV_IA64_CR93 = 4189, 2110 | CV_IA64_CR94 = 4190, 2111 | CV_IA64_CR95 = 4191, 2112 | CV_IA64_CR96 = 4192, 2113 | CV_IA64_CR97 = 4193, 2114 | CV_IA64_CR98 = 4194, 2115 | CV_IA64_CR99 = 4195, 2116 | CV_IA64_CR100 = 4196, 2117 | CV_IA64_CR101 = 4197, 2118 | CV_IA64_CR102 = 4198, 2119 | CV_IA64_CR103 = 4199, 2120 | CV_IA64_CR104 = 4200, 2121 | CV_IA64_CR105 = 4201, 2122 | CV_IA64_CR106 = 4202, 2123 | CV_IA64_CR107 = 4203, 2124 | CV_IA64_CR108 = 4204, 2125 | CV_IA64_CR109 = 4205, 2126 | CV_IA64_CR110 = 4206, 2127 | CV_IA64_CR111 = 4207, 2128 | CV_IA64_CR112 = 4208, 2129 | CV_IA64_CR113 = 4209, 2130 | CV_IA64_CR114 = 4210, 2131 | CV_IA64_CR115 = 4211, 2132 | CV_IA64_CR116 = 4212, 2133 | CV_IA64_CR117 = 4213, 2134 | CV_IA64_CR118 = 4214, 2135 | CV_IA64_CR119 = 4215, 2136 | CV_IA64_CR120 = 4216, 2137 | CV_IA64_CR121 = 4217, 2138 | CV_IA64_CR122 = 4218, 2139 | CV_IA64_CR123 = 4219, 2140 | CV_IA64_CR124 = 4220, 2141 | CV_IA64_CR125 = 4221, 2142 | CV_IA64_CR126 = 4222, 2143 | CV_IA64_CR127 = 4223, 2144 | 2145 | // Protection Key Registers 2146 | 2147 | CV_IA64_Pkr0 = 5120, 2148 | CV_IA64_Pkr1 = 5121, 2149 | CV_IA64_Pkr2 = 5122, 2150 | CV_IA64_Pkr3 = 5123, 2151 | CV_IA64_Pkr4 = 5124, 2152 | CV_IA64_Pkr5 = 5125, 2153 | CV_IA64_Pkr6 = 5126, 2154 | CV_IA64_Pkr7 = 5127, 2155 | CV_IA64_Pkr8 = 5128, 2156 | CV_IA64_Pkr9 = 5129, 2157 | CV_IA64_Pkr10 = 5130, 2158 | CV_IA64_Pkr11 = 5131, 2159 | CV_IA64_Pkr12 = 5132, 2160 | CV_IA64_Pkr13 = 5133, 2161 | CV_IA64_Pkr14 = 5134, 2162 | CV_IA64_Pkr15 = 5135, 2163 | 2164 | // Region Registers 2165 | 2166 | CV_IA64_Rr0 = 6144, 2167 | CV_IA64_Rr1 = 6145, 2168 | CV_IA64_Rr2 = 6146, 2169 | CV_IA64_Rr3 = 6147, 2170 | CV_IA64_Rr4 = 6148, 2171 | CV_IA64_Rr5 = 6149, 2172 | CV_IA64_Rr6 = 6150, 2173 | CV_IA64_Rr7 = 6151, 2174 | 2175 | // Performance Monitor Data Registers 2176 | 2177 | CV_IA64_PFD0 = 7168, 2178 | CV_IA64_PFD1 = 7169, 2179 | CV_IA64_PFD2 = 7170, 2180 | CV_IA64_PFD3 = 7171, 2181 | CV_IA64_PFD4 = 7172, 2182 | CV_IA64_PFD5 = 7173, 2183 | CV_IA64_PFD6 = 7174, 2184 | CV_IA64_PFD7 = 7175, 2185 | CV_IA64_PFD8 = 7176, 2186 | CV_IA64_PFD9 = 7177, 2187 | CV_IA64_PFD10 = 7178, 2188 | CV_IA64_PFD11 = 7179, 2189 | CV_IA64_PFD12 = 7180, 2190 | CV_IA64_PFD13 = 7181, 2191 | CV_IA64_PFD14 = 7182, 2192 | CV_IA64_PFD15 = 7183, 2193 | CV_IA64_PFD16 = 7184, 2194 | CV_IA64_PFD17 = 7185, 2195 | 2196 | // Performance Monitor Config Registers 2197 | 2198 | CV_IA64_PFC0 = 7424, 2199 | CV_IA64_PFC1 = 7425, 2200 | CV_IA64_PFC2 = 7426, 2201 | CV_IA64_PFC3 = 7427, 2202 | CV_IA64_PFC4 = 7428, 2203 | CV_IA64_PFC5 = 7429, 2204 | CV_IA64_PFC6 = 7430, 2205 | CV_IA64_PFC7 = 7431, 2206 | CV_IA64_PFC8 = 7432, 2207 | CV_IA64_PFC9 = 7433, 2208 | CV_IA64_PFC10 = 7434, 2209 | CV_IA64_PFC11 = 7435, 2210 | CV_IA64_PFC12 = 7436, 2211 | CV_IA64_PFC13 = 7437, 2212 | CV_IA64_PFC14 = 7438, 2213 | CV_IA64_PFC15 = 7439, 2214 | 2215 | // Instruction Translation Registers 2216 | 2217 | CV_IA64_TrI0 = 8192, 2218 | CV_IA64_TrI1 = 8193, 2219 | CV_IA64_TrI2 = 8194, 2220 | CV_IA64_TrI3 = 8195, 2221 | CV_IA64_TrI4 = 8196, 2222 | CV_IA64_TrI5 = 8197, 2223 | CV_IA64_TrI6 = 8198, 2224 | CV_IA64_TrI7 = 8199, 2225 | 2226 | // Data Translation Registers 2227 | 2228 | CV_IA64_TrD0 = 8320, 2229 | CV_IA64_TrD1 = 8321, 2230 | CV_IA64_TrD2 = 8322, 2231 | CV_IA64_TrD3 = 8323, 2232 | CV_IA64_TrD4 = 8324, 2233 | CV_IA64_TrD5 = 8325, 2234 | CV_IA64_TrD6 = 8326, 2235 | CV_IA64_TrD7 = 8327, 2236 | 2237 | // Instruction Breakpoint Registers 2238 | 2239 | CV_IA64_DbI0 = 8448, 2240 | CV_IA64_DbI1 = 8449, 2241 | CV_IA64_DbI2 = 8450, 2242 | CV_IA64_DbI3 = 8451, 2243 | CV_IA64_DbI4 = 8452, 2244 | CV_IA64_DbI5 = 8453, 2245 | CV_IA64_DbI6 = 8454, 2246 | CV_IA64_DbI7 = 8455, 2247 | 2248 | // Data Breakpoint Registers 2249 | 2250 | CV_IA64_DbD0 = 8576, 2251 | CV_IA64_DbD1 = 8577, 2252 | CV_IA64_DbD2 = 8578, 2253 | CV_IA64_DbD3 = 8579, 2254 | CV_IA64_DbD4 = 8580, 2255 | CV_IA64_DbD5 = 8581, 2256 | CV_IA64_DbD6 = 8582, 2257 | CV_IA64_DbD7 = 8583, 2258 | 2259 | // 2260 | // Register set for the TriCore processor. 2261 | // 2262 | 2263 | CV_TRI_NOREG = CV_REG_NONE, 2264 | 2265 | // General Purpose Data Registers 2266 | 2267 | CV_TRI_D0 = 10, 2268 | CV_TRI_D1 = 11, 2269 | CV_TRI_D2 = 12, 2270 | CV_TRI_D3 = 13, 2271 | CV_TRI_D4 = 14, 2272 | CV_TRI_D5 = 15, 2273 | CV_TRI_D6 = 16, 2274 | CV_TRI_D7 = 17, 2275 | CV_TRI_D8 = 18, 2276 | CV_TRI_D9 = 19, 2277 | CV_TRI_D10 = 20, 2278 | CV_TRI_D11 = 21, 2279 | CV_TRI_D12 = 22, 2280 | CV_TRI_D13 = 23, 2281 | CV_TRI_D14 = 24, 2282 | CV_TRI_D15 = 25, 2283 | 2284 | // General Purpose Address Registers 2285 | 2286 | CV_TRI_A0 = 26, 2287 | CV_TRI_A1 = 27, 2288 | CV_TRI_A2 = 28, 2289 | CV_TRI_A3 = 29, 2290 | CV_TRI_A4 = 30, 2291 | CV_TRI_A5 = 31, 2292 | CV_TRI_A6 = 32, 2293 | CV_TRI_A7 = 33, 2294 | CV_TRI_A8 = 34, 2295 | CV_TRI_A9 = 35, 2296 | CV_TRI_A10 = 36, 2297 | CV_TRI_A11 = 37, 2298 | CV_TRI_A12 = 38, 2299 | CV_TRI_A13 = 39, 2300 | CV_TRI_A14 = 40, 2301 | CV_TRI_A15 = 41, 2302 | 2303 | // Extended (64-bit) data registers 2304 | 2305 | CV_TRI_E0 = 42, 2306 | CV_TRI_E2 = 43, 2307 | CV_TRI_E4 = 44, 2308 | CV_TRI_E6 = 45, 2309 | CV_TRI_E8 = 46, 2310 | CV_TRI_E10 = 47, 2311 | CV_TRI_E12 = 48, 2312 | CV_TRI_E14 = 49, 2313 | 2314 | // Extended (64-bit) address registers 2315 | 2316 | CV_TRI_EA0 = 50, 2317 | CV_TRI_EA2 = 51, 2318 | CV_TRI_EA4 = 52, 2319 | CV_TRI_EA6 = 53, 2320 | CV_TRI_EA8 = 54, 2321 | CV_TRI_EA10 = 55, 2322 | CV_TRI_EA12 = 56, 2323 | CV_TRI_EA14 = 57, 2324 | 2325 | CV_TRI_PSW = 58, 2326 | CV_TRI_PCXI = 59, 2327 | CV_TRI_PC = 60, 2328 | CV_TRI_FCX = 61, 2329 | CV_TRI_LCX = 62, 2330 | CV_TRI_ISP = 63, 2331 | CV_TRI_ICR = 64, 2332 | CV_TRI_BIV = 65, 2333 | CV_TRI_BTV = 66, 2334 | CV_TRI_SYSCON = 67, 2335 | CV_TRI_DPRx_0 = 68, 2336 | CV_TRI_DPRx_1 = 69, 2337 | CV_TRI_DPRx_2 = 70, 2338 | CV_TRI_DPRx_3 = 71, 2339 | CV_TRI_CPRx_0 = 68, 2340 | CV_TRI_CPRx_1 = 69, 2341 | CV_TRI_CPRx_2 = 70, 2342 | CV_TRI_CPRx_3 = 71, 2343 | CV_TRI_DPMx_0 = 68, 2344 | CV_TRI_DPMx_1 = 69, 2345 | CV_TRI_DPMx_2 = 70, 2346 | CV_TRI_DPMx_3 = 71, 2347 | CV_TRI_CPMx_0 = 68, 2348 | CV_TRI_CPMx_1 = 69, 2349 | CV_TRI_CPMx_2 = 70, 2350 | CV_TRI_CPMx_3 = 71, 2351 | CV_TRI_DBGSSR = 72, 2352 | CV_TRI_EXEVT = 73, 2353 | CV_TRI_SWEVT = 74, 2354 | CV_TRI_CREVT = 75, 2355 | CV_TRI_TRnEVT = 76, 2356 | CV_TRI_MMUCON = 77, 2357 | CV_TRI_ASI = 78, 2358 | CV_TRI_TVA = 79, 2359 | CV_TRI_TPA = 80, 2360 | CV_TRI_TPX = 81, 2361 | CV_TRI_TFA = 82, 2362 | 2363 | // 2364 | // Register set for the AM33 and related processors. 2365 | // 2366 | 2367 | CV_AM33_NOREG = CV_REG_NONE, 2368 | 2369 | // "Extended" (general purpose integer) registers 2370 | CV_AM33_E0 = 10, 2371 | CV_AM33_E1 = 11, 2372 | CV_AM33_E2 = 12, 2373 | CV_AM33_E3 = 13, 2374 | CV_AM33_E4 = 14, 2375 | CV_AM33_E5 = 15, 2376 | CV_AM33_E6 = 16, 2377 | CV_AM33_E7 = 17, 2378 | 2379 | // Address registers 2380 | CV_AM33_A0 = 20, 2381 | CV_AM33_A1 = 21, 2382 | CV_AM33_A2 = 22, 2383 | CV_AM33_A3 = 23, 2384 | 2385 | // Integer data registers 2386 | CV_AM33_D0 = 30, 2387 | CV_AM33_D1 = 31, 2388 | CV_AM33_D2 = 32, 2389 | CV_AM33_D3 = 33, 2390 | 2391 | // (Single-precision) floating-point registers 2392 | CV_AM33_FS0 = 40, 2393 | CV_AM33_FS1 = 41, 2394 | CV_AM33_FS2 = 42, 2395 | CV_AM33_FS3 = 43, 2396 | CV_AM33_FS4 = 44, 2397 | CV_AM33_FS5 = 45, 2398 | CV_AM33_FS6 = 46, 2399 | CV_AM33_FS7 = 47, 2400 | CV_AM33_FS8 = 48, 2401 | CV_AM33_FS9 = 49, 2402 | CV_AM33_FS10 = 50, 2403 | CV_AM33_FS11 = 51, 2404 | CV_AM33_FS12 = 52, 2405 | CV_AM33_FS13 = 53, 2406 | CV_AM33_FS14 = 54, 2407 | CV_AM33_FS15 = 55, 2408 | CV_AM33_FS16 = 56, 2409 | CV_AM33_FS17 = 57, 2410 | CV_AM33_FS18 = 58, 2411 | CV_AM33_FS19 = 59, 2412 | CV_AM33_FS20 = 60, 2413 | CV_AM33_FS21 = 61, 2414 | CV_AM33_FS22 = 62, 2415 | CV_AM33_FS23 = 63, 2416 | CV_AM33_FS24 = 64, 2417 | CV_AM33_FS25 = 65, 2418 | CV_AM33_FS26 = 66, 2419 | CV_AM33_FS27 = 67, 2420 | CV_AM33_FS28 = 68, 2421 | CV_AM33_FS29 = 69, 2422 | CV_AM33_FS30 = 70, 2423 | CV_AM33_FS31 = 71, 2424 | 2425 | // Special purpose registers 2426 | 2427 | // Stack pointer 2428 | CV_AM33_SP = 80, 2429 | 2430 | // Program counter 2431 | CV_AM33_PC = 81, 2432 | 2433 | // Multiply-divide/accumulate registers 2434 | CV_AM33_MDR = 82, 2435 | CV_AM33_MDRQ = 83, 2436 | CV_AM33_MCRH = 84, 2437 | CV_AM33_MCRL = 85, 2438 | CV_AM33_MCVF = 86, 2439 | 2440 | // CPU status words 2441 | CV_AM33_EPSW = 87, 2442 | CV_AM33_FPCR = 88, 2443 | 2444 | // Loop buffer registers 2445 | CV_AM33_LIR = 89, 2446 | CV_AM33_LAR = 90, 2447 | 2448 | // 2449 | // Register set for the Mitsubishi M32R 2450 | // 2451 | 2452 | CV_M32R_NOREG = CV_REG_NONE, 2453 | 2454 | CV_M32R_R0 = 10, 2455 | CV_M32R_R1 = 11, 2456 | CV_M32R_R2 = 12, 2457 | CV_M32R_R3 = 13, 2458 | CV_M32R_R4 = 14, 2459 | CV_M32R_R5 = 15, 2460 | CV_M32R_R6 = 16, 2461 | CV_M32R_R7 = 17, 2462 | CV_M32R_R8 = 18, 2463 | CV_M32R_R9 = 19, 2464 | CV_M32R_R10 = 20, 2465 | CV_M32R_R11 = 21, 2466 | CV_M32R_R12 = 22, // Gloabal Pointer, if used 2467 | CV_M32R_R13 = 23, // Frame Pointer, if allocated 2468 | CV_M32R_R14 = 24, // Link Register 2469 | CV_M32R_R15 = 25, // Stack Pointer 2470 | CV_M32R_PSW = 26, // Preocessor Status Register 2471 | CV_M32R_CBR = 27, // Condition Bit Register 2472 | CV_M32R_SPI = 28, // Interrupt Stack Pointer 2473 | CV_M32R_SPU = 29, // User Stack Pointer 2474 | CV_M32R_SPO = 30, // OS Stack Pointer 2475 | CV_M32R_BPC = 31, // Backup Program Counter 2476 | CV_M32R_ACHI = 32, // Accumulator High 2477 | CV_M32R_ACLO = 33, // Accumulator Low 2478 | CV_M32R_PC = 34, // Program Counter 2479 | 2480 | // 2481 | // Register set for the SuperH SHMedia processor including compact 2482 | // mode 2483 | // 2484 | 2485 | // Integer - 64 bit general registers 2486 | CV_SHMEDIA_NOREG = CV_REG_NONE, 2487 | CV_SHMEDIA_R0 = 10, 2488 | CV_SHMEDIA_R1 = 11, 2489 | CV_SHMEDIA_R2 = 12, 2490 | CV_SHMEDIA_R3 = 13, 2491 | CV_SHMEDIA_R4 = 14, 2492 | CV_SHMEDIA_R5 = 15, 2493 | CV_SHMEDIA_R6 = 16, 2494 | CV_SHMEDIA_R7 = 17, 2495 | CV_SHMEDIA_R8 = 18, 2496 | CV_SHMEDIA_R9 = 19, 2497 | CV_SHMEDIA_R10 = 20, 2498 | CV_SHMEDIA_R11 = 21, 2499 | CV_SHMEDIA_R12 = 22, 2500 | CV_SHMEDIA_R13 = 23, 2501 | CV_SHMEDIA_R14 = 24, 2502 | CV_SHMEDIA_R15 = 25, 2503 | CV_SHMEDIA_R16 = 26, 2504 | CV_SHMEDIA_R17 = 27, 2505 | CV_SHMEDIA_R18 = 28, 2506 | CV_SHMEDIA_R19 = 29, 2507 | CV_SHMEDIA_R20 = 30, 2508 | CV_SHMEDIA_R21 = 31, 2509 | CV_SHMEDIA_R22 = 32, 2510 | CV_SHMEDIA_R23 = 33, 2511 | CV_SHMEDIA_R24 = 34, 2512 | CV_SHMEDIA_R25 = 35, 2513 | CV_SHMEDIA_R26 = 36, 2514 | CV_SHMEDIA_R27 = 37, 2515 | CV_SHMEDIA_R28 = 38, 2516 | CV_SHMEDIA_R29 = 39, 2517 | CV_SHMEDIA_R30 = 40, 2518 | CV_SHMEDIA_R31 = 41, 2519 | CV_SHMEDIA_R32 = 42, 2520 | CV_SHMEDIA_R33 = 43, 2521 | CV_SHMEDIA_R34 = 44, 2522 | CV_SHMEDIA_R35 = 45, 2523 | CV_SHMEDIA_R36 = 46, 2524 | CV_SHMEDIA_R37 = 47, 2525 | CV_SHMEDIA_R38 = 48, 2526 | CV_SHMEDIA_R39 = 49, 2527 | CV_SHMEDIA_R40 = 50, 2528 | CV_SHMEDIA_R41 = 51, 2529 | CV_SHMEDIA_R42 = 52, 2530 | CV_SHMEDIA_R43 = 53, 2531 | CV_SHMEDIA_R44 = 54, 2532 | CV_SHMEDIA_R45 = 55, 2533 | CV_SHMEDIA_R46 = 56, 2534 | CV_SHMEDIA_R47 = 57, 2535 | CV_SHMEDIA_R48 = 58, 2536 | CV_SHMEDIA_R49 = 59, 2537 | CV_SHMEDIA_R50 = 60, 2538 | CV_SHMEDIA_R51 = 61, 2539 | CV_SHMEDIA_R52 = 62, 2540 | CV_SHMEDIA_R53 = 63, 2541 | CV_SHMEDIA_R54 = 64, 2542 | CV_SHMEDIA_R55 = 65, 2543 | CV_SHMEDIA_R56 = 66, 2544 | CV_SHMEDIA_R57 = 67, 2545 | CV_SHMEDIA_R58 = 68, 2546 | CV_SHMEDIA_R59 = 69, 2547 | CV_SHMEDIA_R60 = 70, 2548 | CV_SHMEDIA_R61 = 71, 2549 | CV_SHMEDIA_R62 = 72, 2550 | CV_SHMEDIA_R63 = 73, 2551 | 2552 | // Target Registers - 32 bit 2553 | CV_SHMEDIA_TR0 = 74, 2554 | CV_SHMEDIA_TR1 = 75, 2555 | CV_SHMEDIA_TR2 = 76, 2556 | CV_SHMEDIA_TR3 = 77, 2557 | CV_SHMEDIA_TR4 = 78, 2558 | CV_SHMEDIA_TR5 = 79, 2559 | CV_SHMEDIA_TR6 = 80, 2560 | CV_SHMEDIA_TR7 = 81, 2561 | CV_SHMEDIA_TR8 = 82, // future-proof 2562 | CV_SHMEDIA_TR9 = 83, // future-proof 2563 | CV_SHMEDIA_TR10 = 84, // future-proof 2564 | CV_SHMEDIA_TR11 = 85, // future-proof 2565 | CV_SHMEDIA_TR12 = 86, // future-proof 2566 | CV_SHMEDIA_TR13 = 87, // future-proof 2567 | CV_SHMEDIA_TR14 = 88, // future-proof 2568 | CV_SHMEDIA_TR15 = 89, // future-proof 2569 | 2570 | // Single - 32 bit fp registers 2571 | CV_SHMEDIA_FR0 = 128, 2572 | CV_SHMEDIA_FR1 = 129, 2573 | CV_SHMEDIA_FR2 = 130, 2574 | CV_SHMEDIA_FR3 = 131, 2575 | CV_SHMEDIA_FR4 = 132, 2576 | CV_SHMEDIA_FR5 = 133, 2577 | CV_SHMEDIA_FR6 = 134, 2578 | CV_SHMEDIA_FR7 = 135, 2579 | CV_SHMEDIA_FR8 = 136, 2580 | CV_SHMEDIA_FR9 = 137, 2581 | CV_SHMEDIA_FR10 = 138, 2582 | CV_SHMEDIA_FR11 = 139, 2583 | CV_SHMEDIA_FR12 = 140, 2584 | CV_SHMEDIA_FR13 = 141, 2585 | CV_SHMEDIA_FR14 = 142, 2586 | CV_SHMEDIA_FR15 = 143, 2587 | CV_SHMEDIA_FR16 = 144, 2588 | CV_SHMEDIA_FR17 = 145, 2589 | CV_SHMEDIA_FR18 = 146, 2590 | CV_SHMEDIA_FR19 = 147, 2591 | CV_SHMEDIA_FR20 = 148, 2592 | CV_SHMEDIA_FR21 = 149, 2593 | CV_SHMEDIA_FR22 = 150, 2594 | CV_SHMEDIA_FR23 = 151, 2595 | CV_SHMEDIA_FR24 = 152, 2596 | CV_SHMEDIA_FR25 = 153, 2597 | CV_SHMEDIA_FR26 = 154, 2598 | CV_SHMEDIA_FR27 = 155, 2599 | CV_SHMEDIA_FR28 = 156, 2600 | CV_SHMEDIA_FR29 = 157, 2601 | CV_SHMEDIA_FR30 = 158, 2602 | CV_SHMEDIA_FR31 = 159, 2603 | CV_SHMEDIA_FR32 = 160, 2604 | CV_SHMEDIA_FR33 = 161, 2605 | CV_SHMEDIA_FR34 = 162, 2606 | CV_SHMEDIA_FR35 = 163, 2607 | CV_SHMEDIA_FR36 = 164, 2608 | CV_SHMEDIA_FR37 = 165, 2609 | CV_SHMEDIA_FR38 = 166, 2610 | CV_SHMEDIA_FR39 = 167, 2611 | CV_SHMEDIA_FR40 = 168, 2612 | CV_SHMEDIA_FR41 = 169, 2613 | CV_SHMEDIA_FR42 = 170, 2614 | CV_SHMEDIA_FR43 = 171, 2615 | CV_SHMEDIA_FR44 = 172, 2616 | CV_SHMEDIA_FR45 = 173, 2617 | CV_SHMEDIA_FR46 = 174, 2618 | CV_SHMEDIA_FR47 = 175, 2619 | CV_SHMEDIA_FR48 = 176, 2620 | CV_SHMEDIA_FR49 = 177, 2621 | CV_SHMEDIA_FR50 = 178, 2622 | CV_SHMEDIA_FR51 = 179, 2623 | CV_SHMEDIA_FR52 = 180, 2624 | CV_SHMEDIA_FR53 = 181, 2625 | CV_SHMEDIA_FR54 = 182, 2626 | CV_SHMEDIA_FR55 = 183, 2627 | CV_SHMEDIA_FR56 = 184, 2628 | CV_SHMEDIA_FR57 = 185, 2629 | CV_SHMEDIA_FR58 = 186, 2630 | CV_SHMEDIA_FR59 = 187, 2631 | CV_SHMEDIA_FR60 = 188, 2632 | CV_SHMEDIA_FR61 = 189, 2633 | CV_SHMEDIA_FR62 = 190, 2634 | CV_SHMEDIA_FR63 = 191, 2635 | 2636 | // Double - 64 bit synonyms for 32bit fp register pairs 2637 | // subtract 128 to find first base single register 2638 | CV_SHMEDIA_DR0 = 256, 2639 | CV_SHMEDIA_DR2 = 258, 2640 | CV_SHMEDIA_DR4 = 260, 2641 | CV_SHMEDIA_DR6 = 262, 2642 | CV_SHMEDIA_DR8 = 264, 2643 | CV_SHMEDIA_DR10 = 266, 2644 | CV_SHMEDIA_DR12 = 268, 2645 | CV_SHMEDIA_DR14 = 270, 2646 | CV_SHMEDIA_DR16 = 272, 2647 | CV_SHMEDIA_DR18 = 274, 2648 | CV_SHMEDIA_DR20 = 276, 2649 | CV_SHMEDIA_DR22 = 278, 2650 | CV_SHMEDIA_DR24 = 280, 2651 | CV_SHMEDIA_DR26 = 282, 2652 | CV_SHMEDIA_DR28 = 284, 2653 | CV_SHMEDIA_DR30 = 286, 2654 | CV_SHMEDIA_DR32 = 288, 2655 | CV_SHMEDIA_DR34 = 290, 2656 | CV_SHMEDIA_DR36 = 292, 2657 | CV_SHMEDIA_DR38 = 294, 2658 | CV_SHMEDIA_DR40 = 296, 2659 | CV_SHMEDIA_DR42 = 298, 2660 | CV_SHMEDIA_DR44 = 300, 2661 | CV_SHMEDIA_DR46 = 302, 2662 | CV_SHMEDIA_DR48 = 304, 2663 | CV_SHMEDIA_DR50 = 306, 2664 | CV_SHMEDIA_DR52 = 308, 2665 | CV_SHMEDIA_DR54 = 310, 2666 | CV_SHMEDIA_DR56 = 312, 2667 | CV_SHMEDIA_DR58 = 314, 2668 | CV_SHMEDIA_DR60 = 316, 2669 | CV_SHMEDIA_DR62 = 318, 2670 | 2671 | // Vector - 128 bit synonyms for 32bit fp register quads 2672 | // subtract 384 to find first base single register 2673 | CV_SHMEDIA_FV0 = 512, 2674 | CV_SHMEDIA_FV4 = 516, 2675 | CV_SHMEDIA_FV8 = 520, 2676 | CV_SHMEDIA_FV12 = 524, 2677 | CV_SHMEDIA_FV16 = 528, 2678 | CV_SHMEDIA_FV20 = 532, 2679 | CV_SHMEDIA_FV24 = 536, 2680 | CV_SHMEDIA_FV28 = 540, 2681 | CV_SHMEDIA_FV32 = 544, 2682 | CV_SHMEDIA_FV36 = 548, 2683 | CV_SHMEDIA_FV40 = 552, 2684 | CV_SHMEDIA_FV44 = 556, 2685 | CV_SHMEDIA_FV48 = 560, 2686 | CV_SHMEDIA_FV52 = 564, 2687 | CV_SHMEDIA_FV56 = 568, 2688 | CV_SHMEDIA_FV60 = 572, 2689 | 2690 | // Matrix - 512 bit synonyms for 16 adjacent 32bit fp registers 2691 | // subtract 896 to find first base single register 2692 | CV_SHMEDIA_MTRX0 = 1024, 2693 | CV_SHMEDIA_MTRX16 = 1040, 2694 | CV_SHMEDIA_MTRX32 = 1056, 2695 | CV_SHMEDIA_MTRX48 = 1072, 2696 | 2697 | // Control - Implementation defined 64bit control registers 2698 | CV_SHMEDIA_CR0 = 2000, 2699 | CV_SHMEDIA_CR1 = 2001, 2700 | CV_SHMEDIA_CR2 = 2002, 2701 | CV_SHMEDIA_CR3 = 2003, 2702 | CV_SHMEDIA_CR4 = 2004, 2703 | CV_SHMEDIA_CR5 = 2005, 2704 | CV_SHMEDIA_CR6 = 2006, 2705 | CV_SHMEDIA_CR7 = 2007, 2706 | CV_SHMEDIA_CR8 = 2008, 2707 | CV_SHMEDIA_CR9 = 2009, 2708 | CV_SHMEDIA_CR10 = 2010, 2709 | CV_SHMEDIA_CR11 = 2011, 2710 | CV_SHMEDIA_CR12 = 2012, 2711 | CV_SHMEDIA_CR13 = 2013, 2712 | CV_SHMEDIA_CR14 = 2014, 2713 | CV_SHMEDIA_CR15 = 2015, 2714 | CV_SHMEDIA_CR16 = 2016, 2715 | CV_SHMEDIA_CR17 = 2017, 2716 | CV_SHMEDIA_CR18 = 2018, 2717 | CV_SHMEDIA_CR19 = 2019, 2718 | CV_SHMEDIA_CR20 = 2020, 2719 | CV_SHMEDIA_CR21 = 2021, 2720 | CV_SHMEDIA_CR22 = 2022, 2721 | CV_SHMEDIA_CR23 = 2023, 2722 | CV_SHMEDIA_CR24 = 2024, 2723 | CV_SHMEDIA_CR25 = 2025, 2724 | CV_SHMEDIA_CR26 = 2026, 2725 | CV_SHMEDIA_CR27 = 2027, 2726 | CV_SHMEDIA_CR28 = 2028, 2727 | CV_SHMEDIA_CR29 = 2029, 2728 | CV_SHMEDIA_CR30 = 2030, 2729 | CV_SHMEDIA_CR31 = 2031, 2730 | CV_SHMEDIA_CR32 = 2032, 2731 | CV_SHMEDIA_CR33 = 2033, 2732 | CV_SHMEDIA_CR34 = 2034, 2733 | CV_SHMEDIA_CR35 = 2035, 2734 | CV_SHMEDIA_CR36 = 2036, 2735 | CV_SHMEDIA_CR37 = 2037, 2736 | CV_SHMEDIA_CR38 = 2038, 2737 | CV_SHMEDIA_CR39 = 2039, 2738 | CV_SHMEDIA_CR40 = 2040, 2739 | CV_SHMEDIA_CR41 = 2041, 2740 | CV_SHMEDIA_CR42 = 2042, 2741 | CV_SHMEDIA_CR43 = 2043, 2742 | CV_SHMEDIA_CR44 = 2044, 2743 | CV_SHMEDIA_CR45 = 2045, 2744 | CV_SHMEDIA_CR46 = 2046, 2745 | CV_SHMEDIA_CR47 = 2047, 2746 | CV_SHMEDIA_CR48 = 2048, 2747 | CV_SHMEDIA_CR49 = 2049, 2748 | CV_SHMEDIA_CR50 = 2050, 2749 | CV_SHMEDIA_CR51 = 2051, 2750 | CV_SHMEDIA_CR52 = 2052, 2751 | CV_SHMEDIA_CR53 = 2053, 2752 | CV_SHMEDIA_CR54 = 2054, 2753 | CV_SHMEDIA_CR55 = 2055, 2754 | CV_SHMEDIA_CR56 = 2056, 2755 | CV_SHMEDIA_CR57 = 2057, 2756 | CV_SHMEDIA_CR58 = 2058, 2757 | CV_SHMEDIA_CR59 = 2059, 2758 | CV_SHMEDIA_CR60 = 2060, 2759 | CV_SHMEDIA_CR61 = 2061, 2760 | CV_SHMEDIA_CR62 = 2062, 2761 | CV_SHMEDIA_CR63 = 2063, 2762 | 2763 | CV_SHMEDIA_FPSCR = 2064, 2764 | 2765 | // Compact mode synonyms 2766 | CV_SHMEDIA_GBR = CV_SHMEDIA_R16, 2767 | CV_SHMEDIA_MACL = 90, // synonym for lower 32bits of media R17 2768 | CV_SHMEDIA_MACH = 91, // synonym for upper 32bits of media R17 2769 | CV_SHMEDIA_PR = CV_SHMEDIA_R18, 2770 | CV_SHMEDIA_T = 92, // synonym for lowest bit of media R19 2771 | CV_SHMEDIA_FPUL = CV_SHMEDIA_FR32, 2772 | CV_SHMEDIA_PC = 93, 2773 | CV_SHMEDIA_SR = CV_SHMEDIA_CR0, 2774 | 2775 | // 2776 | // AMD64 registers 2777 | // 2778 | 2779 | CV_AMD64_AL = 1, 2780 | CV_AMD64_CL = 2, 2781 | CV_AMD64_DL = 3, 2782 | CV_AMD64_BL = 4, 2783 | CV_AMD64_AH = 5, 2784 | CV_AMD64_CH = 6, 2785 | CV_AMD64_DH = 7, 2786 | CV_AMD64_BH = 8, 2787 | CV_AMD64_AX = 9, 2788 | CV_AMD64_CX = 10, 2789 | CV_AMD64_DX = 11, 2790 | CV_AMD64_BX = 12, 2791 | CV_AMD64_SP = 13, 2792 | CV_AMD64_BP = 14, 2793 | CV_AMD64_SI = 15, 2794 | CV_AMD64_DI = 16, 2795 | CV_AMD64_EAX = 17, 2796 | CV_AMD64_ECX = 18, 2797 | CV_AMD64_EDX = 19, 2798 | CV_AMD64_EBX = 20, 2799 | CV_AMD64_ESP = 21, 2800 | CV_AMD64_EBP = 22, 2801 | CV_AMD64_ESI = 23, 2802 | CV_AMD64_EDI = 24, 2803 | CV_AMD64_ES = 25, 2804 | CV_AMD64_CS = 26, 2805 | CV_AMD64_SS = 27, 2806 | CV_AMD64_DS = 28, 2807 | CV_AMD64_FS = 29, 2808 | CV_AMD64_GS = 30, 2809 | CV_AMD64_FLAGS = 32, 2810 | CV_AMD64_RIP = 33, 2811 | CV_AMD64_EFLAGS = 34, 2812 | 2813 | // Control registers 2814 | CV_AMD64_CR0 = 80, 2815 | CV_AMD64_CR1 = 81, 2816 | CV_AMD64_CR2 = 82, 2817 | CV_AMD64_CR3 = 83, 2818 | CV_AMD64_CR4 = 84, 2819 | CV_AMD64_CR8 = 88, 2820 | 2821 | // Debug registers 2822 | CV_AMD64_DR0 = 90, 2823 | CV_AMD64_DR1 = 91, 2824 | CV_AMD64_DR2 = 92, 2825 | CV_AMD64_DR3 = 93, 2826 | CV_AMD64_DR4 = 94, 2827 | CV_AMD64_DR5 = 95, 2828 | CV_AMD64_DR6 = 96, 2829 | CV_AMD64_DR7 = 97, 2830 | CV_AMD64_DR8 = 98, 2831 | CV_AMD64_DR9 = 99, 2832 | CV_AMD64_DR10 = 100, 2833 | CV_AMD64_DR11 = 101, 2834 | CV_AMD64_DR12 = 102, 2835 | CV_AMD64_DR13 = 103, 2836 | CV_AMD64_DR14 = 104, 2837 | CV_AMD64_DR15 = 105, 2838 | 2839 | CV_AMD64_GDTR = 110, 2840 | CV_AMD64_GDTL = 111, 2841 | CV_AMD64_IDTR = 112, 2842 | CV_AMD64_IDTL = 113, 2843 | CV_AMD64_LDTR = 114, 2844 | CV_AMD64_TR = 115, 2845 | 2846 | CV_AMD64_ST0 = 128, 2847 | CV_AMD64_ST1 = 129, 2848 | CV_AMD64_ST2 = 130, 2849 | CV_AMD64_ST3 = 131, 2850 | CV_AMD64_ST4 = 132, 2851 | CV_AMD64_ST5 = 133, 2852 | CV_AMD64_ST6 = 134, 2853 | CV_AMD64_ST7 = 135, 2854 | CV_AMD64_CTRL = 136, 2855 | CV_AMD64_STAT = 137, 2856 | CV_AMD64_TAG = 138, 2857 | CV_AMD64_FPIP = 139, 2858 | CV_AMD64_FPCS = 140, 2859 | CV_AMD64_FPDO = 141, 2860 | CV_AMD64_FPDS = 142, 2861 | CV_AMD64_ISEM = 143, 2862 | CV_AMD64_FPEIP = 144, 2863 | CV_AMD64_FPEDO = 145, 2864 | 2865 | CV_AMD64_MM0 = 146, 2866 | CV_AMD64_MM1 = 147, 2867 | CV_AMD64_MM2 = 148, 2868 | CV_AMD64_MM3 = 149, 2869 | CV_AMD64_MM4 = 150, 2870 | CV_AMD64_MM5 = 151, 2871 | CV_AMD64_MM6 = 152, 2872 | CV_AMD64_MM7 = 153, 2873 | 2874 | CV_AMD64_XMM0 = 154, // KATMAI registers 2875 | CV_AMD64_XMM1 = 155, 2876 | CV_AMD64_XMM2 = 156, 2877 | CV_AMD64_XMM3 = 157, 2878 | CV_AMD64_XMM4 = 158, 2879 | CV_AMD64_XMM5 = 159, 2880 | CV_AMD64_XMM6 = 160, 2881 | CV_AMD64_XMM7 = 161, 2882 | 2883 | CV_AMD64_XMM0_0 = 162, // KATMAI sub-registers 2884 | CV_AMD64_XMM0_1 = 163, 2885 | CV_AMD64_XMM0_2 = 164, 2886 | CV_AMD64_XMM0_3 = 165, 2887 | CV_AMD64_XMM1_0 = 166, 2888 | CV_AMD64_XMM1_1 = 167, 2889 | CV_AMD64_XMM1_2 = 168, 2890 | CV_AMD64_XMM1_3 = 169, 2891 | CV_AMD64_XMM2_0 = 170, 2892 | CV_AMD64_XMM2_1 = 171, 2893 | CV_AMD64_XMM2_2 = 172, 2894 | CV_AMD64_XMM2_3 = 173, 2895 | CV_AMD64_XMM3_0 = 174, 2896 | CV_AMD64_XMM3_1 = 175, 2897 | CV_AMD64_XMM3_2 = 176, 2898 | CV_AMD64_XMM3_3 = 177, 2899 | CV_AMD64_XMM4_0 = 178, 2900 | CV_AMD64_XMM4_1 = 179, 2901 | CV_AMD64_XMM4_2 = 180, 2902 | CV_AMD64_XMM4_3 = 181, 2903 | CV_AMD64_XMM5_0 = 182, 2904 | CV_AMD64_XMM5_1 = 183, 2905 | CV_AMD64_XMM5_2 = 184, 2906 | CV_AMD64_XMM5_3 = 185, 2907 | CV_AMD64_XMM6_0 = 186, 2908 | CV_AMD64_XMM6_1 = 187, 2909 | CV_AMD64_XMM6_2 = 188, 2910 | CV_AMD64_XMM6_3 = 189, 2911 | CV_AMD64_XMM7_0 = 190, 2912 | CV_AMD64_XMM7_1 = 191, 2913 | CV_AMD64_XMM7_2 = 192, 2914 | CV_AMD64_XMM7_3 = 193, 2915 | 2916 | CV_AMD64_XMM0L = 194, 2917 | CV_AMD64_XMM1L = 195, 2918 | CV_AMD64_XMM2L = 196, 2919 | CV_AMD64_XMM3L = 197, 2920 | CV_AMD64_XMM4L = 198, 2921 | CV_AMD64_XMM5L = 199, 2922 | CV_AMD64_XMM6L = 200, 2923 | CV_AMD64_XMM7L = 201, 2924 | 2925 | CV_AMD64_XMM0H = 202, 2926 | CV_AMD64_XMM1H = 203, 2927 | CV_AMD64_XMM2H = 204, 2928 | CV_AMD64_XMM3H = 205, 2929 | CV_AMD64_XMM4H = 206, 2930 | CV_AMD64_XMM5H = 207, 2931 | CV_AMD64_XMM6H = 208, 2932 | CV_AMD64_XMM7H = 209, 2933 | 2934 | CV_AMD64_MXCSR = 211, // XMM status register 2935 | 2936 | CV_AMD64_EMM0L = 220, // XMM sub-registers (WNI integer) 2937 | CV_AMD64_EMM1L = 221, 2938 | CV_AMD64_EMM2L = 222, 2939 | CV_AMD64_EMM3L = 223, 2940 | CV_AMD64_EMM4L = 224, 2941 | CV_AMD64_EMM5L = 225, 2942 | CV_AMD64_EMM6L = 226, 2943 | CV_AMD64_EMM7L = 227, 2944 | 2945 | CV_AMD64_EMM0H = 228, 2946 | CV_AMD64_EMM1H = 229, 2947 | CV_AMD64_EMM2H = 230, 2948 | CV_AMD64_EMM3H = 231, 2949 | CV_AMD64_EMM4H = 232, 2950 | CV_AMD64_EMM5H = 233, 2951 | CV_AMD64_EMM6H = 234, 2952 | CV_AMD64_EMM7H = 235, 2953 | 2954 | // do not change the order of these regs, first one must be even too 2955 | CV_AMD64_MM00 = 236, 2956 | CV_AMD64_MM01 = 237, 2957 | CV_AMD64_MM10 = 238, 2958 | CV_AMD64_MM11 = 239, 2959 | CV_AMD64_MM20 = 240, 2960 | CV_AMD64_MM21 = 241, 2961 | CV_AMD64_MM30 = 242, 2962 | CV_AMD64_MM31 = 243, 2963 | CV_AMD64_MM40 = 244, 2964 | CV_AMD64_MM41 = 245, 2965 | CV_AMD64_MM50 = 246, 2966 | CV_AMD64_MM51 = 247, 2967 | CV_AMD64_MM60 = 248, 2968 | CV_AMD64_MM61 = 249, 2969 | CV_AMD64_MM70 = 250, 2970 | CV_AMD64_MM71 = 251, 2971 | 2972 | // Extended KATMAI registers 2973 | CV_AMD64_XMM8 = 252, // KATMAI registers 2974 | CV_AMD64_XMM9 = 253, 2975 | CV_AMD64_XMM10 = 254, 2976 | CV_AMD64_XMM11 = 255, 2977 | CV_AMD64_XMM12 = 256, 2978 | CV_AMD64_XMM13 = 257, 2979 | CV_AMD64_XMM14 = 258, 2980 | CV_AMD64_XMM15 = 259, 2981 | 2982 | CV_AMD64_XMM8_0 = 260, // KATMAI sub-registers 2983 | CV_AMD64_XMM8_1 = 261, 2984 | CV_AMD64_XMM8_2 = 262, 2985 | CV_AMD64_XMM8_3 = 263, 2986 | CV_AMD64_XMM9_0 = 264, 2987 | CV_AMD64_XMM9_1 = 265, 2988 | CV_AMD64_XMM9_2 = 266, 2989 | CV_AMD64_XMM9_3 = 267, 2990 | CV_AMD64_XMM10_0 = 268, 2991 | CV_AMD64_XMM10_1 = 269, 2992 | CV_AMD64_XMM10_2 = 270, 2993 | CV_AMD64_XMM10_3 = 271, 2994 | CV_AMD64_XMM11_0 = 272, 2995 | CV_AMD64_XMM11_1 = 273, 2996 | CV_AMD64_XMM11_2 = 274, 2997 | CV_AMD64_XMM11_3 = 275, 2998 | CV_AMD64_XMM12_0 = 276, 2999 | CV_AMD64_XMM12_1 = 277, 3000 | CV_AMD64_XMM12_2 = 278, 3001 | CV_AMD64_XMM12_3 = 279, 3002 | CV_AMD64_XMM13_0 = 280, 3003 | CV_AMD64_XMM13_1 = 281, 3004 | CV_AMD64_XMM13_2 = 282, 3005 | CV_AMD64_XMM13_3 = 283, 3006 | CV_AMD64_XMM14_0 = 284, 3007 | CV_AMD64_XMM14_1 = 285, 3008 | CV_AMD64_XMM14_2 = 286, 3009 | CV_AMD64_XMM14_3 = 287, 3010 | CV_AMD64_XMM15_0 = 288, 3011 | CV_AMD64_XMM15_1 = 289, 3012 | CV_AMD64_XMM15_2 = 290, 3013 | CV_AMD64_XMM15_3 = 291, 3014 | 3015 | CV_AMD64_XMM8L = 292, 3016 | CV_AMD64_XMM9L = 293, 3017 | CV_AMD64_XMM10L = 294, 3018 | CV_AMD64_XMM11L = 295, 3019 | CV_AMD64_XMM12L = 296, 3020 | CV_AMD64_XMM13L = 297, 3021 | CV_AMD64_XMM14L = 298, 3022 | CV_AMD64_XMM15L = 299, 3023 | 3024 | CV_AMD64_XMM8H = 300, 3025 | CV_AMD64_XMM9H = 301, 3026 | CV_AMD64_XMM10H = 302, 3027 | CV_AMD64_XMM11H = 303, 3028 | CV_AMD64_XMM12H = 304, 3029 | CV_AMD64_XMM13H = 305, 3030 | CV_AMD64_XMM14H = 306, 3031 | CV_AMD64_XMM15H = 307, 3032 | 3033 | CV_AMD64_EMM8L = 308, // XMM sub-registers (WNI integer) 3034 | CV_AMD64_EMM9L = 309, 3035 | CV_AMD64_EMM10L = 310, 3036 | CV_AMD64_EMM11L = 311, 3037 | CV_AMD64_EMM12L = 312, 3038 | CV_AMD64_EMM13L = 313, 3039 | CV_AMD64_EMM14L = 314, 3040 | CV_AMD64_EMM15L = 315, 3041 | 3042 | CV_AMD64_EMM8H = 316, 3043 | CV_AMD64_EMM9H = 317, 3044 | CV_AMD64_EMM10H = 318, 3045 | CV_AMD64_EMM11H = 319, 3046 | CV_AMD64_EMM12H = 320, 3047 | CV_AMD64_EMM13H = 321, 3048 | CV_AMD64_EMM14H = 322, 3049 | CV_AMD64_EMM15H = 323, 3050 | 3051 | // Low byte forms of some standard registers 3052 | CV_AMD64_SIL = 324, 3053 | CV_AMD64_DIL = 325, 3054 | CV_AMD64_BPL = 326, 3055 | CV_AMD64_SPL = 327, 3056 | 3057 | // 64-bit regular registers 3058 | CV_AMD64_RAX = 328, 3059 | CV_AMD64_RBX = 329, 3060 | CV_AMD64_RCX = 330, 3061 | CV_AMD64_RDX = 331, 3062 | CV_AMD64_RSI = 332, 3063 | CV_AMD64_RDI = 333, 3064 | CV_AMD64_RBP = 334, 3065 | CV_AMD64_RSP = 335, 3066 | 3067 | // 64-bit integer registers with 8-, 16-, and 32-bit forms (B, W, and D) 3068 | CV_AMD64_R8 = 336, 3069 | CV_AMD64_R9 = 337, 3070 | CV_AMD64_R10 = 338, 3071 | CV_AMD64_R11 = 339, 3072 | CV_AMD64_R12 = 340, 3073 | CV_AMD64_R13 = 341, 3074 | CV_AMD64_R14 = 342, 3075 | CV_AMD64_R15 = 343, 3076 | 3077 | CV_AMD64_R8B = 344, 3078 | CV_AMD64_R9B = 345, 3079 | CV_AMD64_R10B = 346, 3080 | CV_AMD64_R11B = 347, 3081 | CV_AMD64_R12B = 348, 3082 | CV_AMD64_R13B = 349, 3083 | CV_AMD64_R14B = 350, 3084 | CV_AMD64_R15B = 351, 3085 | 3086 | CV_AMD64_R8W = 352, 3087 | CV_AMD64_R9W = 353, 3088 | CV_AMD64_R10W = 354, 3089 | CV_AMD64_R11W = 355, 3090 | CV_AMD64_R12W = 356, 3091 | CV_AMD64_R13W = 357, 3092 | CV_AMD64_R14W = 358, 3093 | CV_AMD64_R15W = 359, 3094 | 3095 | CV_AMD64_R8D = 360, 3096 | CV_AMD64_R9D = 361, 3097 | CV_AMD64_R10D = 362, 3098 | CV_AMD64_R11D = 363, 3099 | CV_AMD64_R12D = 364, 3100 | CV_AMD64_R13D = 365, 3101 | CV_AMD64_R14D = 366, 3102 | CV_AMD64_R15D = 367, 3103 | 3104 | // AVX registers 256 bits 3105 | CV_AMD64_YMM0 = 368, 3106 | CV_AMD64_YMM1 = 369, 3107 | CV_AMD64_YMM2 = 370, 3108 | CV_AMD64_YMM3 = 371, 3109 | CV_AMD64_YMM4 = 372, 3110 | CV_AMD64_YMM5 = 373, 3111 | CV_AMD64_YMM6 = 374, 3112 | CV_AMD64_YMM7 = 375, 3113 | CV_AMD64_YMM8 = 376, 3114 | CV_AMD64_YMM9 = 377, 3115 | CV_AMD64_YMM10 = 378, 3116 | CV_AMD64_YMM11 = 379, 3117 | CV_AMD64_YMM12 = 380, 3118 | CV_AMD64_YMM13 = 381, 3119 | CV_AMD64_YMM14 = 382, 3120 | CV_AMD64_YMM15 = 383, 3121 | 3122 | // AVX registers upper 128 bits 3123 | CV_AMD64_YMM0H = 384, 3124 | CV_AMD64_YMM1H = 385, 3125 | CV_AMD64_YMM2H = 386, 3126 | CV_AMD64_YMM3H = 387, 3127 | CV_AMD64_YMM4H = 388, 3128 | CV_AMD64_YMM5H = 389, 3129 | CV_AMD64_YMM6H = 390, 3130 | CV_AMD64_YMM7H = 391, 3131 | CV_AMD64_YMM8H = 392, 3132 | CV_AMD64_YMM9H = 393, 3133 | CV_AMD64_YMM10H = 394, 3134 | CV_AMD64_YMM11H = 395, 3135 | CV_AMD64_YMM12H = 396, 3136 | CV_AMD64_YMM13H = 397, 3137 | CV_AMD64_YMM14H = 398, 3138 | CV_AMD64_YMM15H = 399, 3139 | 3140 | //Lower/upper 8 bytes of XMM registers. Unlike CV_AMD64_XMM, these 3141 | //values reprsesent the bit patterns of the registers as 64-bit integers, not 3142 | //the representation of these registers as a double. 3143 | CV_AMD64_XMM0IL = 400, 3144 | CV_AMD64_XMM1IL = 401, 3145 | CV_AMD64_XMM2IL = 402, 3146 | CV_AMD64_XMM3IL = 403, 3147 | CV_AMD64_XMM4IL = 404, 3148 | CV_AMD64_XMM5IL = 405, 3149 | CV_AMD64_XMM6IL = 406, 3150 | CV_AMD64_XMM7IL = 407, 3151 | CV_AMD64_XMM8IL = 408, 3152 | CV_AMD64_XMM9IL = 409, 3153 | CV_AMD64_XMM10IL = 410, 3154 | CV_AMD64_XMM11IL = 411, 3155 | CV_AMD64_XMM12IL = 412, 3156 | CV_AMD64_XMM13IL = 413, 3157 | CV_AMD64_XMM14IL = 414, 3158 | CV_AMD64_XMM15IL = 415, 3159 | 3160 | CV_AMD64_XMM0IH = 416, 3161 | CV_AMD64_XMM1IH = 417, 3162 | CV_AMD64_XMM2IH = 418, 3163 | CV_AMD64_XMM3IH = 419, 3164 | CV_AMD64_XMM4IH = 420, 3165 | CV_AMD64_XMM5IH = 421, 3166 | CV_AMD64_XMM6IH = 422, 3167 | CV_AMD64_XMM7IH = 423, 3168 | CV_AMD64_XMM8IH = 424, 3169 | CV_AMD64_XMM9IH = 425, 3170 | CV_AMD64_XMM10IH = 426, 3171 | CV_AMD64_XMM11IH = 427, 3172 | CV_AMD64_XMM12IH = 428, 3173 | CV_AMD64_XMM13IH = 429, 3174 | CV_AMD64_XMM14IH = 430, 3175 | CV_AMD64_XMM15IH = 431, 3176 | 3177 | CV_AMD64_YMM0I0 = 432, // AVX integer registers 3178 | CV_AMD64_YMM0I1 = 433, 3179 | CV_AMD64_YMM0I2 = 434, 3180 | CV_AMD64_YMM0I3 = 435, 3181 | CV_AMD64_YMM1I0 = 436, 3182 | CV_AMD64_YMM1I1 = 437, 3183 | CV_AMD64_YMM1I2 = 438, 3184 | CV_AMD64_YMM1I3 = 439, 3185 | CV_AMD64_YMM2I0 = 440, 3186 | CV_AMD64_YMM2I1 = 441, 3187 | CV_AMD64_YMM2I2 = 442, 3188 | CV_AMD64_YMM2I3 = 443, 3189 | CV_AMD64_YMM3I0 = 444, 3190 | CV_AMD64_YMM3I1 = 445, 3191 | CV_AMD64_YMM3I2 = 446, 3192 | CV_AMD64_YMM3I3 = 447, 3193 | CV_AMD64_YMM4I0 = 448, 3194 | CV_AMD64_YMM4I1 = 449, 3195 | CV_AMD64_YMM4I2 = 450, 3196 | CV_AMD64_YMM4I3 = 451, 3197 | CV_AMD64_YMM5I0 = 452, 3198 | CV_AMD64_YMM5I1 = 453, 3199 | CV_AMD64_YMM5I2 = 454, 3200 | CV_AMD64_YMM5I3 = 455, 3201 | CV_AMD64_YMM6I0 = 456, 3202 | CV_AMD64_YMM6I1 = 457, 3203 | CV_AMD64_YMM6I2 = 458, 3204 | CV_AMD64_YMM6I3 = 459, 3205 | CV_AMD64_YMM7I0 = 460, 3206 | CV_AMD64_YMM7I1 = 461, 3207 | CV_AMD64_YMM7I2 = 462, 3208 | CV_AMD64_YMM7I3 = 463, 3209 | CV_AMD64_YMM8I0 = 464, 3210 | CV_AMD64_YMM8I1 = 465, 3211 | CV_AMD64_YMM8I2 = 466, 3212 | CV_AMD64_YMM8I3 = 467, 3213 | CV_AMD64_YMM9I0 = 468, 3214 | CV_AMD64_YMM9I1 = 469, 3215 | CV_AMD64_YMM9I2 = 470, 3216 | CV_AMD64_YMM9I3 = 471, 3217 | CV_AMD64_YMM10I0 = 472, 3218 | CV_AMD64_YMM10I1 = 473, 3219 | CV_AMD64_YMM10I2 = 474, 3220 | CV_AMD64_YMM10I3 = 475, 3221 | CV_AMD64_YMM11I0 = 476, 3222 | CV_AMD64_YMM11I1 = 477, 3223 | CV_AMD64_YMM11I2 = 478, 3224 | CV_AMD64_YMM11I3 = 479, 3225 | CV_AMD64_YMM12I0 = 480, 3226 | CV_AMD64_YMM12I1 = 481, 3227 | CV_AMD64_YMM12I2 = 482, 3228 | CV_AMD64_YMM12I3 = 483, 3229 | CV_AMD64_YMM13I0 = 484, 3230 | CV_AMD64_YMM13I1 = 485, 3231 | CV_AMD64_YMM13I2 = 486, 3232 | CV_AMD64_YMM13I3 = 487, 3233 | CV_AMD64_YMM14I0 = 488, 3234 | CV_AMD64_YMM14I1 = 489, 3235 | CV_AMD64_YMM14I2 = 490, 3236 | CV_AMD64_YMM14I3 = 491, 3237 | CV_AMD64_YMM15I0 = 492, 3238 | CV_AMD64_YMM15I1 = 493, 3239 | CV_AMD64_YMM15I2 = 494, 3240 | CV_AMD64_YMM15I3 = 495, 3241 | 3242 | CV_AMD64_YMM0F0 = 496, // AVX floating-point single precise registers 3243 | CV_AMD64_YMM0F1 = 497, 3244 | CV_AMD64_YMM0F2 = 498, 3245 | CV_AMD64_YMM0F3 = 499, 3246 | CV_AMD64_YMM0F4 = 500, 3247 | CV_AMD64_YMM0F5 = 501, 3248 | CV_AMD64_YMM0F6 = 502, 3249 | CV_AMD64_YMM0F7 = 503, 3250 | CV_AMD64_YMM1F0 = 504, 3251 | CV_AMD64_YMM1F1 = 505, 3252 | CV_AMD64_YMM1F2 = 506, 3253 | CV_AMD64_YMM1F3 = 507, 3254 | CV_AMD64_YMM1F4 = 508, 3255 | CV_AMD64_YMM1F5 = 509, 3256 | CV_AMD64_YMM1F6 = 510, 3257 | CV_AMD64_YMM1F7 = 511, 3258 | CV_AMD64_YMM2F0 = 512, 3259 | CV_AMD64_YMM2F1 = 513, 3260 | CV_AMD64_YMM2F2 = 514, 3261 | CV_AMD64_YMM2F3 = 515, 3262 | CV_AMD64_YMM2F4 = 516, 3263 | CV_AMD64_YMM2F5 = 517, 3264 | CV_AMD64_YMM2F6 = 518, 3265 | CV_AMD64_YMM2F7 = 519, 3266 | CV_AMD64_YMM3F0 = 520, 3267 | CV_AMD64_YMM3F1 = 521, 3268 | CV_AMD64_YMM3F2 = 522, 3269 | CV_AMD64_YMM3F3 = 523, 3270 | CV_AMD64_YMM3F4 = 524, 3271 | CV_AMD64_YMM3F5 = 525, 3272 | CV_AMD64_YMM3F6 = 526, 3273 | CV_AMD64_YMM3F7 = 527, 3274 | CV_AMD64_YMM4F0 = 528, 3275 | CV_AMD64_YMM4F1 = 529, 3276 | CV_AMD64_YMM4F2 = 530, 3277 | CV_AMD64_YMM4F3 = 531, 3278 | CV_AMD64_YMM4F4 = 532, 3279 | CV_AMD64_YMM4F5 = 533, 3280 | CV_AMD64_YMM4F6 = 534, 3281 | CV_AMD64_YMM4F7 = 535, 3282 | CV_AMD64_YMM5F0 = 536, 3283 | CV_AMD64_YMM5F1 = 537, 3284 | CV_AMD64_YMM5F2 = 538, 3285 | CV_AMD64_YMM5F3 = 539, 3286 | CV_AMD64_YMM5F4 = 540, 3287 | CV_AMD64_YMM5F5 = 541, 3288 | CV_AMD64_YMM5F6 = 542, 3289 | CV_AMD64_YMM5F7 = 543, 3290 | CV_AMD64_YMM6F0 = 544, 3291 | CV_AMD64_YMM6F1 = 545, 3292 | CV_AMD64_YMM6F2 = 546, 3293 | CV_AMD64_YMM6F3 = 547, 3294 | CV_AMD64_YMM6F4 = 548, 3295 | CV_AMD64_YMM6F5 = 549, 3296 | CV_AMD64_YMM6F6 = 550, 3297 | CV_AMD64_YMM6F7 = 551, 3298 | CV_AMD64_YMM7F0 = 552, 3299 | CV_AMD64_YMM7F1 = 553, 3300 | CV_AMD64_YMM7F2 = 554, 3301 | CV_AMD64_YMM7F3 = 555, 3302 | CV_AMD64_YMM7F4 = 556, 3303 | CV_AMD64_YMM7F5 = 557, 3304 | CV_AMD64_YMM7F6 = 558, 3305 | CV_AMD64_YMM7F7 = 559, 3306 | CV_AMD64_YMM8F0 = 560, 3307 | CV_AMD64_YMM8F1 = 561, 3308 | CV_AMD64_YMM8F2 = 562, 3309 | CV_AMD64_YMM8F3 = 563, 3310 | CV_AMD64_YMM8F4 = 564, 3311 | CV_AMD64_YMM8F5 = 565, 3312 | CV_AMD64_YMM8F6 = 566, 3313 | CV_AMD64_YMM8F7 = 567, 3314 | CV_AMD64_YMM9F0 = 568, 3315 | CV_AMD64_YMM9F1 = 569, 3316 | CV_AMD64_YMM9F2 = 570, 3317 | CV_AMD64_YMM9F3 = 571, 3318 | CV_AMD64_YMM9F4 = 572, 3319 | CV_AMD64_YMM9F5 = 573, 3320 | CV_AMD64_YMM9F6 = 574, 3321 | CV_AMD64_YMM9F7 = 575, 3322 | CV_AMD64_YMM10F0 = 576, 3323 | CV_AMD64_YMM10F1 = 577, 3324 | CV_AMD64_YMM10F2 = 578, 3325 | CV_AMD64_YMM10F3 = 579, 3326 | CV_AMD64_YMM10F4 = 580, 3327 | CV_AMD64_YMM10F5 = 581, 3328 | CV_AMD64_YMM10F6 = 582, 3329 | CV_AMD64_YMM10F7 = 583, 3330 | CV_AMD64_YMM11F0 = 584, 3331 | CV_AMD64_YMM11F1 = 585, 3332 | CV_AMD64_YMM11F2 = 586, 3333 | CV_AMD64_YMM11F3 = 587, 3334 | CV_AMD64_YMM11F4 = 588, 3335 | CV_AMD64_YMM11F5 = 589, 3336 | CV_AMD64_YMM11F6 = 590, 3337 | CV_AMD64_YMM11F7 = 591, 3338 | CV_AMD64_YMM12F0 = 592, 3339 | CV_AMD64_YMM12F1 = 593, 3340 | CV_AMD64_YMM12F2 = 594, 3341 | CV_AMD64_YMM12F3 = 595, 3342 | CV_AMD64_YMM12F4 = 596, 3343 | CV_AMD64_YMM12F5 = 597, 3344 | CV_AMD64_YMM12F6 = 598, 3345 | CV_AMD64_YMM12F7 = 599, 3346 | CV_AMD64_YMM13F0 = 600, 3347 | CV_AMD64_YMM13F1 = 601, 3348 | CV_AMD64_YMM13F2 = 602, 3349 | CV_AMD64_YMM13F3 = 603, 3350 | CV_AMD64_YMM13F4 = 604, 3351 | CV_AMD64_YMM13F5 = 605, 3352 | CV_AMD64_YMM13F6 = 606, 3353 | CV_AMD64_YMM13F7 = 607, 3354 | CV_AMD64_YMM14F0 = 608, 3355 | CV_AMD64_YMM14F1 = 609, 3356 | CV_AMD64_YMM14F2 = 610, 3357 | CV_AMD64_YMM14F3 = 611, 3358 | CV_AMD64_YMM14F4 = 612, 3359 | CV_AMD64_YMM14F5 = 613, 3360 | CV_AMD64_YMM14F6 = 614, 3361 | CV_AMD64_YMM14F7 = 615, 3362 | CV_AMD64_YMM15F0 = 616, 3363 | CV_AMD64_YMM15F1 = 617, 3364 | CV_AMD64_YMM15F2 = 618, 3365 | CV_AMD64_YMM15F3 = 619, 3366 | CV_AMD64_YMM15F4 = 620, 3367 | CV_AMD64_YMM15F5 = 621, 3368 | CV_AMD64_YMM15F6 = 622, 3369 | CV_AMD64_YMM15F7 = 623, 3370 | 3371 | CV_AMD64_YMM0D0 = 624, // AVX floating-point double precise registers 3372 | CV_AMD64_YMM0D1 = 625, 3373 | CV_AMD64_YMM0D2 = 626, 3374 | CV_AMD64_YMM0D3 = 627, 3375 | CV_AMD64_YMM1D0 = 628, 3376 | CV_AMD64_YMM1D1 = 629, 3377 | CV_AMD64_YMM1D2 = 630, 3378 | CV_AMD64_YMM1D3 = 631, 3379 | CV_AMD64_YMM2D0 = 632, 3380 | CV_AMD64_YMM2D1 = 633, 3381 | CV_AMD64_YMM2D2 = 634, 3382 | CV_AMD64_YMM2D3 = 635, 3383 | CV_AMD64_YMM3D0 = 636, 3384 | CV_AMD64_YMM3D1 = 637, 3385 | CV_AMD64_YMM3D2 = 638, 3386 | CV_AMD64_YMM3D3 = 639, 3387 | CV_AMD64_YMM4D0 = 640, 3388 | CV_AMD64_YMM4D1 = 641, 3389 | CV_AMD64_YMM4D2 = 642, 3390 | CV_AMD64_YMM4D3 = 643, 3391 | CV_AMD64_YMM5D0 = 644, 3392 | CV_AMD64_YMM5D1 = 645, 3393 | CV_AMD64_YMM5D2 = 646, 3394 | CV_AMD64_YMM5D3 = 647, 3395 | CV_AMD64_YMM6D0 = 648, 3396 | CV_AMD64_YMM6D1 = 649, 3397 | CV_AMD64_YMM6D2 = 650, 3398 | CV_AMD64_YMM6D3 = 651, 3399 | CV_AMD64_YMM7D0 = 652, 3400 | CV_AMD64_YMM7D1 = 653, 3401 | CV_AMD64_YMM7D2 = 654, 3402 | CV_AMD64_YMM7D3 = 655, 3403 | CV_AMD64_YMM8D0 = 656, 3404 | CV_AMD64_YMM8D1 = 657, 3405 | CV_AMD64_YMM8D2 = 658, 3406 | CV_AMD64_YMM8D3 = 659, 3407 | CV_AMD64_YMM9D0 = 660, 3408 | CV_AMD64_YMM9D1 = 661, 3409 | CV_AMD64_YMM9D2 = 662, 3410 | CV_AMD64_YMM9D3 = 663, 3411 | CV_AMD64_YMM10D0 = 664, 3412 | CV_AMD64_YMM10D1 = 665, 3413 | CV_AMD64_YMM10D2 = 666, 3414 | CV_AMD64_YMM10D3 = 667, 3415 | CV_AMD64_YMM11D0 = 668, 3416 | CV_AMD64_YMM11D1 = 669, 3417 | CV_AMD64_YMM11D2 = 670, 3418 | CV_AMD64_YMM11D3 = 671, 3419 | CV_AMD64_YMM12D0 = 672, 3420 | CV_AMD64_YMM12D1 = 673, 3421 | CV_AMD64_YMM12D2 = 674, 3422 | CV_AMD64_YMM12D3 = 675, 3423 | CV_AMD64_YMM13D0 = 676, 3424 | CV_AMD64_YMM13D1 = 677, 3425 | CV_AMD64_YMM13D2 = 678, 3426 | CV_AMD64_YMM13D3 = 679, 3427 | CV_AMD64_YMM14D0 = 680, 3428 | CV_AMD64_YMM14D1 = 681, 3429 | CV_AMD64_YMM14D2 = 682, 3430 | CV_AMD64_YMM14D3 = 683, 3431 | CV_AMD64_YMM15D0 = 684, 3432 | CV_AMD64_YMM15D1 = 685, 3433 | CV_AMD64_YMM15D2 = 686, 3434 | CV_AMD64_YMM15D3 = 687 3435 | 3436 | 3437 | // Note: Next set of platform registers need to go into a new enum... 3438 | // this one is above 44K now. 3439 | 3440 | } CV_HREG_e; 3441 | 3442 | typedef enum CV_HLSLREG_e { 3443 | CV_HLSLREG_TEMP = 0, 3444 | CV_HLSLREG_INPUT = 1, 3445 | CV_HLSLREG_OUTPUT = 2, 3446 | CV_HLSLREG_INDEXABLE_TEMP = 3, 3447 | CV_HLSLREG_IMMEDIATE32 = 4, 3448 | CV_HLSLREG_IMMEDIATE64 = 5, 3449 | CV_HLSLREG_SAMPLER = 6, 3450 | CV_HLSLREG_RESOURCE = 7, 3451 | CV_HLSLREG_CONSTANT_BUFFER = 8, 3452 | CV_HLSLREG_IMMEDIATE_CONSTANT_BUFFER = 9, 3453 | CV_HLSLREG_LABEL = 10, 3454 | CV_HLSLREG_INPUT_PRIMITIVEID = 11, 3455 | CV_HLSLREG_OUTPUT_DEPTH = 12, 3456 | CV_HLSLREG_NULL = 13, 3457 | CV_HLSLREG_RASTERIZER = 14, 3458 | CV_HLSLREG_OUTPUT_COVERAGE_MASK = 15, 3459 | CV_HLSLREG_STREAM = 16, 3460 | CV_HLSLREG_FUNCTION_BODY = 17, 3461 | CV_HLSLREG_FUNCTION_TABLE = 18, 3462 | CV_HLSLREG_INTERFACE = 19, 3463 | CV_HLSLREG_FUNCTION_INPUT = 20, 3464 | CV_HLSLREG_FUNCTION_OUTPUT = 21, 3465 | CV_HLSLREG_OUTPUT_CONTROL_POINT_ID = 22, 3466 | CV_HLSLREG_INPUT_FORK_INSTANCE_ID = 23, 3467 | CV_HLSLREG_INPUT_JOIN_INSTANCE_ID = 24, 3468 | CV_HLSLREG_INPUT_CONTROL_POINT = 25, 3469 | CV_HLSLREG_OUTPUT_CONTROL_POINT = 26, 3470 | CV_HLSLREG_INPUT_PATCH_CONSTANT = 27, 3471 | CV_HLSLREG_INPUT_DOMAIN_POINT = 28, 3472 | CV_HLSLREG_THIS_POINTER = 29, 3473 | CV_HLSLREG_UNORDERED_ACCESS_VIEW = 30, 3474 | CV_HLSLREG_THREAD_GROUP_SHARED_MEMORY = 31, 3475 | CV_HLSLREG_INPUT_THREAD_ID = 32, 3476 | CV_HLSLREG_INPUT_THREAD_GROUP_ID = 33, 3477 | CV_HLSLREG_INPUT_THREAD_ID_IN_GROUP = 34, 3478 | CV_HLSLREG_INPUT_COVERAGE_MASK = 35, 3479 | CV_HLSLREG_INPUT_THREAD_ID_IN_GROUP_FLATTENED = 36, 3480 | CV_HLSLREG_INPUT_GS_INSTANCE_ID = 37, 3481 | CV_HLSLREG_OUTPUT_DEPTH_GREATER_EQUAL = 38, 3482 | CV_HLSLREG_OUTPUT_DEPTH_LESS_EQUAL = 39, 3483 | CV_HLSLREG_CYCLE_COUNTER = 40, 3484 | } CV_HLSLREG_e; 3485 | 3486 | enum StackFrameTypeEnum 3487 | { 3488 | FrameTypeFPO, // Frame pointer omitted, FPO info available 3489 | FrameTypeTrap, // Kernel Trap frame 3490 | FrameTypeTSS, // Kernel Trap frame 3491 | FrameTypeStandard, // Standard EBP stackframe 3492 | FrameTypeFrameData, // Frame pointer omitted, FrameData info available 3493 | 3494 | FrameTypeUnknown = -1, // Frame which does not have any debug info 3495 | }; 3496 | 3497 | enum MemoryTypeEnum 3498 | { 3499 | MemTypeCode, // Read only code memory 3500 | MemTypeData, // Read only data/stack memory 3501 | MemTypeStack, // Read only stack memory 3502 | MemTypeCodeOnHeap, // Read only memory for code generated on heap by runtime 3503 | 3504 | MemTypeAny = -1, 3505 | }; 3506 | 3507 | typedef enum CV_HLSLMemorySpace_e 3508 | { 3509 | // HLSL specific memory spaces 3510 | 3511 | CV_HLSL_MEMSPACE_DATA = 0x00, 3512 | CV_HLSL_MEMSPACE_SAMPLER = 0x01, 3513 | CV_HLSL_MEMSPACE_RESOURCE = 0x02, 3514 | CV_HLSL_MEMSPACE_RWRESOURCE = 0x03, 3515 | 3516 | CV_HLSL_MEMSPACE_MAX = 0x0F, 3517 | } CV_HLSLMemorySpace_e; 3518 | 3519 | #endif 3520 | --------------------------------------------------------------------------------