From 22d38e54c5ccc394286c8b4f787d0d8d161122dd Mon Sep 17 00:00:00 2001 From: Michael Maltsev <4129781+m417z@users.noreply.github.com> Date: Sun, 1 Oct 2023 21:49:43 +0300 Subject: [PATCH] Initial commit --- .clang-format | 16 + .gitattributes | 63 + .gitignore | 261 + LICENSE | 674 + MainDlg.cpp | 257 + MainDlg.h | 62 + README.md | 11 + finddlg.h | 71 + libraries/dia/cvconst.h | 4109 +++++ libraries/dia/dia2.h | 21777 +++++++++++++++++++++++ libraries/dia/diacreate.h | 42 + libraries/dia/lib/amd64/diaguids.lib | Bin 0 -> 1716242 bytes libraries/dia/lib/arm/diaguids.lib | Bin 0 -> 1722622 bytes libraries/dia/lib/arm64/diaguids.lib | Bin 0 -> 1726308 bytes libraries/dia/lib/diaguids.lib | Bin 0 -> 1708058 bytes libraries/wil/Tracelogging.h | 3925 ++++ libraries/wil/_version.txt | 3 + libraries/wil/com.h | 3007 ++++ libraries/wil/com_apartment_variable.h | 467 + libraries/wil/common.h | 798 + libraries/wil/coroutine.h | 810 + libraries/wil/cppwinrt.h | 491 + libraries/wil/cppwinrt_authoring.h | 284 + libraries/wil/cppwinrt_helpers.h | 352 + libraries/wil/cppwinrt_wrl.h | 74 + libraries/wil/filesystem.h | 1050 ++ libraries/wil/nt_result_macros.h | 168 + libraries/wil/registry.h | 3270 ++++ libraries/wil/registry_helpers.h | 1860 ++ libraries/wil/resource.h | 7095 ++++++++ libraries/wil/result.h | 1281 ++ libraries/wil/result_macros.h | 6156 +++++++ libraries/wil/result_originate.h | 126 + libraries/wil/rpc_helpers.h | 206 + libraries/wil/safecast.h | 369 + libraries/wil/stl.h | 196 + libraries/wil/token_helpers.h | 613 + libraries/wil/traceloggingconfig.h | 71 + libraries/wil/win32_helpers.h | 898 + libraries/wil/win32_result_macros.h | 104 + libraries/wil/winrt.h | 2332 +++ libraries/wil/wistd_config.h | 571 + libraries/wil/wistd_functional.h | 548 + libraries/wil/wistd_memory.h | 1038 ++ libraries/wil/wistd_type_traits.h | 4504 +++++ libraries/wil/wrl.h | 127 + res/windhawk-symbol-helper.ico | Bin 0 -> 112688 bytes resource.h | 32 + screenshot.png | Bin 0 -> 38764 bytes stdafx.cpp | 1 + stdafx.h | 70 + symbol_enum.cpp | 405 + symbol_enum.h | 39 + view.h | 93 + windhawk-symbol-helper.cpp | 39 + windhawk-symbol-helper.h | 1 + windhawk-symbol-helper.rc | 279 + windhawk-symbol-helper.sln | 31 + windhawk-symbol-helper.vcxproj | 249 + windhawk-symbol-helper.vcxproj.filters | 61 + 60 files changed, 71437 insertions(+) create mode 100644 .clang-format create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 MainDlg.cpp create mode 100644 MainDlg.h create mode 100644 README.md create mode 100644 finddlg.h create mode 100644 libraries/dia/cvconst.h create mode 100644 libraries/dia/dia2.h create mode 100644 libraries/dia/diacreate.h create mode 100644 libraries/dia/lib/amd64/diaguids.lib create mode 100644 libraries/dia/lib/arm/diaguids.lib create mode 100644 libraries/dia/lib/arm64/diaguids.lib create mode 100644 libraries/dia/lib/diaguids.lib create mode 100644 libraries/wil/Tracelogging.h create mode 100644 libraries/wil/_version.txt create mode 100644 libraries/wil/com.h create mode 100644 libraries/wil/com_apartment_variable.h create mode 100644 libraries/wil/common.h create mode 100644 libraries/wil/coroutine.h create mode 100644 libraries/wil/cppwinrt.h create mode 100644 libraries/wil/cppwinrt_authoring.h create mode 100644 libraries/wil/cppwinrt_helpers.h create mode 100644 libraries/wil/cppwinrt_wrl.h create mode 100644 libraries/wil/filesystem.h create mode 100644 libraries/wil/nt_result_macros.h create mode 100644 libraries/wil/registry.h create mode 100644 libraries/wil/registry_helpers.h create mode 100644 libraries/wil/resource.h create mode 100644 libraries/wil/result.h create mode 100644 libraries/wil/result_macros.h create mode 100644 libraries/wil/result_originate.h create mode 100644 libraries/wil/rpc_helpers.h create mode 100644 libraries/wil/safecast.h create mode 100644 libraries/wil/stl.h create mode 100644 libraries/wil/token_helpers.h create mode 100644 libraries/wil/traceloggingconfig.h create mode 100644 libraries/wil/win32_helpers.h create mode 100644 libraries/wil/win32_result_macros.h create mode 100644 libraries/wil/winrt.h create mode 100644 libraries/wil/wistd_config.h create mode 100644 libraries/wil/wistd_functional.h create mode 100644 libraries/wil/wistd_memory.h create mode 100644 libraries/wil/wistd_type_traits.h create mode 100644 libraries/wil/wrl.h create mode 100644 res/windhawk-symbol-helper.ico create mode 100644 resource.h create mode 100644 screenshot.png create mode 100644 stdafx.cpp create mode 100644 stdafx.h create mode 100644 symbol_enum.cpp create mode 100644 symbol_enum.h create mode 100644 view.h create mode 100644 windhawk-symbol-helper.cpp create mode 100644 windhawk-symbol-helper.h create mode 100644 windhawk-symbol-helper.rc create mode 100644 windhawk-symbol-helper.sln create mode 100644 windhawk-symbol-helper.vcxproj create mode 100644 windhawk-symbol-helper.vcxproj.filters diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..d58eab9 --- /dev/null +++ b/.clang-format @@ -0,0 +1,16 @@ +BasedOnStyle: Chromium +IndentWidth: 4 + +# Reference: https://github.com/chromium/chromium/blob/3d90e395a5e87e305e567c097c434549f0d0874e/.clang-format +# Make sure code like: +# BEGIN_MESSAGE_MAP() +# MESSAGE_HANDLER(WidgetHostViewHost_Update, OnUpdate) +# END_MESSAGE_MAP() +# gets correctly indented. +MacroBlockBegin: "^\ +BEGIN_MSG_MAP|\ +BEGIN_MSG_MAP_EX|\ +BEGIN_DLGRESIZE_MAP$" +MacroBlockEnd: "^\ +END_MSG_MAP|\ +END_DLGRESIZE_MAP$" diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..1ff0c42 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,63 @@ +############################################################################### +# Set default behavior to automatically normalize line endings. +############################################################################### +* text=auto + +############################################################################### +# Set default behavior for command prompt diff. +# +# This is need for earlier builds of msysgit that does not have it on by +# default for csharp files. +# Note: This is only used by command line +############################################################################### +#*.cs diff=csharp + +############################################################################### +# Set the merge driver for project and solution files +# +# Merging from the command prompt will add diff markers to the files if there +# are conflicts (Merging from VS is not affected by the settings below, in VS +# the diff markers are never inserted). Diff markers may cause the following +# file extensions to fail to load in VS. An alternative would be to treat +# these files as binary and thus will always conflict and require user +# intervention with every merge. To do so, just uncomment the entries below +############################################################################### +#*.sln merge=binary +#*.csproj merge=binary +#*.vbproj merge=binary +#*.vcxproj merge=binary +#*.vcproj merge=binary +#*.dbproj merge=binary +#*.fsproj merge=binary +#*.lsproj merge=binary +#*.wixproj merge=binary +#*.modelproj merge=binary +#*.sqlproj merge=binary +#*.wwaproj merge=binary + +############################################################################### +# behavior for image files +# +# image files are treated as binary by default. +############################################################################### +#*.jpg binary +#*.png binary +#*.gif binary + +############################################################################### +# diff behavior for common document formats +# +# Convert binary document formats to text before diffing them. This feature +# is only available from the command line. Turn it on by uncommenting the +# entries below. +############################################################################### +#*.doc diff=astextplain +#*.DOC diff=astextplain +#*.docx diff=astextplain +#*.DOCX diff=astextplain +#*.dot diff=astextplain +#*.DOT diff=astextplain +#*.pdf diff=astextplain +#*.PDF diff=astextplain +#*.rtf diff=astextplain +#*.RTF diff=astextplain diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..48a07ae --- /dev/null +++ b/.gitignore @@ -0,0 +1,261 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. + +# User-specific files +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ + +# Visual Studio 2015 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUNIT +*.VisualState.xml +TestResult.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# DNX +project.lock.json +project.fragment.lock.json +artifacts/ + +*_i.c +*_p.c +*_i.h +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# JustCode is a .NET coding add-in +.JustCode + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# TODO: Comment the next line if you want to checkin your web deploy settings +# but database connection strings (with potential passwords) will be unencrypted +#*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# The packages folder can be ignored because of Package Restore +**/packages/* +# except build/, which is used as an MSBuild target. +!**/packages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/packages/repositories.config +# NuGet v3's project.json files produces more ignoreable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +node_modules/ +orleans.codegen.cs + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm + +# SQL Server files +*.mdf +*.ldf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# JetBrains Rider +.idea/ +*.sln.iml + +# CodeRush +.cr/ + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..217cdbc --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + Windhawk Symbol Helper. + Copyright (C) 2023 Michael Maltsev + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Windhawk Symbol Helper Copyright (C) 2023 Michael Maltsev + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/MainDlg.cpp b/MainDlg.cpp new file mode 100644 index 0000000..a4bed70 --- /dev/null +++ b/MainDlg.cpp @@ -0,0 +1,257 @@ +#include "stdafx.h" + +#include "MainDlg.h" + +#include "symbol_enum.h" + +namespace { + +void OpenUrl(HWND hWnd, PCWSTR url) { + if ((INT_PTR)ShellExecute(hWnd, L"open", url, nullptr, nullptr, + SW_SHOWNORMAL) <= 32) { + CString errorMsg; + errorMsg.Format( + L"Failed to open link, you can copy it with Ctrl+C and open it in " + L"a browser manually:\n\n%s", + url); + MessageBox(hWnd, errorMsg, nullptr, MB_ICONHAND); + } +} + +} // namespace + +BOOL CMainDlg::PreTranslateMessage(MSG* pMsg) { + if (m_resultsEdit.PreTranslateMessage(pMsg)) { + return TRUE; + } + + if (m_accelerator && ::TranslateAccelerator(m_hWnd, m_accelerator, pMsg)) { + return TRUE; + } + + return CWindow::IsDialogMessage(pMsg); +} + +BOOL CMainDlg::OnInitDialog(CWindow wndFocus, LPARAM lInitParam) { + // Center the dialog on the screen. + CenterWindow(); + + // Set icons. + HICON hIcon = AtlLoadIconImage(IDR_MAINFRAME, LR_DEFAULTCOLOR, + ::GetSystemMetrics(SM_CXICON), + ::GetSystemMetrics(SM_CYICON)); + SetIcon(hIcon, TRUE); + HICON hIconSmall = AtlLoadIconImage(IDR_MAINFRAME, LR_DEFAULTCOLOR, + ::GetSystemMetrics(SM_CXSMICON), + ::GetSystemMetrics(SM_CYSMICON)); + SetIcon(hIconSmall, FALSE); + + // Bind keys... + m_accelerator = AtlLoadAccelerators(IDR_MAINFRAME); + + // Register object for message filtering and idle updates. + CMessageLoop* pLoop = _Module.GetMessageLoop(); + ATLASSERT(pLoop != NULL); + pLoop->AddMessageFilter(this); + + // Populate values. + CEdit(GetDlgItem(IDC_ENGINE_DIR)) + .SetWindowText(LR"(C:\Program Files\Windhawk\Engine\1.3.1)"); + CEdit(GetDlgItem(IDC_SYMBOLS_DIR)) + .SetWindowText(LR"(C:\ProgramData\Windhawk\Engine\Symbols)"); + CEdit(GetDlgItem(IDC_SYMBOL_SERVER)) + .SetWindowText(LR"(https://msdl.microsoft.com/download/symbols)"); + CEdit(GetDlgItem(IDC_TARGET_EXECUTABLE)) + .SetWindowText(LR"(C:\Windows\Explorer.exe)"); + CButton(GetDlgItem(IDC_UNDECORATED)).SetCheck(BST_CHECKED); + + // Init edit control. + auto resultsPlaceholderControl = GetDlgItem(IDC_RESULTS_PLACEHOLDER); + + CRect rc; + resultsPlaceholderControl.GetClientRect(&rc); + resultsPlaceholderControl.MapWindowPoints(m_hWnd, rc); + m_resultsEdit.Create(m_hWnd, rc, nullptr, + WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_MULTILINE | + ES_AUTOVSCROLL | ES_AUTOHSCROLL | ES_WANTRETURN | + WS_VSCROLL | WS_HSCROLL, + WS_EX_CLIENTEDGE, IDC_RESULTS); + + CLogFont fontAttributes(AtlGetDefaultGuiFont()); + wcscpy_s(fontAttributes.lfFaceName, L"Consolas"); + m_resultsEditFont = fontAttributes.CreateFontIndirect(); + m_resultsEdit.SetFont(m_resultsEditFont); + + // Init resizing. + DlgResize_Init(); + + return TRUE; +} + +void CMainDlg::OnDestroy() { + m_enumSymbolsThread.reset(); + + PostQuitMessage(0); +} + +void CMainDlg::OnAppAbout(UINT uNotifyCode, int nID, CWindow wndCtl) { + PCWSTR content = + L"A tool to get symbols from executables the same way Windhawk mods do " + L"with the symbols API.\n\n" + L"The tool was created to help with Windhawk mod development.\n\n" + L"Windhawk can be downloaded at windhawk.net.\n\n" + L"Compiled at " __DATE__ " " __TIME__ "\n\n"; + + TASKDIALOGCONFIG taskDialogConfig{ + .cbSize = sizeof(taskDialogConfig), + .hwndParent = m_hWnd, + .hInstance = _Module.GetModuleInstance(), + .dwFlags = TDF_ENABLE_HYPERLINKS | TDF_ALLOW_DIALOG_CANCELLATION | + TDF_POSITION_RELATIVE_TO_WINDOW, + .pszWindowTitle = L"About", + .pszMainIcon = MAKEINTRESOURCE(IDR_MAINFRAME), + .pszMainInstruction = L"Windhawk Symbol Helper", + .pszContent = content, + .pfCallback = [](HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, + LONG_PTR lpRefData) -> HRESULT { + switch (msg) { + case TDN_HYPERLINK_CLICKED: + OpenUrl(hwnd, (PCWSTR)lParam); + break; + } + + return S_OK; + }, + }; + + ::TaskDialogIndirect(&taskDialogConfig, nullptr, nullptr, nullptr); +} + +void CMainDlg::OnOK(UINT uNotifyCode, int nID, CWindow wndCtl) { + if (m_enumSymbolsThread) { + m_enumSymbolsThread->request_stop(); + GetDlgItem(IDOK).EnableWindow(FALSE); + return; + } + + struct { + CString engineDir; + CString symbolsDir; + CString symbolServer; + CString targetExecutable; + bool undecorated; + bool decorated; + bool log; + } threadParams; + + GetDlgItemText(IDC_ENGINE_DIR, threadParams.engineDir); + GetDlgItemText(IDC_SYMBOLS_DIR, threadParams.symbolsDir); + GetDlgItemText(IDC_SYMBOL_SERVER, threadParams.symbolServer); + GetDlgItemText(IDC_TARGET_EXECUTABLE, threadParams.targetExecutable); + threadParams.undecorated = + CButton(GetDlgItem(IDC_UNDECORATED)).GetCheck() != BST_UNCHECKED; + threadParams.decorated = + CButton(GetDlgItem(IDC_DECORATED)).GetCheck() != BST_UNCHECKED; + threadParams.log = CButton(GetDlgItem(IDC_LOG)).GetCheck() != BST_UNCHECKED; + + SetDlgItemText(IDOK, L"Cancel"); + + m_enumSymbolsThread = std::jthread([threadParams = std::move(threadParams), + &enumSymbolsResult = + m_enumSymbolsResult, + hWnd = + m_hWnd](std::stop_token stopToken) { + try { + CStringA logOutput; + CString result; + int count = 0; + + { + SymbolEnum::Callbacks callbacks{ + .queryCancel = + [&stopToken]() { return stopToken.stop_requested(); }, + .notifyProgress = + [hWnd](int progress) { + CWindow(hWnd).PostMessage(UWM_PROGRESS, + (WPARAM)progress); + }, + }; + + if (threadParams.log) { + callbacks.notifyLog = [&logOutput](PCSTR message) { + logOutput += message; + logOutput += "\r\n"; + }; + } + + SymbolEnum symbolEnum(threadParams.targetExecutable.GetString(), + 0, threadParams.engineDir.GetString(), + threadParams.symbolsDir.GetString(), + threadParams.symbolServer.GetString(), + callbacks); + + while (auto iter = symbolEnum.GetNextSymbol(false)) { + if (stopToken.stop_requested()) { + throw std::runtime_error("Cancelled"); + } + + CString addressStr; + addressStr.Format(L"%p", iter->address); + + if (threadParams.undecorated) { + result += L"["; + result += addressStr; + result += L"] "; + result += iter->name; + result += L"\r\n"; + } + + if (threadParams.decorated) { + result += L"["; + result += addressStr; + result += L"] "; + result += iter->nameDecorated; + result += L"\r\n"; + } + + count++; + } + } + + enumSymbolsResult.Format(L"Found %d symbols\r\n%S%s", count, + logOutput.GetString(), result.GetString()); + } catch (const std::exception& e) { + enumSymbolsResult.Format(L"Error: %S\r\n", e.what()); + } + + CWindow(hWnd).PostMessage(UWM_ENUM_SYMBOLS_DONE); + }); +} + +void CMainDlg::OnCancel(UINT uNotifyCode, int nID, CWindow wndCtl) { + DestroyWindow(); +} + +LRESULT CMainDlg::OnProgress(UINT uMsg, WPARAM wParam, LPARAM lParam) { + int progress = (int)wParam; + + CString text; + text.Format(L"[%d%%] Cancel", progress); + + SetDlgItemText(IDOK, text); + + return 0; +} + +LRESULT CMainDlg::OnEnumSymbolsDone(UINT uMsg, WPARAM wParam, LPARAM lParam) { + m_enumSymbolsThread.reset(); + + SetDlgItemText(IDC_RESULTS, m_enumSymbolsResult); + m_enumSymbolsResult.Empty(); + + SetDlgItemText(IDOK, L"Get &symbols"); + GetDlgItem(IDOK).EnableWindow(TRUE); + + return 0; +} diff --git a/MainDlg.h b/MainDlg.h new file mode 100644 index 0000000..d697616 --- /dev/null +++ b/MainDlg.h @@ -0,0 +1,62 @@ +#pragma once + +#include "resource.h" +#include "view.h" + +class CMainDlg : public CDialogImpl, + public CMessageFilter, + public CDialogResize { + public: + enum { IDD = IDD_MAINDLG }; + + enum { + UWM_PROGRESS = WM_APP, + UWM_ENUM_SYMBOLS_DONE, + }; + + BEGIN_DLGRESIZE_MAP(CMainDlg) + DLGRESIZE_CONTROL(IDC_STATIC_ENGINE_DIR, DLSZ_SIZE_X) + DLGRESIZE_CONTROL(IDC_ENGINE_DIR, DLSZ_SIZE_X) + DLGRESIZE_CONTROL(IDC_STATIC_SYMBOLS_DIR, DLSZ_SIZE_X) + DLGRESIZE_CONTROL(IDC_SYMBOLS_DIR, DLSZ_SIZE_X) + DLGRESIZE_CONTROL(IDC_STATIC_SYMBOL_SERVER, DLSZ_SIZE_X) + DLGRESIZE_CONTROL(IDC_SYMBOL_SERVER, DLSZ_SIZE_X) + DLGRESIZE_CONTROL(IDC_STATIC_TARGET_EXECUTABLE, DLSZ_SIZE_X) + DLGRESIZE_CONTROL(IDC_TARGET_EXECUTABLE, DLSZ_SIZE_X) + DLGRESIZE_CONTROL(IDC_STATIC_RESULTS, DLSZ_SIZE_X) + DLGRESIZE_CONTROL(IDC_RESULTS, DLSZ_SIZE_X | DLSZ_SIZE_Y) + DLGRESIZE_CONTROL(IDOK, DLSZ_MOVE_Y) + DLGRESIZE_CONTROL(ID_APP_ABOUT, DLSZ_CENTER_X | DLSZ_MOVE_Y) + DLGRESIZE_CONTROL(IDCANCEL, DLSZ_MOVE_X | DLSZ_MOVE_Y) + END_DLGRESIZE_MAP() + + private: + BEGIN_MSG_MAP(CMainDlg) + CHAIN_MSG_MAP(CDialogResize) + MSG_WM_INITDIALOG(OnInitDialog) + MSG_WM_DESTROY(OnDestroy) + COMMAND_ID_HANDLER_EX(ID_APP_ABOUT, OnAppAbout) + COMMAND_ID_HANDLER_EX(IDOK, OnOK) + COMMAND_ID_HANDLER_EX(IDCANCEL, OnCancel) + MESSAGE_HANDLER_EX(UWM_PROGRESS, OnProgress) + MESSAGE_HANDLER_EX(UWM_ENUM_SYMBOLS_DONE, OnEnumSymbolsDone) + CHAIN_COMMANDS_MEMBER(m_resultsEdit) + END_MSG_MAP() + + BOOL PreTranslateMessage(MSG* pMsg) override; + + BOOL OnInitDialog(CWindow wndFocus, LPARAM lInitParam); + void OnDestroy(); + void OnAppAbout(UINT uNotifyCode, int nID, CWindow wndCtl); + void OnOK(UINT uNotifyCode, int nID, CWindow wndCtl); + void OnCancel(UINT uNotifyCode, int nID, CWindow wndCtl); + LRESULT OnProgress(UINT uMsg, WPARAM wParam, LPARAM lParam); + LRESULT OnEnumSymbolsDone(UINT uMsg, WPARAM wParam, LPARAM lParam); + + HACCEL m_accelerator = nullptr; + CEditView m_resultsEdit; + CFont m_resultsEditFont; + + std::optional m_enumSymbolsThread; + CString m_enumSymbolsResult; +}; diff --git a/README.md b/README.md new file mode 100644 index 0000000..3d70b68 --- /dev/null +++ b/README.md @@ -0,0 +1,11 @@ +# Windhawk Symbol Helper + +A tool to get symbols from executables the same way Windhawk mods do with the +symbols API. + +The tool was created to help with Windhawk mod development. + +For more information about Windhawk, visit +[windhawk.net](https://windhawk.net/). + +![Screenshot](screenshot.png) diff --git a/finddlg.h b/finddlg.h new file mode 100644 index 0000000..811babb --- /dev/null +++ b/finddlg.h @@ -0,0 +1,71 @@ + +#ifndef __FindReplaceDialogWithMessageFilter_h__ +#define __FindReplaceDialogWithMessageFilter_h__ + +#pragma once + +#ifndef __cplusplus + #error ATL requires C++ compilation (use a .cpp suffix) +#endif + +#ifndef __ATLAPP_H__ + #error FindReplaceDialogWithMessageFilter.h requires atlapp.h to be included first +#endif + +#ifndef __ATLWIN_H__ + #error FindReplaceDialogWithMessageFilter.h requires atlwin.h to be included first +#endif + +class CFindReplaceDialogWithMessageFilter : + public CFindReplaceDialogImpl, + public CMessageFilter +{ +protected: + CMessageLoop* m_messageLoop; + +public: + CFindReplaceDialogWithMessageFilter(CMessageLoop* messageLoop) : + m_messageLoop(messageLoop) + { + } + +public: + BOOL PreTranslateMessage(MSG* pMsg) + { + HWND hWndFocus = ::GetFocus(); + if((m_hWnd == hWndFocus) || this->IsChild(hWndFocus)) + return this->IsDialogMessage(pMsg); + + return FALSE; + } + + virtual void OnFinalMessage(HWND /*hWnd*/) + { + delete this; + } + + BEGIN_MSG_MAP(CFindReplaceDialogWithMessageFilter) + MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) + MESSAGE_HANDLER(WM_DESTROY, OnDestroy) + END_MSG_MAP() + + LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) + { + if(m_messageLoop) + m_messageLoop->AddMessageFilter(this); + + bHandled = FALSE; + return 0; + } + + LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) + { + if(m_messageLoop) + m_messageLoop->RemoveMessageFilter(this); + + bHandled = FALSE; + return 0; + } +}; + +#endif //__FindReplaceDialogWithMessageFilter_h__ diff --git a/libraries/dia/cvconst.h b/libraries/dia/cvconst.h new file mode 100644 index 0000000..a3445d1 --- /dev/null +++ b/libraries/dia/cvconst.h @@ -0,0 +1,4109 @@ +// cvconst.h - codeview constant definitions +//----------------------------------------------------------------- +// +// Copyright Microsoft Corporation. All Rights Reserved. +// +//--------------------------------------------------------------- +#ifndef _CVCONST_H_ +#define _CVCONST_H_ + + + +// Enumeration for function call type + + +typedef enum CV_call_e +{ + CV_CALL_NEAR_C = 0x00, // near right to left push, caller pops stack + CV_CALL_FAR_C = 0x01, // far right to left push, caller pops stack + CV_CALL_NEAR_PASCAL = 0x02, // near left to right push, callee pops stack + CV_CALL_FAR_PASCAL = 0x03, // far left to right push, callee pops stack + CV_CALL_NEAR_FAST = 0x04, // near left to right push with regs, callee pops stack + CV_CALL_FAR_FAST = 0x05, // far left to right push with regs, callee pops stack + CV_CALL_SKIPPED = 0x06, // skipped (unused) call index + CV_CALL_NEAR_STD = 0x07, // near standard call + CV_CALL_FAR_STD = 0x08, // far standard call + CV_CALL_NEAR_SYS = 0x09, // near sys call + CV_CALL_FAR_SYS = 0x0a, // far sys call + CV_CALL_THISCALL = 0x0b, // this call (this passed in register) + CV_CALL_MIPSCALL = 0x0c, // Mips call + CV_CALL_GENERIC = 0x0d, // Generic call sequence + CV_CALL_ALPHACALL = 0x0e, // Alpha call + CV_CALL_PPCCALL = 0x0f, // PPC call + CV_CALL_SHCALL = 0x10, // Hitachi SuperH call + CV_CALL_ARMCALL = 0x11, // ARM call + CV_CALL_AM33CALL = 0x12, // AM33 call + CV_CALL_TRICALL = 0x13, // TriCore Call + CV_CALL_SH5CALL = 0x14, // Hitachi SuperH-5 call + CV_CALL_M32RCALL = 0x15, // M32R Call + CV_CALL_CLRCALL = 0x16, // clr call + CV_CALL_INLINE = 0x17, // Marker for routines always inlined and thus lacking a convention + CV_CALL_NEAR_VECTOR = 0x18, // near left to right push with regs, callee pops stack + CV_CALL_SWIFT = 0x19, // Swift calling convention + CV_CALL_RESERVED = 0x20 // first unused call enumeration + + // Do NOT add any more machine specific conventions. This is to be used for + // calling conventions in the source only (e.g. __cdecl, __stdcall). +} CV_call_e; + + +// Values for the access protection of class attributes + + +typedef enum CV_access_e +{ + CV_private = 1, + CV_protected = 2, + CV_public = 3 +} CV_access_e; + + +typedef enum THUNK_ORDINAL +{ + THUNK_ORDINAL_NOTYPE, // standard thunk + THUNK_ORDINAL_ADJUSTOR, // "this" adjustor thunk + THUNK_ORDINAL_VCALL, // virtual call thunk + THUNK_ORDINAL_PCODE, // pcode thunk + THUNK_ORDINAL_LOAD, // thunk which loads the address to jump to + // via unknown means... + + // trampoline thunk ordinals - only for use in Trampoline thunk symbols + + THUNK_ORDINAL_TRAMP_INCREMENTAL, + THUNK_ORDINAL_TRAMP_BRANCHISLAND, + THUNK_ORDINAL_TRAMP_STRICTICF, +} THUNK_ORDINAL; + + +enum CV_SourceChksum_t +{ + CHKSUM_TYPE_NONE = 0, // indicates no checksum is available + CHKSUM_TYPE_MD5, + CHKSUM_TYPE_SHA1, + CHKSUM_TYPE_SHA_256, +}; + +// +// DIA enums +// + +enum SymTagEnum +{ + SymTagNull, + SymTagExe, + SymTagCompiland, + SymTagCompilandDetails, + SymTagCompilandEnv, + SymTagFunction, + SymTagBlock, + SymTagData, + SymTagAnnotation, + SymTagLabel, + SymTagPublicSymbol, + SymTagUDT, + SymTagEnum, + SymTagFunctionType, + SymTagPointerType, + SymTagArrayType, + SymTagBaseType, + SymTagTypedef, + SymTagBaseClass, + SymTagFriend, + SymTagFunctionArgType, + SymTagFuncDebugStart, + SymTagFuncDebugEnd, + SymTagUsingNamespace, + SymTagVTableShape, + SymTagVTable, + SymTagCustom, + SymTagThunk, + SymTagCustomType, + SymTagManagedType, + SymTagDimension, + SymTagCallSite, + SymTagInlineSite, + SymTagBaseInterface, + SymTagVectorType, + SymTagMatrixType, + SymTagHLSLType, + SymTagCaller, + SymTagCallee, + SymTagExport, + SymTagHeapAllocationSite, + SymTagCoffGroup, + SymTagInlinee, + SymTagMax +}; + +enum LocationType +{ + LocIsNull, + LocIsStatic, + LocIsTLS, + LocIsRegRel, + LocIsThisRel, + LocIsEnregistered, + LocIsBitField, + LocIsSlot, + LocIsIlRel, + LocInMetaData, + LocIsConstant, + LocIsRegRelAliasIndir, + LocTypeMax +}; + +enum DataKind +{ + DataIsUnknown, + DataIsLocal, + DataIsStaticLocal, + DataIsParam, + DataIsObjectPtr, + DataIsFileStatic, + DataIsGlobal, + DataIsMember, + DataIsStaticMember, + DataIsConstant +}; + +enum UdtKind +{ + UdtStruct, + UdtClass, + UdtUnion, + UdtInterface +}; + +enum BasicType +{ + btNoType = 0, + btVoid = 1, + btChar = 2, + btWChar = 3, + btInt = 6, + btUInt = 7, + btFloat = 8, + btBCD = 9, + btBool = 10, + btLong = 13, + btULong = 14, + btCurrency = 25, + btDate = 26, + btVariant = 27, + btComplex = 28, + btBit = 29, + btBSTR = 30, + btHresult = 31, + btChar16 = 32, // char16_t + btChar32 = 33, // char32_t + btChar8 = 34, // char8_t +}; + + +// enumeration for type modifier values + +typedef enum CV_modifier_e +{ + // 0x0000 - 0x01ff - Reserved. + + CV_MOD_INVALID = 0x0000, + + // Standard modifiers. + + CV_MOD_CONST = 0x0001, + CV_MOD_VOLATILE = 0x0002, + CV_MOD_UNALIGNED = 0x0003, + + // 0x0200 - 0x03ff - HLSL modifiers. + + CV_MOD_HLSL_UNIFORM = 0x0200, + CV_MOD_HLSL_LINE = 0x0201, + CV_MOD_HLSL_TRIANGLE = 0x0202, + CV_MOD_HLSL_LINEADJ = 0x0203, + CV_MOD_HLSL_TRIANGLEADJ = 0x0204, + CV_MOD_HLSL_LINEAR = 0x0205, + CV_MOD_HLSL_CENTROID = 0x0206, + CV_MOD_HLSL_CONSTINTERP = 0x0207, + CV_MOD_HLSL_NOPERSPECTIVE = 0x0208, + CV_MOD_HLSL_SAMPLE = 0x0209, + CV_MOD_HLSL_CENTER = 0x020a, + CV_MOD_HLSL_SNORM = 0x020b, + CV_MOD_HLSL_UNORM = 0x020c, + CV_MOD_HLSL_PRECISE = 0x020d, + CV_MOD_HLSL_UAV_GLOBALLY_COHERENT = 0x020e, + + // 0x0400 - 0xffff - Unused. + +} CV_modifier_e; + + +// built-in type kinds + + +typedef enum CV_builtin_e +{ + // 0x0000 - 0x01ff - Reserved. + CV_BI_INVALID = 0x0000, + + // 0x0200 - 0x03ff - HLSL types. + + CV_BI_HLSL_INTERFACE_POINTER = 0x0200, + CV_BI_HLSL_TEXTURE1D = 0x0201, + CV_BI_HLSL_TEXTURE1D_ARRAY = 0x0202, + CV_BI_HLSL_TEXTURE2D = 0x0203, + CV_BI_HLSL_TEXTURE2D_ARRAY = 0x0204, + CV_BI_HLSL_TEXTURE3D = 0x0205, + CV_BI_HLSL_TEXTURECUBE = 0x0206, + CV_BI_HLSL_TEXTURECUBE_ARRAY = 0x0207, + CV_BI_HLSL_TEXTURE2DMS = 0x0208, + CV_BI_HLSL_TEXTURE2DMS_ARRAY = 0x0209, + CV_BI_HLSL_SAMPLER = 0x020a, + CV_BI_HLSL_SAMPLERCOMPARISON = 0x020b, + CV_BI_HLSL_BUFFER = 0x020c, + CV_BI_HLSL_POINTSTREAM = 0x020d, + CV_BI_HLSL_LINESTREAM = 0x020e, + CV_BI_HLSL_TRIANGLESTREAM = 0x020f, + CV_BI_HLSL_INPUTPATCH = 0x0210, + CV_BI_HLSL_OUTPUTPATCH = 0x0211, + CV_BI_HLSL_RWTEXTURE1D = 0x0212, + CV_BI_HLSL_RWTEXTURE1D_ARRAY = 0x0213, + CV_BI_HLSL_RWTEXTURE2D = 0x0214, + CV_BI_HLSL_RWTEXTURE2D_ARRAY = 0x0215, + CV_BI_HLSL_RWTEXTURE3D = 0x0216, + CV_BI_HLSL_RWBUFFER = 0x0217, + CV_BI_HLSL_BYTEADDRESS_BUFFER = 0x0218, + CV_BI_HLSL_RWBYTEADDRESS_BUFFER = 0x0219, + CV_BI_HLSL_STRUCTURED_BUFFER = 0x021a, + CV_BI_HLSL_RWSTRUCTURED_BUFFER = 0x021b, + CV_BI_HLSL_APPEND_STRUCTURED_BUFFER = 0x021c, + CV_BI_HLSL_CONSUME_STRUCTURED_BUFFER= 0x021d, + CV_BI_HLSL_MIN8FLOAT = 0x021e, + CV_BI_HLSL_MIN10FLOAT = 0x021f, + CV_BI_HLSL_MIN16FLOAT = 0x0220, + CV_BI_HLSL_MIN12INT = 0x0221, + CV_BI_HLSL_MIN16INT = 0x0222, + CV_BI_HLSL_MIN16UINT = 0x0223, + CV_BI_HLSL_CONSTANT_BUFFER = 0x0224, + + // 0x0400 - 0xffff - Unused. + +} CV_builtin_e; + + +// enum describing the compile flag source language + + +typedef enum CV_CFL_LANG +{ + CV_CFL_C = 0x00, + CV_CFL_CXX = 0x01, + CV_CFL_FORTRAN = 0x02, + CV_CFL_MASM = 0x03, + CV_CFL_PASCAL = 0x04, + CV_CFL_BASIC = 0x05, + CV_CFL_COBOL = 0x06, + CV_CFL_LINK = 0x07, + CV_CFL_CVTRES = 0x08, + CV_CFL_CVTPGD = 0x09, + CV_CFL_CSHARP = 0x0A, // C# + CV_CFL_VB = 0x0B, // Visual Basic + CV_CFL_ILASM = 0x0C, // IL (as in CLR) ASM + CV_CFL_JAVA = 0x0D, + CV_CFL_JSCRIPT = 0x0E, + CV_CFL_MSIL = 0x0F, // Unknown MSIL (LTCG of .NETMODULE) + CV_CFL_HLSL = 0x10, // High Level Shader Language + CV_CFL_OBJC = 0x11, // Objective-C + CV_CFL_OBJCXX = 0x12, // Objective-C++ + CV_CFL_SWIFT = 0x13, // Swift +} CV_CFL_LANG; + + +// enum describing target processor + + +typedef enum CV_CPU_TYPE_e +{ + CV_CFL_8080 = 0x00, + CV_CFL_8086 = 0x01, + CV_CFL_80286 = 0x02, + CV_CFL_80386 = 0x03, + CV_CFL_80486 = 0x04, + CV_CFL_PENTIUM = 0x05, + CV_CFL_PENTIUMII = 0x06, + CV_CFL_PENTIUMPRO = CV_CFL_PENTIUMII, + CV_CFL_PENTIUMIII = 0x07, + CV_CFL_MIPS = 0x10, + CV_CFL_MIPSR4000 = CV_CFL_MIPS, // don't break current code + CV_CFL_MIPS16 = 0x11, + CV_CFL_MIPS32 = 0x12, + CV_CFL_MIPS64 = 0x13, + CV_CFL_MIPSI = 0x14, + CV_CFL_MIPSII = 0x15, + CV_CFL_MIPSIII = 0x16, + CV_CFL_MIPSIV = 0x17, + CV_CFL_MIPSV = 0x18, + CV_CFL_M68000 = 0x20, + CV_CFL_M68010 = 0x21, + CV_CFL_M68020 = 0x22, + CV_CFL_M68030 = 0x23, + CV_CFL_M68040 = 0x24, + CV_CFL_ALPHA = 0x30, + CV_CFL_ALPHA_21064 = 0x30, + CV_CFL_ALPHA_21164 = 0x31, + CV_CFL_ALPHA_21164A = 0x32, + CV_CFL_ALPHA_21264 = 0x33, + CV_CFL_ALPHA_21364 = 0x34, + CV_CFL_PPC601 = 0x40, + CV_CFL_PPC603 = 0x41, + CV_CFL_PPC604 = 0x42, + CV_CFL_PPC620 = 0x43, + CV_CFL_PPCFP = 0x44, + CV_CFL_PPCBE = 0x45, + CV_CFL_SH3 = 0x50, + CV_CFL_SH3E = 0x51, + CV_CFL_SH3DSP = 0x52, + CV_CFL_SH4 = 0x53, + CV_CFL_SHMEDIA = 0x54, + CV_CFL_ARM3 = 0x60, + CV_CFL_ARM4 = 0x61, + CV_CFL_ARM4T = 0x62, + CV_CFL_ARM5 = 0x63, + CV_CFL_ARM5T = 0x64, + CV_CFL_ARM6 = 0x65, + CV_CFL_ARM_XMAC = 0x66, + CV_CFL_ARM_WMMX = 0x67, + CV_CFL_ARM7 = 0x68, + CV_CFL_OMNI = 0x70, + CV_CFL_IA64 = 0x80, + CV_CFL_IA64_1 = 0x80, + CV_CFL_IA64_2 = 0x81, + CV_CFL_CEE = 0x90, + CV_CFL_AM33 = 0xA0, + CV_CFL_M32R = 0xB0, + CV_CFL_TRICORE = 0xC0, + CV_CFL_X64 = 0xD0, + CV_CFL_AMD64 = CV_CFL_X64, + CV_CFL_EBC = 0xE0, + CV_CFL_THUMB = 0xF0, + CV_CFL_ARMNT = 0xF4, + CV_CFL_ARM64 = 0xF6, + CV_CFL_HYBRID_X86_ARM64 = 0xF7, + CV_CFL_ARM64EC = 0xF8, + CV_CFL_ARM64X = 0xF9, + CV_CFL_D3D11_SHADER = 0x100, +} CV_CPU_TYPE_e; + +typedef enum CV_HREG_e +{ + // Register subset shared by all processor types, + // must not overlap with any of the ranges below, hence the high values + + CV_ALLREG_ERR = 30000, + CV_ALLREG_TEB = 30001, + CV_ALLREG_TIMER = 30002, + CV_ALLREG_EFAD1 = 30003, + CV_ALLREG_EFAD2 = 30004, + CV_ALLREG_EFAD3 = 30005, + CV_ALLREG_VFRAME= 30006, + CV_ALLREG_HANDLE= 30007, + CV_ALLREG_PARAMS= 30008, + CV_ALLREG_LOCALS= 30009, + CV_ALLREG_TID = 30010, + CV_ALLREG_ENV = 30011, + CV_ALLREG_CMDLN = 30012, + + + // Register set for the Intel 80x86 and ix86 processor series + // (plus PCODE registers) + + CV_REG_NONE = 0, + CV_REG_AL = 1, + CV_REG_CL = 2, + CV_REG_DL = 3, + CV_REG_BL = 4, + CV_REG_AH = 5, + CV_REG_CH = 6, + CV_REG_DH = 7, + CV_REG_BH = 8, + CV_REG_AX = 9, + CV_REG_CX = 10, + CV_REG_DX = 11, + CV_REG_BX = 12, + CV_REG_SP = 13, + CV_REG_BP = 14, + CV_REG_SI = 15, + CV_REG_DI = 16, + CV_REG_EAX = 17, + CV_REG_ECX = 18, + CV_REG_EDX = 19, + CV_REG_EBX = 20, + CV_REG_ESP = 21, + CV_REG_EBP = 22, + CV_REG_ESI = 23, + CV_REG_EDI = 24, + CV_REG_ES = 25, + CV_REG_CS = 26, + CV_REG_SS = 27, + CV_REG_DS = 28, + CV_REG_FS = 29, + CV_REG_GS = 30, + CV_REG_IP = 31, + CV_REG_FLAGS = 32, + CV_REG_EIP = 33, + CV_REG_EFLAGS = 34, + CV_REG_TEMP = 40, // PCODE Temp + CV_REG_TEMPH = 41, // PCODE TempH + CV_REG_QUOTE = 42, // PCODE Quote + CV_REG_PCDR3 = 43, // PCODE reserved + CV_REG_PCDR4 = 44, // PCODE reserved + CV_REG_PCDR5 = 45, // PCODE reserved + CV_REG_PCDR6 = 46, // PCODE reserved + CV_REG_PCDR7 = 47, // PCODE reserved + CV_REG_CR0 = 80, // CR0 -- control registers + CV_REG_CR1 = 81, + CV_REG_CR2 = 82, + CV_REG_CR3 = 83, + CV_REG_CR4 = 84, // Pentium + CV_REG_DR0 = 90, // Debug register + CV_REG_DR1 = 91, + CV_REG_DR2 = 92, + CV_REG_DR3 = 93, + CV_REG_DR4 = 94, + CV_REG_DR5 = 95, + CV_REG_DR6 = 96, + CV_REG_DR7 = 97, + CV_REG_GDTR = 110, + CV_REG_GDTL = 111, + CV_REG_IDTR = 112, + CV_REG_IDTL = 113, + CV_REG_LDTR = 114, + CV_REG_TR = 115, + + CV_REG_PSEUDO1 = 116, + CV_REG_PSEUDO2 = 117, + CV_REG_PSEUDO3 = 118, + CV_REG_PSEUDO4 = 119, + CV_REG_PSEUDO5 = 120, + CV_REG_PSEUDO6 = 121, + CV_REG_PSEUDO7 = 122, + CV_REG_PSEUDO8 = 123, + CV_REG_PSEUDO9 = 124, + + CV_REG_ST0 = 128, + CV_REG_ST1 = 129, + CV_REG_ST2 = 130, + CV_REG_ST3 = 131, + CV_REG_ST4 = 132, + CV_REG_ST5 = 133, + CV_REG_ST6 = 134, + CV_REG_ST7 = 135, + CV_REG_CTRL = 136, + CV_REG_STAT = 137, + CV_REG_TAG = 138, + CV_REG_FPIP = 139, + CV_REG_FPCS = 140, + CV_REG_FPDO = 141, + CV_REG_FPDS = 142, + CV_REG_ISEM = 143, + CV_REG_FPEIP = 144, + CV_REG_FPEDO = 145, + + CV_REG_MM0 = 146, + CV_REG_MM1 = 147, + CV_REG_MM2 = 148, + CV_REG_MM3 = 149, + CV_REG_MM4 = 150, + CV_REG_MM5 = 151, + CV_REG_MM6 = 152, + CV_REG_MM7 = 153, + + CV_REG_XMM0 = 154, // KATMAI registers + CV_REG_XMM1 = 155, + CV_REG_XMM2 = 156, + CV_REG_XMM3 = 157, + CV_REG_XMM4 = 158, + CV_REG_XMM5 = 159, + CV_REG_XMM6 = 160, + CV_REG_XMM7 = 161, + + CV_REG_XMM00 = 162, // KATMAI sub-registers + CV_REG_XMM01 = 163, + CV_REG_XMM02 = 164, + CV_REG_XMM03 = 165, + CV_REG_XMM10 = 166, + CV_REG_XMM11 = 167, + CV_REG_XMM12 = 168, + CV_REG_XMM13 = 169, + CV_REG_XMM20 = 170, + CV_REG_XMM21 = 171, + CV_REG_XMM22 = 172, + CV_REG_XMM23 = 173, + CV_REG_XMM30 = 174, + CV_REG_XMM31 = 175, + CV_REG_XMM32 = 176, + CV_REG_XMM33 = 177, + CV_REG_XMM40 = 178, + CV_REG_XMM41 = 179, + CV_REG_XMM42 = 180, + CV_REG_XMM43 = 181, + CV_REG_XMM50 = 182, + CV_REG_XMM51 = 183, + CV_REG_XMM52 = 184, + CV_REG_XMM53 = 185, + CV_REG_XMM60 = 186, + CV_REG_XMM61 = 187, + CV_REG_XMM62 = 188, + CV_REG_XMM63 = 189, + CV_REG_XMM70 = 190, + CV_REG_XMM71 = 191, + CV_REG_XMM72 = 192, + CV_REG_XMM73 = 193, + + CV_REG_XMM0L = 194, + CV_REG_XMM1L = 195, + CV_REG_XMM2L = 196, + CV_REG_XMM3L = 197, + CV_REG_XMM4L = 198, + CV_REG_XMM5L = 199, + CV_REG_XMM6L = 200, + CV_REG_XMM7L = 201, + + CV_REG_XMM0H = 202, + CV_REG_XMM1H = 203, + CV_REG_XMM2H = 204, + CV_REG_XMM3H = 205, + CV_REG_XMM4H = 206, + CV_REG_XMM5H = 207, + CV_REG_XMM6H = 208, + CV_REG_XMM7H = 209, + + CV_REG_MXCSR = 211, // XMM status register + + CV_REG_EDXEAX = 212, // EDX:EAX pair + + CV_REG_EMM0L = 220, // XMM sub-registers (WNI integer) + CV_REG_EMM1L = 221, + CV_REG_EMM2L = 222, + CV_REG_EMM3L = 223, + CV_REG_EMM4L = 224, + CV_REG_EMM5L = 225, + CV_REG_EMM6L = 226, + CV_REG_EMM7L = 227, + + CV_REG_EMM0H = 228, + CV_REG_EMM1H = 229, + CV_REG_EMM2H = 230, + CV_REG_EMM3H = 231, + CV_REG_EMM4H = 232, + CV_REG_EMM5H = 233, + CV_REG_EMM6H = 234, + CV_REG_EMM7H = 235, + + // do not change the order of these regs, first one must be even too + CV_REG_MM00 = 236, + CV_REG_MM01 = 237, + CV_REG_MM10 = 238, + CV_REG_MM11 = 239, + CV_REG_MM20 = 240, + CV_REG_MM21 = 241, + CV_REG_MM30 = 242, + CV_REG_MM31 = 243, + CV_REG_MM40 = 244, + CV_REG_MM41 = 245, + CV_REG_MM50 = 246, + CV_REG_MM51 = 247, + CV_REG_MM60 = 248, + CV_REG_MM61 = 249, + CV_REG_MM70 = 250, + CV_REG_MM71 = 251, + + CV_REG_YMM0 = 252, // AVX registers + CV_REG_YMM1 = 253, + CV_REG_YMM2 = 254, + CV_REG_YMM3 = 255, + CV_REG_YMM4 = 256, + CV_REG_YMM5 = 257, + CV_REG_YMM6 = 258, + CV_REG_YMM7 = 259, + + CV_REG_YMM0H = 260, + CV_REG_YMM1H = 261, + CV_REG_YMM2H = 262, + CV_REG_YMM3H = 263, + CV_REG_YMM4H = 264, + CV_REG_YMM5H = 265, + CV_REG_YMM6H = 266, + CV_REG_YMM7H = 267, + + CV_REG_YMM0I0 = 268, // AVX integer registers + CV_REG_YMM0I1 = 269, + CV_REG_YMM0I2 = 270, + CV_REG_YMM0I3 = 271, + CV_REG_YMM1I0 = 272, + CV_REG_YMM1I1 = 273, + CV_REG_YMM1I2 = 274, + CV_REG_YMM1I3 = 275, + CV_REG_YMM2I0 = 276, + CV_REG_YMM2I1 = 277, + CV_REG_YMM2I2 = 278, + CV_REG_YMM2I3 = 279, + CV_REG_YMM3I0 = 280, + CV_REG_YMM3I1 = 281, + CV_REG_YMM3I2 = 282, + CV_REG_YMM3I3 = 283, + CV_REG_YMM4I0 = 284, + CV_REG_YMM4I1 = 285, + CV_REG_YMM4I2 = 286, + CV_REG_YMM4I3 = 287, + CV_REG_YMM5I0 = 288, + CV_REG_YMM5I1 = 289, + CV_REG_YMM5I2 = 290, + CV_REG_YMM5I3 = 291, + CV_REG_YMM6I0 = 292, + CV_REG_YMM6I1 = 293, + CV_REG_YMM6I2 = 294, + CV_REG_YMM6I3 = 295, + CV_REG_YMM7I0 = 296, + CV_REG_YMM7I1 = 297, + CV_REG_YMM7I2 = 298, + CV_REG_YMM7I3 = 299, + + CV_REG_YMM0F0 = 300, // AVX floating-point single precise registers + CV_REG_YMM0F1 = 301, + CV_REG_YMM0F2 = 302, + CV_REG_YMM0F3 = 303, + CV_REG_YMM0F4 = 304, + CV_REG_YMM0F5 = 305, + CV_REG_YMM0F6 = 306, + CV_REG_YMM0F7 = 307, + CV_REG_YMM1F0 = 308, + CV_REG_YMM1F1 = 309, + CV_REG_YMM1F2 = 310, + CV_REG_YMM1F3 = 311, + CV_REG_YMM1F4 = 312, + CV_REG_YMM1F5 = 313, + CV_REG_YMM1F6 = 314, + CV_REG_YMM1F7 = 315, + CV_REG_YMM2F0 = 316, + CV_REG_YMM2F1 = 317, + CV_REG_YMM2F2 = 318, + CV_REG_YMM2F3 = 319, + CV_REG_YMM2F4 = 320, + CV_REG_YMM2F5 = 321, + CV_REG_YMM2F6 = 322, + CV_REG_YMM2F7 = 323, + CV_REG_YMM3F0 = 324, + CV_REG_YMM3F1 = 325, + CV_REG_YMM3F2 = 326, + CV_REG_YMM3F3 = 327, + CV_REG_YMM3F4 = 328, + CV_REG_YMM3F5 = 329, + CV_REG_YMM3F6 = 330, + CV_REG_YMM3F7 = 331, + CV_REG_YMM4F0 = 332, + CV_REG_YMM4F1 = 333, + CV_REG_YMM4F2 = 334, + CV_REG_YMM4F3 = 335, + CV_REG_YMM4F4 = 336, + CV_REG_YMM4F5 = 337, + CV_REG_YMM4F6 = 338, + CV_REG_YMM4F7 = 339, + CV_REG_YMM5F0 = 340, + CV_REG_YMM5F1 = 341, + CV_REG_YMM5F2 = 342, + CV_REG_YMM5F3 = 343, + CV_REG_YMM5F4 = 344, + CV_REG_YMM5F5 = 345, + CV_REG_YMM5F6 = 346, + CV_REG_YMM5F7 = 347, + CV_REG_YMM6F0 = 348, + CV_REG_YMM6F1 = 349, + CV_REG_YMM6F2 = 350, + CV_REG_YMM6F3 = 351, + CV_REG_YMM6F4 = 352, + CV_REG_YMM6F5 = 353, + CV_REG_YMM6F6 = 354, + CV_REG_YMM6F7 = 355, + CV_REG_YMM7F0 = 356, + CV_REG_YMM7F1 = 357, + CV_REG_YMM7F2 = 358, + CV_REG_YMM7F3 = 359, + CV_REG_YMM7F4 = 360, + CV_REG_YMM7F5 = 361, + CV_REG_YMM7F6 = 362, + CV_REG_YMM7F7 = 363, + + CV_REG_YMM0D0 = 364, // AVX floating-point double precise registers + CV_REG_YMM0D1 = 365, + CV_REG_YMM0D2 = 366, + CV_REG_YMM0D3 = 367, + CV_REG_YMM1D0 = 368, + CV_REG_YMM1D1 = 369, + CV_REG_YMM1D2 = 370, + CV_REG_YMM1D3 = 371, + CV_REG_YMM2D0 = 372, + CV_REG_YMM2D1 = 373, + CV_REG_YMM2D2 = 374, + CV_REG_YMM2D3 = 375, + CV_REG_YMM3D0 = 376, + CV_REG_YMM3D1 = 377, + CV_REG_YMM3D2 = 378, + CV_REG_YMM3D3 = 379, + CV_REG_YMM4D0 = 380, + CV_REG_YMM4D1 = 381, + CV_REG_YMM4D2 = 382, + CV_REG_YMM4D3 = 383, + CV_REG_YMM5D0 = 384, + CV_REG_YMM5D1 = 385, + CV_REG_YMM5D2 = 386, + CV_REG_YMM5D3 = 387, + CV_REG_YMM6D0 = 388, + CV_REG_YMM6D1 = 389, + CV_REG_YMM6D2 = 390, + CV_REG_YMM6D3 = 391, + CV_REG_YMM7D0 = 392, + CV_REG_YMM7D1 = 393, + CV_REG_YMM7D2 = 394, + CV_REG_YMM7D3 = 395, + + CV_REG_BND0 = 396, // x86 MPX bounds registers + CV_REG_BND1 = 397, + CV_REG_BND2 = 398, + CV_REG_BND3 = 399, + CV_REG_BNDCFGU = 400, + CV_REG_BNDSTATUS = 401, + + CV_REG_ZMM0 = 402, // AVX-512 registers + CV_REG_ZMM1 = 403, + CV_REG_ZMM2 = 404, + CV_REG_ZMM3 = 405, + CV_REG_ZMM4 = 406, + CV_REG_ZMM5 = 407, + CV_REG_ZMM6 = 408, + CV_REG_ZMM7 = 409, + + CV_REG_ZMM0H = 410, + CV_REG_ZMM1H = 411, + CV_REG_ZMM2H = 412, + CV_REG_ZMM3H = 413, + CV_REG_ZMM4H = 414, + CV_REG_ZMM5H = 415, + CV_REG_ZMM6H = 416, + CV_REG_ZMM7H = 417, + + CV_REG_K0 = 418, + CV_REG_K1 = 419, + CV_REG_K2 = 420, + CV_REG_K3 = 421, + CV_REG_K4 = 422, + CV_REG_K5 = 423, + CV_REG_K6 = 424, + CV_REG_K7 = 425, + + CV_REG_SSP = 426, // CET- Shadow Stack Pointer + + // registers for the 68K processors + + CV_R68_D0 = 0, + CV_R68_D1 = 1, + CV_R68_D2 = 2, + CV_R68_D3 = 3, + CV_R68_D4 = 4, + CV_R68_D5 = 5, + CV_R68_D6 = 6, + CV_R68_D7 = 7, + CV_R68_A0 = 8, + CV_R68_A1 = 9, + CV_R68_A2 = 10, + CV_R68_A3 = 11, + CV_R68_A4 = 12, + CV_R68_A5 = 13, + CV_R68_A6 = 14, + CV_R68_A7 = 15, + CV_R68_CCR = 16, + CV_R68_SR = 17, + CV_R68_USP = 18, + CV_R68_MSP = 19, + CV_R68_SFC = 20, + CV_R68_DFC = 21, + CV_R68_CACR = 22, + CV_R68_VBR = 23, + CV_R68_CAAR = 24, + CV_R68_ISP = 25, + CV_R68_PC = 26, + //reserved 27 + CV_R68_FPCR = 28, + CV_R68_FPSR = 29, + CV_R68_FPIAR = 30, + //reserved 31 + CV_R68_FP0 = 32, + CV_R68_FP1 = 33, + CV_R68_FP2 = 34, + CV_R68_FP3 = 35, + CV_R68_FP4 = 36, + CV_R68_FP5 = 37, + CV_R68_FP6 = 38, + CV_R68_FP7 = 39, + //reserved 40 + CV_R68_MMUSR030 = 41, + CV_R68_MMUSR = 42, + CV_R68_URP = 43, + CV_R68_DTT0 = 44, + CV_R68_DTT1 = 45, + CV_R68_ITT0 = 46, + CV_R68_ITT1 = 47, + //reserved 50 + CV_R68_PSR = 51, + CV_R68_PCSR = 52, + CV_R68_VAL = 53, + CV_R68_CRP = 54, + CV_R68_SRP = 55, + CV_R68_DRP = 56, + CV_R68_TC = 57, + CV_R68_AC = 58, + CV_R68_SCC = 59, + CV_R68_CAL = 60, + CV_R68_TT0 = 61, + CV_R68_TT1 = 62, + //reserved 63 + CV_R68_BAD0 = 64, + CV_R68_BAD1 = 65, + CV_R68_BAD2 = 66, + CV_R68_BAD3 = 67, + CV_R68_BAD4 = 68, + CV_R68_BAD5 = 69, + CV_R68_BAD6 = 70, + CV_R68_BAD7 = 71, + CV_R68_BAC0 = 72, + CV_R68_BAC1 = 73, + CV_R68_BAC2 = 74, + CV_R68_BAC3 = 75, + CV_R68_BAC4 = 76, + CV_R68_BAC5 = 77, + CV_R68_BAC6 = 78, + CV_R68_BAC7 = 79, + + // Register set for the MIPS 4000 + + CV_M4_NOREG = CV_REG_NONE, + + CV_M4_IntZERO = 10, /* CPU REGISTER */ + CV_M4_IntAT = 11, + CV_M4_IntV0 = 12, + CV_M4_IntV1 = 13, + CV_M4_IntA0 = 14, + CV_M4_IntA1 = 15, + CV_M4_IntA2 = 16, + CV_M4_IntA3 = 17, + CV_M4_IntT0 = 18, + CV_M4_IntT1 = 19, + CV_M4_IntT2 = 20, + CV_M4_IntT3 = 21, + CV_M4_IntT4 = 22, + CV_M4_IntT5 = 23, + CV_M4_IntT6 = 24, + CV_M4_IntT7 = 25, + CV_M4_IntS0 = 26, + CV_M4_IntS1 = 27, + CV_M4_IntS2 = 28, + CV_M4_IntS3 = 29, + CV_M4_IntS4 = 30, + CV_M4_IntS5 = 31, + CV_M4_IntS6 = 32, + CV_M4_IntS7 = 33, + CV_M4_IntT8 = 34, + CV_M4_IntT9 = 35, + CV_M4_IntKT0 = 36, + CV_M4_IntKT1 = 37, + CV_M4_IntGP = 38, + CV_M4_IntSP = 39, + CV_M4_IntS8 = 40, + CV_M4_IntRA = 41, + CV_M4_IntLO = 42, + CV_M4_IntHI = 43, + + CV_M4_Fir = 50, + CV_M4_Psr = 51, + + CV_M4_FltF0 = 60, /* Floating point registers */ + CV_M4_FltF1 = 61, + CV_M4_FltF2 = 62, + CV_M4_FltF3 = 63, + CV_M4_FltF4 = 64, + CV_M4_FltF5 = 65, + CV_M4_FltF6 = 66, + CV_M4_FltF7 = 67, + CV_M4_FltF8 = 68, + CV_M4_FltF9 = 69, + CV_M4_FltF10 = 70, + CV_M4_FltF11 = 71, + CV_M4_FltF12 = 72, + CV_M4_FltF13 = 73, + CV_M4_FltF14 = 74, + CV_M4_FltF15 = 75, + CV_M4_FltF16 = 76, + CV_M4_FltF17 = 77, + CV_M4_FltF18 = 78, + CV_M4_FltF19 = 79, + CV_M4_FltF20 = 80, + CV_M4_FltF21 = 81, + CV_M4_FltF22 = 82, + CV_M4_FltF23 = 83, + CV_M4_FltF24 = 84, + CV_M4_FltF25 = 85, + CV_M4_FltF26 = 86, + CV_M4_FltF27 = 87, + CV_M4_FltF28 = 88, + CV_M4_FltF29 = 89, + CV_M4_FltF30 = 90, + CV_M4_FltF31 = 91, + CV_M4_FltFsr = 92, + + + // Register set for the ALPHA AXP + + CV_ALPHA_NOREG = CV_REG_NONE, + + CV_ALPHA_FltF0 = 10, // Floating point registers + CV_ALPHA_FltF1 = 11, + CV_ALPHA_FltF2 = 12, + CV_ALPHA_FltF3 = 13, + CV_ALPHA_FltF4 = 14, + CV_ALPHA_FltF5 = 15, + CV_ALPHA_FltF6 = 16, + CV_ALPHA_FltF7 = 17, + CV_ALPHA_FltF8 = 18, + CV_ALPHA_FltF9 = 19, + CV_ALPHA_FltF10 = 20, + CV_ALPHA_FltF11 = 21, + CV_ALPHA_FltF12 = 22, + CV_ALPHA_FltF13 = 23, + CV_ALPHA_FltF14 = 24, + CV_ALPHA_FltF15 = 25, + CV_ALPHA_FltF16 = 26, + CV_ALPHA_FltF17 = 27, + CV_ALPHA_FltF18 = 28, + CV_ALPHA_FltF19 = 29, + CV_ALPHA_FltF20 = 30, + CV_ALPHA_FltF21 = 31, + CV_ALPHA_FltF22 = 32, + CV_ALPHA_FltF23 = 33, + CV_ALPHA_FltF24 = 34, + CV_ALPHA_FltF25 = 35, + CV_ALPHA_FltF26 = 36, + CV_ALPHA_FltF27 = 37, + CV_ALPHA_FltF28 = 38, + CV_ALPHA_FltF29 = 39, + CV_ALPHA_FltF30 = 40, + CV_ALPHA_FltF31 = 41, + + CV_ALPHA_IntV0 = 42, // Integer registers + CV_ALPHA_IntT0 = 43, + CV_ALPHA_IntT1 = 44, + CV_ALPHA_IntT2 = 45, + CV_ALPHA_IntT3 = 46, + CV_ALPHA_IntT4 = 47, + CV_ALPHA_IntT5 = 48, + CV_ALPHA_IntT6 = 49, + CV_ALPHA_IntT7 = 50, + CV_ALPHA_IntS0 = 51, + CV_ALPHA_IntS1 = 52, + CV_ALPHA_IntS2 = 53, + CV_ALPHA_IntS3 = 54, + CV_ALPHA_IntS4 = 55, + CV_ALPHA_IntS5 = 56, + CV_ALPHA_IntFP = 57, + CV_ALPHA_IntA0 = 58, + CV_ALPHA_IntA1 = 59, + CV_ALPHA_IntA2 = 60, + CV_ALPHA_IntA3 = 61, + CV_ALPHA_IntA4 = 62, + CV_ALPHA_IntA5 = 63, + CV_ALPHA_IntT8 = 64, + CV_ALPHA_IntT9 = 65, + CV_ALPHA_IntT10 = 66, + CV_ALPHA_IntT11 = 67, + CV_ALPHA_IntRA = 68, + CV_ALPHA_IntT12 = 69, + CV_ALPHA_IntAT = 70, + CV_ALPHA_IntGP = 71, + CV_ALPHA_IntSP = 72, + CV_ALPHA_IntZERO = 73, + + + CV_ALPHA_Fpcr = 74, // Control registers + CV_ALPHA_Fir = 75, + CV_ALPHA_Psr = 76, + CV_ALPHA_FltFsr = 77, + CV_ALPHA_SoftFpcr = 78, + + // Register Set for Motorola/IBM PowerPC + + /* + ** PowerPC General Registers ( User Level ) + */ + CV_PPC_GPR0 = 1, + CV_PPC_GPR1 = 2, + CV_PPC_GPR2 = 3, + CV_PPC_GPR3 = 4, + CV_PPC_GPR4 = 5, + CV_PPC_GPR5 = 6, + CV_PPC_GPR6 = 7, + CV_PPC_GPR7 = 8, + CV_PPC_GPR8 = 9, + CV_PPC_GPR9 = 10, + CV_PPC_GPR10 = 11, + CV_PPC_GPR11 = 12, + CV_PPC_GPR12 = 13, + CV_PPC_GPR13 = 14, + CV_PPC_GPR14 = 15, + CV_PPC_GPR15 = 16, + CV_PPC_GPR16 = 17, + CV_PPC_GPR17 = 18, + CV_PPC_GPR18 = 19, + CV_PPC_GPR19 = 20, + CV_PPC_GPR20 = 21, + CV_PPC_GPR21 = 22, + CV_PPC_GPR22 = 23, + CV_PPC_GPR23 = 24, + CV_PPC_GPR24 = 25, + CV_PPC_GPR25 = 26, + CV_PPC_GPR26 = 27, + CV_PPC_GPR27 = 28, + CV_PPC_GPR28 = 29, + CV_PPC_GPR29 = 30, + CV_PPC_GPR30 = 31, + CV_PPC_GPR31 = 32, + + /* + ** PowerPC Condition Register ( User Level ) + */ + CV_PPC_CR = 33, + CV_PPC_CR0 = 34, + CV_PPC_CR1 = 35, + CV_PPC_CR2 = 36, + CV_PPC_CR3 = 37, + CV_PPC_CR4 = 38, + CV_PPC_CR5 = 39, + CV_PPC_CR6 = 40, + CV_PPC_CR7 = 41, + + /* + ** PowerPC Floating Point Registers ( User Level ) + */ + CV_PPC_FPR0 = 42, + CV_PPC_FPR1 = 43, + CV_PPC_FPR2 = 44, + CV_PPC_FPR3 = 45, + CV_PPC_FPR4 = 46, + CV_PPC_FPR5 = 47, + CV_PPC_FPR6 = 48, + CV_PPC_FPR7 = 49, + CV_PPC_FPR8 = 50, + CV_PPC_FPR9 = 51, + CV_PPC_FPR10 = 52, + CV_PPC_FPR11 = 53, + CV_PPC_FPR12 = 54, + CV_PPC_FPR13 = 55, + CV_PPC_FPR14 = 56, + CV_PPC_FPR15 = 57, + CV_PPC_FPR16 = 58, + CV_PPC_FPR17 = 59, + CV_PPC_FPR18 = 60, + CV_PPC_FPR19 = 61, + CV_PPC_FPR20 = 62, + CV_PPC_FPR21 = 63, + CV_PPC_FPR22 = 64, + CV_PPC_FPR23 = 65, + CV_PPC_FPR24 = 66, + CV_PPC_FPR25 = 67, + CV_PPC_FPR26 = 68, + CV_PPC_FPR27 = 69, + CV_PPC_FPR28 = 70, + CV_PPC_FPR29 = 71, + CV_PPC_FPR30 = 72, + CV_PPC_FPR31 = 73, + + /* + ** PowerPC Floating Point Status and Control Register ( User Level ) + */ + CV_PPC_FPSCR = 74, + + /* + ** PowerPC Machine State Register ( Supervisor Level ) + */ + CV_PPC_MSR = 75, + + /* + ** PowerPC Segment Registers ( Supervisor Level ) + */ + CV_PPC_SR0 = 76, + CV_PPC_SR1 = 77, + CV_PPC_SR2 = 78, + CV_PPC_SR3 = 79, + CV_PPC_SR4 = 80, + CV_PPC_SR5 = 81, + CV_PPC_SR6 = 82, + CV_PPC_SR7 = 83, + CV_PPC_SR8 = 84, + CV_PPC_SR9 = 85, + CV_PPC_SR10 = 86, + CV_PPC_SR11 = 87, + CV_PPC_SR12 = 88, + CV_PPC_SR13 = 89, + CV_PPC_SR14 = 90, + CV_PPC_SR15 = 91, + + /* + ** For all of the special purpose registers add 100 to the SPR# that the + ** Motorola/IBM documentation gives with the exception of any imaginary + ** registers. + */ + + /* + ** PowerPC Special Purpose Registers ( User Level ) + */ + CV_PPC_PC = 99, // PC (imaginary register) + + CV_PPC_MQ = 100, // MPC601 + CV_PPC_XER = 101, + CV_PPC_RTCU = 104, // MPC601 + CV_PPC_RTCL = 105, // MPC601 + CV_PPC_LR = 108, + CV_PPC_CTR = 109, + + CV_PPC_COMPARE = 110, // part of XER (internal to the debugger only) + CV_PPC_COUNT = 111, // part of XER (internal to the debugger only) + + /* + ** PowerPC Special Purpose Registers ( Supervisor Level ) + */ + CV_PPC_DSISR = 118, + CV_PPC_DAR = 119, + CV_PPC_DEC = 122, + CV_PPC_SDR1 = 125, + CV_PPC_SRR0 = 126, + CV_PPC_SRR1 = 127, + CV_PPC_SPRG0 = 372, + CV_PPC_SPRG1 = 373, + CV_PPC_SPRG2 = 374, + CV_PPC_SPRG3 = 375, + CV_PPC_ASR = 280, // 64-bit implementations only + CV_PPC_EAR = 382, + CV_PPC_PVR = 287, + CV_PPC_BAT0U = 628, + CV_PPC_BAT0L = 629, + CV_PPC_BAT1U = 630, + CV_PPC_BAT1L = 631, + CV_PPC_BAT2U = 632, + CV_PPC_BAT2L = 633, + CV_PPC_BAT3U = 634, + CV_PPC_BAT3L = 635, + CV_PPC_DBAT0U = 636, + CV_PPC_DBAT0L = 637, + CV_PPC_DBAT1U = 638, + CV_PPC_DBAT1L = 639, + CV_PPC_DBAT2U = 640, + CV_PPC_DBAT2L = 641, + CV_PPC_DBAT3U = 642, + CV_PPC_DBAT3L = 643, + + /* + ** PowerPC Special Purpose Registers Implementation Dependent ( Supervisor Level ) + */ + + /* + ** Doesn't appear that IBM/Motorola has finished defining these. + */ + + CV_PPC_PMR0 = 1044, // MPC620, + CV_PPC_PMR1 = 1045, // MPC620, + CV_PPC_PMR2 = 1046, // MPC620, + CV_PPC_PMR3 = 1047, // MPC620, + CV_PPC_PMR4 = 1048, // MPC620, + CV_PPC_PMR5 = 1049, // MPC620, + CV_PPC_PMR6 = 1050, // MPC620, + CV_PPC_PMR7 = 1051, // MPC620, + CV_PPC_PMR8 = 1052, // MPC620, + CV_PPC_PMR9 = 1053, // MPC620, + CV_PPC_PMR10 = 1054, // MPC620, + CV_PPC_PMR11 = 1055, // MPC620, + CV_PPC_PMR12 = 1056, // MPC620, + CV_PPC_PMR13 = 1057, // MPC620, + CV_PPC_PMR14 = 1058, // MPC620, + CV_PPC_PMR15 = 1059, // MPC620, + + CV_PPC_DMISS = 1076, // MPC603 + CV_PPC_DCMP = 1077, // MPC603 + CV_PPC_HASH1 = 1078, // MPC603 + CV_PPC_HASH2 = 1079, // MPC603 + CV_PPC_IMISS = 1080, // MPC603 + CV_PPC_ICMP = 1081, // MPC603 + CV_PPC_RPA = 1082, // MPC603 + + CV_PPC_HID0 = 1108, // MPC601, MPC603, MPC620 + CV_PPC_HID1 = 1109, // MPC601 + CV_PPC_HID2 = 1110, // MPC601, MPC603, MPC620 ( IABR ) + CV_PPC_HID3 = 1111, // Not Defined + CV_PPC_HID4 = 1112, // Not Defined + CV_PPC_HID5 = 1113, // MPC601, MPC604, MPC620 ( DABR ) + CV_PPC_HID6 = 1114, // Not Defined + CV_PPC_HID7 = 1115, // Not Defined + CV_PPC_HID8 = 1116, // MPC620 ( BUSCSR ) + CV_PPC_HID9 = 1117, // MPC620 ( L2CSR ) + CV_PPC_HID10 = 1118, // Not Defined + CV_PPC_HID11 = 1119, // Not Defined + CV_PPC_HID12 = 1120, // Not Defined + CV_PPC_HID13 = 1121, // MPC604 ( HCR ) + CV_PPC_HID14 = 1122, // Not Defined + CV_PPC_HID15 = 1123, // MPC601, MPC604, MPC620 ( PIR ) + + // + // JAVA VM registers + // + + CV_JAVA_PC = 1, + + // + // Register set for the Hitachi SH3 + // + + CV_SH3_NOREG = CV_REG_NONE, + + CV_SH3_IntR0 = 10, // CPU REGISTER + CV_SH3_IntR1 = 11, + CV_SH3_IntR2 = 12, + CV_SH3_IntR3 = 13, + CV_SH3_IntR4 = 14, + CV_SH3_IntR5 = 15, + CV_SH3_IntR6 = 16, + CV_SH3_IntR7 = 17, + CV_SH3_IntR8 = 18, + CV_SH3_IntR9 = 19, + CV_SH3_IntR10 = 20, + CV_SH3_IntR11 = 21, + CV_SH3_IntR12 = 22, + CV_SH3_IntR13 = 23, + CV_SH3_IntFp = 24, + CV_SH3_IntSp = 25, + CV_SH3_Gbr = 38, + CV_SH3_Pr = 39, + CV_SH3_Mach = 40, + CV_SH3_Macl = 41, + + CV_SH3_Pc = 50, + CV_SH3_Sr = 51, + + CV_SH3_BarA = 60, + CV_SH3_BasrA = 61, + CV_SH3_BamrA = 62, + CV_SH3_BbrA = 63, + CV_SH3_BarB = 64, + CV_SH3_BasrB = 65, + CV_SH3_BamrB = 66, + CV_SH3_BbrB = 67, + CV_SH3_BdrB = 68, + CV_SH3_BdmrB = 69, + CV_SH3_Brcr = 70, + + // + // Additional registers for Hitachi SH processors + // + + CV_SH_Fpscr = 75, // floating point status/control register + CV_SH_Fpul = 76, // floating point communication register + + CV_SH_FpR0 = 80, // Floating point registers + CV_SH_FpR1 = 81, + CV_SH_FpR2 = 82, + CV_SH_FpR3 = 83, + CV_SH_FpR4 = 84, + CV_SH_FpR5 = 85, + CV_SH_FpR6 = 86, + CV_SH_FpR7 = 87, + CV_SH_FpR8 = 88, + CV_SH_FpR9 = 89, + CV_SH_FpR10 = 90, + CV_SH_FpR11 = 91, + CV_SH_FpR12 = 92, + CV_SH_FpR13 = 93, + CV_SH_FpR14 = 94, + CV_SH_FpR15 = 95, + + CV_SH_XFpR0 = 96, + CV_SH_XFpR1 = 97, + CV_SH_XFpR2 = 98, + CV_SH_XFpR3 = 99, + CV_SH_XFpR4 = 100, + CV_SH_XFpR5 = 101, + CV_SH_XFpR6 = 102, + CV_SH_XFpR7 = 103, + CV_SH_XFpR8 = 104, + CV_SH_XFpR9 = 105, + CV_SH_XFpR10 = 106, + CV_SH_XFpR11 = 107, + CV_SH_XFpR12 = 108, + CV_SH_XFpR13 = 109, + CV_SH_XFpR14 = 110, + CV_SH_XFpR15 = 111, + + // + // Register set for the ARM processor. + // + + CV_ARM_NOREG = CV_REG_NONE, + + CV_ARM_R0 = 10, + CV_ARM_R1 = 11, + CV_ARM_R2 = 12, + CV_ARM_R3 = 13, + CV_ARM_R4 = 14, + CV_ARM_R5 = 15, + CV_ARM_R6 = 16, + CV_ARM_R7 = 17, + CV_ARM_R8 = 18, + CV_ARM_R9 = 19, + CV_ARM_R10 = 20, + CV_ARM_R11 = 21, // Frame pointer, if allocated + CV_ARM_R12 = 22, + CV_ARM_SP = 23, // Stack pointer + CV_ARM_LR = 24, // Link Register + CV_ARM_PC = 25, // Program counter + CV_ARM_CPSR = 26, // Current program status register + + CV_ARM_ACC0 = 27, // DSP co-processor 0 40 bit accumulator + + // + // Registers for ARM VFP10 support + // + + CV_ARM_FPSCR = 40, + CV_ARM_FPEXC = 41, + + CV_ARM_FS0 = 50, + CV_ARM_FS1 = 51, + CV_ARM_FS2 = 52, + CV_ARM_FS3 = 53, + CV_ARM_FS4 = 54, + CV_ARM_FS5 = 55, + CV_ARM_FS6 = 56, + CV_ARM_FS7 = 57, + CV_ARM_FS8 = 58, + CV_ARM_FS9 = 59, + CV_ARM_FS10 = 60, + CV_ARM_FS11 = 61, + CV_ARM_FS12 = 62, + CV_ARM_FS13 = 63, + CV_ARM_FS14 = 64, + CV_ARM_FS15 = 65, + CV_ARM_FS16 = 66, + CV_ARM_FS17 = 67, + CV_ARM_FS18 = 68, + CV_ARM_FS19 = 69, + CV_ARM_FS20 = 70, + CV_ARM_FS21 = 71, + CV_ARM_FS22 = 72, + CV_ARM_FS23 = 73, + CV_ARM_FS24 = 74, + CV_ARM_FS25 = 75, + CV_ARM_FS26 = 76, + CV_ARM_FS27 = 77, + CV_ARM_FS28 = 78, + CV_ARM_FS29 = 79, + CV_ARM_FS30 = 80, + CV_ARM_FS31 = 81, + + // + // ARM VFP Floating Point Extra control registers + // + + CV_ARM_FPEXTRA0 = 90, + CV_ARM_FPEXTRA1 = 91, + CV_ARM_FPEXTRA2 = 92, + CV_ARM_FPEXTRA3 = 93, + CV_ARM_FPEXTRA4 = 94, + CV_ARM_FPEXTRA5 = 95, + CV_ARM_FPEXTRA6 = 96, + CV_ARM_FPEXTRA7 = 97, + + // XSCALE Concan co-processor registers + CV_ARM_WR0 = 128, + CV_ARM_WR1 = 129, + CV_ARM_WR2 = 130, + CV_ARM_WR3 = 131, + CV_ARM_WR4 = 132, + CV_ARM_WR5 = 133, + CV_ARM_WR6 = 134, + CV_ARM_WR7 = 135, + CV_ARM_WR8 = 136, + CV_ARM_WR9 = 137, + CV_ARM_WR10 = 138, + CV_ARM_WR11 = 139, + CV_ARM_WR12 = 140, + CV_ARM_WR13 = 141, + CV_ARM_WR14 = 142, + CV_ARM_WR15 = 143, + + // XSCALE Concan co-processor control registers + CV_ARM_WCID = 144, + CV_ARM_WCON = 145, + CV_ARM_WCSSF = 146, + CV_ARM_WCASF = 147, + CV_ARM_WC4 = 148, + CV_ARM_WC5 = 149, + CV_ARM_WC6 = 150, + CV_ARM_WC7 = 151, + CV_ARM_WCGR0 = 152, + CV_ARM_WCGR1 = 153, + CV_ARM_WCGR2 = 154, + CV_ARM_WCGR3 = 155, + CV_ARM_WC12 = 156, + CV_ARM_WC13 = 157, + CV_ARM_WC14 = 158, + CV_ARM_WC15 = 159, + + // + // ARM VFPv3/Neon extended floating Point + // + + CV_ARM_FS32 = 200, + CV_ARM_FS33 = 201, + CV_ARM_FS34 = 202, + CV_ARM_FS35 = 203, + CV_ARM_FS36 = 204, + CV_ARM_FS37 = 205, + CV_ARM_FS38 = 206, + CV_ARM_FS39 = 207, + CV_ARM_FS40 = 208, + CV_ARM_FS41 = 209, + CV_ARM_FS42 = 210, + CV_ARM_FS43 = 211, + CV_ARM_FS44 = 212, + CV_ARM_FS45 = 213, + CV_ARM_FS46 = 214, + CV_ARM_FS47 = 215, + CV_ARM_FS48 = 216, + CV_ARM_FS49 = 217, + CV_ARM_FS50 = 218, + CV_ARM_FS51 = 219, + CV_ARM_FS52 = 220, + CV_ARM_FS53 = 221, + CV_ARM_FS54 = 222, + CV_ARM_FS55 = 223, + CV_ARM_FS56 = 224, + CV_ARM_FS57 = 225, + CV_ARM_FS58 = 226, + CV_ARM_FS59 = 227, + CV_ARM_FS60 = 228, + CV_ARM_FS61 = 229, + CV_ARM_FS62 = 230, + CV_ARM_FS63 = 231, + + // ARM double-precision floating point + + CV_ARM_ND0 = 300, + CV_ARM_ND1 = 301, + CV_ARM_ND2 = 302, + CV_ARM_ND3 = 303, + CV_ARM_ND4 = 304, + CV_ARM_ND5 = 305, + CV_ARM_ND6 = 306, + CV_ARM_ND7 = 307, + CV_ARM_ND8 = 308, + CV_ARM_ND9 = 309, + CV_ARM_ND10 = 310, + CV_ARM_ND11 = 311, + CV_ARM_ND12 = 312, + CV_ARM_ND13 = 313, + CV_ARM_ND14 = 314, + CV_ARM_ND15 = 315, + CV_ARM_ND16 = 316, + CV_ARM_ND17 = 317, + CV_ARM_ND18 = 318, + CV_ARM_ND19 = 319, + CV_ARM_ND20 = 320, + CV_ARM_ND21 = 321, + CV_ARM_ND22 = 322, + CV_ARM_ND23 = 323, + CV_ARM_ND24 = 324, + CV_ARM_ND25 = 325, + CV_ARM_ND26 = 326, + CV_ARM_ND27 = 327, + CV_ARM_ND28 = 328, + CV_ARM_ND29 = 329, + CV_ARM_ND30 = 330, + CV_ARM_ND31 = 331, + + // ARM extended precision floating point + + CV_ARM_NQ0 = 400, + CV_ARM_NQ1 = 401, + CV_ARM_NQ2 = 402, + CV_ARM_NQ3 = 403, + CV_ARM_NQ4 = 404, + CV_ARM_NQ5 = 405, + CV_ARM_NQ6 = 406, + CV_ARM_NQ7 = 407, + CV_ARM_NQ8 = 408, + CV_ARM_NQ9 = 409, + CV_ARM_NQ10 = 410, + CV_ARM_NQ11 = 411, + CV_ARM_NQ12 = 412, + CV_ARM_NQ13 = 413, + CV_ARM_NQ14 = 414, + CV_ARM_NQ15 = 415, + + // + // Register set for ARM64 + // + + CV_ARM64_NOREG = CV_REG_NONE, + + // General purpose 32-bit integer registers + + CV_ARM64_W0 = 10, + CV_ARM64_W1 = 11, + CV_ARM64_W2 = 12, + CV_ARM64_W3 = 13, + CV_ARM64_W4 = 14, + CV_ARM64_W5 = 15, + CV_ARM64_W6 = 16, + CV_ARM64_W7 = 17, + CV_ARM64_W8 = 18, + CV_ARM64_W9 = 19, + CV_ARM64_W10 = 20, + CV_ARM64_W11 = 21, + CV_ARM64_W12 = 22, + CV_ARM64_W13 = 23, + CV_ARM64_W14 = 24, + CV_ARM64_W15 = 25, + CV_ARM64_W16 = 26, + CV_ARM64_W17 = 27, + CV_ARM64_W18 = 28, + CV_ARM64_W19 = 29, + CV_ARM64_W20 = 30, + CV_ARM64_W21 = 31, + CV_ARM64_W22 = 32, + CV_ARM64_W23 = 33, + CV_ARM64_W24 = 34, + CV_ARM64_W25 = 35, + CV_ARM64_W26 = 36, + CV_ARM64_W27 = 37, + CV_ARM64_W28 = 38, + CV_ARM64_W29 = 39, + CV_ARM64_W30 = 40, + CV_ARM64_WZR = 41, + + // General purpose 64-bit integer registers + + CV_ARM64_X0 = 50, + CV_ARM64_X1 = 51, + CV_ARM64_X2 = 52, + CV_ARM64_X3 = 53, + CV_ARM64_X4 = 54, + CV_ARM64_X5 = 55, + CV_ARM64_X6 = 56, + CV_ARM64_X7 = 57, + CV_ARM64_X8 = 58, + CV_ARM64_X9 = 59, + CV_ARM64_X10 = 60, + CV_ARM64_X11 = 61, + CV_ARM64_X12 = 62, + CV_ARM64_X13 = 63, + CV_ARM64_X14 = 64, + CV_ARM64_X15 = 65, + CV_ARM64_IP0 = 66, + CV_ARM64_IP1 = 67, + CV_ARM64_X18 = 68, + CV_ARM64_X19 = 69, + CV_ARM64_X20 = 70, + CV_ARM64_X21 = 71, + CV_ARM64_X22 = 72, + CV_ARM64_X23 = 73, + CV_ARM64_X24 = 74, + CV_ARM64_X25 = 75, + CV_ARM64_X26 = 76, + CV_ARM64_X27 = 77, + CV_ARM64_X28 = 78, + CV_ARM64_FP = 79, + CV_ARM64_LR = 80, + CV_ARM64_SP = 81, + CV_ARM64_ZR = 82, + CV_ARM64_PC = 83, + + // status registers + + CV_ARM64_NZCV = 90, + CV_ARM64_CPSR = 91, + + // 32-bit floating point registers + + CV_ARM64_S0 = 100, + CV_ARM64_S1 = 101, + CV_ARM64_S2 = 102, + CV_ARM64_S3 = 103, + CV_ARM64_S4 = 104, + CV_ARM64_S5 = 105, + CV_ARM64_S6 = 106, + CV_ARM64_S7 = 107, + CV_ARM64_S8 = 108, + CV_ARM64_S9 = 109, + CV_ARM64_S10 = 110, + CV_ARM64_S11 = 111, + CV_ARM64_S12 = 112, + CV_ARM64_S13 = 113, + CV_ARM64_S14 = 114, + CV_ARM64_S15 = 115, + CV_ARM64_S16 = 116, + CV_ARM64_S17 = 117, + CV_ARM64_S18 = 118, + CV_ARM64_S19 = 119, + CV_ARM64_S20 = 120, + CV_ARM64_S21 = 121, + CV_ARM64_S22 = 122, + CV_ARM64_S23 = 123, + CV_ARM64_S24 = 124, + CV_ARM64_S25 = 125, + CV_ARM64_S26 = 126, + CV_ARM64_S27 = 127, + CV_ARM64_S28 = 128, + CV_ARM64_S29 = 129, + CV_ARM64_S30 = 130, + CV_ARM64_S31 = 131, + + // 64-bit floating point registers + + CV_ARM64_D0 = 140, + CV_ARM64_D1 = 141, + CV_ARM64_D2 = 142, + CV_ARM64_D3 = 143, + CV_ARM64_D4 = 144, + CV_ARM64_D5 = 145, + CV_ARM64_D6 = 146, + CV_ARM64_D7 = 147, + CV_ARM64_D8 = 148, + CV_ARM64_D9 = 149, + CV_ARM64_D10 = 150, + CV_ARM64_D11 = 151, + CV_ARM64_D12 = 152, + CV_ARM64_D13 = 153, + CV_ARM64_D14 = 154, + CV_ARM64_D15 = 155, + CV_ARM64_D16 = 156, + CV_ARM64_D17 = 157, + CV_ARM64_D18 = 158, + CV_ARM64_D19 = 159, + CV_ARM64_D20 = 160, + CV_ARM64_D21 = 161, + CV_ARM64_D22 = 162, + CV_ARM64_D23 = 163, + CV_ARM64_D24 = 164, + CV_ARM64_D25 = 165, + CV_ARM64_D26 = 166, + CV_ARM64_D27 = 167, + CV_ARM64_D28 = 168, + CV_ARM64_D29 = 169, + CV_ARM64_D30 = 170, + CV_ARM64_D31 = 171, + + // 128-bit SIMD registers + + CV_ARM64_Q0 = 180, + CV_ARM64_Q1 = 181, + CV_ARM64_Q2 = 182, + CV_ARM64_Q3 = 183, + CV_ARM64_Q4 = 184, + CV_ARM64_Q5 = 185, + CV_ARM64_Q6 = 186, + CV_ARM64_Q7 = 187, + CV_ARM64_Q8 = 188, + CV_ARM64_Q9 = 189, + CV_ARM64_Q10 = 190, + CV_ARM64_Q11 = 191, + CV_ARM64_Q12 = 192, + CV_ARM64_Q13 = 193, + CV_ARM64_Q14 = 194, + CV_ARM64_Q15 = 195, + CV_ARM64_Q16 = 196, + CV_ARM64_Q17 = 197, + CV_ARM64_Q18 = 198, + CV_ARM64_Q19 = 199, + CV_ARM64_Q20 = 200, + CV_ARM64_Q21 = 201, + CV_ARM64_Q22 = 202, + CV_ARM64_Q23 = 203, + CV_ARM64_Q24 = 204, + CV_ARM64_Q25 = 205, + CV_ARM64_Q26 = 206, + CV_ARM64_Q27 = 207, + CV_ARM64_Q28 = 208, + CV_ARM64_Q29 = 209, + CV_ARM64_Q30 = 210, + CV_ARM64_Q31 = 211, + + // Floating point status register + + CV_ARM64_FPSR = 220, + CV_ARM64_FPCR = 221, + + // 8-bit floating point registers + + CV_ARM64_B0 = 230, + CV_ARM64_B1 = 231, + CV_ARM64_B2 = 232, + CV_ARM64_B3 = 233, + CV_ARM64_B4 = 234, + CV_ARM64_B5 = 235, + CV_ARM64_B6 = 236, + CV_ARM64_B7 = 237, + CV_ARM64_B8 = 238, + CV_ARM64_B9 = 239, + CV_ARM64_B10 = 240, + CV_ARM64_B11 = 241, + CV_ARM64_B12 = 242, + CV_ARM64_B13 = 243, + CV_ARM64_B14 = 244, + CV_ARM64_B15 = 245, + CV_ARM64_B16 = 246, + CV_ARM64_B17 = 247, + CV_ARM64_B18 = 248, + CV_ARM64_B19 = 249, + CV_ARM64_B20 = 250, + CV_ARM64_B21 = 251, + CV_ARM64_B22 = 252, + CV_ARM64_B23 = 253, + CV_ARM64_B24 = 254, + CV_ARM64_B25 = 255, + CV_ARM64_B26 = 256, + CV_ARM64_B27 = 257, + CV_ARM64_B28 = 258, + CV_ARM64_B29 = 259, + CV_ARM64_B30 = 260, + CV_ARM64_B31 = 261, + + // 16-bit floating point registers + + CV_ARM64_H0 = 270, + CV_ARM64_H1 = 271, + CV_ARM64_H2 = 272, + CV_ARM64_H3 = 273, + CV_ARM64_H4 = 274, + CV_ARM64_H5 = 275, + CV_ARM64_H6 = 276, + CV_ARM64_H7 = 277, + CV_ARM64_H8 = 278, + CV_ARM64_H9 = 279, + CV_ARM64_H10 = 280, + CV_ARM64_H11 = 281, + CV_ARM64_H12 = 282, + CV_ARM64_H13 = 283, + CV_ARM64_H14 = 284, + CV_ARM64_H15 = 285, + CV_ARM64_H16 = 286, + CV_ARM64_H17 = 287, + CV_ARM64_H18 = 288, + CV_ARM64_H19 = 289, + CV_ARM64_H20 = 290, + CV_ARM64_H21 = 291, + CV_ARM64_H22 = 292, + CV_ARM64_H23 = 293, + CV_ARM64_H24 = 294, + CV_ARM64_H25 = 295, + CV_ARM64_H26 = 296, + CV_ARM64_H27 = 297, + CV_ARM64_H28 = 298, + CV_ARM64_H29 = 299, + CV_ARM64_H30 = 300, + CV_ARM64_H31 = 301, + + // 128-bit vector registers + + CV_ARM64_V0 = 310, + CV_ARM64_V1 = 311, + CV_ARM64_V2 = 312, + CV_ARM64_V3 = 313, + CV_ARM64_V4 = 314, + CV_ARM64_V5 = 315, + CV_ARM64_V6 = 316, + CV_ARM64_V7 = 317, + CV_ARM64_V8 = 318, + CV_ARM64_V9 = 319, + CV_ARM64_V10 = 320, + CV_ARM64_V11 = 321, + CV_ARM64_V12 = 322, + CV_ARM64_V13 = 323, + CV_ARM64_V14 = 324, + CV_ARM64_V15 = 325, + CV_ARM64_V16 = 326, + CV_ARM64_V17 = 327, + CV_ARM64_V18 = 328, + CV_ARM64_V19 = 329, + CV_ARM64_V20 = 330, + CV_ARM64_V21 = 331, + CV_ARM64_V22 = 332, + CV_ARM64_V23 = 333, + CV_ARM64_V24 = 334, + CV_ARM64_V25 = 335, + CV_ARM64_V26 = 336, + CV_ARM64_V27 = 337, + CV_ARM64_V28 = 338, + CV_ARM64_V29 = 339, + CV_ARM64_V30 = 340, + CV_ARM64_V31 = 341, + + // 128-bit SIMD registers upper 64 bits + + CV_ARM64_Q0H = 350, + CV_ARM64_Q1H = 351, + CV_ARM64_Q2H = 352, + CV_ARM64_Q3H = 353, + CV_ARM64_Q4H = 354, + CV_ARM64_Q5H = 355, + CV_ARM64_Q6H = 356, + CV_ARM64_Q7H = 357, + CV_ARM64_Q8H = 358, + CV_ARM64_Q9H = 359, + CV_ARM64_Q10H = 360, + CV_ARM64_Q11H = 361, + CV_ARM64_Q12H = 362, + CV_ARM64_Q13H = 363, + CV_ARM64_Q14H = 364, + CV_ARM64_Q15H = 365, + CV_ARM64_Q16H = 366, + CV_ARM64_Q17H = 367, + CV_ARM64_Q18H = 368, + CV_ARM64_Q19H = 369, + CV_ARM64_Q20H = 370, + CV_ARM64_Q21H = 371, + CV_ARM64_Q22H = 372, + CV_ARM64_Q23H = 373, + CV_ARM64_Q24H = 374, + CV_ARM64_Q25H = 375, + CV_ARM64_Q26H = 376, + CV_ARM64_Q27H = 377, + CV_ARM64_Q28H = 378, + CV_ARM64_Q29H = 379, + CV_ARM64_Q30H = 380, + CV_ARM64_Q31H = 381, + + // + // Register set for Intel IA64 + // + + CV_IA64_NOREG = CV_REG_NONE, + + // Branch Registers + + CV_IA64_Br0 = 512, + CV_IA64_Br1 = 513, + CV_IA64_Br2 = 514, + CV_IA64_Br3 = 515, + CV_IA64_Br4 = 516, + CV_IA64_Br5 = 517, + CV_IA64_Br6 = 518, + CV_IA64_Br7 = 519, + + // Predicate Registers + + CV_IA64_P0 = 704, + CV_IA64_P1 = 705, + CV_IA64_P2 = 706, + CV_IA64_P3 = 707, + CV_IA64_P4 = 708, + CV_IA64_P5 = 709, + CV_IA64_P6 = 710, + CV_IA64_P7 = 711, + CV_IA64_P8 = 712, + CV_IA64_P9 = 713, + CV_IA64_P10 = 714, + CV_IA64_P11 = 715, + CV_IA64_P12 = 716, + CV_IA64_P13 = 717, + CV_IA64_P14 = 718, + CV_IA64_P15 = 719, + CV_IA64_P16 = 720, + CV_IA64_P17 = 721, + CV_IA64_P18 = 722, + CV_IA64_P19 = 723, + CV_IA64_P20 = 724, + CV_IA64_P21 = 725, + CV_IA64_P22 = 726, + CV_IA64_P23 = 727, + CV_IA64_P24 = 728, + CV_IA64_P25 = 729, + CV_IA64_P26 = 730, + CV_IA64_P27 = 731, + CV_IA64_P28 = 732, + CV_IA64_P29 = 733, + CV_IA64_P30 = 734, + CV_IA64_P31 = 735, + CV_IA64_P32 = 736, + CV_IA64_P33 = 737, + CV_IA64_P34 = 738, + CV_IA64_P35 = 739, + CV_IA64_P36 = 740, + CV_IA64_P37 = 741, + CV_IA64_P38 = 742, + CV_IA64_P39 = 743, + CV_IA64_P40 = 744, + CV_IA64_P41 = 745, + CV_IA64_P42 = 746, + CV_IA64_P43 = 747, + CV_IA64_P44 = 748, + CV_IA64_P45 = 749, + CV_IA64_P46 = 750, + CV_IA64_P47 = 751, + CV_IA64_P48 = 752, + CV_IA64_P49 = 753, + CV_IA64_P50 = 754, + CV_IA64_P51 = 755, + CV_IA64_P52 = 756, + CV_IA64_P53 = 757, + CV_IA64_P54 = 758, + CV_IA64_P55 = 759, + CV_IA64_P56 = 760, + CV_IA64_P57 = 761, + CV_IA64_P58 = 762, + CV_IA64_P59 = 763, + CV_IA64_P60 = 764, + CV_IA64_P61 = 765, + CV_IA64_P62 = 766, + CV_IA64_P63 = 767, + + CV_IA64_Preds = 768, + + // Banked General Registers + + CV_IA64_IntH0 = 832, + CV_IA64_IntH1 = 833, + CV_IA64_IntH2 = 834, + CV_IA64_IntH3 = 835, + CV_IA64_IntH4 = 836, + CV_IA64_IntH5 = 837, + CV_IA64_IntH6 = 838, + CV_IA64_IntH7 = 839, + CV_IA64_IntH8 = 840, + CV_IA64_IntH9 = 841, + CV_IA64_IntH10 = 842, + CV_IA64_IntH11 = 843, + CV_IA64_IntH12 = 844, + CV_IA64_IntH13 = 845, + CV_IA64_IntH14 = 846, + CV_IA64_IntH15 = 847, + + // Special Registers + + CV_IA64_Ip = 1016, + CV_IA64_Umask = 1017, + CV_IA64_Cfm = 1018, + CV_IA64_Psr = 1019, + + // Banked General Registers + + CV_IA64_Nats = 1020, + CV_IA64_Nats2 = 1021, + CV_IA64_Nats3 = 1022, + + // General-Purpose Registers + + // Integer registers + CV_IA64_IntR0 = 1024, + CV_IA64_IntR1 = 1025, + CV_IA64_IntR2 = 1026, + CV_IA64_IntR3 = 1027, + CV_IA64_IntR4 = 1028, + CV_IA64_IntR5 = 1029, + CV_IA64_IntR6 = 1030, + CV_IA64_IntR7 = 1031, + CV_IA64_IntR8 = 1032, + CV_IA64_IntR9 = 1033, + CV_IA64_IntR10 = 1034, + CV_IA64_IntR11 = 1035, + CV_IA64_IntR12 = 1036, + CV_IA64_IntR13 = 1037, + CV_IA64_IntR14 = 1038, + CV_IA64_IntR15 = 1039, + CV_IA64_IntR16 = 1040, + CV_IA64_IntR17 = 1041, + CV_IA64_IntR18 = 1042, + CV_IA64_IntR19 = 1043, + CV_IA64_IntR20 = 1044, + CV_IA64_IntR21 = 1045, + CV_IA64_IntR22 = 1046, + CV_IA64_IntR23 = 1047, + CV_IA64_IntR24 = 1048, + CV_IA64_IntR25 = 1049, + CV_IA64_IntR26 = 1050, + CV_IA64_IntR27 = 1051, + CV_IA64_IntR28 = 1052, + CV_IA64_IntR29 = 1053, + CV_IA64_IntR30 = 1054, + CV_IA64_IntR31 = 1055, + + // Register Stack + CV_IA64_IntR32 = 1056, + CV_IA64_IntR33 = 1057, + CV_IA64_IntR34 = 1058, + CV_IA64_IntR35 = 1059, + CV_IA64_IntR36 = 1060, + CV_IA64_IntR37 = 1061, + CV_IA64_IntR38 = 1062, + CV_IA64_IntR39 = 1063, + CV_IA64_IntR40 = 1064, + CV_IA64_IntR41 = 1065, + CV_IA64_IntR42 = 1066, + CV_IA64_IntR43 = 1067, + CV_IA64_IntR44 = 1068, + CV_IA64_IntR45 = 1069, + CV_IA64_IntR46 = 1070, + CV_IA64_IntR47 = 1071, + CV_IA64_IntR48 = 1072, + CV_IA64_IntR49 = 1073, + CV_IA64_IntR50 = 1074, + CV_IA64_IntR51 = 1075, + CV_IA64_IntR52 = 1076, + CV_IA64_IntR53 = 1077, + CV_IA64_IntR54 = 1078, + CV_IA64_IntR55 = 1079, + CV_IA64_IntR56 = 1080, + CV_IA64_IntR57 = 1081, + CV_IA64_IntR58 = 1082, + CV_IA64_IntR59 = 1083, + CV_IA64_IntR60 = 1084, + CV_IA64_IntR61 = 1085, + CV_IA64_IntR62 = 1086, + CV_IA64_IntR63 = 1087, + CV_IA64_IntR64 = 1088, + CV_IA64_IntR65 = 1089, + CV_IA64_IntR66 = 1090, + CV_IA64_IntR67 = 1091, + CV_IA64_IntR68 = 1092, + CV_IA64_IntR69 = 1093, + CV_IA64_IntR70 = 1094, + CV_IA64_IntR71 = 1095, + CV_IA64_IntR72 = 1096, + CV_IA64_IntR73 = 1097, + CV_IA64_IntR74 = 1098, + CV_IA64_IntR75 = 1099, + CV_IA64_IntR76 = 1100, + CV_IA64_IntR77 = 1101, + CV_IA64_IntR78 = 1102, + CV_IA64_IntR79 = 1103, + CV_IA64_IntR80 = 1104, + CV_IA64_IntR81 = 1105, + CV_IA64_IntR82 = 1106, + CV_IA64_IntR83 = 1107, + CV_IA64_IntR84 = 1108, + CV_IA64_IntR85 = 1109, + CV_IA64_IntR86 = 1110, + CV_IA64_IntR87 = 1111, + CV_IA64_IntR88 = 1112, + CV_IA64_IntR89 = 1113, + CV_IA64_IntR90 = 1114, + CV_IA64_IntR91 = 1115, + CV_IA64_IntR92 = 1116, + CV_IA64_IntR93 = 1117, + CV_IA64_IntR94 = 1118, + CV_IA64_IntR95 = 1119, + CV_IA64_IntR96 = 1120, + CV_IA64_IntR97 = 1121, + CV_IA64_IntR98 = 1122, + CV_IA64_IntR99 = 1123, + CV_IA64_IntR100 = 1124, + CV_IA64_IntR101 = 1125, + CV_IA64_IntR102 = 1126, + CV_IA64_IntR103 = 1127, + CV_IA64_IntR104 = 1128, + CV_IA64_IntR105 = 1129, + CV_IA64_IntR106 = 1130, + CV_IA64_IntR107 = 1131, + CV_IA64_IntR108 = 1132, + CV_IA64_IntR109 = 1133, + CV_IA64_IntR110 = 1134, + CV_IA64_IntR111 = 1135, + CV_IA64_IntR112 = 1136, + CV_IA64_IntR113 = 1137, + CV_IA64_IntR114 = 1138, + CV_IA64_IntR115 = 1139, + CV_IA64_IntR116 = 1140, + CV_IA64_IntR117 = 1141, + CV_IA64_IntR118 = 1142, + CV_IA64_IntR119 = 1143, + CV_IA64_IntR120 = 1144, + CV_IA64_IntR121 = 1145, + CV_IA64_IntR122 = 1146, + CV_IA64_IntR123 = 1147, + CV_IA64_IntR124 = 1148, + CV_IA64_IntR125 = 1149, + CV_IA64_IntR126 = 1150, + CV_IA64_IntR127 = 1151, + + // Floating-Point Registers + + // Low Floating Point Registers + CV_IA64_FltF0 = 2048, + CV_IA64_FltF1 = 2049, + CV_IA64_FltF2 = 2050, + CV_IA64_FltF3 = 2051, + CV_IA64_FltF4 = 2052, + CV_IA64_FltF5 = 2053, + CV_IA64_FltF6 = 2054, + CV_IA64_FltF7 = 2055, + CV_IA64_FltF8 = 2056, + CV_IA64_FltF9 = 2057, + CV_IA64_FltF10 = 2058, + CV_IA64_FltF11 = 2059, + CV_IA64_FltF12 = 2060, + CV_IA64_FltF13 = 2061, + CV_IA64_FltF14 = 2062, + CV_IA64_FltF15 = 2063, + CV_IA64_FltF16 = 2064, + CV_IA64_FltF17 = 2065, + CV_IA64_FltF18 = 2066, + CV_IA64_FltF19 = 2067, + CV_IA64_FltF20 = 2068, + CV_IA64_FltF21 = 2069, + CV_IA64_FltF22 = 2070, + CV_IA64_FltF23 = 2071, + CV_IA64_FltF24 = 2072, + CV_IA64_FltF25 = 2073, + CV_IA64_FltF26 = 2074, + CV_IA64_FltF27 = 2075, + CV_IA64_FltF28 = 2076, + CV_IA64_FltF29 = 2077, + CV_IA64_FltF30 = 2078, + CV_IA64_FltF31 = 2079, + + // High Floating Point Registers + CV_IA64_FltF32 = 2080, + CV_IA64_FltF33 = 2081, + CV_IA64_FltF34 = 2082, + CV_IA64_FltF35 = 2083, + CV_IA64_FltF36 = 2084, + CV_IA64_FltF37 = 2085, + CV_IA64_FltF38 = 2086, + CV_IA64_FltF39 = 2087, + CV_IA64_FltF40 = 2088, + CV_IA64_FltF41 = 2089, + CV_IA64_FltF42 = 2090, + CV_IA64_FltF43 = 2091, + CV_IA64_FltF44 = 2092, + CV_IA64_FltF45 = 2093, + CV_IA64_FltF46 = 2094, + CV_IA64_FltF47 = 2095, + CV_IA64_FltF48 = 2096, + CV_IA64_FltF49 = 2097, + CV_IA64_FltF50 = 2098, + CV_IA64_FltF51 = 2099, + CV_IA64_FltF52 = 2100, + CV_IA64_FltF53 = 2101, + CV_IA64_FltF54 = 2102, + CV_IA64_FltF55 = 2103, + CV_IA64_FltF56 = 2104, + CV_IA64_FltF57 = 2105, + CV_IA64_FltF58 = 2106, + CV_IA64_FltF59 = 2107, + CV_IA64_FltF60 = 2108, + CV_IA64_FltF61 = 2109, + CV_IA64_FltF62 = 2110, + CV_IA64_FltF63 = 2111, + CV_IA64_FltF64 = 2112, + CV_IA64_FltF65 = 2113, + CV_IA64_FltF66 = 2114, + CV_IA64_FltF67 = 2115, + CV_IA64_FltF68 = 2116, + CV_IA64_FltF69 = 2117, + CV_IA64_FltF70 = 2118, + CV_IA64_FltF71 = 2119, + CV_IA64_FltF72 = 2120, + CV_IA64_FltF73 = 2121, + CV_IA64_FltF74 = 2122, + CV_IA64_FltF75 = 2123, + CV_IA64_FltF76 = 2124, + CV_IA64_FltF77 = 2125, + CV_IA64_FltF78 = 2126, + CV_IA64_FltF79 = 2127, + CV_IA64_FltF80 = 2128, + CV_IA64_FltF81 = 2129, + CV_IA64_FltF82 = 2130, + CV_IA64_FltF83 = 2131, + CV_IA64_FltF84 = 2132, + CV_IA64_FltF85 = 2133, + CV_IA64_FltF86 = 2134, + CV_IA64_FltF87 = 2135, + CV_IA64_FltF88 = 2136, + CV_IA64_FltF89 = 2137, + CV_IA64_FltF90 = 2138, + CV_IA64_FltF91 = 2139, + CV_IA64_FltF92 = 2140, + CV_IA64_FltF93 = 2141, + CV_IA64_FltF94 = 2142, + CV_IA64_FltF95 = 2143, + CV_IA64_FltF96 = 2144, + CV_IA64_FltF97 = 2145, + CV_IA64_FltF98 = 2146, + CV_IA64_FltF99 = 2147, + CV_IA64_FltF100 = 2148, + CV_IA64_FltF101 = 2149, + CV_IA64_FltF102 = 2150, + CV_IA64_FltF103 = 2151, + CV_IA64_FltF104 = 2152, + CV_IA64_FltF105 = 2153, + CV_IA64_FltF106 = 2154, + CV_IA64_FltF107 = 2155, + CV_IA64_FltF108 = 2156, + CV_IA64_FltF109 = 2157, + CV_IA64_FltF110 = 2158, + CV_IA64_FltF111 = 2159, + CV_IA64_FltF112 = 2160, + CV_IA64_FltF113 = 2161, + CV_IA64_FltF114 = 2162, + CV_IA64_FltF115 = 2163, + CV_IA64_FltF116 = 2164, + CV_IA64_FltF117 = 2165, + CV_IA64_FltF118 = 2166, + CV_IA64_FltF119 = 2167, + CV_IA64_FltF120 = 2168, + CV_IA64_FltF121 = 2169, + CV_IA64_FltF122 = 2170, + CV_IA64_FltF123 = 2171, + CV_IA64_FltF124 = 2172, + CV_IA64_FltF125 = 2173, + CV_IA64_FltF126 = 2174, + CV_IA64_FltF127 = 2175, + + // Application Registers + + CV_IA64_ApKR0 = 3072, + CV_IA64_ApKR1 = 3073, + CV_IA64_ApKR2 = 3074, + CV_IA64_ApKR3 = 3075, + CV_IA64_ApKR4 = 3076, + CV_IA64_ApKR5 = 3077, + CV_IA64_ApKR6 = 3078, + CV_IA64_ApKR7 = 3079, + CV_IA64_AR8 = 3080, + CV_IA64_AR9 = 3081, + CV_IA64_AR10 = 3082, + CV_IA64_AR11 = 3083, + CV_IA64_AR12 = 3084, + CV_IA64_AR13 = 3085, + CV_IA64_AR14 = 3086, + CV_IA64_AR15 = 3087, + CV_IA64_RsRSC = 3088, + CV_IA64_RsBSP = 3089, + CV_IA64_RsBSPSTORE = 3090, + CV_IA64_RsRNAT = 3091, + CV_IA64_AR20 = 3092, + CV_IA64_StFCR = 3093, + CV_IA64_AR22 = 3094, + CV_IA64_AR23 = 3095, + CV_IA64_EFLAG = 3096, + CV_IA64_CSD = 3097, + CV_IA64_SSD = 3098, + CV_IA64_CFLG = 3099, + CV_IA64_StFSR = 3100, + CV_IA64_StFIR = 3101, + CV_IA64_StFDR = 3102, + CV_IA64_AR31 = 3103, + CV_IA64_ApCCV = 3104, + CV_IA64_AR33 = 3105, + CV_IA64_AR34 = 3106, + CV_IA64_AR35 = 3107, + CV_IA64_ApUNAT = 3108, + CV_IA64_AR37 = 3109, + CV_IA64_AR38 = 3110, + CV_IA64_AR39 = 3111, + CV_IA64_StFPSR = 3112, + CV_IA64_AR41 = 3113, + CV_IA64_AR42 = 3114, + CV_IA64_AR43 = 3115, + CV_IA64_ApITC = 3116, + CV_IA64_AR45 = 3117, + CV_IA64_AR46 = 3118, + CV_IA64_AR47 = 3119, + CV_IA64_AR48 = 3120, + CV_IA64_AR49 = 3121, + CV_IA64_AR50 = 3122, + CV_IA64_AR51 = 3123, + CV_IA64_AR52 = 3124, + CV_IA64_AR53 = 3125, + CV_IA64_AR54 = 3126, + CV_IA64_AR55 = 3127, + CV_IA64_AR56 = 3128, + CV_IA64_AR57 = 3129, + CV_IA64_AR58 = 3130, + CV_IA64_AR59 = 3131, + CV_IA64_AR60 = 3132, + CV_IA64_AR61 = 3133, + CV_IA64_AR62 = 3134, + CV_IA64_AR63 = 3135, + CV_IA64_RsPFS = 3136, + CV_IA64_ApLC = 3137, + CV_IA64_ApEC = 3138, + CV_IA64_AR67 = 3139, + CV_IA64_AR68 = 3140, + CV_IA64_AR69 = 3141, + CV_IA64_AR70 = 3142, + CV_IA64_AR71 = 3143, + CV_IA64_AR72 = 3144, + CV_IA64_AR73 = 3145, + CV_IA64_AR74 = 3146, + CV_IA64_AR75 = 3147, + CV_IA64_AR76 = 3148, + CV_IA64_AR77 = 3149, + CV_IA64_AR78 = 3150, + CV_IA64_AR79 = 3151, + CV_IA64_AR80 = 3152, + CV_IA64_AR81 = 3153, + CV_IA64_AR82 = 3154, + CV_IA64_AR83 = 3155, + CV_IA64_AR84 = 3156, + CV_IA64_AR85 = 3157, + CV_IA64_AR86 = 3158, + CV_IA64_AR87 = 3159, + CV_IA64_AR88 = 3160, + CV_IA64_AR89 = 3161, + CV_IA64_AR90 = 3162, + CV_IA64_AR91 = 3163, + CV_IA64_AR92 = 3164, + CV_IA64_AR93 = 3165, + CV_IA64_AR94 = 3166, + CV_IA64_AR95 = 3167, + CV_IA64_AR96 = 3168, + CV_IA64_AR97 = 3169, + CV_IA64_AR98 = 3170, + CV_IA64_AR99 = 3171, + CV_IA64_AR100 = 3172, + CV_IA64_AR101 = 3173, + CV_IA64_AR102 = 3174, + CV_IA64_AR103 = 3175, + CV_IA64_AR104 = 3176, + CV_IA64_AR105 = 3177, + CV_IA64_AR106 = 3178, + CV_IA64_AR107 = 3179, + CV_IA64_AR108 = 3180, + CV_IA64_AR109 = 3181, + CV_IA64_AR110 = 3182, + CV_IA64_AR111 = 3183, + CV_IA64_AR112 = 3184, + CV_IA64_AR113 = 3185, + CV_IA64_AR114 = 3186, + CV_IA64_AR115 = 3187, + CV_IA64_AR116 = 3188, + CV_IA64_AR117 = 3189, + CV_IA64_AR118 = 3190, + CV_IA64_AR119 = 3191, + CV_IA64_AR120 = 3192, + CV_IA64_AR121 = 3193, + CV_IA64_AR122 = 3194, + CV_IA64_AR123 = 3195, + CV_IA64_AR124 = 3196, + CV_IA64_AR125 = 3197, + CV_IA64_AR126 = 3198, + CV_IA64_AR127 = 3199, + + // CPUID Registers + + CV_IA64_CPUID0 = 3328, + CV_IA64_CPUID1 = 3329, + CV_IA64_CPUID2 = 3330, + CV_IA64_CPUID3 = 3331, + CV_IA64_CPUID4 = 3332, + + // Control Registers + + CV_IA64_ApDCR = 4096, + CV_IA64_ApITM = 4097, + CV_IA64_ApIVA = 4098, + CV_IA64_CR3 = 4099, + CV_IA64_CR4 = 4100, + CV_IA64_CR5 = 4101, + CV_IA64_CR6 = 4102, + CV_IA64_CR7 = 4103, + CV_IA64_ApPTA = 4104, + CV_IA64_ApGPTA = 4105, + CV_IA64_CR10 = 4106, + CV_IA64_CR11 = 4107, + CV_IA64_CR12 = 4108, + CV_IA64_CR13 = 4109, + CV_IA64_CR14 = 4110, + CV_IA64_CR15 = 4111, + CV_IA64_StIPSR = 4112, + CV_IA64_StISR = 4113, + CV_IA64_CR18 = 4114, + CV_IA64_StIIP = 4115, + CV_IA64_StIFA = 4116, + CV_IA64_StITIR = 4117, + CV_IA64_StIIPA = 4118, + CV_IA64_StIFS = 4119, + CV_IA64_StIIM = 4120, + CV_IA64_StIHA = 4121, + CV_IA64_CR26 = 4122, + CV_IA64_CR27 = 4123, + CV_IA64_CR28 = 4124, + CV_IA64_CR29 = 4125, + CV_IA64_CR30 = 4126, + CV_IA64_CR31 = 4127, + CV_IA64_CR32 = 4128, + CV_IA64_CR33 = 4129, + CV_IA64_CR34 = 4130, + CV_IA64_CR35 = 4131, + CV_IA64_CR36 = 4132, + CV_IA64_CR37 = 4133, + CV_IA64_CR38 = 4134, + CV_IA64_CR39 = 4135, + CV_IA64_CR40 = 4136, + CV_IA64_CR41 = 4137, + CV_IA64_CR42 = 4138, + CV_IA64_CR43 = 4139, + CV_IA64_CR44 = 4140, + CV_IA64_CR45 = 4141, + CV_IA64_CR46 = 4142, + CV_IA64_CR47 = 4143, + CV_IA64_CR48 = 4144, + CV_IA64_CR49 = 4145, + CV_IA64_CR50 = 4146, + CV_IA64_CR51 = 4147, + CV_IA64_CR52 = 4148, + CV_IA64_CR53 = 4149, + CV_IA64_CR54 = 4150, + CV_IA64_CR55 = 4151, + CV_IA64_CR56 = 4152, + CV_IA64_CR57 = 4153, + CV_IA64_CR58 = 4154, + CV_IA64_CR59 = 4155, + CV_IA64_CR60 = 4156, + CV_IA64_CR61 = 4157, + CV_IA64_CR62 = 4158, + CV_IA64_CR63 = 4159, + CV_IA64_SaLID = 4160, + CV_IA64_SaIVR = 4161, + CV_IA64_SaTPR = 4162, + CV_IA64_SaEOI = 4163, + CV_IA64_SaIRR0 = 4164, + CV_IA64_SaIRR1 = 4165, + CV_IA64_SaIRR2 = 4166, + CV_IA64_SaIRR3 = 4167, + CV_IA64_SaITV = 4168, + CV_IA64_SaPMV = 4169, + CV_IA64_SaCMCV = 4170, + CV_IA64_CR75 = 4171, + CV_IA64_CR76 = 4172, + CV_IA64_CR77 = 4173, + CV_IA64_CR78 = 4174, + CV_IA64_CR79 = 4175, + CV_IA64_SaLRR0 = 4176, + CV_IA64_SaLRR1 = 4177, + CV_IA64_CR82 = 4178, + CV_IA64_CR83 = 4179, + CV_IA64_CR84 = 4180, + CV_IA64_CR85 = 4181, + CV_IA64_CR86 = 4182, + CV_IA64_CR87 = 4183, + CV_IA64_CR88 = 4184, + CV_IA64_CR89 = 4185, + CV_IA64_CR90 = 4186, + CV_IA64_CR91 = 4187, + CV_IA64_CR92 = 4188, + CV_IA64_CR93 = 4189, + CV_IA64_CR94 = 4190, + CV_IA64_CR95 = 4191, + CV_IA64_CR96 = 4192, + CV_IA64_CR97 = 4193, + CV_IA64_CR98 = 4194, + CV_IA64_CR99 = 4195, + CV_IA64_CR100 = 4196, + CV_IA64_CR101 = 4197, + CV_IA64_CR102 = 4198, + CV_IA64_CR103 = 4199, + CV_IA64_CR104 = 4200, + CV_IA64_CR105 = 4201, + CV_IA64_CR106 = 4202, + CV_IA64_CR107 = 4203, + CV_IA64_CR108 = 4204, + CV_IA64_CR109 = 4205, + CV_IA64_CR110 = 4206, + CV_IA64_CR111 = 4207, + CV_IA64_CR112 = 4208, + CV_IA64_CR113 = 4209, + CV_IA64_CR114 = 4210, + CV_IA64_CR115 = 4211, + CV_IA64_CR116 = 4212, + CV_IA64_CR117 = 4213, + CV_IA64_CR118 = 4214, + CV_IA64_CR119 = 4215, + CV_IA64_CR120 = 4216, + CV_IA64_CR121 = 4217, + CV_IA64_CR122 = 4218, + CV_IA64_CR123 = 4219, + CV_IA64_CR124 = 4220, + CV_IA64_CR125 = 4221, + CV_IA64_CR126 = 4222, + CV_IA64_CR127 = 4223, + + // Protection Key Registers + + CV_IA64_Pkr0 = 5120, + CV_IA64_Pkr1 = 5121, + CV_IA64_Pkr2 = 5122, + CV_IA64_Pkr3 = 5123, + CV_IA64_Pkr4 = 5124, + CV_IA64_Pkr5 = 5125, + CV_IA64_Pkr6 = 5126, + CV_IA64_Pkr7 = 5127, + CV_IA64_Pkr8 = 5128, + CV_IA64_Pkr9 = 5129, + CV_IA64_Pkr10 = 5130, + CV_IA64_Pkr11 = 5131, + CV_IA64_Pkr12 = 5132, + CV_IA64_Pkr13 = 5133, + CV_IA64_Pkr14 = 5134, + CV_IA64_Pkr15 = 5135, + + // Region Registers + + CV_IA64_Rr0 = 6144, + CV_IA64_Rr1 = 6145, + CV_IA64_Rr2 = 6146, + CV_IA64_Rr3 = 6147, + CV_IA64_Rr4 = 6148, + CV_IA64_Rr5 = 6149, + CV_IA64_Rr6 = 6150, + CV_IA64_Rr7 = 6151, + + // Performance Monitor Data Registers + + CV_IA64_PFD0 = 7168, + CV_IA64_PFD1 = 7169, + CV_IA64_PFD2 = 7170, + CV_IA64_PFD3 = 7171, + CV_IA64_PFD4 = 7172, + CV_IA64_PFD5 = 7173, + CV_IA64_PFD6 = 7174, + CV_IA64_PFD7 = 7175, + CV_IA64_PFD8 = 7176, + CV_IA64_PFD9 = 7177, + CV_IA64_PFD10 = 7178, + CV_IA64_PFD11 = 7179, + CV_IA64_PFD12 = 7180, + CV_IA64_PFD13 = 7181, + CV_IA64_PFD14 = 7182, + CV_IA64_PFD15 = 7183, + CV_IA64_PFD16 = 7184, + CV_IA64_PFD17 = 7185, + + // Performance Monitor Config Registers + + CV_IA64_PFC0 = 7424, + CV_IA64_PFC1 = 7425, + CV_IA64_PFC2 = 7426, + CV_IA64_PFC3 = 7427, + CV_IA64_PFC4 = 7428, + CV_IA64_PFC5 = 7429, + CV_IA64_PFC6 = 7430, + CV_IA64_PFC7 = 7431, + CV_IA64_PFC8 = 7432, + CV_IA64_PFC9 = 7433, + CV_IA64_PFC10 = 7434, + CV_IA64_PFC11 = 7435, + CV_IA64_PFC12 = 7436, + CV_IA64_PFC13 = 7437, + CV_IA64_PFC14 = 7438, + CV_IA64_PFC15 = 7439, + + // Instruction Translation Registers + + CV_IA64_TrI0 = 8192, + CV_IA64_TrI1 = 8193, + CV_IA64_TrI2 = 8194, + CV_IA64_TrI3 = 8195, + CV_IA64_TrI4 = 8196, + CV_IA64_TrI5 = 8197, + CV_IA64_TrI6 = 8198, + CV_IA64_TrI7 = 8199, + + // Data Translation Registers + + CV_IA64_TrD0 = 8320, + CV_IA64_TrD1 = 8321, + CV_IA64_TrD2 = 8322, + CV_IA64_TrD3 = 8323, + CV_IA64_TrD4 = 8324, + CV_IA64_TrD5 = 8325, + CV_IA64_TrD6 = 8326, + CV_IA64_TrD7 = 8327, + + // Instruction Breakpoint Registers + + CV_IA64_DbI0 = 8448, + CV_IA64_DbI1 = 8449, + CV_IA64_DbI2 = 8450, + CV_IA64_DbI3 = 8451, + CV_IA64_DbI4 = 8452, + CV_IA64_DbI5 = 8453, + CV_IA64_DbI6 = 8454, + CV_IA64_DbI7 = 8455, + + // Data Breakpoint Registers + + CV_IA64_DbD0 = 8576, + CV_IA64_DbD1 = 8577, + CV_IA64_DbD2 = 8578, + CV_IA64_DbD3 = 8579, + CV_IA64_DbD4 = 8580, + CV_IA64_DbD5 = 8581, + CV_IA64_DbD6 = 8582, + CV_IA64_DbD7 = 8583, + + // + // Register set for the TriCore processor. + // + + CV_TRI_NOREG = CV_REG_NONE, + + // General Purpose Data Registers + + CV_TRI_D0 = 10, + CV_TRI_D1 = 11, + CV_TRI_D2 = 12, + CV_TRI_D3 = 13, + CV_TRI_D4 = 14, + CV_TRI_D5 = 15, + CV_TRI_D6 = 16, + CV_TRI_D7 = 17, + CV_TRI_D8 = 18, + CV_TRI_D9 = 19, + CV_TRI_D10 = 20, + CV_TRI_D11 = 21, + CV_TRI_D12 = 22, + CV_TRI_D13 = 23, + CV_TRI_D14 = 24, + CV_TRI_D15 = 25, + + // General Purpose Address Registers + + CV_TRI_A0 = 26, + CV_TRI_A1 = 27, + CV_TRI_A2 = 28, + CV_TRI_A3 = 29, + CV_TRI_A4 = 30, + CV_TRI_A5 = 31, + CV_TRI_A6 = 32, + CV_TRI_A7 = 33, + CV_TRI_A8 = 34, + CV_TRI_A9 = 35, + CV_TRI_A10 = 36, + CV_TRI_A11 = 37, + CV_TRI_A12 = 38, + CV_TRI_A13 = 39, + CV_TRI_A14 = 40, + CV_TRI_A15 = 41, + + // Extended (64-bit) data registers + + CV_TRI_E0 = 42, + CV_TRI_E2 = 43, + CV_TRI_E4 = 44, + CV_TRI_E6 = 45, + CV_TRI_E8 = 46, + CV_TRI_E10 = 47, + CV_TRI_E12 = 48, + CV_TRI_E14 = 49, + + // Extended (64-bit) address registers + + CV_TRI_EA0 = 50, + CV_TRI_EA2 = 51, + CV_TRI_EA4 = 52, + CV_TRI_EA6 = 53, + CV_TRI_EA8 = 54, + CV_TRI_EA10 = 55, + CV_TRI_EA12 = 56, + CV_TRI_EA14 = 57, + + CV_TRI_PSW = 58, + CV_TRI_PCXI = 59, + CV_TRI_PC = 60, + CV_TRI_FCX = 61, + CV_TRI_LCX = 62, + CV_TRI_ISP = 63, + CV_TRI_ICR = 64, + CV_TRI_BIV = 65, + CV_TRI_BTV = 66, + CV_TRI_SYSCON = 67, + CV_TRI_DPRx_0 = 68, + CV_TRI_DPRx_1 = 69, + CV_TRI_DPRx_2 = 70, + CV_TRI_DPRx_3 = 71, + CV_TRI_CPRx_0 = 68, + CV_TRI_CPRx_1 = 69, + CV_TRI_CPRx_2 = 70, + CV_TRI_CPRx_3 = 71, + CV_TRI_DPMx_0 = 68, + CV_TRI_DPMx_1 = 69, + CV_TRI_DPMx_2 = 70, + CV_TRI_DPMx_3 = 71, + CV_TRI_CPMx_0 = 68, + CV_TRI_CPMx_1 = 69, + CV_TRI_CPMx_2 = 70, + CV_TRI_CPMx_3 = 71, + CV_TRI_DBGSSR = 72, + CV_TRI_EXEVT = 73, + CV_TRI_SWEVT = 74, + CV_TRI_CREVT = 75, + CV_TRI_TRnEVT = 76, + CV_TRI_MMUCON = 77, + CV_TRI_ASI = 78, + CV_TRI_TVA = 79, + CV_TRI_TPA = 80, + CV_TRI_TPX = 81, + CV_TRI_TFA = 82, + + // + // Register set for the AM33 and related processors. + // + + CV_AM33_NOREG = CV_REG_NONE, + + // "Extended" (general purpose integer) registers + CV_AM33_E0 = 10, + CV_AM33_E1 = 11, + CV_AM33_E2 = 12, + CV_AM33_E3 = 13, + CV_AM33_E4 = 14, + CV_AM33_E5 = 15, + CV_AM33_E6 = 16, + CV_AM33_E7 = 17, + + // Address registers + CV_AM33_A0 = 20, + CV_AM33_A1 = 21, + CV_AM33_A2 = 22, + CV_AM33_A3 = 23, + + // Integer data registers + CV_AM33_D0 = 30, + CV_AM33_D1 = 31, + CV_AM33_D2 = 32, + CV_AM33_D3 = 33, + + // (Single-precision) floating-point registers + CV_AM33_FS0 = 40, + CV_AM33_FS1 = 41, + CV_AM33_FS2 = 42, + CV_AM33_FS3 = 43, + CV_AM33_FS4 = 44, + CV_AM33_FS5 = 45, + CV_AM33_FS6 = 46, + CV_AM33_FS7 = 47, + CV_AM33_FS8 = 48, + CV_AM33_FS9 = 49, + CV_AM33_FS10 = 50, + CV_AM33_FS11 = 51, + CV_AM33_FS12 = 52, + CV_AM33_FS13 = 53, + CV_AM33_FS14 = 54, + CV_AM33_FS15 = 55, + CV_AM33_FS16 = 56, + CV_AM33_FS17 = 57, + CV_AM33_FS18 = 58, + CV_AM33_FS19 = 59, + CV_AM33_FS20 = 60, + CV_AM33_FS21 = 61, + CV_AM33_FS22 = 62, + CV_AM33_FS23 = 63, + CV_AM33_FS24 = 64, + CV_AM33_FS25 = 65, + CV_AM33_FS26 = 66, + CV_AM33_FS27 = 67, + CV_AM33_FS28 = 68, + CV_AM33_FS29 = 69, + CV_AM33_FS30 = 70, + CV_AM33_FS31 = 71, + + // Special purpose registers + + // Stack pointer + CV_AM33_SP = 80, + + // Program counter + CV_AM33_PC = 81, + + // Multiply-divide/accumulate registers + CV_AM33_MDR = 82, + CV_AM33_MDRQ = 83, + CV_AM33_MCRH = 84, + CV_AM33_MCRL = 85, + CV_AM33_MCVF = 86, + + // CPU status words + CV_AM33_EPSW = 87, + CV_AM33_FPCR = 88, + + // Loop buffer registers + CV_AM33_LIR = 89, + CV_AM33_LAR = 90, + + // + // Register set for the Mitsubishi M32R + // + + CV_M32R_NOREG = CV_REG_NONE, + + CV_M32R_R0 = 10, + CV_M32R_R1 = 11, + CV_M32R_R2 = 12, + CV_M32R_R3 = 13, + CV_M32R_R4 = 14, + CV_M32R_R5 = 15, + CV_M32R_R6 = 16, + CV_M32R_R7 = 17, + CV_M32R_R8 = 18, + CV_M32R_R9 = 19, + CV_M32R_R10 = 20, + CV_M32R_R11 = 21, + CV_M32R_R12 = 22, // Gloabal Pointer, if used + CV_M32R_R13 = 23, // Frame Pointer, if allocated + CV_M32R_R14 = 24, // Link Register + CV_M32R_R15 = 25, // Stack Pointer + CV_M32R_PSW = 26, // Preocessor Status Register + CV_M32R_CBR = 27, // Condition Bit Register + CV_M32R_SPI = 28, // Interrupt Stack Pointer + CV_M32R_SPU = 29, // User Stack Pointer + CV_M32R_SPO = 30, // OS Stack Pointer + CV_M32R_BPC = 31, // Backup Program Counter + CV_M32R_ACHI = 32, // Accumulator High + CV_M32R_ACLO = 33, // Accumulator Low + CV_M32R_PC = 34, // Program Counter + + // + // Register set for the SuperH SHMedia processor including compact + // mode + // + + // Integer - 64 bit general registers + CV_SHMEDIA_NOREG = CV_REG_NONE, + CV_SHMEDIA_R0 = 10, + CV_SHMEDIA_R1 = 11, + CV_SHMEDIA_R2 = 12, + CV_SHMEDIA_R3 = 13, + CV_SHMEDIA_R4 = 14, + CV_SHMEDIA_R5 = 15, + CV_SHMEDIA_R6 = 16, + CV_SHMEDIA_R7 = 17, + CV_SHMEDIA_R8 = 18, + CV_SHMEDIA_R9 = 19, + CV_SHMEDIA_R10 = 20, + CV_SHMEDIA_R11 = 21, + CV_SHMEDIA_R12 = 22, + CV_SHMEDIA_R13 = 23, + CV_SHMEDIA_R14 = 24, + CV_SHMEDIA_R15 = 25, + CV_SHMEDIA_R16 = 26, + CV_SHMEDIA_R17 = 27, + CV_SHMEDIA_R18 = 28, + CV_SHMEDIA_R19 = 29, + CV_SHMEDIA_R20 = 30, + CV_SHMEDIA_R21 = 31, + CV_SHMEDIA_R22 = 32, + CV_SHMEDIA_R23 = 33, + CV_SHMEDIA_R24 = 34, + CV_SHMEDIA_R25 = 35, + CV_SHMEDIA_R26 = 36, + CV_SHMEDIA_R27 = 37, + CV_SHMEDIA_R28 = 38, + CV_SHMEDIA_R29 = 39, + CV_SHMEDIA_R30 = 40, + CV_SHMEDIA_R31 = 41, + CV_SHMEDIA_R32 = 42, + CV_SHMEDIA_R33 = 43, + CV_SHMEDIA_R34 = 44, + CV_SHMEDIA_R35 = 45, + CV_SHMEDIA_R36 = 46, + CV_SHMEDIA_R37 = 47, + CV_SHMEDIA_R38 = 48, + CV_SHMEDIA_R39 = 49, + CV_SHMEDIA_R40 = 50, + CV_SHMEDIA_R41 = 51, + CV_SHMEDIA_R42 = 52, + CV_SHMEDIA_R43 = 53, + CV_SHMEDIA_R44 = 54, + CV_SHMEDIA_R45 = 55, + CV_SHMEDIA_R46 = 56, + CV_SHMEDIA_R47 = 57, + CV_SHMEDIA_R48 = 58, + CV_SHMEDIA_R49 = 59, + CV_SHMEDIA_R50 = 60, + CV_SHMEDIA_R51 = 61, + CV_SHMEDIA_R52 = 62, + CV_SHMEDIA_R53 = 63, + CV_SHMEDIA_R54 = 64, + CV_SHMEDIA_R55 = 65, + CV_SHMEDIA_R56 = 66, + CV_SHMEDIA_R57 = 67, + CV_SHMEDIA_R58 = 68, + CV_SHMEDIA_R59 = 69, + CV_SHMEDIA_R60 = 70, + CV_SHMEDIA_R61 = 71, + CV_SHMEDIA_R62 = 72, + CV_SHMEDIA_R63 = 73, + + // Target Registers - 32 bit + CV_SHMEDIA_TR0 = 74, + CV_SHMEDIA_TR1 = 75, + CV_SHMEDIA_TR2 = 76, + CV_SHMEDIA_TR3 = 77, + CV_SHMEDIA_TR4 = 78, + CV_SHMEDIA_TR5 = 79, + CV_SHMEDIA_TR6 = 80, + CV_SHMEDIA_TR7 = 81, + CV_SHMEDIA_TR8 = 82, // future-proof + CV_SHMEDIA_TR9 = 83, // future-proof + CV_SHMEDIA_TR10 = 84, // future-proof + CV_SHMEDIA_TR11 = 85, // future-proof + CV_SHMEDIA_TR12 = 86, // future-proof + CV_SHMEDIA_TR13 = 87, // future-proof + CV_SHMEDIA_TR14 = 88, // future-proof + CV_SHMEDIA_TR15 = 89, // future-proof + + // Single - 32 bit fp registers + CV_SHMEDIA_FR0 = 128, + CV_SHMEDIA_FR1 = 129, + CV_SHMEDIA_FR2 = 130, + CV_SHMEDIA_FR3 = 131, + CV_SHMEDIA_FR4 = 132, + CV_SHMEDIA_FR5 = 133, + CV_SHMEDIA_FR6 = 134, + CV_SHMEDIA_FR7 = 135, + CV_SHMEDIA_FR8 = 136, + CV_SHMEDIA_FR9 = 137, + CV_SHMEDIA_FR10 = 138, + CV_SHMEDIA_FR11 = 139, + CV_SHMEDIA_FR12 = 140, + CV_SHMEDIA_FR13 = 141, + CV_SHMEDIA_FR14 = 142, + CV_SHMEDIA_FR15 = 143, + CV_SHMEDIA_FR16 = 144, + CV_SHMEDIA_FR17 = 145, + CV_SHMEDIA_FR18 = 146, + CV_SHMEDIA_FR19 = 147, + CV_SHMEDIA_FR20 = 148, + CV_SHMEDIA_FR21 = 149, + CV_SHMEDIA_FR22 = 150, + CV_SHMEDIA_FR23 = 151, + CV_SHMEDIA_FR24 = 152, + CV_SHMEDIA_FR25 = 153, + CV_SHMEDIA_FR26 = 154, + CV_SHMEDIA_FR27 = 155, + CV_SHMEDIA_FR28 = 156, + CV_SHMEDIA_FR29 = 157, + CV_SHMEDIA_FR30 = 158, + CV_SHMEDIA_FR31 = 159, + CV_SHMEDIA_FR32 = 160, + CV_SHMEDIA_FR33 = 161, + CV_SHMEDIA_FR34 = 162, + CV_SHMEDIA_FR35 = 163, + CV_SHMEDIA_FR36 = 164, + CV_SHMEDIA_FR37 = 165, + CV_SHMEDIA_FR38 = 166, + CV_SHMEDIA_FR39 = 167, + CV_SHMEDIA_FR40 = 168, + CV_SHMEDIA_FR41 = 169, + CV_SHMEDIA_FR42 = 170, + CV_SHMEDIA_FR43 = 171, + CV_SHMEDIA_FR44 = 172, + CV_SHMEDIA_FR45 = 173, + CV_SHMEDIA_FR46 = 174, + CV_SHMEDIA_FR47 = 175, + CV_SHMEDIA_FR48 = 176, + CV_SHMEDIA_FR49 = 177, + CV_SHMEDIA_FR50 = 178, + CV_SHMEDIA_FR51 = 179, + CV_SHMEDIA_FR52 = 180, + CV_SHMEDIA_FR53 = 181, + CV_SHMEDIA_FR54 = 182, + CV_SHMEDIA_FR55 = 183, + CV_SHMEDIA_FR56 = 184, + CV_SHMEDIA_FR57 = 185, + CV_SHMEDIA_FR58 = 186, + CV_SHMEDIA_FR59 = 187, + CV_SHMEDIA_FR60 = 188, + CV_SHMEDIA_FR61 = 189, + CV_SHMEDIA_FR62 = 190, + CV_SHMEDIA_FR63 = 191, + + // Double - 64 bit synonyms for 32bit fp register pairs + // subtract 128 to find first base single register + CV_SHMEDIA_DR0 = 256, + CV_SHMEDIA_DR2 = 258, + CV_SHMEDIA_DR4 = 260, + CV_SHMEDIA_DR6 = 262, + CV_SHMEDIA_DR8 = 264, + CV_SHMEDIA_DR10 = 266, + CV_SHMEDIA_DR12 = 268, + CV_SHMEDIA_DR14 = 270, + CV_SHMEDIA_DR16 = 272, + CV_SHMEDIA_DR18 = 274, + CV_SHMEDIA_DR20 = 276, + CV_SHMEDIA_DR22 = 278, + CV_SHMEDIA_DR24 = 280, + CV_SHMEDIA_DR26 = 282, + CV_SHMEDIA_DR28 = 284, + CV_SHMEDIA_DR30 = 286, + CV_SHMEDIA_DR32 = 288, + CV_SHMEDIA_DR34 = 290, + CV_SHMEDIA_DR36 = 292, + CV_SHMEDIA_DR38 = 294, + CV_SHMEDIA_DR40 = 296, + CV_SHMEDIA_DR42 = 298, + CV_SHMEDIA_DR44 = 300, + CV_SHMEDIA_DR46 = 302, + CV_SHMEDIA_DR48 = 304, + CV_SHMEDIA_DR50 = 306, + CV_SHMEDIA_DR52 = 308, + CV_SHMEDIA_DR54 = 310, + CV_SHMEDIA_DR56 = 312, + CV_SHMEDIA_DR58 = 314, + CV_SHMEDIA_DR60 = 316, + CV_SHMEDIA_DR62 = 318, + + // Vector - 128 bit synonyms for 32bit fp register quads + // subtract 384 to find first base single register + CV_SHMEDIA_FV0 = 512, + CV_SHMEDIA_FV4 = 516, + CV_SHMEDIA_FV8 = 520, + CV_SHMEDIA_FV12 = 524, + CV_SHMEDIA_FV16 = 528, + CV_SHMEDIA_FV20 = 532, + CV_SHMEDIA_FV24 = 536, + CV_SHMEDIA_FV28 = 540, + CV_SHMEDIA_FV32 = 544, + CV_SHMEDIA_FV36 = 548, + CV_SHMEDIA_FV40 = 552, + CV_SHMEDIA_FV44 = 556, + CV_SHMEDIA_FV48 = 560, + CV_SHMEDIA_FV52 = 564, + CV_SHMEDIA_FV56 = 568, + CV_SHMEDIA_FV60 = 572, + + // Matrix - 512 bit synonyms for 16 adjacent 32bit fp registers + // subtract 896 to find first base single register + CV_SHMEDIA_MTRX0 = 1024, + CV_SHMEDIA_MTRX16 = 1040, + CV_SHMEDIA_MTRX32 = 1056, + CV_SHMEDIA_MTRX48 = 1072, + + // Control - Implementation defined 64bit control registers + CV_SHMEDIA_CR0 = 2000, + CV_SHMEDIA_CR1 = 2001, + CV_SHMEDIA_CR2 = 2002, + CV_SHMEDIA_CR3 = 2003, + CV_SHMEDIA_CR4 = 2004, + CV_SHMEDIA_CR5 = 2005, + CV_SHMEDIA_CR6 = 2006, + CV_SHMEDIA_CR7 = 2007, + CV_SHMEDIA_CR8 = 2008, + CV_SHMEDIA_CR9 = 2009, + CV_SHMEDIA_CR10 = 2010, + CV_SHMEDIA_CR11 = 2011, + CV_SHMEDIA_CR12 = 2012, + CV_SHMEDIA_CR13 = 2013, + CV_SHMEDIA_CR14 = 2014, + CV_SHMEDIA_CR15 = 2015, + CV_SHMEDIA_CR16 = 2016, + CV_SHMEDIA_CR17 = 2017, + CV_SHMEDIA_CR18 = 2018, + CV_SHMEDIA_CR19 = 2019, + CV_SHMEDIA_CR20 = 2020, + CV_SHMEDIA_CR21 = 2021, + CV_SHMEDIA_CR22 = 2022, + CV_SHMEDIA_CR23 = 2023, + CV_SHMEDIA_CR24 = 2024, + CV_SHMEDIA_CR25 = 2025, + CV_SHMEDIA_CR26 = 2026, + CV_SHMEDIA_CR27 = 2027, + CV_SHMEDIA_CR28 = 2028, + CV_SHMEDIA_CR29 = 2029, + CV_SHMEDIA_CR30 = 2030, + CV_SHMEDIA_CR31 = 2031, + CV_SHMEDIA_CR32 = 2032, + CV_SHMEDIA_CR33 = 2033, + CV_SHMEDIA_CR34 = 2034, + CV_SHMEDIA_CR35 = 2035, + CV_SHMEDIA_CR36 = 2036, + CV_SHMEDIA_CR37 = 2037, + CV_SHMEDIA_CR38 = 2038, + CV_SHMEDIA_CR39 = 2039, + CV_SHMEDIA_CR40 = 2040, + CV_SHMEDIA_CR41 = 2041, + CV_SHMEDIA_CR42 = 2042, + CV_SHMEDIA_CR43 = 2043, + CV_SHMEDIA_CR44 = 2044, + CV_SHMEDIA_CR45 = 2045, + CV_SHMEDIA_CR46 = 2046, + CV_SHMEDIA_CR47 = 2047, + CV_SHMEDIA_CR48 = 2048, + CV_SHMEDIA_CR49 = 2049, + CV_SHMEDIA_CR50 = 2050, + CV_SHMEDIA_CR51 = 2051, + CV_SHMEDIA_CR52 = 2052, + CV_SHMEDIA_CR53 = 2053, + CV_SHMEDIA_CR54 = 2054, + CV_SHMEDIA_CR55 = 2055, + CV_SHMEDIA_CR56 = 2056, + CV_SHMEDIA_CR57 = 2057, + CV_SHMEDIA_CR58 = 2058, + CV_SHMEDIA_CR59 = 2059, + CV_SHMEDIA_CR60 = 2060, + CV_SHMEDIA_CR61 = 2061, + CV_SHMEDIA_CR62 = 2062, + CV_SHMEDIA_CR63 = 2063, + + CV_SHMEDIA_FPSCR = 2064, + + // Compact mode synonyms + CV_SHMEDIA_GBR = CV_SHMEDIA_R16, + CV_SHMEDIA_MACL = 90, // synonym for lower 32bits of media R17 + CV_SHMEDIA_MACH = 91, // synonym for upper 32bits of media R17 + CV_SHMEDIA_PR = CV_SHMEDIA_R18, + CV_SHMEDIA_T = 92, // synonym for lowest bit of media R19 + CV_SHMEDIA_FPUL = CV_SHMEDIA_FR32, + CV_SHMEDIA_PC = 93, + CV_SHMEDIA_SR = CV_SHMEDIA_CR0, + + // + // AMD64 registers + // + + CV_AMD64_AL = 1, + CV_AMD64_CL = 2, + CV_AMD64_DL = 3, + CV_AMD64_BL = 4, + CV_AMD64_AH = 5, + CV_AMD64_CH = 6, + CV_AMD64_DH = 7, + CV_AMD64_BH = 8, + CV_AMD64_AX = 9, + CV_AMD64_CX = 10, + CV_AMD64_DX = 11, + CV_AMD64_BX = 12, + CV_AMD64_SP = 13, + CV_AMD64_BP = 14, + CV_AMD64_SI = 15, + CV_AMD64_DI = 16, + CV_AMD64_EAX = 17, + CV_AMD64_ECX = 18, + CV_AMD64_EDX = 19, + CV_AMD64_EBX = 20, + CV_AMD64_ESP = 21, + CV_AMD64_EBP = 22, + CV_AMD64_ESI = 23, + CV_AMD64_EDI = 24, + CV_AMD64_ES = 25, + CV_AMD64_CS = 26, + CV_AMD64_SS = 27, + CV_AMD64_DS = 28, + CV_AMD64_FS = 29, + CV_AMD64_GS = 30, + CV_AMD64_FLAGS = 32, + CV_AMD64_RIP = 33, + CV_AMD64_EFLAGS = 34, + + // Control registers + CV_AMD64_CR0 = 80, + CV_AMD64_CR1 = 81, + CV_AMD64_CR2 = 82, + CV_AMD64_CR3 = 83, + CV_AMD64_CR4 = 84, + CV_AMD64_CR8 = 88, + + // Debug registers + CV_AMD64_DR0 = 90, + CV_AMD64_DR1 = 91, + CV_AMD64_DR2 = 92, + CV_AMD64_DR3 = 93, + CV_AMD64_DR4 = 94, + CV_AMD64_DR5 = 95, + CV_AMD64_DR6 = 96, + CV_AMD64_DR7 = 97, + CV_AMD64_DR8 = 98, + CV_AMD64_DR9 = 99, + CV_AMD64_DR10 = 100, + CV_AMD64_DR11 = 101, + CV_AMD64_DR12 = 102, + CV_AMD64_DR13 = 103, + CV_AMD64_DR14 = 104, + CV_AMD64_DR15 = 105, + + CV_AMD64_GDTR = 110, + CV_AMD64_GDTL = 111, + CV_AMD64_IDTR = 112, + CV_AMD64_IDTL = 113, + CV_AMD64_LDTR = 114, + CV_AMD64_TR = 115, + + CV_AMD64_ST0 = 128, + CV_AMD64_ST1 = 129, + CV_AMD64_ST2 = 130, + CV_AMD64_ST3 = 131, + CV_AMD64_ST4 = 132, + CV_AMD64_ST5 = 133, + CV_AMD64_ST6 = 134, + CV_AMD64_ST7 = 135, + CV_AMD64_CTRL = 136, + CV_AMD64_STAT = 137, + CV_AMD64_TAG = 138, + CV_AMD64_FPIP = 139, + CV_AMD64_FPCS = 140, + CV_AMD64_FPDO = 141, + CV_AMD64_FPDS = 142, + CV_AMD64_ISEM = 143, + CV_AMD64_FPEIP = 144, + CV_AMD64_FPEDO = 145, + + CV_AMD64_MM0 = 146, + CV_AMD64_MM1 = 147, + CV_AMD64_MM2 = 148, + CV_AMD64_MM3 = 149, + CV_AMD64_MM4 = 150, + CV_AMD64_MM5 = 151, + CV_AMD64_MM6 = 152, + CV_AMD64_MM7 = 153, + + CV_AMD64_XMM0 = 154, // KATMAI registers + CV_AMD64_XMM1 = 155, + CV_AMD64_XMM2 = 156, + CV_AMD64_XMM3 = 157, + CV_AMD64_XMM4 = 158, + CV_AMD64_XMM5 = 159, + CV_AMD64_XMM6 = 160, + CV_AMD64_XMM7 = 161, + + CV_AMD64_XMM0_0 = 162, // KATMAI sub-registers + CV_AMD64_XMM0_1 = 163, + CV_AMD64_XMM0_2 = 164, + CV_AMD64_XMM0_3 = 165, + CV_AMD64_XMM1_0 = 166, + CV_AMD64_XMM1_1 = 167, + CV_AMD64_XMM1_2 = 168, + CV_AMD64_XMM1_3 = 169, + CV_AMD64_XMM2_0 = 170, + CV_AMD64_XMM2_1 = 171, + CV_AMD64_XMM2_2 = 172, + CV_AMD64_XMM2_3 = 173, + CV_AMD64_XMM3_0 = 174, + CV_AMD64_XMM3_1 = 175, + CV_AMD64_XMM3_2 = 176, + CV_AMD64_XMM3_3 = 177, + CV_AMD64_XMM4_0 = 178, + CV_AMD64_XMM4_1 = 179, + CV_AMD64_XMM4_2 = 180, + CV_AMD64_XMM4_3 = 181, + CV_AMD64_XMM5_0 = 182, + CV_AMD64_XMM5_1 = 183, + CV_AMD64_XMM5_2 = 184, + CV_AMD64_XMM5_3 = 185, + CV_AMD64_XMM6_0 = 186, + CV_AMD64_XMM6_1 = 187, + CV_AMD64_XMM6_2 = 188, + CV_AMD64_XMM6_3 = 189, + CV_AMD64_XMM7_0 = 190, + CV_AMD64_XMM7_1 = 191, + CV_AMD64_XMM7_2 = 192, + CV_AMD64_XMM7_3 = 193, + + CV_AMD64_XMM0L = 194, + CV_AMD64_XMM1L = 195, + CV_AMD64_XMM2L = 196, + CV_AMD64_XMM3L = 197, + CV_AMD64_XMM4L = 198, + CV_AMD64_XMM5L = 199, + CV_AMD64_XMM6L = 200, + CV_AMD64_XMM7L = 201, + + CV_AMD64_XMM0H = 202, + CV_AMD64_XMM1H = 203, + CV_AMD64_XMM2H = 204, + CV_AMD64_XMM3H = 205, + CV_AMD64_XMM4H = 206, + CV_AMD64_XMM5H = 207, + CV_AMD64_XMM6H = 208, + CV_AMD64_XMM7H = 209, + + CV_AMD64_MXCSR = 211, // XMM status register + + CV_AMD64_EMM0L = 220, // XMM sub-registers (WNI integer) + CV_AMD64_EMM1L = 221, + CV_AMD64_EMM2L = 222, + CV_AMD64_EMM3L = 223, + CV_AMD64_EMM4L = 224, + CV_AMD64_EMM5L = 225, + CV_AMD64_EMM6L = 226, + CV_AMD64_EMM7L = 227, + + CV_AMD64_EMM0H = 228, + CV_AMD64_EMM1H = 229, + CV_AMD64_EMM2H = 230, + CV_AMD64_EMM3H = 231, + CV_AMD64_EMM4H = 232, + CV_AMD64_EMM5H = 233, + CV_AMD64_EMM6H = 234, + CV_AMD64_EMM7H = 235, + + // do not change the order of these regs, first one must be even too + CV_AMD64_MM00 = 236, + CV_AMD64_MM01 = 237, + CV_AMD64_MM10 = 238, + CV_AMD64_MM11 = 239, + CV_AMD64_MM20 = 240, + CV_AMD64_MM21 = 241, + CV_AMD64_MM30 = 242, + CV_AMD64_MM31 = 243, + CV_AMD64_MM40 = 244, + CV_AMD64_MM41 = 245, + CV_AMD64_MM50 = 246, + CV_AMD64_MM51 = 247, + CV_AMD64_MM60 = 248, + CV_AMD64_MM61 = 249, + CV_AMD64_MM70 = 250, + CV_AMD64_MM71 = 251, + + // Extended KATMAI registers + CV_AMD64_XMM8 = 252, // KATMAI registers + CV_AMD64_XMM9 = 253, + CV_AMD64_XMM10 = 254, + CV_AMD64_XMM11 = 255, + CV_AMD64_XMM12 = 256, + CV_AMD64_XMM13 = 257, + CV_AMD64_XMM14 = 258, + CV_AMD64_XMM15 = 259, + + CV_AMD64_XMM8_0 = 260, // KATMAI sub-registers + CV_AMD64_XMM8_1 = 261, + CV_AMD64_XMM8_2 = 262, + CV_AMD64_XMM8_3 = 263, + CV_AMD64_XMM9_0 = 264, + CV_AMD64_XMM9_1 = 265, + CV_AMD64_XMM9_2 = 266, + CV_AMD64_XMM9_3 = 267, + CV_AMD64_XMM10_0 = 268, + CV_AMD64_XMM10_1 = 269, + CV_AMD64_XMM10_2 = 270, + CV_AMD64_XMM10_3 = 271, + CV_AMD64_XMM11_0 = 272, + CV_AMD64_XMM11_1 = 273, + CV_AMD64_XMM11_2 = 274, + CV_AMD64_XMM11_3 = 275, + CV_AMD64_XMM12_0 = 276, + CV_AMD64_XMM12_1 = 277, + CV_AMD64_XMM12_2 = 278, + CV_AMD64_XMM12_3 = 279, + CV_AMD64_XMM13_0 = 280, + CV_AMD64_XMM13_1 = 281, + CV_AMD64_XMM13_2 = 282, + CV_AMD64_XMM13_3 = 283, + CV_AMD64_XMM14_0 = 284, + CV_AMD64_XMM14_1 = 285, + CV_AMD64_XMM14_2 = 286, + CV_AMD64_XMM14_3 = 287, + CV_AMD64_XMM15_0 = 288, + CV_AMD64_XMM15_1 = 289, + CV_AMD64_XMM15_2 = 290, + CV_AMD64_XMM15_3 = 291, + + CV_AMD64_XMM8L = 292, + CV_AMD64_XMM9L = 293, + CV_AMD64_XMM10L = 294, + CV_AMD64_XMM11L = 295, + CV_AMD64_XMM12L = 296, + CV_AMD64_XMM13L = 297, + CV_AMD64_XMM14L = 298, + CV_AMD64_XMM15L = 299, + + CV_AMD64_XMM8H = 300, + CV_AMD64_XMM9H = 301, + CV_AMD64_XMM10H = 302, + CV_AMD64_XMM11H = 303, + CV_AMD64_XMM12H = 304, + CV_AMD64_XMM13H = 305, + CV_AMD64_XMM14H = 306, + CV_AMD64_XMM15H = 307, + + CV_AMD64_EMM8L = 308, // XMM sub-registers (WNI integer) + CV_AMD64_EMM9L = 309, + CV_AMD64_EMM10L = 310, + CV_AMD64_EMM11L = 311, + CV_AMD64_EMM12L = 312, + CV_AMD64_EMM13L = 313, + CV_AMD64_EMM14L = 314, + CV_AMD64_EMM15L = 315, + + CV_AMD64_EMM8H = 316, + CV_AMD64_EMM9H = 317, + CV_AMD64_EMM10H = 318, + CV_AMD64_EMM11H = 319, + CV_AMD64_EMM12H = 320, + CV_AMD64_EMM13H = 321, + CV_AMD64_EMM14H = 322, + CV_AMD64_EMM15H = 323, + + // Low byte forms of some standard registers + CV_AMD64_SIL = 324, + CV_AMD64_DIL = 325, + CV_AMD64_BPL = 326, + CV_AMD64_SPL = 327, + + // 64-bit regular registers + CV_AMD64_RAX = 328, + CV_AMD64_RBX = 329, + CV_AMD64_RCX = 330, + CV_AMD64_RDX = 331, + CV_AMD64_RSI = 332, + CV_AMD64_RDI = 333, + CV_AMD64_RBP = 334, + CV_AMD64_RSP = 335, + + // 64-bit integer registers with 8-, 16-, and 32-bit forms (B, W, and D) + CV_AMD64_R8 = 336, + CV_AMD64_R9 = 337, + CV_AMD64_R10 = 338, + CV_AMD64_R11 = 339, + CV_AMD64_R12 = 340, + CV_AMD64_R13 = 341, + CV_AMD64_R14 = 342, + CV_AMD64_R15 = 343, + + CV_AMD64_R8B = 344, + CV_AMD64_R9B = 345, + CV_AMD64_R10B = 346, + CV_AMD64_R11B = 347, + CV_AMD64_R12B = 348, + CV_AMD64_R13B = 349, + CV_AMD64_R14B = 350, + CV_AMD64_R15B = 351, + + CV_AMD64_R8W = 352, + CV_AMD64_R9W = 353, + CV_AMD64_R10W = 354, + CV_AMD64_R11W = 355, + CV_AMD64_R12W = 356, + CV_AMD64_R13W = 357, + CV_AMD64_R14W = 358, + CV_AMD64_R15W = 359, + + CV_AMD64_R8D = 360, + CV_AMD64_R9D = 361, + CV_AMD64_R10D = 362, + CV_AMD64_R11D = 363, + CV_AMD64_R12D = 364, + CV_AMD64_R13D = 365, + CV_AMD64_R14D = 366, + CV_AMD64_R15D = 367, + + // AVX registers 256 bits + CV_AMD64_YMM0 = 368, + CV_AMD64_YMM1 = 369, + CV_AMD64_YMM2 = 370, + CV_AMD64_YMM3 = 371, + CV_AMD64_YMM4 = 372, + CV_AMD64_YMM5 = 373, + CV_AMD64_YMM6 = 374, + CV_AMD64_YMM7 = 375, + CV_AMD64_YMM8 = 376, + CV_AMD64_YMM9 = 377, + CV_AMD64_YMM10 = 378, + CV_AMD64_YMM11 = 379, + CV_AMD64_YMM12 = 380, + CV_AMD64_YMM13 = 381, + CV_AMD64_YMM14 = 382, + CV_AMD64_YMM15 = 383, + + // AVX registers upper 128 bits + CV_AMD64_YMM0H = 384, + CV_AMD64_YMM1H = 385, + CV_AMD64_YMM2H = 386, + CV_AMD64_YMM3H = 387, + CV_AMD64_YMM4H = 388, + CV_AMD64_YMM5H = 389, + CV_AMD64_YMM6H = 390, + CV_AMD64_YMM7H = 391, + CV_AMD64_YMM8H = 392, + CV_AMD64_YMM9H = 393, + CV_AMD64_YMM10H = 394, + CV_AMD64_YMM11H = 395, + CV_AMD64_YMM12H = 396, + CV_AMD64_YMM13H = 397, + CV_AMD64_YMM14H = 398, + CV_AMD64_YMM15H = 399, + + //Lower/upper 8 bytes of XMM registers. Unlike CV_AMD64_XMM, these + //values reprsesent the bit patterns of the registers as 64-bit integers, not + //the representation of these registers as a double. + CV_AMD64_XMM0IL = 400, + CV_AMD64_XMM1IL = 401, + CV_AMD64_XMM2IL = 402, + CV_AMD64_XMM3IL = 403, + CV_AMD64_XMM4IL = 404, + CV_AMD64_XMM5IL = 405, + CV_AMD64_XMM6IL = 406, + CV_AMD64_XMM7IL = 407, + CV_AMD64_XMM8IL = 408, + CV_AMD64_XMM9IL = 409, + CV_AMD64_XMM10IL = 410, + CV_AMD64_XMM11IL = 411, + CV_AMD64_XMM12IL = 412, + CV_AMD64_XMM13IL = 413, + CV_AMD64_XMM14IL = 414, + CV_AMD64_XMM15IL = 415, + + CV_AMD64_XMM0IH = 416, + CV_AMD64_XMM1IH = 417, + CV_AMD64_XMM2IH = 418, + CV_AMD64_XMM3IH = 419, + CV_AMD64_XMM4IH = 420, + CV_AMD64_XMM5IH = 421, + CV_AMD64_XMM6IH = 422, + CV_AMD64_XMM7IH = 423, + CV_AMD64_XMM8IH = 424, + CV_AMD64_XMM9IH = 425, + CV_AMD64_XMM10IH = 426, + CV_AMD64_XMM11IH = 427, + CV_AMD64_XMM12IH = 428, + CV_AMD64_XMM13IH = 429, + CV_AMD64_XMM14IH = 430, + CV_AMD64_XMM15IH = 431, + + CV_AMD64_YMM0I0 = 432, // AVX integer registers + CV_AMD64_YMM0I1 = 433, + CV_AMD64_YMM0I2 = 434, + CV_AMD64_YMM0I3 = 435, + CV_AMD64_YMM1I0 = 436, + CV_AMD64_YMM1I1 = 437, + CV_AMD64_YMM1I2 = 438, + CV_AMD64_YMM1I3 = 439, + CV_AMD64_YMM2I0 = 440, + CV_AMD64_YMM2I1 = 441, + CV_AMD64_YMM2I2 = 442, + CV_AMD64_YMM2I3 = 443, + CV_AMD64_YMM3I0 = 444, + CV_AMD64_YMM3I1 = 445, + CV_AMD64_YMM3I2 = 446, + CV_AMD64_YMM3I3 = 447, + CV_AMD64_YMM4I0 = 448, + CV_AMD64_YMM4I1 = 449, + CV_AMD64_YMM4I2 = 450, + CV_AMD64_YMM4I3 = 451, + CV_AMD64_YMM5I0 = 452, + CV_AMD64_YMM5I1 = 453, + CV_AMD64_YMM5I2 = 454, + CV_AMD64_YMM5I3 = 455, + CV_AMD64_YMM6I0 = 456, + CV_AMD64_YMM6I1 = 457, + CV_AMD64_YMM6I2 = 458, + CV_AMD64_YMM6I3 = 459, + CV_AMD64_YMM7I0 = 460, + CV_AMD64_YMM7I1 = 461, + CV_AMD64_YMM7I2 = 462, + CV_AMD64_YMM7I3 = 463, + CV_AMD64_YMM8I0 = 464, + CV_AMD64_YMM8I1 = 465, + CV_AMD64_YMM8I2 = 466, + CV_AMD64_YMM8I3 = 467, + CV_AMD64_YMM9I0 = 468, + CV_AMD64_YMM9I1 = 469, + CV_AMD64_YMM9I2 = 470, + CV_AMD64_YMM9I3 = 471, + CV_AMD64_YMM10I0 = 472, + CV_AMD64_YMM10I1 = 473, + CV_AMD64_YMM10I2 = 474, + CV_AMD64_YMM10I3 = 475, + CV_AMD64_YMM11I0 = 476, + CV_AMD64_YMM11I1 = 477, + CV_AMD64_YMM11I2 = 478, + CV_AMD64_YMM11I3 = 479, + CV_AMD64_YMM12I0 = 480, + CV_AMD64_YMM12I1 = 481, + CV_AMD64_YMM12I2 = 482, + CV_AMD64_YMM12I3 = 483, + CV_AMD64_YMM13I0 = 484, + CV_AMD64_YMM13I1 = 485, + CV_AMD64_YMM13I2 = 486, + CV_AMD64_YMM13I3 = 487, + CV_AMD64_YMM14I0 = 488, + CV_AMD64_YMM14I1 = 489, + CV_AMD64_YMM14I2 = 490, + CV_AMD64_YMM14I3 = 491, + CV_AMD64_YMM15I0 = 492, + CV_AMD64_YMM15I1 = 493, + CV_AMD64_YMM15I2 = 494, + CV_AMD64_YMM15I3 = 495, + + CV_AMD64_YMM0F0 = 496, // AVX floating-point single precise registers + CV_AMD64_YMM0F1 = 497, + CV_AMD64_YMM0F2 = 498, + CV_AMD64_YMM0F3 = 499, + CV_AMD64_YMM0F4 = 500, + CV_AMD64_YMM0F5 = 501, + CV_AMD64_YMM0F6 = 502, + CV_AMD64_YMM0F7 = 503, + CV_AMD64_YMM1F0 = 504, + CV_AMD64_YMM1F1 = 505, + CV_AMD64_YMM1F2 = 506, + CV_AMD64_YMM1F3 = 507, + CV_AMD64_YMM1F4 = 508, + CV_AMD64_YMM1F5 = 509, + CV_AMD64_YMM1F6 = 510, + CV_AMD64_YMM1F7 = 511, + CV_AMD64_YMM2F0 = 512, + CV_AMD64_YMM2F1 = 513, + CV_AMD64_YMM2F2 = 514, + CV_AMD64_YMM2F3 = 515, + CV_AMD64_YMM2F4 = 516, + CV_AMD64_YMM2F5 = 517, + CV_AMD64_YMM2F6 = 518, + CV_AMD64_YMM2F7 = 519, + CV_AMD64_YMM3F0 = 520, + CV_AMD64_YMM3F1 = 521, + CV_AMD64_YMM3F2 = 522, + CV_AMD64_YMM3F3 = 523, + CV_AMD64_YMM3F4 = 524, + CV_AMD64_YMM3F5 = 525, + CV_AMD64_YMM3F6 = 526, + CV_AMD64_YMM3F7 = 527, + CV_AMD64_YMM4F0 = 528, + CV_AMD64_YMM4F1 = 529, + CV_AMD64_YMM4F2 = 530, + CV_AMD64_YMM4F3 = 531, + CV_AMD64_YMM4F4 = 532, + CV_AMD64_YMM4F5 = 533, + CV_AMD64_YMM4F6 = 534, + CV_AMD64_YMM4F7 = 535, + CV_AMD64_YMM5F0 = 536, + CV_AMD64_YMM5F1 = 537, + CV_AMD64_YMM5F2 = 538, + CV_AMD64_YMM5F3 = 539, + CV_AMD64_YMM5F4 = 540, + CV_AMD64_YMM5F5 = 541, + CV_AMD64_YMM5F6 = 542, + CV_AMD64_YMM5F7 = 543, + CV_AMD64_YMM6F0 = 544, + CV_AMD64_YMM6F1 = 545, + CV_AMD64_YMM6F2 = 546, + CV_AMD64_YMM6F3 = 547, + CV_AMD64_YMM6F4 = 548, + CV_AMD64_YMM6F5 = 549, + CV_AMD64_YMM6F6 = 550, + CV_AMD64_YMM6F7 = 551, + CV_AMD64_YMM7F0 = 552, + CV_AMD64_YMM7F1 = 553, + CV_AMD64_YMM7F2 = 554, + CV_AMD64_YMM7F3 = 555, + CV_AMD64_YMM7F4 = 556, + CV_AMD64_YMM7F5 = 557, + CV_AMD64_YMM7F6 = 558, + CV_AMD64_YMM7F7 = 559, + CV_AMD64_YMM8F0 = 560, + CV_AMD64_YMM8F1 = 561, + CV_AMD64_YMM8F2 = 562, + CV_AMD64_YMM8F3 = 563, + CV_AMD64_YMM8F4 = 564, + CV_AMD64_YMM8F5 = 565, + CV_AMD64_YMM8F6 = 566, + CV_AMD64_YMM8F7 = 567, + CV_AMD64_YMM9F0 = 568, + CV_AMD64_YMM9F1 = 569, + CV_AMD64_YMM9F2 = 570, + CV_AMD64_YMM9F3 = 571, + CV_AMD64_YMM9F4 = 572, + CV_AMD64_YMM9F5 = 573, + CV_AMD64_YMM9F6 = 574, + CV_AMD64_YMM9F7 = 575, + CV_AMD64_YMM10F0 = 576, + CV_AMD64_YMM10F1 = 577, + CV_AMD64_YMM10F2 = 578, + CV_AMD64_YMM10F3 = 579, + CV_AMD64_YMM10F4 = 580, + CV_AMD64_YMM10F5 = 581, + CV_AMD64_YMM10F6 = 582, + CV_AMD64_YMM10F7 = 583, + CV_AMD64_YMM11F0 = 584, + CV_AMD64_YMM11F1 = 585, + CV_AMD64_YMM11F2 = 586, + CV_AMD64_YMM11F3 = 587, + CV_AMD64_YMM11F4 = 588, + CV_AMD64_YMM11F5 = 589, + CV_AMD64_YMM11F6 = 590, + CV_AMD64_YMM11F7 = 591, + CV_AMD64_YMM12F0 = 592, + CV_AMD64_YMM12F1 = 593, + CV_AMD64_YMM12F2 = 594, + CV_AMD64_YMM12F3 = 595, + CV_AMD64_YMM12F4 = 596, + CV_AMD64_YMM12F5 = 597, + CV_AMD64_YMM12F6 = 598, + CV_AMD64_YMM12F7 = 599, + CV_AMD64_YMM13F0 = 600, + CV_AMD64_YMM13F1 = 601, + CV_AMD64_YMM13F2 = 602, + CV_AMD64_YMM13F3 = 603, + CV_AMD64_YMM13F4 = 604, + CV_AMD64_YMM13F5 = 605, + CV_AMD64_YMM13F6 = 606, + CV_AMD64_YMM13F7 = 607, + CV_AMD64_YMM14F0 = 608, + CV_AMD64_YMM14F1 = 609, + CV_AMD64_YMM14F2 = 610, + CV_AMD64_YMM14F3 = 611, + CV_AMD64_YMM14F4 = 612, + CV_AMD64_YMM14F5 = 613, + CV_AMD64_YMM14F6 = 614, + CV_AMD64_YMM14F7 = 615, + CV_AMD64_YMM15F0 = 616, + CV_AMD64_YMM15F1 = 617, + CV_AMD64_YMM15F2 = 618, + CV_AMD64_YMM15F3 = 619, + CV_AMD64_YMM15F4 = 620, + CV_AMD64_YMM15F5 = 621, + CV_AMD64_YMM15F6 = 622, + CV_AMD64_YMM15F7 = 623, + + CV_AMD64_YMM0D0 = 624, // AVX floating-point double precise registers + CV_AMD64_YMM0D1 = 625, + CV_AMD64_YMM0D2 = 626, + CV_AMD64_YMM0D3 = 627, + CV_AMD64_YMM1D0 = 628, + CV_AMD64_YMM1D1 = 629, + CV_AMD64_YMM1D2 = 630, + CV_AMD64_YMM1D3 = 631, + CV_AMD64_YMM2D0 = 632, + CV_AMD64_YMM2D1 = 633, + CV_AMD64_YMM2D2 = 634, + CV_AMD64_YMM2D3 = 635, + CV_AMD64_YMM3D0 = 636, + CV_AMD64_YMM3D1 = 637, + CV_AMD64_YMM3D2 = 638, + CV_AMD64_YMM3D3 = 639, + CV_AMD64_YMM4D0 = 640, + CV_AMD64_YMM4D1 = 641, + CV_AMD64_YMM4D2 = 642, + CV_AMD64_YMM4D3 = 643, + CV_AMD64_YMM5D0 = 644, + CV_AMD64_YMM5D1 = 645, + CV_AMD64_YMM5D2 = 646, + CV_AMD64_YMM5D3 = 647, + CV_AMD64_YMM6D0 = 648, + CV_AMD64_YMM6D1 = 649, + CV_AMD64_YMM6D2 = 650, + CV_AMD64_YMM6D3 = 651, + CV_AMD64_YMM7D0 = 652, + CV_AMD64_YMM7D1 = 653, + CV_AMD64_YMM7D2 = 654, + CV_AMD64_YMM7D3 = 655, + CV_AMD64_YMM8D0 = 656, + CV_AMD64_YMM8D1 = 657, + CV_AMD64_YMM8D2 = 658, + CV_AMD64_YMM8D3 = 659, + CV_AMD64_YMM9D0 = 660, + CV_AMD64_YMM9D1 = 661, + CV_AMD64_YMM9D2 = 662, + CV_AMD64_YMM9D3 = 663, + CV_AMD64_YMM10D0 = 664, + CV_AMD64_YMM10D1 = 665, + CV_AMD64_YMM10D2 = 666, + CV_AMD64_YMM10D3 = 667, + CV_AMD64_YMM11D0 = 668, + CV_AMD64_YMM11D1 = 669, + CV_AMD64_YMM11D2 = 670, + CV_AMD64_YMM11D3 = 671, + CV_AMD64_YMM12D0 = 672, + CV_AMD64_YMM12D1 = 673, + CV_AMD64_YMM12D2 = 674, + CV_AMD64_YMM12D3 = 675, + CV_AMD64_YMM13D0 = 676, + CV_AMD64_YMM13D1 = 677, + CV_AMD64_YMM13D2 = 678, + CV_AMD64_YMM13D3 = 679, + CV_AMD64_YMM14D0 = 680, + CV_AMD64_YMM14D1 = 681, + CV_AMD64_YMM14D2 = 682, + CV_AMD64_YMM14D3 = 683, + CV_AMD64_YMM15D0 = 684, + CV_AMD64_YMM15D1 = 685, + CV_AMD64_YMM15D2 = 686, + CV_AMD64_YMM15D3 = 687, + + CV_AMD64_BND0 = 688, // AMD64 MPX bounds registers + CV_AMD64_BND1 = 689, + CV_AMD64_BND2 = 690, + CV_AMD64_BND3 = 691, + CV_AMD64_BNDCFGU = 692, + CV_AMD64_BNDSTATUS = 693, + + CV_AMD64_XMM16 = 694, // AVX-512 registers + CV_AMD64_XMM17 = 695, + CV_AMD64_XMM18 = 696, + CV_AMD64_XMM19 = 697, + CV_AMD64_XMM20 = 698, + CV_AMD64_XMM21 = 699, + CV_AMD64_XMM22 = 700, + CV_AMD64_XMM23 = 701, + CV_AMD64_XMM24 = 702, + CV_AMD64_XMM25 = 703, + CV_AMD64_XMM26 = 704, + CV_AMD64_XMM27 = 705, + CV_AMD64_XMM28 = 706, + CV_AMD64_XMM29 = 707, + CV_AMD64_XMM30 = 708, + CV_AMD64_XMM31 = 709, + + CV_AMD64_YMM16 = 710, + CV_AMD64_YMM17 = 711, + CV_AMD64_YMM18 = 712, + CV_AMD64_YMM19 = 713, + CV_AMD64_YMM20 = 714, + CV_AMD64_YMM21 = 715, + CV_AMD64_YMM22 = 716, + CV_AMD64_YMM23 = 717, + CV_AMD64_YMM24 = 718, + CV_AMD64_YMM25 = 719, + CV_AMD64_YMM26 = 720, + CV_AMD64_YMM27 = 721, + CV_AMD64_YMM28 = 722, + CV_AMD64_YMM29 = 723, + CV_AMD64_YMM30 = 724, + CV_AMD64_YMM31 = 725, + + CV_AMD64_ZMM0 = 726, + CV_AMD64_ZMM1 = 727, + CV_AMD64_ZMM2 = 728, + CV_AMD64_ZMM3 = 729, + CV_AMD64_ZMM4 = 730, + CV_AMD64_ZMM5 = 731, + CV_AMD64_ZMM6 = 732, + CV_AMD64_ZMM7 = 733, + CV_AMD64_ZMM8 = 734, + CV_AMD64_ZMM9 = 735, + CV_AMD64_ZMM10 = 736, + CV_AMD64_ZMM11 = 737, + CV_AMD64_ZMM12 = 738, + CV_AMD64_ZMM13 = 739, + CV_AMD64_ZMM14 = 740, + CV_AMD64_ZMM15 = 741, + CV_AMD64_ZMM16 = 742, + CV_AMD64_ZMM17 = 743, + CV_AMD64_ZMM18 = 744, + CV_AMD64_ZMM19 = 745, + CV_AMD64_ZMM20 = 746, + CV_AMD64_ZMM21 = 747, + CV_AMD64_ZMM22 = 748, + CV_AMD64_ZMM23 = 749, + CV_AMD64_ZMM24 = 750, + CV_AMD64_ZMM25 = 751, + CV_AMD64_ZMM26 = 752, + CV_AMD64_ZMM27 = 753, + CV_AMD64_ZMM28 = 754, + CV_AMD64_ZMM29 = 755, + CV_AMD64_ZMM30 = 756, + CV_AMD64_ZMM31 = 757, + + CV_AMD64_K0 = 758, + CV_AMD64_K1 = 759, + CV_AMD64_K2 = 760, + CV_AMD64_K3 = 761, + CV_AMD64_K4 = 762, + CV_AMD64_K5 = 763, + CV_AMD64_K6 = 764, + CV_AMD64_K7 = 765, + + CV_AMD64_ZMM0H = 766, // upper 256 bits of the first 16 AMD64 AVX-512 registers + CV_AMD64_ZMM1H = 767, + CV_AMD64_ZMM2H = 768, + CV_AMD64_ZMM3H = 769, + CV_AMD64_ZMM4H = 770, + CV_AMD64_ZMM5H = 771, + CV_AMD64_ZMM6H = 772, + CV_AMD64_ZMM7H = 773, + CV_AMD64_ZMM8H = 774, + CV_AMD64_ZMM9H = 775, + CV_AMD64_ZMM10H = 776, + CV_AMD64_ZMM11H = 777, + CV_AMD64_ZMM12H = 778, + CV_AMD64_ZMM13H = 779, + CV_AMD64_ZMM14H = 780, + CV_AMD64_ZMM15H = 781, + + CV_AMD64_XMM16L = 782, // extended KATMAI registers + CV_AMD64_XMM17L = 783, + CV_AMD64_XMM18L = 784, + CV_AMD64_XMM19L = 785, + CV_AMD64_XMM20L = 786, + CV_AMD64_XMM21L = 787, + CV_AMD64_XMM22L = 788, + CV_AMD64_XMM23L = 789, + CV_AMD64_XMM24L = 790, + CV_AMD64_XMM25L = 791, + CV_AMD64_XMM26L = 792, + CV_AMD64_XMM27L = 793, + CV_AMD64_XMM28L = 794, + CV_AMD64_XMM29L = 795, + CV_AMD64_XMM30L = 796, + CV_AMD64_XMM31L = 797, + + CV_AMD64_XMM16_0 = 798, + CV_AMD64_XMM17_0 = 799, + CV_AMD64_XMM18_0 = 800, + CV_AMD64_XMM19_0 = 801, + CV_AMD64_XMM20_0 = 802, + CV_AMD64_XMM21_0 = 803, + CV_AMD64_XMM22_0 = 804, + CV_AMD64_XMM23_0 = 805, + CV_AMD64_XMM24_0 = 806, + CV_AMD64_XMM25_0 = 807, + CV_AMD64_XMM26_0 = 808, + CV_AMD64_XMM27_0 = 809, + CV_AMD64_XMM28_0 = 810, + CV_AMD64_XMM29_0 = 811, + CV_AMD64_XMM30_0 = 812, + CV_AMD64_XMM31_0 = 813, + + CV_AMD64_XMM16H = 814, + CV_AMD64_XMM17H = 815, + CV_AMD64_XMM18H = 816, + CV_AMD64_XMM19H = 817, + CV_AMD64_XMM20H = 818, + CV_AMD64_XMM21H = 819, + CV_AMD64_XMM22H = 820, + CV_AMD64_XMM23H = 821, + CV_AMD64_XMM24H = 822, + CV_AMD64_XMM25H = 823, + CV_AMD64_XMM26H = 824, + CV_AMD64_XMM27H = 825, + CV_AMD64_XMM28H = 826, + CV_AMD64_XMM29H = 827, + CV_AMD64_XMM30H = 828, + CV_AMD64_XMM31H = 829, + + CV_AMD64_EMM16H = 830, + CV_AMD64_EMM17H = 831, + CV_AMD64_EMM18H = 832, + CV_AMD64_EMM19H = 833, + CV_AMD64_EMM20H = 834, + CV_AMD64_EMM21H = 835, + CV_AMD64_EMM22H = 836, + CV_AMD64_EMM23H = 837, + CV_AMD64_EMM24H = 838, + CV_AMD64_EMM25H = 839, + CV_AMD64_EMM26H = 840, + CV_AMD64_EMM27H = 841, + CV_AMD64_EMM28H = 842, + CV_AMD64_EMM29H = 843, + CV_AMD64_EMM30H = 844, + CV_AMD64_EMM31H = 845, + + CV_AMD64_SSP = 846, // CET- Shadow Stack Pointer + + CV_AMD64_TMM0 = 847, // AMX tile registers + CV_AMD64_TMM1 = 848, + CV_AMD64_TMM2 = 849, + CV_AMD64_TMM3 = 850, + CV_AMD64_TMM4 = 851, + CV_AMD64_TMM5 = 852, + CV_AMD64_TMM6 = 853, + CV_AMD64_TMM7 = 854, + + // Note: Next set of platform registers need to go into a new enum... + // this one is above 44K now. + +} CV_HREG_e; + +typedef enum CV_HLSLREG_e +{ + CV_HLSLREG_TEMP = 0, + CV_HLSLREG_INPUT = 1, + CV_HLSLREG_OUTPUT = 2, + CV_HLSLREG_INDEXABLE_TEMP = 3, + CV_HLSLREG_IMMEDIATE32 = 4, + CV_HLSLREG_IMMEDIATE64 = 5, + CV_HLSLREG_SAMPLER = 6, + CV_HLSLREG_RESOURCE = 7, + CV_HLSLREG_CONSTANT_BUFFER = 8, + CV_HLSLREG_IMMEDIATE_CONSTANT_BUFFER = 9, + CV_HLSLREG_LABEL = 10, + CV_HLSLREG_INPUT_PRIMITIVEID = 11, + CV_HLSLREG_OUTPUT_DEPTH = 12, + CV_HLSLREG_NULL = 13, + CV_HLSLREG_RASTERIZER = 14, + CV_HLSLREG_OUTPUT_COVERAGE_MASK = 15, + CV_HLSLREG_STREAM = 16, + CV_HLSLREG_FUNCTION_BODY = 17, + CV_HLSLREG_FUNCTION_TABLE = 18, + CV_HLSLREG_INTERFACE = 19, + CV_HLSLREG_FUNCTION_INPUT = 20, + CV_HLSLREG_FUNCTION_OUTPUT = 21, + CV_HLSLREG_OUTPUT_CONTROL_POINT_ID = 22, + CV_HLSLREG_INPUT_FORK_INSTANCE_ID = 23, + CV_HLSLREG_INPUT_JOIN_INSTANCE_ID = 24, + CV_HLSLREG_INPUT_CONTROL_POINT = 25, + CV_HLSLREG_OUTPUT_CONTROL_POINT = 26, + CV_HLSLREG_INPUT_PATCH_CONSTANT = 27, + CV_HLSLREG_INPUT_DOMAIN_POINT = 28, + CV_HLSLREG_THIS_POINTER = 29, + CV_HLSLREG_UNORDERED_ACCESS_VIEW = 30, + CV_HLSLREG_THREAD_GROUP_SHARED_MEMORY = 31, + CV_HLSLREG_INPUT_THREAD_ID = 32, + CV_HLSLREG_INPUT_THREAD_GROUP_ID = 33, + CV_HLSLREG_INPUT_THREAD_ID_IN_GROUP = 34, + CV_HLSLREG_INPUT_COVERAGE_MASK = 35, + CV_HLSLREG_INPUT_THREAD_ID_IN_GROUP_FLATTENED = 36, + CV_HLSLREG_INPUT_GS_INSTANCE_ID = 37, + CV_HLSLREG_OUTPUT_DEPTH_GREATER_EQUAL = 38, + CV_HLSLREG_OUTPUT_DEPTH_LESS_EQUAL = 39, + CV_HLSLREG_CYCLE_COUNTER = 40, +} CV_HLSLREG_e; + +enum StackFrameTypeEnum +{ + FrameTypeFPO, // Frame pointer omitted, FPO info available + FrameTypeTrap, // Kernel Trap frame + FrameTypeTSS, // Kernel Trap frame + FrameTypeStandard, // Standard EBP stackframe + FrameTypeFrameData, // Frame pointer omitted, FrameData info available + + FrameTypeUnknown = -1, // Frame which does not have any debug info +}; + +enum MemoryTypeEnum +{ + MemTypeCode, // Read only code memory + MemTypeData, // Read only data/stack memory + MemTypeStack, // Read only stack memory + MemTypeCodeOnHeap, // Read only memory for code generated on heap by runtime + + MemTypeAny = -1, +}; + +typedef enum CV_HLSLMemorySpace_e +{ + // HLSL specific memory spaces + + CV_HLSL_MEMSPACE_DATA = 0x00, + CV_HLSL_MEMSPACE_SAMPLER = 0x01, + CV_HLSL_MEMSPACE_RESOURCE = 0x02, + CV_HLSL_MEMSPACE_RWRESOURCE = 0x03, + + CV_HLSL_MEMSPACE_MAX = 0x0F, +} CV_HLSLMemorySpace_e; + +enum +{ + NAMEHASH_BUILD_START, + NAMEHASH_BUILD_PAUSE, + NAMEHASH_BUILD_RESUME, + NAMEHASH_BUILD_COMPLETE, + NAMEHASH_BUILD_ERROR, + NAMEHASH_BUILD_OOM = NAMEHASH_BUILD_ERROR, + NAMEHASH_BUILD_FAIL_TO_OPEN_MOD, +}; + +#endif diff --git a/libraries/dia/dia2.h b/libraries/dia/dia2.h new file mode 100644 index 0000000..299bf25 --- /dev/null +++ b/libraries/dia/dia2.h @@ -0,0 +1,21777 @@ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0622 */ +/* @@MIDL_FILE_HEADING( ) */ + +#pragma warning( disable: 4049 ) /* more than 64k source lines */ + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 475 +#endif + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCSAL_H_VERSION__ +#define __REQUIRED_RPCSAL_H_VERSION__ 100 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + +#ifndef COM_NO_WINDOWS_H +#include "windows.h" +#include "ole2.h" +#endif /*COM_NO_WINDOWS_H*/ + +#ifndef __dia2_h__ +#define __dia2_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +/* Forward Declarations */ + +#ifndef __IDiaLoadCallback_FWD_DEFINED__ +#define __IDiaLoadCallback_FWD_DEFINED__ +typedef interface IDiaLoadCallback IDiaLoadCallback; + +#endif /* __IDiaLoadCallback_FWD_DEFINED__ */ + + +#ifndef __IDiaLoadCallback2_FWD_DEFINED__ +#define __IDiaLoadCallback2_FWD_DEFINED__ +typedef interface IDiaLoadCallback2 IDiaLoadCallback2; + +#endif /* __IDiaLoadCallback2_FWD_DEFINED__ */ + + +#ifndef __IDiaReadExeAtOffsetCallback_FWD_DEFINED__ +#define __IDiaReadExeAtOffsetCallback_FWD_DEFINED__ +typedef interface IDiaReadExeAtOffsetCallback IDiaReadExeAtOffsetCallback; + +#endif /* __IDiaReadExeAtOffsetCallback_FWD_DEFINED__ */ + + +#ifndef __IDiaReadExeAtRVACallback_FWD_DEFINED__ +#define __IDiaReadExeAtRVACallback_FWD_DEFINED__ +typedef interface IDiaReadExeAtRVACallback IDiaReadExeAtRVACallback; + +#endif /* __IDiaReadExeAtRVACallback_FWD_DEFINED__ */ + + +#ifndef __IDiaDataSource_FWD_DEFINED__ +#define __IDiaDataSource_FWD_DEFINED__ +typedef interface IDiaDataSource IDiaDataSource; + +#endif /* __IDiaDataSource_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumSymbols_FWD_DEFINED__ +#define __IDiaEnumSymbols_FWD_DEFINED__ +typedef interface IDiaEnumSymbols IDiaEnumSymbols; + +#endif /* __IDiaEnumSymbols_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumSymbolsByAddr_FWD_DEFINED__ +#define __IDiaEnumSymbolsByAddr_FWD_DEFINED__ +typedef interface IDiaEnumSymbolsByAddr IDiaEnumSymbolsByAddr; + +#endif /* __IDiaEnumSymbolsByAddr_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumSourceFiles_FWD_DEFINED__ +#define __IDiaEnumSourceFiles_FWD_DEFINED__ +typedef interface IDiaEnumSourceFiles IDiaEnumSourceFiles; + +#endif /* __IDiaEnumSourceFiles_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumInputAssemblyFiles_FWD_DEFINED__ +#define __IDiaEnumInputAssemblyFiles_FWD_DEFINED__ +typedef interface IDiaEnumInputAssemblyFiles IDiaEnumInputAssemblyFiles; + +#endif /* __IDiaEnumInputAssemblyFiles_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumLineNumbers_FWD_DEFINED__ +#define __IDiaEnumLineNumbers_FWD_DEFINED__ +typedef interface IDiaEnumLineNumbers IDiaEnumLineNumbers; + +#endif /* __IDiaEnumLineNumbers_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumInjectedSources_FWD_DEFINED__ +#define __IDiaEnumInjectedSources_FWD_DEFINED__ +typedef interface IDiaEnumInjectedSources IDiaEnumInjectedSources; + +#endif /* __IDiaEnumInjectedSources_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumSegments_FWD_DEFINED__ +#define __IDiaEnumSegments_FWD_DEFINED__ +typedef interface IDiaEnumSegments IDiaEnumSegments; + +#endif /* __IDiaEnumSegments_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumSectionContribs_FWD_DEFINED__ +#define __IDiaEnumSectionContribs_FWD_DEFINED__ +typedef interface IDiaEnumSectionContribs IDiaEnumSectionContribs; + +#endif /* __IDiaEnumSectionContribs_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumFrameData_FWD_DEFINED__ +#define __IDiaEnumFrameData_FWD_DEFINED__ +typedef interface IDiaEnumFrameData IDiaEnumFrameData; + +#endif /* __IDiaEnumFrameData_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumDebugStreamData_FWD_DEFINED__ +#define __IDiaEnumDebugStreamData_FWD_DEFINED__ +typedef interface IDiaEnumDebugStreamData IDiaEnumDebugStreamData; + +#endif /* __IDiaEnumDebugStreamData_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumDebugStreams_FWD_DEFINED__ +#define __IDiaEnumDebugStreams_FWD_DEFINED__ +typedef interface IDiaEnumDebugStreams IDiaEnumDebugStreams; + +#endif /* __IDiaEnumDebugStreams_FWD_DEFINED__ */ + + +#ifndef __IDiaAddressMap_FWD_DEFINED__ +#define __IDiaAddressMap_FWD_DEFINED__ +typedef interface IDiaAddressMap IDiaAddressMap; + +#endif /* __IDiaAddressMap_FWD_DEFINED__ */ + + +#ifndef __IDiaSession_FWD_DEFINED__ +#define __IDiaSession_FWD_DEFINED__ +typedef interface IDiaSession IDiaSession; + +#endif /* __IDiaSession_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol_FWD_DEFINED__ +#define __IDiaSymbol_FWD_DEFINED__ +typedef interface IDiaSymbol IDiaSymbol; + +#endif /* __IDiaSymbol_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol2_FWD_DEFINED__ +#define __IDiaSymbol2_FWD_DEFINED__ +typedef interface IDiaSymbol2 IDiaSymbol2; + +#endif /* __IDiaSymbol2_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol3_FWD_DEFINED__ +#define __IDiaSymbol3_FWD_DEFINED__ +typedef interface IDiaSymbol3 IDiaSymbol3; + +#endif /* __IDiaSymbol3_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol4_FWD_DEFINED__ +#define __IDiaSymbol4_FWD_DEFINED__ +typedef interface IDiaSymbol4 IDiaSymbol4; + +#endif /* __IDiaSymbol4_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol5_FWD_DEFINED__ +#define __IDiaSymbol5_FWD_DEFINED__ +typedef interface IDiaSymbol5 IDiaSymbol5; + +#endif /* __IDiaSymbol5_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol6_FWD_DEFINED__ +#define __IDiaSymbol6_FWD_DEFINED__ +typedef interface IDiaSymbol6 IDiaSymbol6; + +#endif /* __IDiaSymbol6_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol7_FWD_DEFINED__ +#define __IDiaSymbol7_FWD_DEFINED__ +typedef interface IDiaSymbol7 IDiaSymbol7; + +#endif /* __IDiaSymbol7_FWD_DEFINED__ */ + + +#ifndef __IDiaSourceFile_FWD_DEFINED__ +#define __IDiaSourceFile_FWD_DEFINED__ +typedef interface IDiaSourceFile IDiaSourceFile; + +#endif /* __IDiaSourceFile_FWD_DEFINED__ */ + + +#ifndef __IDiaInputAssemblyFile_FWD_DEFINED__ +#define __IDiaInputAssemblyFile_FWD_DEFINED__ +typedef interface IDiaInputAssemblyFile IDiaInputAssemblyFile; + +#endif /* __IDiaInputAssemblyFile_FWD_DEFINED__ */ + + +#ifndef __IDiaLineNumber_FWD_DEFINED__ +#define __IDiaLineNumber_FWD_DEFINED__ +typedef interface IDiaLineNumber IDiaLineNumber; + +#endif /* __IDiaLineNumber_FWD_DEFINED__ */ + + +#ifndef __IDiaSectionContrib_FWD_DEFINED__ +#define __IDiaSectionContrib_FWD_DEFINED__ +typedef interface IDiaSectionContrib IDiaSectionContrib; + +#endif /* __IDiaSectionContrib_FWD_DEFINED__ */ + + +#ifndef __IDiaSegment_FWD_DEFINED__ +#define __IDiaSegment_FWD_DEFINED__ +typedef interface IDiaSegment IDiaSegment; + +#endif /* __IDiaSegment_FWD_DEFINED__ */ + + +#ifndef __IDiaInjectedSource_FWD_DEFINED__ +#define __IDiaInjectedSource_FWD_DEFINED__ +typedef interface IDiaInjectedSource IDiaInjectedSource; + +#endif /* __IDiaInjectedSource_FWD_DEFINED__ */ + + +#ifndef __IDiaStackWalkFrame_FWD_DEFINED__ +#define __IDiaStackWalkFrame_FWD_DEFINED__ +typedef interface IDiaStackWalkFrame IDiaStackWalkFrame; + +#endif /* __IDiaStackWalkFrame_FWD_DEFINED__ */ + + +#ifndef __IDiaFrameData_FWD_DEFINED__ +#define __IDiaFrameData_FWD_DEFINED__ +typedef interface IDiaFrameData IDiaFrameData; + +#endif /* __IDiaFrameData_FWD_DEFINED__ */ + + +#ifndef __IDiaImageData_FWD_DEFINED__ +#define __IDiaImageData_FWD_DEFINED__ +typedef interface IDiaImageData IDiaImageData; + +#endif /* __IDiaImageData_FWD_DEFINED__ */ + + +#ifndef __IDiaTable_FWD_DEFINED__ +#define __IDiaTable_FWD_DEFINED__ +typedef interface IDiaTable IDiaTable; + +#endif /* __IDiaTable_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumTables_FWD_DEFINED__ +#define __IDiaEnumTables_FWD_DEFINED__ +typedef interface IDiaEnumTables IDiaEnumTables; + +#endif /* __IDiaEnumTables_FWD_DEFINED__ */ + + +#ifndef __DiaSource_FWD_DEFINED__ +#define __DiaSource_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class DiaSource DiaSource; +#else +typedef struct DiaSource DiaSource; +#endif /* __cplusplus */ + +#endif /* __DiaSource_FWD_DEFINED__ */ + + +#ifndef __DiaSourceAlt_FWD_DEFINED__ +#define __DiaSourceAlt_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class DiaSourceAlt DiaSourceAlt; +#else +typedef struct DiaSourceAlt DiaSourceAlt; +#endif /* __cplusplus */ + +#endif /* __DiaSourceAlt_FWD_DEFINED__ */ + + +#ifndef __DiaStackWalker_FWD_DEFINED__ +#define __DiaStackWalker_FWD_DEFINED__ + +#ifdef __cplusplus +typedef class DiaStackWalker DiaStackWalker; +#else +typedef struct DiaStackWalker DiaStackWalker; +#endif /* __cplusplus */ + +#endif /* __DiaStackWalker_FWD_DEFINED__ */ + + +#ifndef __IDiaSectionContrib_FWD_DEFINED__ +#define __IDiaSectionContrib_FWD_DEFINED__ +typedef interface IDiaSectionContrib IDiaSectionContrib; + +#endif /* __IDiaSectionContrib_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumSectionContribs_FWD_DEFINED__ +#define __IDiaEnumSectionContribs_FWD_DEFINED__ +typedef interface IDiaEnumSectionContribs IDiaEnumSectionContribs; + +#endif /* __IDiaEnumSectionContribs_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol_FWD_DEFINED__ +#define __IDiaSymbol_FWD_DEFINED__ +typedef interface IDiaSymbol IDiaSymbol; + +#endif /* __IDiaSymbol_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol2_FWD_DEFINED__ +#define __IDiaSymbol2_FWD_DEFINED__ +typedef interface IDiaSymbol2 IDiaSymbol2; + +#endif /* __IDiaSymbol2_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol3_FWD_DEFINED__ +#define __IDiaSymbol3_FWD_DEFINED__ +typedef interface IDiaSymbol3 IDiaSymbol3; + +#endif /* __IDiaSymbol3_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol4_FWD_DEFINED__ +#define __IDiaSymbol4_FWD_DEFINED__ +typedef interface IDiaSymbol4 IDiaSymbol4; + +#endif /* __IDiaSymbol4_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol5_FWD_DEFINED__ +#define __IDiaSymbol5_FWD_DEFINED__ +typedef interface IDiaSymbol5 IDiaSymbol5; + +#endif /* __IDiaSymbol5_FWD_DEFINED__ */ + + +#ifndef __IDiaSymbol6_FWD_DEFINED__ +#define __IDiaSymbol6_FWD_DEFINED__ +typedef interface IDiaSymbol6 IDiaSymbol6; + +#endif /* __IDiaSymbol6_FWD_DEFINED__ */ + + +#ifndef __IDiaPropertyStorage_FWD_DEFINED__ +#define __IDiaPropertyStorage_FWD_DEFINED__ +typedef interface IDiaPropertyStorage IDiaPropertyStorage; + +#endif /* __IDiaPropertyStorage_FWD_DEFINED__ */ + + +#ifndef __IDiaStackFrame_FWD_DEFINED__ +#define __IDiaStackFrame_FWD_DEFINED__ +typedef interface IDiaStackFrame IDiaStackFrame; + +#endif /* __IDiaStackFrame_FWD_DEFINED__ */ + + +#ifndef __IDiaEnumStackFrames_FWD_DEFINED__ +#define __IDiaEnumStackFrames_FWD_DEFINED__ +typedef interface IDiaEnumStackFrames IDiaEnumStackFrames; + +#endif /* __IDiaEnumStackFrames_FWD_DEFINED__ */ + + +#ifndef __IDiaStackWalkHelper_FWD_DEFINED__ +#define __IDiaStackWalkHelper_FWD_DEFINED__ +typedef interface IDiaStackWalkHelper IDiaStackWalkHelper; + +#endif /* __IDiaStackWalkHelper_FWD_DEFINED__ */ + + +#ifndef __IDiaStackWalker_FWD_DEFINED__ +#define __IDiaStackWalker_FWD_DEFINED__ +typedef interface IDiaStackWalker IDiaStackWalker; + +#endif /* __IDiaStackWalker_FWD_DEFINED__ */ + + +#ifndef __IDiaStackWalkHelper2_FWD_DEFINED__ +#define __IDiaStackWalkHelper2_FWD_DEFINED__ +typedef interface IDiaStackWalkHelper2 IDiaStackWalkHelper2; + +#endif /* __IDiaStackWalkHelper2_FWD_DEFINED__ */ + + +#ifndef __IDiaStackWalker2_FWD_DEFINED__ +#define __IDiaStackWalker2_FWD_DEFINED__ +typedef interface IDiaStackWalker2 IDiaStackWalker2; + +#endif /* __IDiaStackWalker2_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "objidl.h" +#include "oaidl.h" +#include "propidl.h" +#include "cvconst.h" + +#ifdef __cplusplus +extern "C"{ +#endif + + +/* interface __MIDL_itf_dia2_0000_0000 */ +/* [local] */ + + +enum NameSearchOptions + { + nsNone = 0, + nsfCaseSensitive = 0x1, + nsfCaseInsensitive = 0x2, + nsfFNameExt = 0x4, + nsfRegularExpression = 0x8, + nsfUndecoratedName = 0x10, + nsCaseSensitive = nsfCaseSensitive, + nsCaseInsensitive = nsfCaseInsensitive, + nsFNameExt = ( nsfCaseInsensitive | nsfFNameExt ) , + nsRegularExpression = ( nsfRegularExpression | nsfCaseSensitive ) , + nsCaseInRegularExpression = ( nsfRegularExpression | nsfCaseInsensitive ) + } ; + +enum __MIDL___MIDL_itf_dia2_0000_0000_0001 + { + E_PDB_OK = ( HRESULT )(( ( ( ( unsigned long )1 << 31 ) | ( ( unsigned long )( LONG )0x6d << 16 ) ) | ( unsigned long )1 ) ), + E_PDB_USAGE = ( E_PDB_OK + 1 ) , + E_PDB_OUT_OF_MEMORY = ( E_PDB_USAGE + 1 ) , + E_PDB_FILE_SYSTEM = ( E_PDB_OUT_OF_MEMORY + 1 ) , + E_PDB_NOT_FOUND = ( E_PDB_FILE_SYSTEM + 1 ) , + E_PDB_INVALID_SIG = ( E_PDB_NOT_FOUND + 1 ) , + E_PDB_INVALID_AGE = ( E_PDB_INVALID_SIG + 1 ) , + E_PDB_PRECOMP_REQUIRED = ( E_PDB_INVALID_AGE + 1 ) , + E_PDB_OUT_OF_TI = ( E_PDB_PRECOMP_REQUIRED + 1 ) , + E_PDB_NOT_IMPLEMENTED = ( E_PDB_OUT_OF_TI + 1 ) , + E_PDB_V1_PDB = ( E_PDB_NOT_IMPLEMENTED + 1 ) , + E_PDB_FORMAT = ( E_PDB_V1_PDB + 1 ) , + E_PDB_LIMIT = ( E_PDB_FORMAT + 1 ) , + E_PDB_CORRUPT = ( E_PDB_LIMIT + 1 ) , + E_PDB_TI16 = ( E_PDB_CORRUPT + 1 ) , + E_PDB_ACCESS_DENIED = ( E_PDB_TI16 + 1 ) , + E_PDB_ILLEGAL_TYPE_EDIT = ( E_PDB_ACCESS_DENIED + 1 ) , + E_PDB_INVALID_EXECUTABLE = ( E_PDB_ILLEGAL_TYPE_EDIT + 1 ) , + E_PDB_DBG_NOT_FOUND = ( E_PDB_INVALID_EXECUTABLE + 1 ) , + E_PDB_NO_DEBUG_INFO = ( E_PDB_DBG_NOT_FOUND + 1 ) , + E_PDB_INVALID_EXE_TIMESTAMP = ( E_PDB_NO_DEBUG_INFO + 1 ) , + E_PDB_RESERVED = ( E_PDB_INVALID_EXE_TIMESTAMP + 1 ) , + E_PDB_DEBUG_INFO_NOT_IN_PDB = ( E_PDB_RESERVED + 1 ) , + E_PDB_SYMSRV_BAD_CACHE_PATH = ( E_PDB_DEBUG_INFO_NOT_IN_PDB + 1 ) , + E_PDB_SYMSRV_CACHE_FULL = ( E_PDB_SYMSRV_BAD_CACHE_PATH + 1 ) , + E_PDB_OBJECT_DISPOSED = ( E_PDB_SYMSRV_CACHE_FULL + 1 ) , + E_PDB_MAX = ( E_PDB_OBJECT_DISPOSED + 1 ) + } ; +typedef void ( __cdecl *PfnPDBDebugDirV )( + BOOL __MIDL____MIDL_itf_dia2_0000_00000000, + void *__MIDL____MIDL_itf_dia2_0000_00000001); + + + + + + + + + + + + + + + + + + + + +extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0000_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0000_v0_0_s_ifspec; + +#ifndef __IDiaLoadCallback_INTERFACE_DEFINED__ +#define __IDiaLoadCallback_INTERFACE_DEFINED__ + +/* interface IDiaLoadCallback */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaLoadCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C32ADB82-73F4-421b-95D5-A4706EDF5DBE") + IDiaLoadCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE NotifyDebugDir( + /* [in] */ BOOL fExecutable, + /* [in] */ DWORD cbData, + /* [size_is][in] */ BYTE *pbData) = 0; + + virtual HRESULT STDMETHODCALLTYPE NotifyOpenDBG( + /* [in] */ LPCOLESTR dbgPath, + /* [in] */ HRESULT resultCode) = 0; + + virtual HRESULT STDMETHODCALLTYPE NotifyOpenPDB( + /* [in] */ LPCOLESTR pdbPath, + /* [in] */ HRESULT resultCode) = 0; + + virtual HRESULT STDMETHODCALLTYPE RestrictRegistryAccess( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE RestrictSymbolServerAccess( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaLoadCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaLoadCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaLoadCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaLoadCallback * This); + + HRESULT ( STDMETHODCALLTYPE *NotifyDebugDir )( + IDiaLoadCallback * This, + /* [in] */ BOOL fExecutable, + /* [in] */ DWORD cbData, + /* [size_is][in] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *NotifyOpenDBG )( + IDiaLoadCallback * This, + /* [in] */ LPCOLESTR dbgPath, + /* [in] */ HRESULT resultCode); + + HRESULT ( STDMETHODCALLTYPE *NotifyOpenPDB )( + IDiaLoadCallback * This, + /* [in] */ LPCOLESTR pdbPath, + /* [in] */ HRESULT resultCode); + + HRESULT ( STDMETHODCALLTYPE *RestrictRegistryAccess )( + IDiaLoadCallback * This); + + HRESULT ( STDMETHODCALLTYPE *RestrictSymbolServerAccess )( + IDiaLoadCallback * This); + + END_INTERFACE + } IDiaLoadCallbackVtbl; + + interface IDiaLoadCallback + { + CONST_VTBL struct IDiaLoadCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaLoadCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaLoadCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaLoadCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaLoadCallback_NotifyDebugDir(This,fExecutable,cbData,pbData) \ + ( (This)->lpVtbl -> NotifyDebugDir(This,fExecutable,cbData,pbData) ) + +#define IDiaLoadCallback_NotifyOpenDBG(This,dbgPath,resultCode) \ + ( (This)->lpVtbl -> NotifyOpenDBG(This,dbgPath,resultCode) ) + +#define IDiaLoadCallback_NotifyOpenPDB(This,pdbPath,resultCode) \ + ( (This)->lpVtbl -> NotifyOpenPDB(This,pdbPath,resultCode) ) + +#define IDiaLoadCallback_RestrictRegistryAccess(This) \ + ( (This)->lpVtbl -> RestrictRegistryAccess(This) ) + +#define IDiaLoadCallback_RestrictSymbolServerAccess(This) \ + ( (This)->lpVtbl -> RestrictSymbolServerAccess(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaLoadCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaLoadCallback2_INTERFACE_DEFINED__ +#define __IDiaLoadCallback2_INTERFACE_DEFINED__ + +/* interface IDiaLoadCallback2 */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaLoadCallback2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("4688a074-5a4d-4486-aea8-7b90711d9f7c") + IDiaLoadCallback2 : public IDiaLoadCallback + { + public: + virtual HRESULT STDMETHODCALLTYPE RestrictOriginalPathAccess( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE RestrictReferencePathAccess( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE RestrictDBGAccess( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE RestrictSystemRootAccess( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaLoadCallback2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaLoadCallback2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaLoadCallback2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaLoadCallback2 * This); + + HRESULT ( STDMETHODCALLTYPE *NotifyDebugDir )( + IDiaLoadCallback2 * This, + /* [in] */ BOOL fExecutable, + /* [in] */ DWORD cbData, + /* [size_is][in] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *NotifyOpenDBG )( + IDiaLoadCallback2 * This, + /* [in] */ LPCOLESTR dbgPath, + /* [in] */ HRESULT resultCode); + + HRESULT ( STDMETHODCALLTYPE *NotifyOpenPDB )( + IDiaLoadCallback2 * This, + /* [in] */ LPCOLESTR pdbPath, + /* [in] */ HRESULT resultCode); + + HRESULT ( STDMETHODCALLTYPE *RestrictRegistryAccess )( + IDiaLoadCallback2 * This); + + HRESULT ( STDMETHODCALLTYPE *RestrictSymbolServerAccess )( + IDiaLoadCallback2 * This); + + HRESULT ( STDMETHODCALLTYPE *RestrictOriginalPathAccess )( + IDiaLoadCallback2 * This); + + HRESULT ( STDMETHODCALLTYPE *RestrictReferencePathAccess )( + IDiaLoadCallback2 * This); + + HRESULT ( STDMETHODCALLTYPE *RestrictDBGAccess )( + IDiaLoadCallback2 * This); + + HRESULT ( STDMETHODCALLTYPE *RestrictSystemRootAccess )( + IDiaLoadCallback2 * This); + + END_INTERFACE + } IDiaLoadCallback2Vtbl; + + interface IDiaLoadCallback2 + { + CONST_VTBL struct IDiaLoadCallback2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaLoadCallback2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaLoadCallback2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaLoadCallback2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaLoadCallback2_NotifyDebugDir(This,fExecutable,cbData,pbData) \ + ( (This)->lpVtbl -> NotifyDebugDir(This,fExecutable,cbData,pbData) ) + +#define IDiaLoadCallback2_NotifyOpenDBG(This,dbgPath,resultCode) \ + ( (This)->lpVtbl -> NotifyOpenDBG(This,dbgPath,resultCode) ) + +#define IDiaLoadCallback2_NotifyOpenPDB(This,pdbPath,resultCode) \ + ( (This)->lpVtbl -> NotifyOpenPDB(This,pdbPath,resultCode) ) + +#define IDiaLoadCallback2_RestrictRegistryAccess(This) \ + ( (This)->lpVtbl -> RestrictRegistryAccess(This) ) + +#define IDiaLoadCallback2_RestrictSymbolServerAccess(This) \ + ( (This)->lpVtbl -> RestrictSymbolServerAccess(This) ) + + +#define IDiaLoadCallback2_RestrictOriginalPathAccess(This) \ + ( (This)->lpVtbl -> RestrictOriginalPathAccess(This) ) + +#define IDiaLoadCallback2_RestrictReferencePathAccess(This) \ + ( (This)->lpVtbl -> RestrictReferencePathAccess(This) ) + +#define IDiaLoadCallback2_RestrictDBGAccess(This) \ + ( (This)->lpVtbl -> RestrictDBGAccess(This) ) + +#define IDiaLoadCallback2_RestrictSystemRootAccess(This) \ + ( (This)->lpVtbl -> RestrictSystemRootAccess(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaLoadCallback2_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaReadExeAtOffsetCallback_INTERFACE_DEFINED__ +#define __IDiaReadExeAtOffsetCallback_INTERFACE_DEFINED__ + +/* interface IDiaReadExeAtOffsetCallback */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaReadExeAtOffsetCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("587A461C-B80B-4f54-9194-5032589A6319") + IDiaReadExeAtOffsetCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ReadExecutableAt( + /* [in] */ DWORDLONG fileOffset, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaReadExeAtOffsetCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaReadExeAtOffsetCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaReadExeAtOffsetCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaReadExeAtOffsetCallback * This); + + HRESULT ( STDMETHODCALLTYPE *ReadExecutableAt )( + IDiaReadExeAtOffsetCallback * This, + /* [in] */ DWORDLONG fileOffset, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + END_INTERFACE + } IDiaReadExeAtOffsetCallbackVtbl; + + interface IDiaReadExeAtOffsetCallback + { + CONST_VTBL struct IDiaReadExeAtOffsetCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaReadExeAtOffsetCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaReadExeAtOffsetCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaReadExeAtOffsetCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaReadExeAtOffsetCallback_ReadExecutableAt(This,fileOffset,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> ReadExecutableAt(This,fileOffset,cbData,pcbData,pbData) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaReadExeAtOffsetCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaReadExeAtRVACallback_INTERFACE_DEFINED__ +#define __IDiaReadExeAtRVACallback_INTERFACE_DEFINED__ + +/* interface IDiaReadExeAtRVACallback */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaReadExeAtRVACallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8E3F80CA-7517-432a-BA07-285134AAEA8E") + IDiaReadExeAtRVACallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ReadExecutableAtRVA( + /* [in] */ DWORD relativeVirtualAddress, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaReadExeAtRVACallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaReadExeAtRVACallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaReadExeAtRVACallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaReadExeAtRVACallback * This); + + HRESULT ( STDMETHODCALLTYPE *ReadExecutableAtRVA )( + IDiaReadExeAtRVACallback * This, + /* [in] */ DWORD relativeVirtualAddress, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + END_INTERFACE + } IDiaReadExeAtRVACallbackVtbl; + + interface IDiaReadExeAtRVACallback + { + CONST_VTBL struct IDiaReadExeAtRVACallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaReadExeAtRVACallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaReadExeAtRVACallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaReadExeAtRVACallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaReadExeAtRVACallback_ReadExecutableAtRVA(This,relativeVirtualAddress,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> ReadExecutableAtRVA(This,relativeVirtualAddress,cbData,pcbData,pbData) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaReadExeAtRVACallback_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaDataSource_INTERFACE_DEFINED__ +#define __IDiaDataSource_INTERFACE_DEFINED__ + +/* interface IDiaDataSource */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaDataSource; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("79F1BB5F-B66E-48e5-B6A9-1545C323CA3D") + IDiaDataSource : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lastError( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE loadDataFromPdb( + /* [in] */ LPCOLESTR pdbPath) = 0; + + virtual HRESULT STDMETHODCALLTYPE loadAndValidateDataFromPdb( + /* [in] */ LPCOLESTR pdbPath, + /* [in] */ GUID *pcsig70, + /* [in] */ DWORD sig, + /* [in] */ DWORD age) = 0; + + virtual HRESULT STDMETHODCALLTYPE loadDataForExe( + /* [in] */ LPCOLESTR executable, + /* [in] */ LPCOLESTR searchPath, + /* [in] */ IUnknown *pCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE loadDataFromIStream( + /* [in] */ IStream *pIStream) = 0; + + virtual HRESULT STDMETHODCALLTYPE openSession( + /* [out] */ IDiaSession **ppSession) = 0; + + virtual HRESULT STDMETHODCALLTYPE loadDataFromCodeViewInfo( + /* [in] */ LPCOLESTR executable, + /* [in] */ LPCOLESTR searchPath, + /* [in] */ DWORD cbCvInfo, + /* [size_is][in] */ BYTE *pbCvInfo, + /* [in] */ IUnknown *pCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE loadDataFromMiscInfo( + /* [in] */ LPCOLESTR executable, + /* [in] */ LPCOLESTR searchPath, + /* [in] */ DWORD timeStampExe, + /* [in] */ DWORD timeStampDbg, + /* [in] */ DWORD sizeOfExe, + /* [in] */ DWORD cbMiscInfo, + /* [size_is][in] */ BYTE *pbMiscInfo, + /* [in] */ IUnknown *pCallback) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaDataSourceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaDataSource * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaDataSource * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaDataSource * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lastError )( + IDiaDataSource * This, + /* [retval][out] */ BSTR *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *loadDataFromPdb )( + IDiaDataSource * This, + /* [in] */ LPCOLESTR pdbPath); + + HRESULT ( STDMETHODCALLTYPE *loadAndValidateDataFromPdb )( + IDiaDataSource * This, + /* [in] */ LPCOLESTR pdbPath, + /* [in] */ GUID *pcsig70, + /* [in] */ DWORD sig, + /* [in] */ DWORD age); + + HRESULT ( STDMETHODCALLTYPE *loadDataForExe )( + IDiaDataSource * This, + /* [in] */ LPCOLESTR executable, + /* [in] */ LPCOLESTR searchPath, + /* [in] */ IUnknown *pCallback); + + HRESULT ( STDMETHODCALLTYPE *loadDataFromIStream )( + IDiaDataSource * This, + /* [in] */ IStream *pIStream); + + HRESULT ( STDMETHODCALLTYPE *openSession )( + IDiaDataSource * This, + /* [out] */ IDiaSession **ppSession); + + HRESULT ( STDMETHODCALLTYPE *loadDataFromCodeViewInfo )( + IDiaDataSource * This, + /* [in] */ LPCOLESTR executable, + /* [in] */ LPCOLESTR searchPath, + /* [in] */ DWORD cbCvInfo, + /* [size_is][in] */ BYTE *pbCvInfo, + /* [in] */ IUnknown *pCallback); + + HRESULT ( STDMETHODCALLTYPE *loadDataFromMiscInfo )( + IDiaDataSource * This, + /* [in] */ LPCOLESTR executable, + /* [in] */ LPCOLESTR searchPath, + /* [in] */ DWORD timeStampExe, + /* [in] */ DWORD timeStampDbg, + /* [in] */ DWORD sizeOfExe, + /* [in] */ DWORD cbMiscInfo, + /* [size_is][in] */ BYTE *pbMiscInfo, + /* [in] */ IUnknown *pCallback); + + END_INTERFACE + } IDiaDataSourceVtbl; + + interface IDiaDataSource + { + CONST_VTBL struct IDiaDataSourceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaDataSource_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaDataSource_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaDataSource_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaDataSource_get_lastError(This,pRetVal) \ + ( (This)->lpVtbl -> get_lastError(This,pRetVal) ) + +#define IDiaDataSource_loadDataFromPdb(This,pdbPath) \ + ( (This)->lpVtbl -> loadDataFromPdb(This,pdbPath) ) + +#define IDiaDataSource_loadAndValidateDataFromPdb(This,pdbPath,pcsig70,sig,age) \ + ( (This)->lpVtbl -> loadAndValidateDataFromPdb(This,pdbPath,pcsig70,sig,age) ) + +#define IDiaDataSource_loadDataForExe(This,executable,searchPath,pCallback) \ + ( (This)->lpVtbl -> loadDataForExe(This,executable,searchPath,pCallback) ) + +#define IDiaDataSource_loadDataFromIStream(This,pIStream) \ + ( (This)->lpVtbl -> loadDataFromIStream(This,pIStream) ) + +#define IDiaDataSource_openSession(This,ppSession) \ + ( (This)->lpVtbl -> openSession(This,ppSession) ) + +#define IDiaDataSource_loadDataFromCodeViewInfo(This,executable,searchPath,cbCvInfo,pbCvInfo,pCallback) \ + ( (This)->lpVtbl -> loadDataFromCodeViewInfo(This,executable,searchPath,cbCvInfo,pbCvInfo,pCallback) ) + +#define IDiaDataSource_loadDataFromMiscInfo(This,executable,searchPath,timeStampExe,timeStampDbg,sizeOfExe,cbMiscInfo,pbMiscInfo,pCallback) \ + ( (This)->lpVtbl -> loadDataFromMiscInfo(This,executable,searchPath,timeStampExe,timeStampDbg,sizeOfExe,cbMiscInfo,pbMiscInfo,pCallback) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaDataSource_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumSymbols_INTERFACE_DEFINED__ +#define __IDiaEnumSymbols_INTERFACE_DEFINED__ + +/* interface IDiaEnumSymbols */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumSymbols; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CAB72C48-443B-48f5-9B0B-42F0820AB29A") + IDiaEnumSymbols : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ DWORD index, + /* [retval][out] */ IDiaSymbol **symbol) = 0; + + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [out] */ IDiaSymbol **rgelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IDiaEnumSymbols **ppenum) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumSymbolsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumSymbols * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumSymbols * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumSymbols * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + IDiaEnumSymbols * This, + /* [retval][out] */ IUnknown **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + IDiaEnumSymbols * This, + /* [retval][out] */ LONG *pRetVal); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + IDiaEnumSymbols * This, + /* [in] */ DWORD index, + /* [retval][out] */ IDiaSymbol **symbol); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumSymbols * This, + /* [in] */ ULONG celt, + /* [out] */ IDiaSymbol **rgelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IDiaEnumSymbols * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaEnumSymbols * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaEnumSymbols * This, + /* [out] */ IDiaEnumSymbols **ppenum); + + END_INTERFACE + } IDiaEnumSymbolsVtbl; + + interface IDiaEnumSymbols + { + CONST_VTBL struct IDiaEnumSymbolsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumSymbols_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumSymbols_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumSymbols_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumSymbols_get__NewEnum(This,pRetVal) \ + ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) + +#define IDiaEnumSymbols_get_Count(This,pRetVal) \ + ( (This)->lpVtbl -> get_Count(This,pRetVal) ) + +#define IDiaEnumSymbols_Item(This,index,symbol) \ + ( (This)->lpVtbl -> Item(This,index,symbol) ) + +#define IDiaEnumSymbols_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumSymbols_Skip(This,celt) \ + ( (This)->lpVtbl -> Skip(This,celt) ) + +#define IDiaEnumSymbols_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#define IDiaEnumSymbols_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumSymbols_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumSymbolsByAddr_INTERFACE_DEFINED__ +#define __IDiaEnumSymbolsByAddr_INTERFACE_DEFINED__ + +/* interface IDiaEnumSymbolsByAddr */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumSymbolsByAddr; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("624B7D9C-24EA-4421-9D06-3B577471C1FA") + IDiaEnumSymbolsByAddr : public IUnknown + { + public: + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE symbolByAddr( + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [retval][out] */ IDiaSymbol **ppSymbol) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE symbolByRVA( + /* [in] */ DWORD relativeVirtualAddress, + /* [retval][out] */ IDiaSymbol **ppSymbol) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE symbolByVA( + /* [in] */ ULONGLONG virtualAddress, + /* [retval][out] */ IDiaSymbol **ppSymbol) = 0; + + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [out] */ IDiaSymbol **rgelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Prev( + /* [in] */ ULONG celt, + /* [out] */ IDiaSymbol **rgelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IDiaEnumSymbolsByAddr **ppenum) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumSymbolsByAddrVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumSymbolsByAddr * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumSymbolsByAddr * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumSymbolsByAddr * This); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *symbolByAddr )( + IDiaEnumSymbolsByAddr * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [retval][out] */ IDiaSymbol **ppSymbol); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *symbolByRVA )( + IDiaEnumSymbolsByAddr * This, + /* [in] */ DWORD relativeVirtualAddress, + /* [retval][out] */ IDiaSymbol **ppSymbol); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *symbolByVA )( + IDiaEnumSymbolsByAddr * This, + /* [in] */ ULONGLONG virtualAddress, + /* [retval][out] */ IDiaSymbol **ppSymbol); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumSymbolsByAddr * This, + /* [in] */ ULONG celt, + /* [out] */ IDiaSymbol **rgelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Prev )( + IDiaEnumSymbolsByAddr * This, + /* [in] */ ULONG celt, + /* [out] */ IDiaSymbol **rgelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaEnumSymbolsByAddr * This, + /* [out] */ IDiaEnumSymbolsByAddr **ppenum); + + END_INTERFACE + } IDiaEnumSymbolsByAddrVtbl; + + interface IDiaEnumSymbolsByAddr + { + CONST_VTBL struct IDiaEnumSymbolsByAddrVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumSymbolsByAddr_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumSymbolsByAddr_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumSymbolsByAddr_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumSymbolsByAddr_symbolByAddr(This,isect,offset,ppSymbol) \ + ( (This)->lpVtbl -> symbolByAddr(This,isect,offset,ppSymbol) ) + +#define IDiaEnumSymbolsByAddr_symbolByRVA(This,relativeVirtualAddress,ppSymbol) \ + ( (This)->lpVtbl -> symbolByRVA(This,relativeVirtualAddress,ppSymbol) ) + +#define IDiaEnumSymbolsByAddr_symbolByVA(This,virtualAddress,ppSymbol) \ + ( (This)->lpVtbl -> symbolByVA(This,virtualAddress,ppSymbol) ) + +#define IDiaEnumSymbolsByAddr_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumSymbolsByAddr_Prev(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Prev(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumSymbolsByAddr_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumSymbolsByAddr_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumSourceFiles_INTERFACE_DEFINED__ +#define __IDiaEnumSourceFiles_INTERFACE_DEFINED__ + +/* interface IDiaEnumSourceFiles */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumSourceFiles; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("10F3DBD9-664F-4469-B808-9471C7A50538") + IDiaEnumSourceFiles : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ DWORD index, + /* [retval][out] */ IDiaSourceFile **sourceFile) = 0; + + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [out] */ IDiaSourceFile **rgelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IDiaEnumSourceFiles **ppenum) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumSourceFilesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumSourceFiles * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumSourceFiles * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumSourceFiles * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + IDiaEnumSourceFiles * This, + /* [retval][out] */ IUnknown **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + IDiaEnumSourceFiles * This, + /* [retval][out] */ LONG *pRetVal); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + IDiaEnumSourceFiles * This, + /* [in] */ DWORD index, + /* [retval][out] */ IDiaSourceFile **sourceFile); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumSourceFiles * This, + /* [in] */ ULONG celt, + /* [out] */ IDiaSourceFile **rgelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IDiaEnumSourceFiles * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaEnumSourceFiles * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaEnumSourceFiles * This, + /* [out] */ IDiaEnumSourceFiles **ppenum); + + END_INTERFACE + } IDiaEnumSourceFilesVtbl; + + interface IDiaEnumSourceFiles + { + CONST_VTBL struct IDiaEnumSourceFilesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumSourceFiles_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumSourceFiles_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumSourceFiles_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumSourceFiles_get__NewEnum(This,pRetVal) \ + ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) + +#define IDiaEnumSourceFiles_get_Count(This,pRetVal) \ + ( (This)->lpVtbl -> get_Count(This,pRetVal) ) + +#define IDiaEnumSourceFiles_Item(This,index,sourceFile) \ + ( (This)->lpVtbl -> Item(This,index,sourceFile) ) + +#define IDiaEnumSourceFiles_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumSourceFiles_Skip(This,celt) \ + ( (This)->lpVtbl -> Skip(This,celt) ) + +#define IDiaEnumSourceFiles_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#define IDiaEnumSourceFiles_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumSourceFiles_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumInputAssemblyFiles_INTERFACE_DEFINED__ +#define __IDiaEnumInputAssemblyFiles_INTERFACE_DEFINED__ + +/* interface IDiaEnumInputAssemblyFiles */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumInputAssemblyFiles; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("1C7FF653-51F7-457E-8419-B20F57EF7E4D") + IDiaEnumInputAssemblyFiles : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ DWORD index, + /* [retval][out] */ IDiaInputAssemblyFile **file) = 0; + + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [out] */ IDiaInputAssemblyFile **rgelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IDiaEnumInputAssemblyFiles **ppenum) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumInputAssemblyFilesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumInputAssemblyFiles * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumInputAssemblyFiles * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumInputAssemblyFiles * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + IDiaEnumInputAssemblyFiles * This, + /* [retval][out] */ IUnknown **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + IDiaEnumInputAssemblyFiles * This, + /* [retval][out] */ LONG *pRetVal); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + IDiaEnumInputAssemblyFiles * This, + /* [in] */ DWORD index, + /* [retval][out] */ IDiaInputAssemblyFile **file); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumInputAssemblyFiles * This, + /* [in] */ ULONG celt, + /* [out] */ IDiaInputAssemblyFile **rgelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IDiaEnumInputAssemblyFiles * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaEnumInputAssemblyFiles * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaEnumInputAssemblyFiles * This, + /* [out] */ IDiaEnumInputAssemblyFiles **ppenum); + + END_INTERFACE + } IDiaEnumInputAssemblyFilesVtbl; + + interface IDiaEnumInputAssemblyFiles + { + CONST_VTBL struct IDiaEnumInputAssemblyFilesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumInputAssemblyFiles_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumInputAssemblyFiles_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumInputAssemblyFiles_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumInputAssemblyFiles_get__NewEnum(This,pRetVal) \ + ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) + +#define IDiaEnumInputAssemblyFiles_get_Count(This,pRetVal) \ + ( (This)->lpVtbl -> get_Count(This,pRetVal) ) + +#define IDiaEnumInputAssemblyFiles_Item(This,index,file) \ + ( (This)->lpVtbl -> Item(This,index,file) ) + +#define IDiaEnumInputAssemblyFiles_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumInputAssemblyFiles_Skip(This,celt) \ + ( (This)->lpVtbl -> Skip(This,celt) ) + +#define IDiaEnumInputAssemblyFiles_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#define IDiaEnumInputAssemblyFiles_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumInputAssemblyFiles_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumLineNumbers_INTERFACE_DEFINED__ +#define __IDiaEnumLineNumbers_INTERFACE_DEFINED__ + +/* interface IDiaEnumLineNumbers */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumLineNumbers; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("FE30E878-54AC-44f1-81BA-39DE940F6052") + IDiaEnumLineNumbers : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ DWORD index, + /* [retval][out] */ IDiaLineNumber **lineNumber) = 0; + + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [out] */ IDiaLineNumber **rgelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IDiaEnumLineNumbers **ppenum) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumLineNumbersVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumLineNumbers * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumLineNumbers * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumLineNumbers * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + IDiaEnumLineNumbers * This, + /* [retval][out] */ IUnknown **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + IDiaEnumLineNumbers * This, + /* [retval][out] */ LONG *pRetVal); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + IDiaEnumLineNumbers * This, + /* [in] */ DWORD index, + /* [retval][out] */ IDiaLineNumber **lineNumber); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumLineNumbers * This, + /* [in] */ ULONG celt, + /* [out] */ IDiaLineNumber **rgelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IDiaEnumLineNumbers * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaEnumLineNumbers * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaEnumLineNumbers * This, + /* [out] */ IDiaEnumLineNumbers **ppenum); + + END_INTERFACE + } IDiaEnumLineNumbersVtbl; + + interface IDiaEnumLineNumbers + { + CONST_VTBL struct IDiaEnumLineNumbersVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumLineNumbers_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumLineNumbers_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumLineNumbers_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumLineNumbers_get__NewEnum(This,pRetVal) \ + ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) + +#define IDiaEnumLineNumbers_get_Count(This,pRetVal) \ + ( (This)->lpVtbl -> get_Count(This,pRetVal) ) + +#define IDiaEnumLineNumbers_Item(This,index,lineNumber) \ + ( (This)->lpVtbl -> Item(This,index,lineNumber) ) + +#define IDiaEnumLineNumbers_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumLineNumbers_Skip(This,celt) \ + ( (This)->lpVtbl -> Skip(This,celt) ) + +#define IDiaEnumLineNumbers_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#define IDiaEnumLineNumbers_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumLineNumbers_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumInjectedSources_INTERFACE_DEFINED__ +#define __IDiaEnumInjectedSources_INTERFACE_DEFINED__ + +/* interface IDiaEnumInjectedSources */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumInjectedSources; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("D5612573-6925-4468-8883-98CDEC8C384A") + IDiaEnumInjectedSources : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ DWORD index, + /* [retval][out] */ IDiaInjectedSource **injectedSource) = 0; + + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [out] */ IDiaInjectedSource **rgelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IDiaEnumInjectedSources **ppenum) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumInjectedSourcesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumInjectedSources * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumInjectedSources * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumInjectedSources * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + IDiaEnumInjectedSources * This, + /* [retval][out] */ IUnknown **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + IDiaEnumInjectedSources * This, + /* [retval][out] */ LONG *pRetVal); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + IDiaEnumInjectedSources * This, + /* [in] */ DWORD index, + /* [retval][out] */ IDiaInjectedSource **injectedSource); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumInjectedSources * This, + /* [in] */ ULONG celt, + /* [out] */ IDiaInjectedSource **rgelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IDiaEnumInjectedSources * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaEnumInjectedSources * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaEnumInjectedSources * This, + /* [out] */ IDiaEnumInjectedSources **ppenum); + + END_INTERFACE + } IDiaEnumInjectedSourcesVtbl; + + interface IDiaEnumInjectedSources + { + CONST_VTBL struct IDiaEnumInjectedSourcesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumInjectedSources_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumInjectedSources_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumInjectedSources_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumInjectedSources_get__NewEnum(This,pRetVal) \ + ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) + +#define IDiaEnumInjectedSources_get_Count(This,pRetVal) \ + ( (This)->lpVtbl -> get_Count(This,pRetVal) ) + +#define IDiaEnumInjectedSources_Item(This,index,injectedSource) \ + ( (This)->lpVtbl -> Item(This,index,injectedSource) ) + +#define IDiaEnumInjectedSources_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumInjectedSources_Skip(This,celt) \ + ( (This)->lpVtbl -> Skip(This,celt) ) + +#define IDiaEnumInjectedSources_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#define IDiaEnumInjectedSources_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumInjectedSources_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumSegments_INTERFACE_DEFINED__ +#define __IDiaEnumSegments_INTERFACE_DEFINED__ + +/* interface IDiaEnumSegments */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumSegments; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("E8368CA9-01D1-419d-AC0C-E31235DBDA9F") + IDiaEnumSegments : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ DWORD index, + /* [retval][out] */ IDiaSegment **segment) = 0; + + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [out] */ IDiaSegment **rgelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IDiaEnumSegments **ppenum) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumSegmentsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumSegments * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumSegments * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumSegments * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + IDiaEnumSegments * This, + /* [retval][out] */ IUnknown **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + IDiaEnumSegments * This, + /* [retval][out] */ LONG *pRetVal); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + IDiaEnumSegments * This, + /* [in] */ DWORD index, + /* [retval][out] */ IDiaSegment **segment); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumSegments * This, + /* [in] */ ULONG celt, + /* [out] */ IDiaSegment **rgelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IDiaEnumSegments * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaEnumSegments * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaEnumSegments * This, + /* [out] */ IDiaEnumSegments **ppenum); + + END_INTERFACE + } IDiaEnumSegmentsVtbl; + + interface IDiaEnumSegments + { + CONST_VTBL struct IDiaEnumSegmentsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumSegments_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumSegments_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumSegments_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumSegments_get__NewEnum(This,pRetVal) \ + ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) + +#define IDiaEnumSegments_get_Count(This,pRetVal) \ + ( (This)->lpVtbl -> get_Count(This,pRetVal) ) + +#define IDiaEnumSegments_Item(This,index,segment) \ + ( (This)->lpVtbl -> Item(This,index,segment) ) + +#define IDiaEnumSegments_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumSegments_Skip(This,celt) \ + ( (This)->lpVtbl -> Skip(This,celt) ) + +#define IDiaEnumSegments_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#define IDiaEnumSegments_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumSegments_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumSectionContribs_INTERFACE_DEFINED__ +#define __IDiaEnumSectionContribs_INTERFACE_DEFINED__ + +/* interface IDiaEnumSectionContribs */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumSectionContribs; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("1994DEB2-2C82-4b1d-A57F-AFF424D54A68") + IDiaEnumSectionContribs : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ DWORD index, + /* [retval][out] */ IDiaSectionContrib **section) = 0; + + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [out] */ IDiaSectionContrib **rgelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IDiaEnumSectionContribs **ppenum) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumSectionContribsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumSectionContribs * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumSectionContribs * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumSectionContribs * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + IDiaEnumSectionContribs * This, + /* [retval][out] */ IUnknown **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + IDiaEnumSectionContribs * This, + /* [retval][out] */ LONG *pRetVal); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + IDiaEnumSectionContribs * This, + /* [in] */ DWORD index, + /* [retval][out] */ IDiaSectionContrib **section); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumSectionContribs * This, + /* [in] */ ULONG celt, + /* [out] */ IDiaSectionContrib **rgelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IDiaEnumSectionContribs * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaEnumSectionContribs * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaEnumSectionContribs * This, + /* [out] */ IDiaEnumSectionContribs **ppenum); + + END_INTERFACE + } IDiaEnumSectionContribsVtbl; + + interface IDiaEnumSectionContribs + { + CONST_VTBL struct IDiaEnumSectionContribsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumSectionContribs_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumSectionContribs_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumSectionContribs_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumSectionContribs_get__NewEnum(This,pRetVal) \ + ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) + +#define IDiaEnumSectionContribs_get_Count(This,pRetVal) \ + ( (This)->lpVtbl -> get_Count(This,pRetVal) ) + +#define IDiaEnumSectionContribs_Item(This,index,section) \ + ( (This)->lpVtbl -> Item(This,index,section) ) + +#define IDiaEnumSectionContribs_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumSectionContribs_Skip(This,celt) \ + ( (This)->lpVtbl -> Skip(This,celt) ) + +#define IDiaEnumSectionContribs_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#define IDiaEnumSectionContribs_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumSectionContribs_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumFrameData_INTERFACE_DEFINED__ +#define __IDiaEnumFrameData_INTERFACE_DEFINED__ + +/* interface IDiaEnumFrameData */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumFrameData; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9FC77A4B-3C1C-44ed-A798-6C1DEEA53E1F") + IDiaEnumFrameData : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ DWORD index, + /* [retval][out] */ IDiaFrameData **frame) = 0; + + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [out] */ IDiaFrameData **rgelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IDiaEnumFrameData **ppenum) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE frameByRVA( + /* [in] */ DWORD relativeVirtualAddress, + /* [retval][out] */ IDiaFrameData **frame) = 0; + + virtual /* [helpstring] */ HRESULT STDMETHODCALLTYPE frameByVA( + /* [in] */ ULONGLONG virtualAddress, + /* [retval][out] */ IDiaFrameData **frame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumFrameDataVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumFrameData * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumFrameData * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumFrameData * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + IDiaEnumFrameData * This, + /* [retval][out] */ IUnknown **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + IDiaEnumFrameData * This, + /* [retval][out] */ LONG *pRetVal); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + IDiaEnumFrameData * This, + /* [in] */ DWORD index, + /* [retval][out] */ IDiaFrameData **frame); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumFrameData * This, + /* [in] */ ULONG celt, + /* [out] */ IDiaFrameData **rgelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IDiaEnumFrameData * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaEnumFrameData * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaEnumFrameData * This, + /* [out] */ IDiaEnumFrameData **ppenum); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *frameByRVA )( + IDiaEnumFrameData * This, + /* [in] */ DWORD relativeVirtualAddress, + /* [retval][out] */ IDiaFrameData **frame); + + /* [helpstring] */ HRESULT ( STDMETHODCALLTYPE *frameByVA )( + IDiaEnumFrameData * This, + /* [in] */ ULONGLONG virtualAddress, + /* [retval][out] */ IDiaFrameData **frame); + + END_INTERFACE + } IDiaEnumFrameDataVtbl; + + interface IDiaEnumFrameData + { + CONST_VTBL struct IDiaEnumFrameDataVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumFrameData_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumFrameData_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumFrameData_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumFrameData_get__NewEnum(This,pRetVal) \ + ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) + +#define IDiaEnumFrameData_get_Count(This,pRetVal) \ + ( (This)->lpVtbl -> get_Count(This,pRetVal) ) + +#define IDiaEnumFrameData_Item(This,index,frame) \ + ( (This)->lpVtbl -> Item(This,index,frame) ) + +#define IDiaEnumFrameData_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumFrameData_Skip(This,celt) \ + ( (This)->lpVtbl -> Skip(This,celt) ) + +#define IDiaEnumFrameData_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#define IDiaEnumFrameData_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + +#define IDiaEnumFrameData_frameByRVA(This,relativeVirtualAddress,frame) \ + ( (This)->lpVtbl -> frameByRVA(This,relativeVirtualAddress,frame) ) + +#define IDiaEnumFrameData_frameByVA(This,virtualAddress,frame) \ + ( (This)->lpVtbl -> frameByVA(This,virtualAddress,frame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumFrameData_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumDebugStreamData_INTERFACE_DEFINED__ +#define __IDiaEnumDebugStreamData_INTERFACE_DEFINED__ + +/* interface IDiaEnumDebugStreamData */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumDebugStreamData; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("486943E8-D187-4a6b-A3C4-291259FFF60D") + IDiaEnumDebugStreamData : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_name( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ DWORD index, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData) = 0; + + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IDiaEnumDebugStreamData **ppenum) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumDebugStreamDataVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumDebugStreamData * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumDebugStreamData * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumDebugStreamData * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + IDiaEnumDebugStreamData * This, + /* [retval][out] */ IUnknown **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + IDiaEnumDebugStreamData * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( + IDiaEnumDebugStreamData * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + IDiaEnumDebugStreamData * This, + /* [in] */ DWORD index, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumDebugStreamData * This, + /* [in] */ ULONG celt, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IDiaEnumDebugStreamData * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaEnumDebugStreamData * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaEnumDebugStreamData * This, + /* [out] */ IDiaEnumDebugStreamData **ppenum); + + END_INTERFACE + } IDiaEnumDebugStreamDataVtbl; + + interface IDiaEnumDebugStreamData + { + CONST_VTBL struct IDiaEnumDebugStreamDataVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumDebugStreamData_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumDebugStreamData_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumDebugStreamData_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumDebugStreamData_get__NewEnum(This,pRetVal) \ + ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) + +#define IDiaEnumDebugStreamData_get_Count(This,pRetVal) \ + ( (This)->lpVtbl -> get_Count(This,pRetVal) ) + +#define IDiaEnumDebugStreamData_get_name(This,pRetVal) \ + ( (This)->lpVtbl -> get_name(This,pRetVal) ) + +#define IDiaEnumDebugStreamData_Item(This,index,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> Item(This,index,cbData,pcbData,pbData) ) + +#define IDiaEnumDebugStreamData_Next(This,celt,cbData,pcbData,pbData,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,cbData,pcbData,pbData,pceltFetched) ) + +#define IDiaEnumDebugStreamData_Skip(This,celt) \ + ( (This)->lpVtbl -> Skip(This,celt) ) + +#define IDiaEnumDebugStreamData_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#define IDiaEnumDebugStreamData_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumDebugStreamData_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumDebugStreams_INTERFACE_DEFINED__ +#define __IDiaEnumDebugStreams_INTERFACE_DEFINED__ + +/* interface IDiaEnumDebugStreams */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumDebugStreams; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("08CBB41E-47A6-4f87-92F1-1C9C87CED044") + IDiaEnumDebugStreams : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ VARIANT index, + /* [retval][out] */ IDiaEnumDebugStreamData **stream) = 0; + + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [out] */ IDiaEnumDebugStreamData **rgelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IDiaEnumDebugStreams **ppenum) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumDebugStreamsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumDebugStreams * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumDebugStreams * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumDebugStreams * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + IDiaEnumDebugStreams * This, + /* [retval][out] */ IUnknown **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + IDiaEnumDebugStreams * This, + /* [retval][out] */ LONG *pRetVal); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + IDiaEnumDebugStreams * This, + /* [in] */ VARIANT index, + /* [retval][out] */ IDiaEnumDebugStreamData **stream); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumDebugStreams * This, + /* [in] */ ULONG celt, + /* [out] */ IDiaEnumDebugStreamData **rgelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IDiaEnumDebugStreams * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaEnumDebugStreams * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaEnumDebugStreams * This, + /* [out] */ IDiaEnumDebugStreams **ppenum); + + END_INTERFACE + } IDiaEnumDebugStreamsVtbl; + + interface IDiaEnumDebugStreams + { + CONST_VTBL struct IDiaEnumDebugStreamsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumDebugStreams_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumDebugStreams_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumDebugStreams_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumDebugStreams_get__NewEnum(This,pRetVal) \ + ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) + +#define IDiaEnumDebugStreams_get_Count(This,pRetVal) \ + ( (This)->lpVtbl -> get_Count(This,pRetVal) ) + +#define IDiaEnumDebugStreams_Item(This,index,stream) \ + ( (This)->lpVtbl -> Item(This,index,stream) ) + +#define IDiaEnumDebugStreams_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumDebugStreams_Skip(This,celt) \ + ( (This)->lpVtbl -> Skip(This,celt) ) + +#define IDiaEnumDebugStreams_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#define IDiaEnumDebugStreams_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumDebugStreams_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_dia2_0000_0016 */ +/* [local] */ + +struct DiaAddressMapEntry + { + DWORD rva; + DWORD rvaTo; + } ; + + +extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0016_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0016_v0_0_s_ifspec; + +#ifndef __IDiaAddressMap_INTERFACE_DEFINED__ +#define __IDiaAddressMap_INTERFACE_DEFINED__ + +/* interface IDiaAddressMap */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaAddressMap; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B62A2E7A-067A-4ea3-B598-04C09717502C") + IDiaAddressMap : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressMapEnabled( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_addressMapEnabled( + /* [in] */ BOOL NewVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddressEnabled( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_relativeVirtualAddressEnabled( + /* [in] */ BOOL NewVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_imageAlign( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_imageAlign( + /* [in] */ DWORD NewVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE set_imageHeaders( + /* [in] */ DWORD cbData, + /* [size_is][in] */ BYTE *pbData, + /* [in] */ BOOL originalHeaders) = 0; + + virtual HRESULT STDMETHODCALLTYPE set_addressMap( + /* [in] */ DWORD cData, + /* [size_is][in] */ struct DiaAddressMapEntry *pData, + /* [in] */ BOOL imageToSymbols) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaAddressMapVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaAddressMap * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaAddressMap * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaAddressMap * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressMapEnabled )( + IDiaAddressMap * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_addressMapEnabled )( + IDiaAddressMap * This, + /* [in] */ BOOL NewVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddressEnabled )( + IDiaAddressMap * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_relativeVirtualAddressEnabled )( + IDiaAddressMap * This, + /* [in] */ BOOL NewVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_imageAlign )( + IDiaAddressMap * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_imageAlign )( + IDiaAddressMap * This, + /* [in] */ DWORD NewVal); + + HRESULT ( STDMETHODCALLTYPE *set_imageHeaders )( + IDiaAddressMap * This, + /* [in] */ DWORD cbData, + /* [size_is][in] */ BYTE *pbData, + /* [in] */ BOOL originalHeaders); + + HRESULT ( STDMETHODCALLTYPE *set_addressMap )( + IDiaAddressMap * This, + /* [in] */ DWORD cData, + /* [size_is][in] */ struct DiaAddressMapEntry *pData, + /* [in] */ BOOL imageToSymbols); + + END_INTERFACE + } IDiaAddressMapVtbl; + + interface IDiaAddressMap + { + CONST_VTBL struct IDiaAddressMapVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaAddressMap_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaAddressMap_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaAddressMap_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaAddressMap_get_addressMapEnabled(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressMapEnabled(This,pRetVal) ) + +#define IDiaAddressMap_put_addressMapEnabled(This,NewVal) \ + ( (This)->lpVtbl -> put_addressMapEnabled(This,NewVal) ) + +#define IDiaAddressMap_get_relativeVirtualAddressEnabled(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddressEnabled(This,pRetVal) ) + +#define IDiaAddressMap_put_relativeVirtualAddressEnabled(This,NewVal) \ + ( (This)->lpVtbl -> put_relativeVirtualAddressEnabled(This,NewVal) ) + +#define IDiaAddressMap_get_imageAlign(This,pRetVal) \ + ( (This)->lpVtbl -> get_imageAlign(This,pRetVal) ) + +#define IDiaAddressMap_put_imageAlign(This,NewVal) \ + ( (This)->lpVtbl -> put_imageAlign(This,NewVal) ) + +#define IDiaAddressMap_set_imageHeaders(This,cbData,pbData,originalHeaders) \ + ( (This)->lpVtbl -> set_imageHeaders(This,cbData,pbData,originalHeaders) ) + +#define IDiaAddressMap_set_addressMap(This,cData,pData,imageToSymbols) \ + ( (This)->lpVtbl -> set_addressMap(This,cData,pData,imageToSymbols) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaAddressMap_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaSession_INTERFACE_DEFINED__ +#define __IDiaSession_INTERFACE_DEFINED__ + +/* interface IDiaSession */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaSession; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2F609EE1-D1C8-4E24-8288-3326BADCD211") + IDiaSession : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_loadAddress( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_loadAddress( + /* [in] */ ULONGLONG NewVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_globalScope( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE getEnumTables( + /* [out] */ IDiaEnumTables **ppEnumTables) = 0; + + virtual HRESULT STDMETHODCALLTYPE getSymbolsByAddr( + /* [out] */ IDiaEnumSymbolsByAddr **ppEnumbyAddr) = 0; + + virtual HRESULT STDMETHODCALLTYPE findChildren( + /* [in] */ IDiaSymbol *parent, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findChildrenEx( + /* [in] */ IDiaSymbol *parent, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findChildrenExByAddr( + /* [in] */ IDiaSymbol *parent, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findChildrenExByVA( + /* [in] */ IDiaSymbol *parent, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findChildrenExByRVA( + /* [in] */ IDiaSymbol *parent, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findSymbolByAddr( + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ enum SymTagEnum symtag, + /* [out] */ IDiaSymbol **ppSymbol) = 0; + + virtual HRESULT STDMETHODCALLTYPE findSymbolByRVA( + /* [in] */ DWORD rva, + /* [in] */ enum SymTagEnum symtag, + /* [out] */ IDiaSymbol **ppSymbol) = 0; + + virtual HRESULT STDMETHODCALLTYPE findSymbolByVA( + /* [in] */ ULONGLONG va, + /* [in] */ enum SymTagEnum symtag, + /* [out] */ IDiaSymbol **ppSymbol) = 0; + + virtual HRESULT STDMETHODCALLTYPE findSymbolByToken( + /* [in] */ ULONG token, + /* [in] */ enum SymTagEnum symtag, + /* [out] */ IDiaSymbol **ppSymbol) = 0; + + virtual HRESULT STDMETHODCALLTYPE symsAreEquiv( + /* [in] */ IDiaSymbol *symbolA, + /* [in] */ IDiaSymbol *symbolB) = 0; + + virtual HRESULT STDMETHODCALLTYPE symbolById( + /* [in] */ DWORD id, + /* [out] */ IDiaSymbol **ppSymbol) = 0; + + virtual HRESULT STDMETHODCALLTYPE findSymbolByRVAEx( + /* [in] */ DWORD rva, + /* [in] */ enum SymTagEnum symtag, + /* [out] */ IDiaSymbol **ppSymbol, + /* [out] */ long *displacement) = 0; + + virtual HRESULT STDMETHODCALLTYPE findSymbolByVAEx( + /* [in] */ ULONGLONG va, + /* [in] */ enum SymTagEnum symtag, + /* [out] */ IDiaSymbol **ppSymbol, + /* [out] */ long *displacement) = 0; + + virtual HRESULT STDMETHODCALLTYPE findFile( + /* [in] */ IDiaSymbol *pCompiland, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSourceFiles **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findFileById( + /* [in] */ DWORD uniqueId, + /* [out] */ IDiaSourceFile **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findLines( + /* [in] */ IDiaSymbol *compiland, + /* [in] */ IDiaSourceFile *file, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findLinesByAddr( + /* [in] */ DWORD seg, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findLinesByRVA( + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findLinesByVA( + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findLinesByLinenum( + /* [in] */ IDiaSymbol *compiland, + /* [in] */ IDiaSourceFile *file, + /* [in] */ DWORD linenum, + /* [in] */ DWORD column, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInjectedSource( + /* [in] */ LPCOLESTR srcFile, + /* [out] */ IDiaEnumInjectedSources **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE getEnumDebugStreams( + /* [out] */ IDiaEnumDebugStreams **ppEnumDebugStreams) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineFramesByAddr( + /* [in] */ IDiaSymbol *parent, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineFramesByRVA( + /* [in] */ IDiaSymbol *parent, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineFramesByVA( + /* [in] */ IDiaSymbol *parent, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineeLines( + /* [in] */ IDiaSymbol *parent, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByAddr( + /* [in] */ IDiaSymbol *parent, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByRVA( + /* [in] */ IDiaSymbol *parent, + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByVA( + /* [in] */ IDiaSymbol *parent, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByLinenum( + /* [in] */ IDiaSymbol *compiland, + /* [in] */ IDiaSourceFile *file, + /* [in] */ DWORD linenum, + /* [in] */ DWORD column, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineesByName( + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD option, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findAcceleratorInlineeLinesByLinenum( + /* [in] */ IDiaSymbol *parent, + /* [in] */ IDiaSourceFile *file, + /* [in] */ DWORD linenum, + /* [in] */ DWORD column, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findSymbolsForAcceleratorPointerTag( + /* [in] */ IDiaSymbol *parent, + /* [in] */ DWORD tagValue, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findSymbolsByRVAForAcceleratorPointerTag( + /* [in] */ IDiaSymbol *parent, + /* [in] */ DWORD tagValue, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findAcceleratorInlineesByName( + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD option, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE addressForVA( + /* [in] */ ULONGLONG va, + /* [out] */ DWORD *pISect, + /* [out] */ DWORD *pOffset) = 0; + + virtual HRESULT STDMETHODCALLTYPE addressForRVA( + /* [in] */ DWORD rva, + /* [out] */ DWORD *pISect, + /* [out] */ DWORD *pOffset) = 0; + + virtual HRESULT STDMETHODCALLTYPE findILOffsetsByAddr( + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findILOffsetsByRVA( + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findILOffsetsByVA( + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInputAssemblyFiles( + /* [out] */ IDiaEnumInputAssemblyFiles **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInputAssembly( + /* [in] */ DWORD index, + /* [out] */ IDiaInputAssemblyFile **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInputAssemblyById( + /* [in] */ DWORD uniqueId, + /* [out] */ IDiaInputAssemblyFile **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE getFuncMDTokenMapSize( + /* [out] */ DWORD *pcb) = 0; + + virtual HRESULT STDMETHODCALLTYPE getFuncMDTokenMap( + /* [in] */ DWORD cb, + /* [out] */ DWORD *pcb, + /* [size_is][out] */ BYTE *pb) = 0; + + virtual HRESULT STDMETHODCALLTYPE getTypeMDTokenMapSize( + /* [out] */ DWORD *pcb) = 0; + + virtual HRESULT STDMETHODCALLTYPE getTypeMDTokenMap( + /* [in] */ DWORD cb, + /* [out] */ DWORD *pcb, + /* [size_is][out] */ BYTE *pb) = 0; + + virtual HRESULT STDMETHODCALLTYPE getNumberOfFunctionFragments_VA( + /* [in] */ ULONGLONG vaFunc, + /* [in] */ DWORD cbFunc, + /* [out] */ DWORD *pNumFragments) = 0; + + virtual HRESULT STDMETHODCALLTYPE getNumberOfFunctionFragments_RVA( + /* [in] */ DWORD rvaFunc, + /* [in] */ DWORD cbFunc, + /* [out] */ DWORD *pNumFragments) = 0; + + virtual HRESULT STDMETHODCALLTYPE getFunctionFragments_VA( + /* [in] */ ULONGLONG vaFunc, + /* [in] */ DWORD cbFunc, + /* [in] */ DWORD cFragments, + /* [size_is][out] */ ULONGLONG *pVaFragment, + /* [size_is][out] */ DWORD *pLenFragment) = 0; + + virtual HRESULT STDMETHODCALLTYPE getFunctionFragments_RVA( + /* [in] */ DWORD rvaFunc, + /* [in] */ DWORD cbFunc, + /* [in] */ DWORD cFragments, + /* [size_is][out] */ DWORD *pRvaFragment, + /* [size_is][out] */ DWORD *pLenFragment) = 0; + + virtual HRESULT STDMETHODCALLTYPE getExports( + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE getHeapAllocationSites( + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInputAssemblyFile( + /* [in] */ IDiaSymbol *pSymbol, + /* [out] */ IDiaInputAssemblyFile **ppResult) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaSessionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaSession * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaSession * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaSession * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_loadAddress )( + IDiaSession * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_loadAddress )( + IDiaSession * This, + /* [in] */ ULONGLONG NewVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_globalScope )( + IDiaSession * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + HRESULT ( STDMETHODCALLTYPE *getEnumTables )( + IDiaSession * This, + /* [out] */ IDiaEnumTables **ppEnumTables); + + HRESULT ( STDMETHODCALLTYPE *getSymbolsByAddr )( + IDiaSession * This, + /* [out] */ IDiaEnumSymbolsByAddr **ppEnumbyAddr); + + HRESULT ( STDMETHODCALLTYPE *findChildren )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolByAddr )( + IDiaSession * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ enum SymTagEnum symtag, + /* [out] */ IDiaSymbol **ppSymbol); + + HRESULT ( STDMETHODCALLTYPE *findSymbolByRVA )( + IDiaSession * This, + /* [in] */ DWORD rva, + /* [in] */ enum SymTagEnum symtag, + /* [out] */ IDiaSymbol **ppSymbol); + + HRESULT ( STDMETHODCALLTYPE *findSymbolByVA )( + IDiaSession * This, + /* [in] */ ULONGLONG va, + /* [in] */ enum SymTagEnum symtag, + /* [out] */ IDiaSymbol **ppSymbol); + + HRESULT ( STDMETHODCALLTYPE *findSymbolByToken )( + IDiaSession * This, + /* [in] */ ULONG token, + /* [in] */ enum SymTagEnum symtag, + /* [out] */ IDiaSymbol **ppSymbol); + + HRESULT ( STDMETHODCALLTYPE *symsAreEquiv )( + IDiaSession * This, + /* [in] */ IDiaSymbol *symbolA, + /* [in] */ IDiaSymbol *symbolB); + + HRESULT ( STDMETHODCALLTYPE *symbolById )( + IDiaSession * This, + /* [in] */ DWORD id, + /* [out] */ IDiaSymbol **ppSymbol); + + HRESULT ( STDMETHODCALLTYPE *findSymbolByRVAEx )( + IDiaSession * This, + /* [in] */ DWORD rva, + /* [in] */ enum SymTagEnum symtag, + /* [out] */ IDiaSymbol **ppSymbol, + /* [out] */ long *displacement); + + HRESULT ( STDMETHODCALLTYPE *findSymbolByVAEx )( + IDiaSession * This, + /* [in] */ ULONGLONG va, + /* [in] */ enum SymTagEnum symtag, + /* [out] */ IDiaSymbol **ppSymbol, + /* [out] */ long *displacement); + + HRESULT ( STDMETHODCALLTYPE *findFile )( + IDiaSession * This, + /* [in] */ IDiaSymbol *pCompiland, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSourceFiles **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findFileById )( + IDiaSession * This, + /* [in] */ DWORD uniqueId, + /* [out] */ IDiaSourceFile **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findLines )( + IDiaSession * This, + /* [in] */ IDiaSymbol *compiland, + /* [in] */ IDiaSourceFile *file, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findLinesByAddr )( + IDiaSession * This, + /* [in] */ DWORD seg, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findLinesByRVA )( + IDiaSession * This, + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findLinesByVA )( + IDiaSession * This, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findLinesByLinenum )( + IDiaSession * This, + /* [in] */ IDiaSymbol *compiland, + /* [in] */ IDiaSourceFile *file, + /* [in] */ DWORD linenum, + /* [in] */ DWORD column, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInjectedSource )( + IDiaSession * This, + /* [in] */ LPCOLESTR srcFile, + /* [out] */ IDiaEnumInjectedSources **ppResult); + + HRESULT ( STDMETHODCALLTYPE *getEnumDebugStreams )( + IDiaSession * This, + /* [out] */ IDiaEnumDebugStreams **ppEnumDebugStreams); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByLinenum )( + IDiaSession * This, + /* [in] */ IDiaSymbol *compiland, + /* [in] */ IDiaSourceFile *file, + /* [in] */ DWORD linenum, + /* [in] */ DWORD column, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineesByName )( + IDiaSession * This, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD option, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findAcceleratorInlineeLinesByLinenum )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ IDiaSourceFile *file, + /* [in] */ DWORD linenum, + /* [in] */ DWORD column, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ DWORD tagValue, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( + IDiaSession * This, + /* [in] */ IDiaSymbol *parent, + /* [in] */ DWORD tagValue, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findAcceleratorInlineesByName )( + IDiaSession * This, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD option, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *addressForVA )( + IDiaSession * This, + /* [in] */ ULONGLONG va, + /* [out] */ DWORD *pISect, + /* [out] */ DWORD *pOffset); + + HRESULT ( STDMETHODCALLTYPE *addressForRVA )( + IDiaSession * This, + /* [in] */ DWORD rva, + /* [out] */ DWORD *pISect, + /* [out] */ DWORD *pOffset); + + HRESULT ( STDMETHODCALLTYPE *findILOffsetsByAddr )( + IDiaSession * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findILOffsetsByRVA )( + IDiaSession * This, + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findILOffsetsByVA )( + IDiaSession * This, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFiles )( + IDiaSession * This, + /* [out] */ IDiaEnumInputAssemblyFiles **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInputAssembly )( + IDiaSession * This, + /* [in] */ DWORD index, + /* [out] */ IDiaInputAssemblyFile **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInputAssemblyById )( + IDiaSession * This, + /* [in] */ DWORD uniqueId, + /* [out] */ IDiaInputAssemblyFile **ppResult); + + HRESULT ( STDMETHODCALLTYPE *getFuncMDTokenMapSize )( + IDiaSession * This, + /* [out] */ DWORD *pcb); + + HRESULT ( STDMETHODCALLTYPE *getFuncMDTokenMap )( + IDiaSession * This, + /* [in] */ DWORD cb, + /* [out] */ DWORD *pcb, + /* [size_is][out] */ BYTE *pb); + + HRESULT ( STDMETHODCALLTYPE *getTypeMDTokenMapSize )( + IDiaSession * This, + /* [out] */ DWORD *pcb); + + HRESULT ( STDMETHODCALLTYPE *getTypeMDTokenMap )( + IDiaSession * This, + /* [in] */ DWORD cb, + /* [out] */ DWORD *pcb, + /* [size_is][out] */ BYTE *pb); + + HRESULT ( STDMETHODCALLTYPE *getNumberOfFunctionFragments_VA )( + IDiaSession * This, + /* [in] */ ULONGLONG vaFunc, + /* [in] */ DWORD cbFunc, + /* [out] */ DWORD *pNumFragments); + + HRESULT ( STDMETHODCALLTYPE *getNumberOfFunctionFragments_RVA )( + IDiaSession * This, + /* [in] */ DWORD rvaFunc, + /* [in] */ DWORD cbFunc, + /* [out] */ DWORD *pNumFragments); + + HRESULT ( STDMETHODCALLTYPE *getFunctionFragments_VA )( + IDiaSession * This, + /* [in] */ ULONGLONG vaFunc, + /* [in] */ DWORD cbFunc, + /* [in] */ DWORD cFragments, + /* [size_is][out] */ ULONGLONG *pVaFragment, + /* [size_is][out] */ DWORD *pLenFragment); + + HRESULT ( STDMETHODCALLTYPE *getFunctionFragments_RVA )( + IDiaSession * This, + /* [in] */ DWORD rvaFunc, + /* [in] */ DWORD cbFunc, + /* [in] */ DWORD cFragments, + /* [size_is][out] */ DWORD *pRvaFragment, + /* [size_is][out] */ DWORD *pLenFragment); + + HRESULT ( STDMETHODCALLTYPE *getExports )( + IDiaSession * This, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *getHeapAllocationSites )( + IDiaSession * This, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( + IDiaSession * This, + /* [in] */ IDiaSymbol *pSymbol, + /* [out] */ IDiaInputAssemblyFile **ppResult); + + END_INTERFACE + } IDiaSessionVtbl; + + interface IDiaSession + { + CONST_VTBL struct IDiaSessionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaSession_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaSession_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaSession_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaSession_get_loadAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_loadAddress(This,pRetVal) ) + +#define IDiaSession_put_loadAddress(This,NewVal) \ + ( (This)->lpVtbl -> put_loadAddress(This,NewVal) ) + +#define IDiaSession_get_globalScope(This,pRetVal) \ + ( (This)->lpVtbl -> get_globalScope(This,pRetVal) ) + +#define IDiaSession_getEnumTables(This,ppEnumTables) \ + ( (This)->lpVtbl -> getEnumTables(This,ppEnumTables) ) + +#define IDiaSession_getSymbolsByAddr(This,ppEnumbyAddr) \ + ( (This)->lpVtbl -> getSymbolsByAddr(This,ppEnumbyAddr) ) + +#define IDiaSession_findChildren(This,parent,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildren(This,parent,symtag,name,compareFlags,ppResult) ) + +#define IDiaSession_findChildrenEx(This,parent,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildrenEx(This,parent,symtag,name,compareFlags,ppResult) ) + +#define IDiaSession_findChildrenExByAddr(This,parent,symtag,name,compareFlags,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByAddr(This,parent,symtag,name,compareFlags,isect,offset,ppResult) ) + +#define IDiaSession_findChildrenExByVA(This,parent,symtag,name,compareFlags,va,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByVA(This,parent,symtag,name,compareFlags,va,ppResult) ) + +#define IDiaSession_findChildrenExByRVA(This,parent,symtag,name,compareFlags,rva,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByRVA(This,parent,symtag,name,compareFlags,rva,ppResult) ) + +#define IDiaSession_findSymbolByAddr(This,isect,offset,symtag,ppSymbol) \ + ( (This)->lpVtbl -> findSymbolByAddr(This,isect,offset,symtag,ppSymbol) ) + +#define IDiaSession_findSymbolByRVA(This,rva,symtag,ppSymbol) \ + ( (This)->lpVtbl -> findSymbolByRVA(This,rva,symtag,ppSymbol) ) + +#define IDiaSession_findSymbolByVA(This,va,symtag,ppSymbol) \ + ( (This)->lpVtbl -> findSymbolByVA(This,va,symtag,ppSymbol) ) + +#define IDiaSession_findSymbolByToken(This,token,symtag,ppSymbol) \ + ( (This)->lpVtbl -> findSymbolByToken(This,token,symtag,ppSymbol) ) + +#define IDiaSession_symsAreEquiv(This,symbolA,symbolB) \ + ( (This)->lpVtbl -> symsAreEquiv(This,symbolA,symbolB) ) + +#define IDiaSession_symbolById(This,id,ppSymbol) \ + ( (This)->lpVtbl -> symbolById(This,id,ppSymbol) ) + +#define IDiaSession_findSymbolByRVAEx(This,rva,symtag,ppSymbol,displacement) \ + ( (This)->lpVtbl -> findSymbolByRVAEx(This,rva,symtag,ppSymbol,displacement) ) + +#define IDiaSession_findSymbolByVAEx(This,va,symtag,ppSymbol,displacement) \ + ( (This)->lpVtbl -> findSymbolByVAEx(This,va,symtag,ppSymbol,displacement) ) + +#define IDiaSession_findFile(This,pCompiland,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findFile(This,pCompiland,name,compareFlags,ppResult) ) + +#define IDiaSession_findFileById(This,uniqueId,ppResult) \ + ( (This)->lpVtbl -> findFileById(This,uniqueId,ppResult) ) + +#define IDiaSession_findLines(This,compiland,file,ppResult) \ + ( (This)->lpVtbl -> findLines(This,compiland,file,ppResult) ) + +#define IDiaSession_findLinesByAddr(This,seg,offset,length,ppResult) \ + ( (This)->lpVtbl -> findLinesByAddr(This,seg,offset,length,ppResult) ) + +#define IDiaSession_findLinesByRVA(This,rva,length,ppResult) \ + ( (This)->lpVtbl -> findLinesByRVA(This,rva,length,ppResult) ) + +#define IDiaSession_findLinesByVA(This,va,length,ppResult) \ + ( (This)->lpVtbl -> findLinesByVA(This,va,length,ppResult) ) + +#define IDiaSession_findLinesByLinenum(This,compiland,file,linenum,column,ppResult) \ + ( (This)->lpVtbl -> findLinesByLinenum(This,compiland,file,linenum,column,ppResult) ) + +#define IDiaSession_findInjectedSource(This,srcFile,ppResult) \ + ( (This)->lpVtbl -> findInjectedSource(This,srcFile,ppResult) ) + +#define IDiaSession_getEnumDebugStreams(This,ppEnumDebugStreams) \ + ( (This)->lpVtbl -> getEnumDebugStreams(This,ppEnumDebugStreams) ) + +#define IDiaSession_findInlineFramesByAddr(This,parent,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByAddr(This,parent,isect,offset,ppResult) ) + +#define IDiaSession_findInlineFramesByRVA(This,parent,rva,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByRVA(This,parent,rva,ppResult) ) + +#define IDiaSession_findInlineFramesByVA(This,parent,va,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByVA(This,parent,va,ppResult) ) + +#define IDiaSession_findInlineeLines(This,parent,ppResult) \ + ( (This)->lpVtbl -> findInlineeLines(This,parent,ppResult) ) + +#define IDiaSession_findInlineeLinesByAddr(This,parent,isect,offset,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByAddr(This,parent,isect,offset,length,ppResult) ) + +#define IDiaSession_findInlineeLinesByRVA(This,parent,rva,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByRVA(This,parent,rva,length,ppResult) ) + +#define IDiaSession_findInlineeLinesByVA(This,parent,va,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByVA(This,parent,va,length,ppResult) ) + +#define IDiaSession_findInlineeLinesByLinenum(This,compiland,file,linenum,column,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByLinenum(This,compiland,file,linenum,column,ppResult) ) + +#define IDiaSession_findInlineesByName(This,name,option,ppResult) \ + ( (This)->lpVtbl -> findInlineesByName(This,name,option,ppResult) ) + +#define IDiaSession_findAcceleratorInlineeLinesByLinenum(This,parent,file,linenum,column,ppResult) \ + ( (This)->lpVtbl -> findAcceleratorInlineeLinesByLinenum(This,parent,file,linenum,column,ppResult) ) + +#define IDiaSession_findSymbolsForAcceleratorPointerTag(This,parent,tagValue,ppResult) \ + ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,parent,tagValue,ppResult) ) + +#define IDiaSession_findSymbolsByRVAForAcceleratorPointerTag(This,parent,tagValue,rva,ppResult) \ + ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,parent,tagValue,rva,ppResult) ) + +#define IDiaSession_findAcceleratorInlineesByName(This,name,option,ppResult) \ + ( (This)->lpVtbl -> findAcceleratorInlineesByName(This,name,option,ppResult) ) + +#define IDiaSession_addressForVA(This,va,pISect,pOffset) \ + ( (This)->lpVtbl -> addressForVA(This,va,pISect,pOffset) ) + +#define IDiaSession_addressForRVA(This,rva,pISect,pOffset) \ + ( (This)->lpVtbl -> addressForRVA(This,rva,pISect,pOffset) ) + +#define IDiaSession_findILOffsetsByAddr(This,isect,offset,length,ppResult) \ + ( (This)->lpVtbl -> findILOffsetsByAddr(This,isect,offset,length,ppResult) ) + +#define IDiaSession_findILOffsetsByRVA(This,rva,length,ppResult) \ + ( (This)->lpVtbl -> findILOffsetsByRVA(This,rva,length,ppResult) ) + +#define IDiaSession_findILOffsetsByVA(This,va,length,ppResult) \ + ( (This)->lpVtbl -> findILOffsetsByVA(This,va,length,ppResult) ) + +#define IDiaSession_findInputAssemblyFiles(This,ppResult) \ + ( (This)->lpVtbl -> findInputAssemblyFiles(This,ppResult) ) + +#define IDiaSession_findInputAssembly(This,index,ppResult) \ + ( (This)->lpVtbl -> findInputAssembly(This,index,ppResult) ) + +#define IDiaSession_findInputAssemblyById(This,uniqueId,ppResult) \ + ( (This)->lpVtbl -> findInputAssemblyById(This,uniqueId,ppResult) ) + +#define IDiaSession_getFuncMDTokenMapSize(This,pcb) \ + ( (This)->lpVtbl -> getFuncMDTokenMapSize(This,pcb) ) + +#define IDiaSession_getFuncMDTokenMap(This,cb,pcb,pb) \ + ( (This)->lpVtbl -> getFuncMDTokenMap(This,cb,pcb,pb) ) + +#define IDiaSession_getTypeMDTokenMapSize(This,pcb) \ + ( (This)->lpVtbl -> getTypeMDTokenMapSize(This,pcb) ) + +#define IDiaSession_getTypeMDTokenMap(This,cb,pcb,pb) \ + ( (This)->lpVtbl -> getTypeMDTokenMap(This,cb,pcb,pb) ) + +#define IDiaSession_getNumberOfFunctionFragments_VA(This,vaFunc,cbFunc,pNumFragments) \ + ( (This)->lpVtbl -> getNumberOfFunctionFragments_VA(This,vaFunc,cbFunc,pNumFragments) ) + +#define IDiaSession_getNumberOfFunctionFragments_RVA(This,rvaFunc,cbFunc,pNumFragments) \ + ( (This)->lpVtbl -> getNumberOfFunctionFragments_RVA(This,rvaFunc,cbFunc,pNumFragments) ) + +#define IDiaSession_getFunctionFragments_VA(This,vaFunc,cbFunc,cFragments,pVaFragment,pLenFragment) \ + ( (This)->lpVtbl -> getFunctionFragments_VA(This,vaFunc,cbFunc,cFragments,pVaFragment,pLenFragment) ) + +#define IDiaSession_getFunctionFragments_RVA(This,rvaFunc,cbFunc,cFragments,pRvaFragment,pLenFragment) \ + ( (This)->lpVtbl -> getFunctionFragments_RVA(This,rvaFunc,cbFunc,cFragments,pRvaFragment,pLenFragment) ) + +#define IDiaSession_getExports(This,ppResult) \ + ( (This)->lpVtbl -> getExports(This,ppResult) ) + +#define IDiaSession_getHeapAllocationSites(This,ppResult) \ + ( (This)->lpVtbl -> getHeapAllocationSites(This,ppResult) ) + +#define IDiaSession_findInputAssemblyFile(This,pSymbol,ppResult) \ + ( (This)->lpVtbl -> findInputAssemblyFile(This,pSymbol,ppResult) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaSession_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaSymbol_INTERFACE_DEFINED__ +#define __IDiaSymbol_INTERFACE_DEFINED__ + +/* interface IDiaSymbol */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaSymbol; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("cb787b2f-bd6c-4635-ba52-933126bd2dcd") + IDiaSymbol : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_symIndexId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_symTag( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_name( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lexicalParent( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_classParent( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_type( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_dataKind( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_locationType( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressOffset( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_offset( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_slot( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_volatileType( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_constType( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_unalignedType( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_access( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_libraryName( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_platform( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_language( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_editAndContinueEnabled( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frontEndMajor( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frontEndMinor( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frontEndBuild( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_backEndMajor( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_backEndMinor( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_backEndBuild( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sourceFileName( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_unused( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_thunkOrdinal( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_thisAdjust( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBaseOffset( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtual( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_intro( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_pure( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_callingConvention( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_value( + /* [retval][out] */ VARIANT *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_baseType( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_token( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_timeStamp( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_guid( + /* [retval][out] */ GUID *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_symbolsFileName( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_reference( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_count( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_bitPosition( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_arrayIndexType( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_packed( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_constructor( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_overloadedOperator( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_nested( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasNestedTypes( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasAssignmentOperator( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasCastOperator( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_scoped( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBaseClass( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_indirectVirtualBaseClass( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBasePointerOffset( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualTableShape( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lexicalParentId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_classParentId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_typeId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_arrayIndexTypeId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualTableShapeId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_code( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_function( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_managed( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_msil( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBaseDispIndex( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_undecoratedName( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_age( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_signature( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilerGenerated( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressTaken( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_rank( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lowerBound( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_upperBound( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lowerBoundId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_upperBoundId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_dataBytes( + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData) = 0; + + virtual HRESULT STDMETHODCALLTYPE findChildren( + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findChildrenEx( + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findChildrenExByAddr( + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findChildrenExByVA( + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findChildrenExByRVA( + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_targetSection( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_targetOffset( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_targetRelativeVirtualAddress( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_targetVirtualAddress( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_machineType( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_oemId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_oemSymbolId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_types( + /* [in] */ DWORD cTypes, + /* [out] */ DWORD *pcTypes, + /* [size_is][size_is][out] */ IDiaSymbol **pTypes) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_typeIds( + /* [in] */ DWORD cTypeIds, + /* [out] */ DWORD *pcTypeIds, + /* [size_is][out] */ DWORD *pdwTypeIds) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_objectPointerType( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_udtKind( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_undecoratedNameEx( + /* [in] */ DWORD undecorateOptions, + /* [out] */ BSTR *name) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noReturn( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_customCallingConvention( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noInline( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_optimizedCodeDebugInfo( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_notReached( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_interruptReturn( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_farReturn( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isStatic( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasDebugInfo( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isLTCG( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isDataAligned( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasSecurityChecks( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilerName( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasAlloca( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasSetJump( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasLongJump( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasInlAsm( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasEH( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasSEH( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasEHa( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isNaked( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isAggregated( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isSplitted( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_container( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_inlSpec( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noStackOrdering( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualBaseTableType( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasManagedCode( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isHotpatchable( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isCVTCIL( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isMSILNetmodule( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isCTypes( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isStripped( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frontEndQFE( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_backEndQFE( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_wasInlined( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_strictGSCheck( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isCxxReturnUdt( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isConstructorVirtualBase( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_RValueReference( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_unmodifiedType( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_framePointerPresent( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isSafeBuffers( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_intrinsic( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sealed( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hfaFloat( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hfaDouble( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_liveRangeStartAddressSection( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_liveRangeStartAddressOffset( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_liveRangeStartRelativeVirtualAddress( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_countLiveRanges( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_liveRangeLength( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_offsetInUdt( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_paramBasePointerRegisterId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_localBasePointerRegisterId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isLocationControlFlowDependent( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_stride( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_numberOfRows( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_numberOfColumns( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isMatrixRowMajor( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_numericProperties( + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pProperties) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_modifierValues( + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ WORD *pModifiers) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isReturnValue( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isOptimizedAway( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_builtInKind( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerType( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_baseDataSlot( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_baseDataOffset( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_textureSlot( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_samplerSlot( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_uavSlot( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sizeInUdt( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_memorySpaceKind( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_unmodifiedTypeId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_subTypeId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_subType( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_numberOfModifiers( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_numberOfRegisterIndices( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isHLSLData( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isPointerToDataMember( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isPointerToMemberFunction( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isSingleInheritance( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isMultipleInheritance( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isVirtualInheritance( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_restrictedType( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isPointerBasedOnSymbolValue( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_baseSymbol( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_baseSymbolId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_objectFileName( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isAcceleratorGroupSharedLocal( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isAcceleratorPointerTagLiveRange( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isAcceleratorStubFunction( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_numberOfAcceleratorPointerTags( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isSdl( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isWinRTPointer( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isRefUdt( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isValueUdt( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isInterfaceUdt( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineFramesByAddr( + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineFramesByRVA( + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineFramesByVA( + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineeLines( + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByAddr( + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByRVA( + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInlineeLinesByVA( + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findSymbolsForAcceleratorPointerTag( + /* [in] */ DWORD tagValue, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE findSymbolsByRVAForAcceleratorPointerTag( + /* [in] */ DWORD tagValue, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_acceleratorPointerTags( + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pPointerTags) = 0; + + virtual HRESULT STDMETHODCALLTYPE getSrcLineOnTypeDefn( + /* [out] */ IDiaLineNumber **ppResult) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isPGO( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasValidPGOCounts( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isOptimizedForSpeed( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PGOEntryCount( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PGOEdgeCount( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_PGODynamicInstructionCount( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_staticSize( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_finalLiveStaticSize( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_phaseName( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasControlFlowCheck( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_constantExport( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_dataExport( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_privateExport( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noNameExport( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_exportHasExplicitlyAssignedOrdinal( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_exportIsForwarder( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_ordinal( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frameSize( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_exceptionHandlerAddressSection( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_exceptionHandlerAddressOffset( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_exceptionHandlerRelativeVirtualAddress( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_exceptionHandlerVirtualAddress( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE findInputAssemblyFile( + /* [out] */ IDiaInputAssemblyFile **ppResult) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_characteristics( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_coffGroup( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_bindID( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_bindSpace( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_bindSlot( + /* [retval][out] */ DWORD *pRetVal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaSymbolVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaSymbol * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaSymbol * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaSymbol * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( + IDiaSymbol * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( + IDiaSymbol * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( + IDiaSymbol * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( + IDiaSymbol * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( + IDiaSymbol * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( + IDiaSymbol * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( + IDiaSymbol * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( + IDiaSymbol * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( + IDiaSymbol * This, + /* [retval][out] */ VARIANT *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( + IDiaSymbol * This, + /* [retval][out] */ GUID *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( + IDiaSymbol * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( + IDiaSymbol * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( + IDiaSymbol * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( + IDiaSymbol * This, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *findChildren )( + IDiaSymbol * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( + IDiaSymbol * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( + IDiaSymbol * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( + IDiaSymbol * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( + IDiaSymbol * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( + IDiaSymbol * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_types )( + IDiaSymbol * This, + /* [in] */ DWORD cTypes, + /* [out] */ DWORD *pcTypes, + /* [size_is][size_is][out] */ IDiaSymbol **pTypes); + + HRESULT ( STDMETHODCALLTYPE *get_typeIds )( + IDiaSymbol * This, + /* [in] */ DWORD cTypeIds, + /* [out] */ DWORD *pcTypeIds, + /* [size_is][out] */ DWORD *pdwTypeIds); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( + IDiaSymbol * This, + /* [in] */ DWORD undecorateOptions, + /* [out] */ BSTR *name); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( + IDiaSymbol * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( + IDiaSymbol * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( + IDiaSymbol * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pProperties); + + HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( + IDiaSymbol * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ WORD *pModifiers); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( + IDiaSymbol * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( + IDiaSymbol * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( + IDiaSymbol * This, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( + IDiaSymbol * This, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( + IDiaSymbol * This, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( + IDiaSymbol * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( + IDiaSymbol * This, + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( + IDiaSymbol * This, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( + IDiaSymbol * This, + /* [in] */ DWORD tagValue, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( + IDiaSymbol * This, + /* [in] */ DWORD tagValue, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( + IDiaSymbol * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pPointerTags); + + HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( + IDiaSymbol * This, + /* [out] */ IDiaLineNumber **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( + IDiaSymbol * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( + IDiaSymbol * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( + IDiaSymbol * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( + IDiaSymbol * This, + /* [out] */ IDiaInputAssemblyFile **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + END_INTERFACE + } IDiaSymbolVtbl; + + interface IDiaSymbol + { + CONST_VTBL struct IDiaSymbolVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaSymbol_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaSymbol_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaSymbol_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaSymbol_get_symIndexId(This,pRetVal) \ + ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) + +#define IDiaSymbol_get_symTag(This,pRetVal) \ + ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) + +#define IDiaSymbol_get_name(This,pRetVal) \ + ( (This)->lpVtbl -> get_name(This,pRetVal) ) + +#define IDiaSymbol_get_lexicalParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) + +#define IDiaSymbol_get_classParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) + +#define IDiaSymbol_get_type(This,pRetVal) \ + ( (This)->lpVtbl -> get_type(This,pRetVal) ) + +#define IDiaSymbol_get_dataKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) + +#define IDiaSymbol_get_locationType(This,pRetVal) \ + ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) + +#define IDiaSymbol_get_addressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) + +#define IDiaSymbol_get_addressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) + +#define IDiaSymbol_get_relativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol_get_virtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) + +#define IDiaSymbol_get_registerId(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) + +#define IDiaSymbol_get_offset(This,pRetVal) \ + ( (This)->lpVtbl -> get_offset(This,pRetVal) ) + +#define IDiaSymbol_get_length(This,pRetVal) \ + ( (This)->lpVtbl -> get_length(This,pRetVal) ) + +#define IDiaSymbol_get_slot(This,pRetVal) \ + ( (This)->lpVtbl -> get_slot(This,pRetVal) ) + +#define IDiaSymbol_get_volatileType(This,pRetVal) \ + ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) + +#define IDiaSymbol_get_constType(This,pRetVal) \ + ( (This)->lpVtbl -> get_constType(This,pRetVal) ) + +#define IDiaSymbol_get_unalignedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) + +#define IDiaSymbol_get_access(This,pRetVal) \ + ( (This)->lpVtbl -> get_access(This,pRetVal) ) + +#define IDiaSymbol_get_libraryName(This,pRetVal) \ + ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) + +#define IDiaSymbol_get_platform(This,pRetVal) \ + ( (This)->lpVtbl -> get_platform(This,pRetVal) ) + +#define IDiaSymbol_get_language(This,pRetVal) \ + ( (This)->lpVtbl -> get_language(This,pRetVal) ) + +#define IDiaSymbol_get_editAndContinueEnabled(This,pRetVal) \ + ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) + +#define IDiaSymbol_get_frontEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) + +#define IDiaSymbol_get_frontEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) + +#define IDiaSymbol_get_frontEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) + +#define IDiaSymbol_get_backEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) + +#define IDiaSymbol_get_backEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) + +#define IDiaSymbol_get_backEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) + +#define IDiaSymbol_get_sourceFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) + +#define IDiaSymbol_get_unused(This,pRetVal) \ + ( (This)->lpVtbl -> get_unused(This,pRetVal) ) + +#define IDiaSymbol_get_thunkOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) + +#define IDiaSymbol_get_thisAdjust(This,pRetVal) \ + ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) + +#define IDiaSymbol_get_virtualBaseOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) + +#define IDiaSymbol_get_virtual(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) + +#define IDiaSymbol_get_intro(This,pRetVal) \ + ( (This)->lpVtbl -> get_intro(This,pRetVal) ) + +#define IDiaSymbol_get_pure(This,pRetVal) \ + ( (This)->lpVtbl -> get_pure(This,pRetVal) ) + +#define IDiaSymbol_get_callingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) + +#define IDiaSymbol_get_value(This,pRetVal) \ + ( (This)->lpVtbl -> get_value(This,pRetVal) ) + +#define IDiaSymbol_get_baseType(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) + +#define IDiaSymbol_get_token(This,pRetVal) \ + ( (This)->lpVtbl -> get_token(This,pRetVal) ) + +#define IDiaSymbol_get_timeStamp(This,pRetVal) \ + ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) + +#define IDiaSymbol_get_guid(This,pRetVal) \ + ( (This)->lpVtbl -> get_guid(This,pRetVal) ) + +#define IDiaSymbol_get_symbolsFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) + +#define IDiaSymbol_get_reference(This,pRetVal) \ + ( (This)->lpVtbl -> get_reference(This,pRetVal) ) + +#define IDiaSymbol_get_count(This,pRetVal) \ + ( (This)->lpVtbl -> get_count(This,pRetVal) ) + +#define IDiaSymbol_get_bitPosition(This,pRetVal) \ + ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) + +#define IDiaSymbol_get_arrayIndexType(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) + +#define IDiaSymbol_get_packed(This,pRetVal) \ + ( (This)->lpVtbl -> get_packed(This,pRetVal) ) + +#define IDiaSymbol_get_constructor(This,pRetVal) \ + ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) + +#define IDiaSymbol_get_overloadedOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) + +#define IDiaSymbol_get_nested(This,pRetVal) \ + ( (This)->lpVtbl -> get_nested(This,pRetVal) ) + +#define IDiaSymbol_get_hasNestedTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) + +#define IDiaSymbol_get_hasAssignmentOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) + +#define IDiaSymbol_get_hasCastOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) + +#define IDiaSymbol_get_scoped(This,pRetVal) \ + ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) + +#define IDiaSymbol_get_virtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol_get_indirectVirtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol_get_virtualBasePointerOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) + +#define IDiaSymbol_get_virtualTableShape(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) + +#define IDiaSymbol_get_lexicalParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) + +#define IDiaSymbol_get_classParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) + +#define IDiaSymbol_get_typeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) + +#define IDiaSymbol_get_arrayIndexTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) + +#define IDiaSymbol_get_virtualTableShapeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) + +#define IDiaSymbol_get_code(This,pRetVal) \ + ( (This)->lpVtbl -> get_code(This,pRetVal) ) + +#define IDiaSymbol_get_function(This,pRetVal) \ + ( (This)->lpVtbl -> get_function(This,pRetVal) ) + +#define IDiaSymbol_get_managed(This,pRetVal) \ + ( (This)->lpVtbl -> get_managed(This,pRetVal) ) + +#define IDiaSymbol_get_msil(This,pRetVal) \ + ( (This)->lpVtbl -> get_msil(This,pRetVal) ) + +#define IDiaSymbol_get_virtualBaseDispIndex(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) + +#define IDiaSymbol_get_undecoratedName(This,pRetVal) \ + ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) + +#define IDiaSymbol_get_age(This,pRetVal) \ + ( (This)->lpVtbl -> get_age(This,pRetVal) ) + +#define IDiaSymbol_get_signature(This,pRetVal) \ + ( (This)->lpVtbl -> get_signature(This,pRetVal) ) + +#define IDiaSymbol_get_compilerGenerated(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) + +#define IDiaSymbol_get_addressTaken(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) + +#define IDiaSymbol_get_rank(This,pRetVal) \ + ( (This)->lpVtbl -> get_rank(This,pRetVal) ) + +#define IDiaSymbol_get_lowerBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) + +#define IDiaSymbol_get_upperBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) + +#define IDiaSymbol_get_lowerBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) + +#define IDiaSymbol_get_upperBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) + +#define IDiaSymbol_get_dataBytes(This,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) + +#define IDiaSymbol_findChildren(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) + +#define IDiaSymbol_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) + +#define IDiaSymbol_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) + +#define IDiaSymbol_get_targetSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) + +#define IDiaSymbol_get_targetOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) + +#define IDiaSymbol_get_targetRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol_get_targetVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol_get_machineType(This,pRetVal) \ + ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) + +#define IDiaSymbol_get_oemId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) + +#define IDiaSymbol_get_oemSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) + +#define IDiaSymbol_get_types(This,cTypes,pcTypes,pTypes) \ + ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) + +#define IDiaSymbol_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ + ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) + +#define IDiaSymbol_get_objectPointerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) + +#define IDiaSymbol_get_udtKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) + +#define IDiaSymbol_get_undecoratedNameEx(This,undecorateOptions,name) \ + ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) + +#define IDiaSymbol_get_noReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) + +#define IDiaSymbol_get_customCallingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) + +#define IDiaSymbol_get_noInline(This,pRetVal) \ + ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) + +#define IDiaSymbol_get_optimizedCodeDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) + +#define IDiaSymbol_get_notReached(This,pRetVal) \ + ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) + +#define IDiaSymbol_get_interruptReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) + +#define IDiaSymbol_get_farReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) + +#define IDiaSymbol_get_isStatic(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) + +#define IDiaSymbol_get_hasDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) + +#define IDiaSymbol_get_isLTCG(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) + +#define IDiaSymbol_get_isDataAligned(This,pRetVal) \ + ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) + +#define IDiaSymbol_get_hasSecurityChecks(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) + +#define IDiaSymbol_get_compilerName(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) + +#define IDiaSymbol_get_hasAlloca(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) + +#define IDiaSymbol_get_hasSetJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) + +#define IDiaSymbol_get_hasLongJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) + +#define IDiaSymbol_get_hasInlAsm(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) + +#define IDiaSymbol_get_hasEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) + +#define IDiaSymbol_get_hasSEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) + +#define IDiaSymbol_get_hasEHa(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) + +#define IDiaSymbol_get_isNaked(This,pRetVal) \ + ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) + +#define IDiaSymbol_get_isAggregated(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) + +#define IDiaSymbol_get_isSplitted(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) + +#define IDiaSymbol_get_container(This,pRetVal) \ + ( (This)->lpVtbl -> get_container(This,pRetVal) ) + +#define IDiaSymbol_get_inlSpec(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) + +#define IDiaSymbol_get_noStackOrdering(This,pRetVal) \ + ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) + +#define IDiaSymbol_get_virtualBaseTableType(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) + +#define IDiaSymbol_get_hasManagedCode(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) + +#define IDiaSymbol_get_isHotpatchable(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) + +#define IDiaSymbol_get_isCVTCIL(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) + +#define IDiaSymbol_get_isMSILNetmodule(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) + +#define IDiaSymbol_get_isCTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) + +#define IDiaSymbol_get_isStripped(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) + +#define IDiaSymbol_get_frontEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) + +#define IDiaSymbol_get_backEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) + +#define IDiaSymbol_get_wasInlined(This,pRetVal) \ + ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) + +#define IDiaSymbol_get_strictGSCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) + +#define IDiaSymbol_get_isCxxReturnUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) + +#define IDiaSymbol_get_isConstructorVirtualBase(This,pRetVal) \ + ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) + +#define IDiaSymbol_get_RValueReference(This,pRetVal) \ + ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) + +#define IDiaSymbol_get_unmodifiedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) + +#define IDiaSymbol_get_framePointerPresent(This,pRetVal) \ + ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) + +#define IDiaSymbol_get_isSafeBuffers(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) + +#define IDiaSymbol_get_intrinsic(This,pRetVal) \ + ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) + +#define IDiaSymbol_get_sealed(This,pRetVal) \ + ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) + +#define IDiaSymbol_get_hfaFloat(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) + +#define IDiaSymbol_get_hfaDouble(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) + +#define IDiaSymbol_get_liveRangeStartAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) + +#define IDiaSymbol_get_liveRangeStartAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) + +#define IDiaSymbol_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol_get_countLiveRanges(This,pRetVal) \ + ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) + +#define IDiaSymbol_get_liveRangeLength(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) + +#define IDiaSymbol_get_offsetInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) + +#define IDiaSymbol_get_paramBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol_get_localBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol_get_isLocationControlFlowDependent(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) + +#define IDiaSymbol_get_stride(This,pRetVal) \ + ( (This)->lpVtbl -> get_stride(This,pRetVal) ) + +#define IDiaSymbol_get_numberOfRows(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) + +#define IDiaSymbol_get_numberOfColumns(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) + +#define IDiaSymbol_get_isMatrixRowMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) + +#define IDiaSymbol_get_numericProperties(This,cnt,pcnt,pProperties) \ + ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) + +#define IDiaSymbol_get_modifierValues(This,cnt,pcnt,pModifiers) \ + ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) + +#define IDiaSymbol_get_isReturnValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) + +#define IDiaSymbol_get_isOptimizedAway(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) + +#define IDiaSymbol_get_builtInKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) + +#define IDiaSymbol_get_registerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) + +#define IDiaSymbol_get_baseDataSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) + +#define IDiaSymbol_get_baseDataOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) + +#define IDiaSymbol_get_textureSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) + +#define IDiaSymbol_get_samplerSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) + +#define IDiaSymbol_get_uavSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) + +#define IDiaSymbol_get_sizeInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) + +#define IDiaSymbol_get_memorySpaceKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) + +#define IDiaSymbol_get_unmodifiedTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) + +#define IDiaSymbol_get_subTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) + +#define IDiaSymbol_get_subType(This,pRetVal) \ + ( (This)->lpVtbl -> get_subType(This,pRetVal) ) + +#define IDiaSymbol_get_numberOfModifiers(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) + +#define IDiaSymbol_get_numberOfRegisterIndices(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) + +#define IDiaSymbol_get_isHLSLData(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) + +#define IDiaSymbol_get_isPointerToDataMember(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) + +#define IDiaSymbol_get_isPointerToMemberFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) + +#define IDiaSymbol_get_isSingleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) + +#define IDiaSymbol_get_isMultipleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) + +#define IDiaSymbol_get_isVirtualInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) + +#define IDiaSymbol_get_restrictedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) + +#define IDiaSymbol_get_isPointerBasedOnSymbolValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) + +#define IDiaSymbol_get_baseSymbol(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) + +#define IDiaSymbol_get_baseSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) + +#define IDiaSymbol_get_objectFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) + +#define IDiaSymbol_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) + +#define IDiaSymbol_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) + +#define IDiaSymbol_get_isAcceleratorStubFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) + +#define IDiaSymbol_get_numberOfAcceleratorPointerTags(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) + +#define IDiaSymbol_get_isSdl(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) + +#define IDiaSymbol_get_isWinRTPointer(This,pRetVal) \ + ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) + +#define IDiaSymbol_get_isRefUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) + +#define IDiaSymbol_get_isValueUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) + +#define IDiaSymbol_get_isInterfaceUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) + +#define IDiaSymbol_findInlineFramesByAddr(This,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) + +#define IDiaSymbol_findInlineFramesByRVA(This,rva,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) + +#define IDiaSymbol_findInlineFramesByVA(This,va,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) + +#define IDiaSymbol_findInlineeLines(This,ppResult) \ + ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) + +#define IDiaSymbol_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) + +#define IDiaSymbol_findInlineeLinesByRVA(This,rva,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) + +#define IDiaSymbol_findInlineeLinesByVA(This,va,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) + +#define IDiaSymbol_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ + ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) + +#define IDiaSymbol_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ + ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) + +#define IDiaSymbol_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ + ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) + +#define IDiaSymbol_getSrcLineOnTypeDefn(This,ppResult) \ + ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) + +#define IDiaSymbol_get_isPGO(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) + +#define IDiaSymbol_get_hasValidPGOCounts(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) + +#define IDiaSymbol_get_isOptimizedForSpeed(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) + +#define IDiaSymbol_get_PGOEntryCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) + +#define IDiaSymbol_get_PGOEdgeCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) + +#define IDiaSymbol_get_PGODynamicInstructionCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) + +#define IDiaSymbol_get_staticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) + +#define IDiaSymbol_get_finalLiveStaticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) + +#define IDiaSymbol_get_phaseName(This,pRetVal) \ + ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) + +#define IDiaSymbol_get_hasControlFlowCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) + +#define IDiaSymbol_get_constantExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) + +#define IDiaSymbol_get_dataExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) + +#define IDiaSymbol_get_privateExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) + +#define IDiaSymbol_get_noNameExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) + +#define IDiaSymbol_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) + +#define IDiaSymbol_get_exportIsForwarder(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) + +#define IDiaSymbol_get_ordinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) + +#define IDiaSymbol_get_frameSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) + +#define IDiaSymbol_get_exceptionHandlerAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) + +#define IDiaSymbol_get_exceptionHandlerAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) + +#define IDiaSymbol_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol_get_exceptionHandlerVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol_findInputAssemblyFile(This,ppResult) \ + ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) + +#define IDiaSymbol_get_characteristics(This,pRetVal) \ + ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) + +#define IDiaSymbol_get_coffGroup(This,pRetVal) \ + ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) + +#define IDiaSymbol_get_bindID(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) + +#define IDiaSymbol_get_bindSpace(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) + +#define IDiaSymbol_get_bindSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_virtualBaseTableType_Proxy( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + +void __RPC_STUB IDiaSymbol_get_virtualBaseTableType_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hasManagedCode_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_hasManagedCode_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isHotpatchable_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isHotpatchable_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isCVTCIL_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isCVTCIL_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isMSILNetmodule_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isMSILNetmodule_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isCTypes_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isCTypes_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isStripped_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isStripped_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_frontEndQFE_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_frontEndQFE_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_backEndQFE_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_backEndQFE_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_wasInlined_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_wasInlined_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_strictGSCheck_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_strictGSCheck_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isCxxReturnUdt_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isCxxReturnUdt_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isConstructorVirtualBase_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isConstructorVirtualBase_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_RValueReference_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_RValueReference_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_unmodifiedType_Proxy( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + +void __RPC_STUB IDiaSymbol_get_unmodifiedType_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_framePointerPresent_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_framePointerPresent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isSafeBuffers_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isSafeBuffers_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_intrinsic_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_intrinsic_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_sealed_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_sealed_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hfaFloat_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_hfaFloat_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hfaDouble_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_hfaDouble_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_liveRangeStartAddressSection_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_liveRangeStartAddressSection_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_liveRangeStartAddressOffset_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_liveRangeStartAddressOffset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_liveRangeStartRelativeVirtualAddress_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_liveRangeStartRelativeVirtualAddress_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_countLiveRanges_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_countLiveRanges_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_liveRangeLength_Proxy( + IDiaSymbol * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_liveRangeLength_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_offsetInUdt_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_offsetInUdt_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_paramBasePointerRegisterId_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_paramBasePointerRegisterId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_localBasePointerRegisterId_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_localBasePointerRegisterId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isLocationControlFlowDependent_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isLocationControlFlowDependent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_stride_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_stride_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_numberOfRows_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_numberOfRows_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_numberOfColumns_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_numberOfColumns_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isMatrixRowMajor_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isMatrixRowMajor_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_get_numericProperties_Proxy( + IDiaSymbol * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pProperties); + + +void __RPC_STUB IDiaSymbol_get_numericProperties_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_get_modifierValues_Proxy( + IDiaSymbol * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ WORD *pModifiers); + + +void __RPC_STUB IDiaSymbol_get_modifierValues_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isReturnValue_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isReturnValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isOptimizedAway_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isOptimizedAway_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_builtInKind_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_builtInKind_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_registerType_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_registerType_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_baseDataSlot_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_baseDataSlot_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_baseDataOffset_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_baseDataOffset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_textureSlot_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_textureSlot_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_samplerSlot_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_samplerSlot_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_uavSlot_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_uavSlot_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_sizeInUdt_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_sizeInUdt_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_memorySpaceKind_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_memorySpaceKind_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_unmodifiedTypeId_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_unmodifiedTypeId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_subTypeId_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_subTypeId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_subType_Proxy( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + +void __RPC_STUB IDiaSymbol_get_subType_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_numberOfModifiers_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_numberOfModifiers_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_numberOfRegisterIndices_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_numberOfRegisterIndices_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isHLSLData_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isHLSLData_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isPointerToDataMember_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isPointerToDataMember_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isPointerToMemberFunction_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isPointerToMemberFunction_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isSingleInheritance_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isSingleInheritance_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isMultipleInheritance_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isMultipleInheritance_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isVirtualInheritance_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isVirtualInheritance_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_restrictedType_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_restrictedType_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isPointerBasedOnSymbolValue_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isPointerBasedOnSymbolValue_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_baseSymbol_Proxy( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + +void __RPC_STUB IDiaSymbol_get_baseSymbol_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_baseSymbolId_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_baseSymbolId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_objectFileName_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BSTR *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_objectFileName_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isAcceleratorGroupSharedLocal_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isAcceleratorGroupSharedLocal_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isAcceleratorPointerTagLiveRange_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isAcceleratorPointerTagLiveRange_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isAcceleratorStubFunction_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isAcceleratorStubFunction_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_numberOfAcceleratorPointerTags_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_numberOfAcceleratorPointerTags_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isSdl_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isSdl_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isWinRTPointer_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isWinRTPointer_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isRefUdt_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isRefUdt_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isValueUdt_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isValueUdt_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isInterfaceUdt_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isInterfaceUdt_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineFramesByAddr_Proxy( + IDiaSymbol * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + +void __RPC_STUB IDiaSymbol_findInlineFramesByAddr_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineFramesByRVA_Proxy( + IDiaSymbol * This, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + +void __RPC_STUB IDiaSymbol_findInlineFramesByRVA_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineFramesByVA_Proxy( + IDiaSymbol * This, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + +void __RPC_STUB IDiaSymbol_findInlineFramesByVA_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineeLines_Proxy( + IDiaSymbol * This, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + +void __RPC_STUB IDiaSymbol_findInlineeLines_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineeLinesByAddr_Proxy( + IDiaSymbol * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + +void __RPC_STUB IDiaSymbol_findInlineeLinesByAddr_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineeLinesByRVA_Proxy( + IDiaSymbol * This, + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + +void __RPC_STUB IDiaSymbol_findInlineeLinesByRVA_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_findInlineeLinesByVA_Proxy( + IDiaSymbol * This, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + +void __RPC_STUB IDiaSymbol_findInlineeLinesByVA_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_findSymbolsForAcceleratorPointerTag_Proxy( + IDiaSymbol * This, + /* [in] */ DWORD tagValue, + /* [out] */ IDiaEnumSymbols **ppResult); + + +void __RPC_STUB IDiaSymbol_findSymbolsForAcceleratorPointerTag_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_findSymbolsByRVAForAcceleratorPointerTag_Proxy( + IDiaSymbol * This, + /* [in] */ DWORD tagValue, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + +void __RPC_STUB IDiaSymbol_findSymbolsByRVAForAcceleratorPointerTag_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_get_acceleratorPointerTags_Proxy( + IDiaSymbol * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pPointerTags); + + +void __RPC_STUB IDiaSymbol_get_acceleratorPointerTags_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_getSrcLineOnTypeDefn_Proxy( + IDiaSymbol * This, + /* [out] */ IDiaLineNumber **ppResult); + + +void __RPC_STUB IDiaSymbol_getSrcLineOnTypeDefn_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isPGO_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isPGO_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hasValidPGOCounts_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_hasValidPGOCounts_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_isOptimizedForSpeed_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_isOptimizedForSpeed_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_PGOEntryCount_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_PGOEntryCount_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_PGOEdgeCount_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_PGOEdgeCount_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_PGODynamicInstructionCount_Proxy( + IDiaSymbol * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_PGODynamicInstructionCount_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_staticSize_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_staticSize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_finalLiveStaticSize_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_finalLiveStaticSize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_phaseName_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BSTR *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_phaseName_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_hasControlFlowCheck_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_hasControlFlowCheck_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_constantExport_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_constantExport_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_dataExport_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_dataExport_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_privateExport_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_privateExport_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_noNameExport_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_noNameExport_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_exportHasExplicitlyAssignedOrdinal_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_exportHasExplicitlyAssignedOrdinal_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_exportIsForwarder_Proxy( + IDiaSymbol * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_exportIsForwarder_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_ordinal_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_ordinal_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_frameSize_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_frameSize_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_exceptionHandlerAddressSection_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_exceptionHandlerAddressSection_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_exceptionHandlerAddressOffset_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_exceptionHandlerAddressOffset_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_exceptionHandlerRelativeVirtualAddress_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_exceptionHandlerRelativeVirtualAddress_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_exceptionHandlerVirtualAddress_Proxy( + IDiaSymbol * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_exceptionHandlerVirtualAddress_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +HRESULT STDMETHODCALLTYPE IDiaSymbol_findInputAssemblyFile_Proxy( + IDiaSymbol * This, + /* [out] */ IDiaInputAssemblyFile **ppResult); + + +void __RPC_STUB IDiaSymbol_findInputAssemblyFile_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_characteristics_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_characteristics_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_coffGroup_Proxy( + IDiaSymbol * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + +void __RPC_STUB IDiaSymbol_get_coffGroup_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_bindID_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_bindID_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_bindSpace_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_bindSpace_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol_get_bindSlot_Proxy( + IDiaSymbol * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol_get_bindSlot_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IDiaSymbol_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaSymbol2_INTERFACE_DEFINED__ +#define __IDiaSymbol2_INTERFACE_DEFINED__ + +/* interface IDiaSymbol2 */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaSymbol2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("611e86cd-b7d1-4546-8a15-070e2b07a427") + IDiaSymbol2 : public IDiaSymbol + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isObjCClass( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isObjCCategory( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isObjCProtocol( + /* [retval][out] */ BOOL *pRetVal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaSymbol2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaSymbol2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaSymbol2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaSymbol2 * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( + IDiaSymbol2 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( + IDiaSymbol2 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( + IDiaSymbol2 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( + IDiaSymbol2 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( + IDiaSymbol2 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( + IDiaSymbol2 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( + IDiaSymbol2 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( + IDiaSymbol2 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( + IDiaSymbol2 * This, + /* [retval][out] */ VARIANT *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( + IDiaSymbol2 * This, + /* [retval][out] */ GUID *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( + IDiaSymbol2 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( + IDiaSymbol2 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( + IDiaSymbol2 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( + IDiaSymbol2 * This, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *findChildren )( + IDiaSymbol2 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( + IDiaSymbol2 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( + IDiaSymbol2 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( + IDiaSymbol2 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( + IDiaSymbol2 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( + IDiaSymbol2 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_types )( + IDiaSymbol2 * This, + /* [in] */ DWORD cTypes, + /* [out] */ DWORD *pcTypes, + /* [size_is][size_is][out] */ IDiaSymbol **pTypes); + + HRESULT ( STDMETHODCALLTYPE *get_typeIds )( + IDiaSymbol2 * This, + /* [in] */ DWORD cTypeIds, + /* [out] */ DWORD *pcTypeIds, + /* [size_is][out] */ DWORD *pdwTypeIds); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( + IDiaSymbol2 * This, + /* [in] */ DWORD undecorateOptions, + /* [out] */ BSTR *name); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( + IDiaSymbol2 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( + IDiaSymbol2 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( + IDiaSymbol2 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pProperties); + + HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( + IDiaSymbol2 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ WORD *pModifiers); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( + IDiaSymbol2 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( + IDiaSymbol2 * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( + IDiaSymbol2 * This, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( + IDiaSymbol2 * This, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( + IDiaSymbol2 * This, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( + IDiaSymbol2 * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( + IDiaSymbol2 * This, + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( + IDiaSymbol2 * This, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( + IDiaSymbol2 * This, + /* [in] */ DWORD tagValue, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( + IDiaSymbol2 * This, + /* [in] */ DWORD tagValue, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( + IDiaSymbol2 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pPointerTags); + + HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( + IDiaSymbol2 * This, + /* [out] */ IDiaLineNumber **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( + IDiaSymbol2 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( + IDiaSymbol2 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( + IDiaSymbol2 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( + IDiaSymbol2 * This, + /* [out] */ IDiaInputAssemblyFile **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( + IDiaSymbol2 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( + IDiaSymbol2 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + END_INTERFACE + } IDiaSymbol2Vtbl; + + interface IDiaSymbol2 + { + CONST_VTBL struct IDiaSymbol2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaSymbol2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaSymbol2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaSymbol2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaSymbol2_get_symIndexId(This,pRetVal) \ + ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) + +#define IDiaSymbol2_get_symTag(This,pRetVal) \ + ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) + +#define IDiaSymbol2_get_name(This,pRetVal) \ + ( (This)->lpVtbl -> get_name(This,pRetVal) ) + +#define IDiaSymbol2_get_lexicalParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) + +#define IDiaSymbol2_get_classParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) + +#define IDiaSymbol2_get_type(This,pRetVal) \ + ( (This)->lpVtbl -> get_type(This,pRetVal) ) + +#define IDiaSymbol2_get_dataKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) + +#define IDiaSymbol2_get_locationType(This,pRetVal) \ + ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) + +#define IDiaSymbol2_get_addressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) + +#define IDiaSymbol2_get_addressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) + +#define IDiaSymbol2_get_relativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol2_get_virtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) + +#define IDiaSymbol2_get_registerId(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) + +#define IDiaSymbol2_get_offset(This,pRetVal) \ + ( (This)->lpVtbl -> get_offset(This,pRetVal) ) + +#define IDiaSymbol2_get_length(This,pRetVal) \ + ( (This)->lpVtbl -> get_length(This,pRetVal) ) + +#define IDiaSymbol2_get_slot(This,pRetVal) \ + ( (This)->lpVtbl -> get_slot(This,pRetVal) ) + +#define IDiaSymbol2_get_volatileType(This,pRetVal) \ + ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) + +#define IDiaSymbol2_get_constType(This,pRetVal) \ + ( (This)->lpVtbl -> get_constType(This,pRetVal) ) + +#define IDiaSymbol2_get_unalignedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) + +#define IDiaSymbol2_get_access(This,pRetVal) \ + ( (This)->lpVtbl -> get_access(This,pRetVal) ) + +#define IDiaSymbol2_get_libraryName(This,pRetVal) \ + ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) + +#define IDiaSymbol2_get_platform(This,pRetVal) \ + ( (This)->lpVtbl -> get_platform(This,pRetVal) ) + +#define IDiaSymbol2_get_language(This,pRetVal) \ + ( (This)->lpVtbl -> get_language(This,pRetVal) ) + +#define IDiaSymbol2_get_editAndContinueEnabled(This,pRetVal) \ + ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) + +#define IDiaSymbol2_get_frontEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) + +#define IDiaSymbol2_get_frontEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) + +#define IDiaSymbol2_get_frontEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) + +#define IDiaSymbol2_get_backEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) + +#define IDiaSymbol2_get_backEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) + +#define IDiaSymbol2_get_backEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) + +#define IDiaSymbol2_get_sourceFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) + +#define IDiaSymbol2_get_unused(This,pRetVal) \ + ( (This)->lpVtbl -> get_unused(This,pRetVal) ) + +#define IDiaSymbol2_get_thunkOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) + +#define IDiaSymbol2_get_thisAdjust(This,pRetVal) \ + ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) + +#define IDiaSymbol2_get_virtualBaseOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) + +#define IDiaSymbol2_get_virtual(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) + +#define IDiaSymbol2_get_intro(This,pRetVal) \ + ( (This)->lpVtbl -> get_intro(This,pRetVal) ) + +#define IDiaSymbol2_get_pure(This,pRetVal) \ + ( (This)->lpVtbl -> get_pure(This,pRetVal) ) + +#define IDiaSymbol2_get_callingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) + +#define IDiaSymbol2_get_value(This,pRetVal) \ + ( (This)->lpVtbl -> get_value(This,pRetVal) ) + +#define IDiaSymbol2_get_baseType(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) + +#define IDiaSymbol2_get_token(This,pRetVal) \ + ( (This)->lpVtbl -> get_token(This,pRetVal) ) + +#define IDiaSymbol2_get_timeStamp(This,pRetVal) \ + ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) + +#define IDiaSymbol2_get_guid(This,pRetVal) \ + ( (This)->lpVtbl -> get_guid(This,pRetVal) ) + +#define IDiaSymbol2_get_symbolsFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) + +#define IDiaSymbol2_get_reference(This,pRetVal) \ + ( (This)->lpVtbl -> get_reference(This,pRetVal) ) + +#define IDiaSymbol2_get_count(This,pRetVal) \ + ( (This)->lpVtbl -> get_count(This,pRetVal) ) + +#define IDiaSymbol2_get_bitPosition(This,pRetVal) \ + ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) + +#define IDiaSymbol2_get_arrayIndexType(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) + +#define IDiaSymbol2_get_packed(This,pRetVal) \ + ( (This)->lpVtbl -> get_packed(This,pRetVal) ) + +#define IDiaSymbol2_get_constructor(This,pRetVal) \ + ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) + +#define IDiaSymbol2_get_overloadedOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) + +#define IDiaSymbol2_get_nested(This,pRetVal) \ + ( (This)->lpVtbl -> get_nested(This,pRetVal) ) + +#define IDiaSymbol2_get_hasNestedTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) + +#define IDiaSymbol2_get_hasAssignmentOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) + +#define IDiaSymbol2_get_hasCastOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) + +#define IDiaSymbol2_get_scoped(This,pRetVal) \ + ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) + +#define IDiaSymbol2_get_virtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol2_get_indirectVirtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol2_get_virtualBasePointerOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) + +#define IDiaSymbol2_get_virtualTableShape(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) + +#define IDiaSymbol2_get_lexicalParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) + +#define IDiaSymbol2_get_classParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) + +#define IDiaSymbol2_get_typeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) + +#define IDiaSymbol2_get_arrayIndexTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) + +#define IDiaSymbol2_get_virtualTableShapeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) + +#define IDiaSymbol2_get_code(This,pRetVal) \ + ( (This)->lpVtbl -> get_code(This,pRetVal) ) + +#define IDiaSymbol2_get_function(This,pRetVal) \ + ( (This)->lpVtbl -> get_function(This,pRetVal) ) + +#define IDiaSymbol2_get_managed(This,pRetVal) \ + ( (This)->lpVtbl -> get_managed(This,pRetVal) ) + +#define IDiaSymbol2_get_msil(This,pRetVal) \ + ( (This)->lpVtbl -> get_msil(This,pRetVal) ) + +#define IDiaSymbol2_get_virtualBaseDispIndex(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) + +#define IDiaSymbol2_get_undecoratedName(This,pRetVal) \ + ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) + +#define IDiaSymbol2_get_age(This,pRetVal) \ + ( (This)->lpVtbl -> get_age(This,pRetVal) ) + +#define IDiaSymbol2_get_signature(This,pRetVal) \ + ( (This)->lpVtbl -> get_signature(This,pRetVal) ) + +#define IDiaSymbol2_get_compilerGenerated(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) + +#define IDiaSymbol2_get_addressTaken(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) + +#define IDiaSymbol2_get_rank(This,pRetVal) \ + ( (This)->lpVtbl -> get_rank(This,pRetVal) ) + +#define IDiaSymbol2_get_lowerBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) + +#define IDiaSymbol2_get_upperBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) + +#define IDiaSymbol2_get_lowerBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) + +#define IDiaSymbol2_get_upperBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) + +#define IDiaSymbol2_get_dataBytes(This,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) + +#define IDiaSymbol2_findChildren(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol2_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol2_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) + +#define IDiaSymbol2_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) + +#define IDiaSymbol2_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) + +#define IDiaSymbol2_get_targetSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) + +#define IDiaSymbol2_get_targetOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) + +#define IDiaSymbol2_get_targetRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol2_get_targetVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol2_get_machineType(This,pRetVal) \ + ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) + +#define IDiaSymbol2_get_oemId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) + +#define IDiaSymbol2_get_oemSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) + +#define IDiaSymbol2_get_types(This,cTypes,pcTypes,pTypes) \ + ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) + +#define IDiaSymbol2_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ + ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) + +#define IDiaSymbol2_get_objectPointerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) + +#define IDiaSymbol2_get_udtKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) + +#define IDiaSymbol2_get_undecoratedNameEx(This,undecorateOptions,name) \ + ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) + +#define IDiaSymbol2_get_noReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) + +#define IDiaSymbol2_get_customCallingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) + +#define IDiaSymbol2_get_noInline(This,pRetVal) \ + ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) + +#define IDiaSymbol2_get_optimizedCodeDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) + +#define IDiaSymbol2_get_notReached(This,pRetVal) \ + ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) + +#define IDiaSymbol2_get_interruptReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) + +#define IDiaSymbol2_get_farReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) + +#define IDiaSymbol2_get_isStatic(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) + +#define IDiaSymbol2_get_hasDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) + +#define IDiaSymbol2_get_isLTCG(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) + +#define IDiaSymbol2_get_isDataAligned(This,pRetVal) \ + ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) + +#define IDiaSymbol2_get_hasSecurityChecks(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) + +#define IDiaSymbol2_get_compilerName(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) + +#define IDiaSymbol2_get_hasAlloca(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) + +#define IDiaSymbol2_get_hasSetJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) + +#define IDiaSymbol2_get_hasLongJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) + +#define IDiaSymbol2_get_hasInlAsm(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) + +#define IDiaSymbol2_get_hasEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) + +#define IDiaSymbol2_get_hasSEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) + +#define IDiaSymbol2_get_hasEHa(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) + +#define IDiaSymbol2_get_isNaked(This,pRetVal) \ + ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) + +#define IDiaSymbol2_get_isAggregated(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) + +#define IDiaSymbol2_get_isSplitted(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) + +#define IDiaSymbol2_get_container(This,pRetVal) \ + ( (This)->lpVtbl -> get_container(This,pRetVal) ) + +#define IDiaSymbol2_get_inlSpec(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) + +#define IDiaSymbol2_get_noStackOrdering(This,pRetVal) \ + ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) + +#define IDiaSymbol2_get_virtualBaseTableType(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) + +#define IDiaSymbol2_get_hasManagedCode(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) + +#define IDiaSymbol2_get_isHotpatchable(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) + +#define IDiaSymbol2_get_isCVTCIL(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) + +#define IDiaSymbol2_get_isMSILNetmodule(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) + +#define IDiaSymbol2_get_isCTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) + +#define IDiaSymbol2_get_isStripped(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) + +#define IDiaSymbol2_get_frontEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) + +#define IDiaSymbol2_get_backEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) + +#define IDiaSymbol2_get_wasInlined(This,pRetVal) \ + ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) + +#define IDiaSymbol2_get_strictGSCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) + +#define IDiaSymbol2_get_isCxxReturnUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) + +#define IDiaSymbol2_get_isConstructorVirtualBase(This,pRetVal) \ + ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) + +#define IDiaSymbol2_get_RValueReference(This,pRetVal) \ + ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) + +#define IDiaSymbol2_get_unmodifiedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) + +#define IDiaSymbol2_get_framePointerPresent(This,pRetVal) \ + ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) + +#define IDiaSymbol2_get_isSafeBuffers(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) + +#define IDiaSymbol2_get_intrinsic(This,pRetVal) \ + ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) + +#define IDiaSymbol2_get_sealed(This,pRetVal) \ + ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) + +#define IDiaSymbol2_get_hfaFloat(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) + +#define IDiaSymbol2_get_hfaDouble(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) + +#define IDiaSymbol2_get_liveRangeStartAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) + +#define IDiaSymbol2_get_liveRangeStartAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) + +#define IDiaSymbol2_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol2_get_countLiveRanges(This,pRetVal) \ + ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) + +#define IDiaSymbol2_get_liveRangeLength(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) + +#define IDiaSymbol2_get_offsetInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) + +#define IDiaSymbol2_get_paramBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol2_get_localBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol2_get_isLocationControlFlowDependent(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) + +#define IDiaSymbol2_get_stride(This,pRetVal) \ + ( (This)->lpVtbl -> get_stride(This,pRetVal) ) + +#define IDiaSymbol2_get_numberOfRows(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) + +#define IDiaSymbol2_get_numberOfColumns(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) + +#define IDiaSymbol2_get_isMatrixRowMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) + +#define IDiaSymbol2_get_numericProperties(This,cnt,pcnt,pProperties) \ + ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) + +#define IDiaSymbol2_get_modifierValues(This,cnt,pcnt,pModifiers) \ + ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) + +#define IDiaSymbol2_get_isReturnValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) + +#define IDiaSymbol2_get_isOptimizedAway(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) + +#define IDiaSymbol2_get_builtInKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) + +#define IDiaSymbol2_get_registerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) + +#define IDiaSymbol2_get_baseDataSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) + +#define IDiaSymbol2_get_baseDataOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) + +#define IDiaSymbol2_get_textureSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) + +#define IDiaSymbol2_get_samplerSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) + +#define IDiaSymbol2_get_uavSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) + +#define IDiaSymbol2_get_sizeInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) + +#define IDiaSymbol2_get_memorySpaceKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) + +#define IDiaSymbol2_get_unmodifiedTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) + +#define IDiaSymbol2_get_subTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) + +#define IDiaSymbol2_get_subType(This,pRetVal) \ + ( (This)->lpVtbl -> get_subType(This,pRetVal) ) + +#define IDiaSymbol2_get_numberOfModifiers(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) + +#define IDiaSymbol2_get_numberOfRegisterIndices(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) + +#define IDiaSymbol2_get_isHLSLData(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) + +#define IDiaSymbol2_get_isPointerToDataMember(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) + +#define IDiaSymbol2_get_isPointerToMemberFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) + +#define IDiaSymbol2_get_isSingleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) + +#define IDiaSymbol2_get_isMultipleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) + +#define IDiaSymbol2_get_isVirtualInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) + +#define IDiaSymbol2_get_restrictedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) + +#define IDiaSymbol2_get_isPointerBasedOnSymbolValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) + +#define IDiaSymbol2_get_baseSymbol(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) + +#define IDiaSymbol2_get_baseSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) + +#define IDiaSymbol2_get_objectFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) + +#define IDiaSymbol2_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) + +#define IDiaSymbol2_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) + +#define IDiaSymbol2_get_isAcceleratorStubFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) + +#define IDiaSymbol2_get_numberOfAcceleratorPointerTags(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) + +#define IDiaSymbol2_get_isSdl(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) + +#define IDiaSymbol2_get_isWinRTPointer(This,pRetVal) \ + ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) + +#define IDiaSymbol2_get_isRefUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) + +#define IDiaSymbol2_get_isValueUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) + +#define IDiaSymbol2_get_isInterfaceUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) + +#define IDiaSymbol2_findInlineFramesByAddr(This,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) + +#define IDiaSymbol2_findInlineFramesByRVA(This,rva,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) + +#define IDiaSymbol2_findInlineFramesByVA(This,va,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) + +#define IDiaSymbol2_findInlineeLines(This,ppResult) \ + ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) + +#define IDiaSymbol2_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) + +#define IDiaSymbol2_findInlineeLinesByRVA(This,rva,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) + +#define IDiaSymbol2_findInlineeLinesByVA(This,va,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) + +#define IDiaSymbol2_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ + ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) + +#define IDiaSymbol2_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ + ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) + +#define IDiaSymbol2_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ + ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) + +#define IDiaSymbol2_getSrcLineOnTypeDefn(This,ppResult) \ + ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) + +#define IDiaSymbol2_get_isPGO(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) + +#define IDiaSymbol2_get_hasValidPGOCounts(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) + +#define IDiaSymbol2_get_isOptimizedForSpeed(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) + +#define IDiaSymbol2_get_PGOEntryCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) + +#define IDiaSymbol2_get_PGOEdgeCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) + +#define IDiaSymbol2_get_PGODynamicInstructionCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) + +#define IDiaSymbol2_get_staticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) + +#define IDiaSymbol2_get_finalLiveStaticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) + +#define IDiaSymbol2_get_phaseName(This,pRetVal) \ + ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) + +#define IDiaSymbol2_get_hasControlFlowCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) + +#define IDiaSymbol2_get_constantExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) + +#define IDiaSymbol2_get_dataExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) + +#define IDiaSymbol2_get_privateExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) + +#define IDiaSymbol2_get_noNameExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) + +#define IDiaSymbol2_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) + +#define IDiaSymbol2_get_exportIsForwarder(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) + +#define IDiaSymbol2_get_ordinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) + +#define IDiaSymbol2_get_frameSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) + +#define IDiaSymbol2_get_exceptionHandlerAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) + +#define IDiaSymbol2_get_exceptionHandlerAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) + +#define IDiaSymbol2_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol2_get_exceptionHandlerVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol2_findInputAssemblyFile(This,ppResult) \ + ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) + +#define IDiaSymbol2_get_characteristics(This,pRetVal) \ + ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) + +#define IDiaSymbol2_get_coffGroup(This,pRetVal) \ + ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) + +#define IDiaSymbol2_get_bindID(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) + +#define IDiaSymbol2_get_bindSpace(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) + +#define IDiaSymbol2_get_bindSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) + + +#define IDiaSymbol2_get_isObjCClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) + +#define IDiaSymbol2_get_isObjCCategory(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) + +#define IDiaSymbol2_get_isObjCProtocol(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol2_get_isObjCClass_Proxy( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol2_get_isObjCClass_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol2_get_isObjCCategory_Proxy( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol2_get_isObjCCategory_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol2_get_isObjCProtocol_Proxy( + IDiaSymbol2 * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol2_get_isObjCProtocol_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IDiaSymbol2_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaSymbol3_INTERFACE_DEFINED__ +#define __IDiaSymbol3_INTERFACE_DEFINED__ + +/* interface IDiaSymbol3 */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaSymbol3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("99b665f7-c1b2-49d3-89b2-a384361acab5") + IDiaSymbol3 : public IDiaSymbol2 + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_inlinee( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_inlineeId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaSymbol3Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaSymbol3 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaSymbol3 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaSymbol3 * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( + IDiaSymbol3 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( + IDiaSymbol3 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( + IDiaSymbol3 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( + IDiaSymbol3 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( + IDiaSymbol3 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( + IDiaSymbol3 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( + IDiaSymbol3 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( + IDiaSymbol3 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( + IDiaSymbol3 * This, + /* [retval][out] */ VARIANT *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( + IDiaSymbol3 * This, + /* [retval][out] */ GUID *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( + IDiaSymbol3 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( + IDiaSymbol3 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( + IDiaSymbol3 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( + IDiaSymbol3 * This, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *findChildren )( + IDiaSymbol3 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( + IDiaSymbol3 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( + IDiaSymbol3 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( + IDiaSymbol3 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( + IDiaSymbol3 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( + IDiaSymbol3 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_types )( + IDiaSymbol3 * This, + /* [in] */ DWORD cTypes, + /* [out] */ DWORD *pcTypes, + /* [size_is][size_is][out] */ IDiaSymbol **pTypes); + + HRESULT ( STDMETHODCALLTYPE *get_typeIds )( + IDiaSymbol3 * This, + /* [in] */ DWORD cTypeIds, + /* [out] */ DWORD *pcTypeIds, + /* [size_is][out] */ DWORD *pdwTypeIds); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( + IDiaSymbol3 * This, + /* [in] */ DWORD undecorateOptions, + /* [out] */ BSTR *name); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( + IDiaSymbol3 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( + IDiaSymbol3 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( + IDiaSymbol3 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pProperties); + + HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( + IDiaSymbol3 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ WORD *pModifiers); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( + IDiaSymbol3 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( + IDiaSymbol3 * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( + IDiaSymbol3 * This, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( + IDiaSymbol3 * This, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( + IDiaSymbol3 * This, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( + IDiaSymbol3 * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( + IDiaSymbol3 * This, + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( + IDiaSymbol3 * This, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( + IDiaSymbol3 * This, + /* [in] */ DWORD tagValue, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( + IDiaSymbol3 * This, + /* [in] */ DWORD tagValue, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( + IDiaSymbol3 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pPointerTags); + + HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( + IDiaSymbol3 * This, + /* [out] */ IDiaLineNumber **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( + IDiaSymbol3 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( + IDiaSymbol3 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( + IDiaSymbol3 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( + IDiaSymbol3 * This, + /* [out] */ IDiaInputAssemblyFile **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( + IDiaSymbol3 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + END_INTERFACE + } IDiaSymbol3Vtbl; + + interface IDiaSymbol3 + { + CONST_VTBL struct IDiaSymbol3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaSymbol3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaSymbol3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaSymbol3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaSymbol3_get_symIndexId(This,pRetVal) \ + ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) + +#define IDiaSymbol3_get_symTag(This,pRetVal) \ + ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) + +#define IDiaSymbol3_get_name(This,pRetVal) \ + ( (This)->lpVtbl -> get_name(This,pRetVal) ) + +#define IDiaSymbol3_get_lexicalParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) + +#define IDiaSymbol3_get_classParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) + +#define IDiaSymbol3_get_type(This,pRetVal) \ + ( (This)->lpVtbl -> get_type(This,pRetVal) ) + +#define IDiaSymbol3_get_dataKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) + +#define IDiaSymbol3_get_locationType(This,pRetVal) \ + ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) + +#define IDiaSymbol3_get_addressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) + +#define IDiaSymbol3_get_addressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) + +#define IDiaSymbol3_get_relativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol3_get_virtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) + +#define IDiaSymbol3_get_registerId(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) + +#define IDiaSymbol3_get_offset(This,pRetVal) \ + ( (This)->lpVtbl -> get_offset(This,pRetVal) ) + +#define IDiaSymbol3_get_length(This,pRetVal) \ + ( (This)->lpVtbl -> get_length(This,pRetVal) ) + +#define IDiaSymbol3_get_slot(This,pRetVal) \ + ( (This)->lpVtbl -> get_slot(This,pRetVal) ) + +#define IDiaSymbol3_get_volatileType(This,pRetVal) \ + ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) + +#define IDiaSymbol3_get_constType(This,pRetVal) \ + ( (This)->lpVtbl -> get_constType(This,pRetVal) ) + +#define IDiaSymbol3_get_unalignedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) + +#define IDiaSymbol3_get_access(This,pRetVal) \ + ( (This)->lpVtbl -> get_access(This,pRetVal) ) + +#define IDiaSymbol3_get_libraryName(This,pRetVal) \ + ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) + +#define IDiaSymbol3_get_platform(This,pRetVal) \ + ( (This)->lpVtbl -> get_platform(This,pRetVal) ) + +#define IDiaSymbol3_get_language(This,pRetVal) \ + ( (This)->lpVtbl -> get_language(This,pRetVal) ) + +#define IDiaSymbol3_get_editAndContinueEnabled(This,pRetVal) \ + ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) + +#define IDiaSymbol3_get_frontEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) + +#define IDiaSymbol3_get_frontEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) + +#define IDiaSymbol3_get_frontEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) + +#define IDiaSymbol3_get_backEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) + +#define IDiaSymbol3_get_backEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) + +#define IDiaSymbol3_get_backEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) + +#define IDiaSymbol3_get_sourceFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) + +#define IDiaSymbol3_get_unused(This,pRetVal) \ + ( (This)->lpVtbl -> get_unused(This,pRetVal) ) + +#define IDiaSymbol3_get_thunkOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) + +#define IDiaSymbol3_get_thisAdjust(This,pRetVal) \ + ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) + +#define IDiaSymbol3_get_virtualBaseOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) + +#define IDiaSymbol3_get_virtual(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) + +#define IDiaSymbol3_get_intro(This,pRetVal) \ + ( (This)->lpVtbl -> get_intro(This,pRetVal) ) + +#define IDiaSymbol3_get_pure(This,pRetVal) \ + ( (This)->lpVtbl -> get_pure(This,pRetVal) ) + +#define IDiaSymbol3_get_callingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) + +#define IDiaSymbol3_get_value(This,pRetVal) \ + ( (This)->lpVtbl -> get_value(This,pRetVal) ) + +#define IDiaSymbol3_get_baseType(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) + +#define IDiaSymbol3_get_token(This,pRetVal) \ + ( (This)->lpVtbl -> get_token(This,pRetVal) ) + +#define IDiaSymbol3_get_timeStamp(This,pRetVal) \ + ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) + +#define IDiaSymbol3_get_guid(This,pRetVal) \ + ( (This)->lpVtbl -> get_guid(This,pRetVal) ) + +#define IDiaSymbol3_get_symbolsFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) + +#define IDiaSymbol3_get_reference(This,pRetVal) \ + ( (This)->lpVtbl -> get_reference(This,pRetVal) ) + +#define IDiaSymbol3_get_count(This,pRetVal) \ + ( (This)->lpVtbl -> get_count(This,pRetVal) ) + +#define IDiaSymbol3_get_bitPosition(This,pRetVal) \ + ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) + +#define IDiaSymbol3_get_arrayIndexType(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) + +#define IDiaSymbol3_get_packed(This,pRetVal) \ + ( (This)->lpVtbl -> get_packed(This,pRetVal) ) + +#define IDiaSymbol3_get_constructor(This,pRetVal) \ + ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) + +#define IDiaSymbol3_get_overloadedOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) + +#define IDiaSymbol3_get_nested(This,pRetVal) \ + ( (This)->lpVtbl -> get_nested(This,pRetVal) ) + +#define IDiaSymbol3_get_hasNestedTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) + +#define IDiaSymbol3_get_hasAssignmentOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) + +#define IDiaSymbol3_get_hasCastOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) + +#define IDiaSymbol3_get_scoped(This,pRetVal) \ + ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) + +#define IDiaSymbol3_get_virtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol3_get_indirectVirtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol3_get_virtualBasePointerOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) + +#define IDiaSymbol3_get_virtualTableShape(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) + +#define IDiaSymbol3_get_lexicalParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) + +#define IDiaSymbol3_get_classParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) + +#define IDiaSymbol3_get_typeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) + +#define IDiaSymbol3_get_arrayIndexTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) + +#define IDiaSymbol3_get_virtualTableShapeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) + +#define IDiaSymbol3_get_code(This,pRetVal) \ + ( (This)->lpVtbl -> get_code(This,pRetVal) ) + +#define IDiaSymbol3_get_function(This,pRetVal) \ + ( (This)->lpVtbl -> get_function(This,pRetVal) ) + +#define IDiaSymbol3_get_managed(This,pRetVal) \ + ( (This)->lpVtbl -> get_managed(This,pRetVal) ) + +#define IDiaSymbol3_get_msil(This,pRetVal) \ + ( (This)->lpVtbl -> get_msil(This,pRetVal) ) + +#define IDiaSymbol3_get_virtualBaseDispIndex(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) + +#define IDiaSymbol3_get_undecoratedName(This,pRetVal) \ + ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) + +#define IDiaSymbol3_get_age(This,pRetVal) \ + ( (This)->lpVtbl -> get_age(This,pRetVal) ) + +#define IDiaSymbol3_get_signature(This,pRetVal) \ + ( (This)->lpVtbl -> get_signature(This,pRetVal) ) + +#define IDiaSymbol3_get_compilerGenerated(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) + +#define IDiaSymbol3_get_addressTaken(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) + +#define IDiaSymbol3_get_rank(This,pRetVal) \ + ( (This)->lpVtbl -> get_rank(This,pRetVal) ) + +#define IDiaSymbol3_get_lowerBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) + +#define IDiaSymbol3_get_upperBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) + +#define IDiaSymbol3_get_lowerBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) + +#define IDiaSymbol3_get_upperBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) + +#define IDiaSymbol3_get_dataBytes(This,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) + +#define IDiaSymbol3_findChildren(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol3_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol3_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) + +#define IDiaSymbol3_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) + +#define IDiaSymbol3_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) + +#define IDiaSymbol3_get_targetSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) + +#define IDiaSymbol3_get_targetOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) + +#define IDiaSymbol3_get_targetRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol3_get_targetVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol3_get_machineType(This,pRetVal) \ + ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) + +#define IDiaSymbol3_get_oemId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) + +#define IDiaSymbol3_get_oemSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) + +#define IDiaSymbol3_get_types(This,cTypes,pcTypes,pTypes) \ + ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) + +#define IDiaSymbol3_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ + ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) + +#define IDiaSymbol3_get_objectPointerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) + +#define IDiaSymbol3_get_udtKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) + +#define IDiaSymbol3_get_undecoratedNameEx(This,undecorateOptions,name) \ + ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) + +#define IDiaSymbol3_get_noReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) + +#define IDiaSymbol3_get_customCallingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) + +#define IDiaSymbol3_get_noInline(This,pRetVal) \ + ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) + +#define IDiaSymbol3_get_optimizedCodeDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) + +#define IDiaSymbol3_get_notReached(This,pRetVal) \ + ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) + +#define IDiaSymbol3_get_interruptReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) + +#define IDiaSymbol3_get_farReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) + +#define IDiaSymbol3_get_isStatic(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) + +#define IDiaSymbol3_get_hasDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) + +#define IDiaSymbol3_get_isLTCG(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) + +#define IDiaSymbol3_get_isDataAligned(This,pRetVal) \ + ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) + +#define IDiaSymbol3_get_hasSecurityChecks(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) + +#define IDiaSymbol3_get_compilerName(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) + +#define IDiaSymbol3_get_hasAlloca(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) + +#define IDiaSymbol3_get_hasSetJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) + +#define IDiaSymbol3_get_hasLongJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) + +#define IDiaSymbol3_get_hasInlAsm(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) + +#define IDiaSymbol3_get_hasEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) + +#define IDiaSymbol3_get_hasSEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) + +#define IDiaSymbol3_get_hasEHa(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) + +#define IDiaSymbol3_get_isNaked(This,pRetVal) \ + ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) + +#define IDiaSymbol3_get_isAggregated(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) + +#define IDiaSymbol3_get_isSplitted(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) + +#define IDiaSymbol3_get_container(This,pRetVal) \ + ( (This)->lpVtbl -> get_container(This,pRetVal) ) + +#define IDiaSymbol3_get_inlSpec(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) + +#define IDiaSymbol3_get_noStackOrdering(This,pRetVal) \ + ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) + +#define IDiaSymbol3_get_virtualBaseTableType(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) + +#define IDiaSymbol3_get_hasManagedCode(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) + +#define IDiaSymbol3_get_isHotpatchable(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) + +#define IDiaSymbol3_get_isCVTCIL(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) + +#define IDiaSymbol3_get_isMSILNetmodule(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) + +#define IDiaSymbol3_get_isCTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) + +#define IDiaSymbol3_get_isStripped(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) + +#define IDiaSymbol3_get_frontEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) + +#define IDiaSymbol3_get_backEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) + +#define IDiaSymbol3_get_wasInlined(This,pRetVal) \ + ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) + +#define IDiaSymbol3_get_strictGSCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) + +#define IDiaSymbol3_get_isCxxReturnUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) + +#define IDiaSymbol3_get_isConstructorVirtualBase(This,pRetVal) \ + ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) + +#define IDiaSymbol3_get_RValueReference(This,pRetVal) \ + ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) + +#define IDiaSymbol3_get_unmodifiedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) + +#define IDiaSymbol3_get_framePointerPresent(This,pRetVal) \ + ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) + +#define IDiaSymbol3_get_isSafeBuffers(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) + +#define IDiaSymbol3_get_intrinsic(This,pRetVal) \ + ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) + +#define IDiaSymbol3_get_sealed(This,pRetVal) \ + ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) + +#define IDiaSymbol3_get_hfaFloat(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) + +#define IDiaSymbol3_get_hfaDouble(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) + +#define IDiaSymbol3_get_liveRangeStartAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) + +#define IDiaSymbol3_get_liveRangeStartAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) + +#define IDiaSymbol3_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol3_get_countLiveRanges(This,pRetVal) \ + ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) + +#define IDiaSymbol3_get_liveRangeLength(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) + +#define IDiaSymbol3_get_offsetInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) + +#define IDiaSymbol3_get_paramBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol3_get_localBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol3_get_isLocationControlFlowDependent(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) + +#define IDiaSymbol3_get_stride(This,pRetVal) \ + ( (This)->lpVtbl -> get_stride(This,pRetVal) ) + +#define IDiaSymbol3_get_numberOfRows(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) + +#define IDiaSymbol3_get_numberOfColumns(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) + +#define IDiaSymbol3_get_isMatrixRowMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) + +#define IDiaSymbol3_get_numericProperties(This,cnt,pcnt,pProperties) \ + ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) + +#define IDiaSymbol3_get_modifierValues(This,cnt,pcnt,pModifiers) \ + ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) + +#define IDiaSymbol3_get_isReturnValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) + +#define IDiaSymbol3_get_isOptimizedAway(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) + +#define IDiaSymbol3_get_builtInKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) + +#define IDiaSymbol3_get_registerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) + +#define IDiaSymbol3_get_baseDataSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) + +#define IDiaSymbol3_get_baseDataOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) + +#define IDiaSymbol3_get_textureSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) + +#define IDiaSymbol3_get_samplerSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) + +#define IDiaSymbol3_get_uavSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) + +#define IDiaSymbol3_get_sizeInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) + +#define IDiaSymbol3_get_memorySpaceKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) + +#define IDiaSymbol3_get_unmodifiedTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) + +#define IDiaSymbol3_get_subTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) + +#define IDiaSymbol3_get_subType(This,pRetVal) \ + ( (This)->lpVtbl -> get_subType(This,pRetVal) ) + +#define IDiaSymbol3_get_numberOfModifiers(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) + +#define IDiaSymbol3_get_numberOfRegisterIndices(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) + +#define IDiaSymbol3_get_isHLSLData(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) + +#define IDiaSymbol3_get_isPointerToDataMember(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) + +#define IDiaSymbol3_get_isPointerToMemberFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) + +#define IDiaSymbol3_get_isSingleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) + +#define IDiaSymbol3_get_isMultipleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) + +#define IDiaSymbol3_get_isVirtualInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) + +#define IDiaSymbol3_get_restrictedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) + +#define IDiaSymbol3_get_isPointerBasedOnSymbolValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) + +#define IDiaSymbol3_get_baseSymbol(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) + +#define IDiaSymbol3_get_baseSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) + +#define IDiaSymbol3_get_objectFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) + +#define IDiaSymbol3_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) + +#define IDiaSymbol3_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) + +#define IDiaSymbol3_get_isAcceleratorStubFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) + +#define IDiaSymbol3_get_numberOfAcceleratorPointerTags(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) + +#define IDiaSymbol3_get_isSdl(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) + +#define IDiaSymbol3_get_isWinRTPointer(This,pRetVal) \ + ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) + +#define IDiaSymbol3_get_isRefUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) + +#define IDiaSymbol3_get_isValueUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) + +#define IDiaSymbol3_get_isInterfaceUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) + +#define IDiaSymbol3_findInlineFramesByAddr(This,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) + +#define IDiaSymbol3_findInlineFramesByRVA(This,rva,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) + +#define IDiaSymbol3_findInlineFramesByVA(This,va,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) + +#define IDiaSymbol3_findInlineeLines(This,ppResult) \ + ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) + +#define IDiaSymbol3_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) + +#define IDiaSymbol3_findInlineeLinesByRVA(This,rva,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) + +#define IDiaSymbol3_findInlineeLinesByVA(This,va,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) + +#define IDiaSymbol3_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ + ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) + +#define IDiaSymbol3_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ + ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) + +#define IDiaSymbol3_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ + ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) + +#define IDiaSymbol3_getSrcLineOnTypeDefn(This,ppResult) \ + ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) + +#define IDiaSymbol3_get_isPGO(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) + +#define IDiaSymbol3_get_hasValidPGOCounts(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) + +#define IDiaSymbol3_get_isOptimizedForSpeed(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) + +#define IDiaSymbol3_get_PGOEntryCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) + +#define IDiaSymbol3_get_PGOEdgeCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) + +#define IDiaSymbol3_get_PGODynamicInstructionCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) + +#define IDiaSymbol3_get_staticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) + +#define IDiaSymbol3_get_finalLiveStaticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) + +#define IDiaSymbol3_get_phaseName(This,pRetVal) \ + ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) + +#define IDiaSymbol3_get_hasControlFlowCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) + +#define IDiaSymbol3_get_constantExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) + +#define IDiaSymbol3_get_dataExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) + +#define IDiaSymbol3_get_privateExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) + +#define IDiaSymbol3_get_noNameExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) + +#define IDiaSymbol3_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) + +#define IDiaSymbol3_get_exportIsForwarder(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) + +#define IDiaSymbol3_get_ordinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) + +#define IDiaSymbol3_get_frameSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) + +#define IDiaSymbol3_get_exceptionHandlerAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) + +#define IDiaSymbol3_get_exceptionHandlerAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) + +#define IDiaSymbol3_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol3_get_exceptionHandlerVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol3_findInputAssemblyFile(This,ppResult) \ + ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) + +#define IDiaSymbol3_get_characteristics(This,pRetVal) \ + ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) + +#define IDiaSymbol3_get_coffGroup(This,pRetVal) \ + ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) + +#define IDiaSymbol3_get_bindID(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) + +#define IDiaSymbol3_get_bindSpace(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) + +#define IDiaSymbol3_get_bindSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) + + +#define IDiaSymbol3_get_isObjCClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) + +#define IDiaSymbol3_get_isObjCCategory(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) + +#define IDiaSymbol3_get_isObjCProtocol(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) + + +#define IDiaSymbol3_get_inlinee(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) + +#define IDiaSymbol3_get_inlineeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol3_get_inlinee_Proxy( + IDiaSymbol3 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + +void __RPC_STUB IDiaSymbol3_get_inlinee_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol3_get_inlineeId_Proxy( + IDiaSymbol3 * This, + /* [retval][out] */ DWORD *pRetVal); + + +void __RPC_STUB IDiaSymbol3_get_inlineeId_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IDiaSymbol3_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaSymbol4_INTERFACE_DEFINED__ +#define __IDiaSymbol4_INTERFACE_DEFINED__ + +/* interface IDiaSymbol4 */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaSymbol4; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("bf6c88a7-e9d6-4346-99a1-d053de5a7808") + IDiaSymbol4 : public IDiaSymbol3 + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_noexcept( + /* [retval][out] */ BOOL *pRetVal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaSymbol4Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaSymbol4 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaSymbol4 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaSymbol4 * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( + IDiaSymbol4 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( + IDiaSymbol4 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( + IDiaSymbol4 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( + IDiaSymbol4 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( + IDiaSymbol4 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( + IDiaSymbol4 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( + IDiaSymbol4 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( + IDiaSymbol4 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( + IDiaSymbol4 * This, + /* [retval][out] */ VARIANT *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( + IDiaSymbol4 * This, + /* [retval][out] */ GUID *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( + IDiaSymbol4 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( + IDiaSymbol4 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( + IDiaSymbol4 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( + IDiaSymbol4 * This, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *findChildren )( + IDiaSymbol4 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( + IDiaSymbol4 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( + IDiaSymbol4 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( + IDiaSymbol4 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( + IDiaSymbol4 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( + IDiaSymbol4 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_types )( + IDiaSymbol4 * This, + /* [in] */ DWORD cTypes, + /* [out] */ DWORD *pcTypes, + /* [size_is][size_is][out] */ IDiaSymbol **pTypes); + + HRESULT ( STDMETHODCALLTYPE *get_typeIds )( + IDiaSymbol4 * This, + /* [in] */ DWORD cTypeIds, + /* [out] */ DWORD *pcTypeIds, + /* [size_is][out] */ DWORD *pdwTypeIds); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( + IDiaSymbol4 * This, + /* [in] */ DWORD undecorateOptions, + /* [out] */ BSTR *name); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( + IDiaSymbol4 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( + IDiaSymbol4 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( + IDiaSymbol4 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pProperties); + + HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( + IDiaSymbol4 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ WORD *pModifiers); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( + IDiaSymbol4 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( + IDiaSymbol4 * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( + IDiaSymbol4 * This, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( + IDiaSymbol4 * This, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( + IDiaSymbol4 * This, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( + IDiaSymbol4 * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( + IDiaSymbol4 * This, + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( + IDiaSymbol4 * This, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( + IDiaSymbol4 * This, + /* [in] */ DWORD tagValue, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( + IDiaSymbol4 * This, + /* [in] */ DWORD tagValue, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( + IDiaSymbol4 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pPointerTags); + + HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( + IDiaSymbol4 * This, + /* [out] */ IDiaLineNumber **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( + IDiaSymbol4 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( + IDiaSymbol4 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( + IDiaSymbol4 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( + IDiaSymbol4 * This, + /* [out] */ IDiaInputAssemblyFile **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( + IDiaSymbol4 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( + IDiaSymbol4 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noexcept )( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + END_INTERFACE + } IDiaSymbol4Vtbl; + + interface IDiaSymbol4 + { + CONST_VTBL struct IDiaSymbol4Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaSymbol4_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaSymbol4_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaSymbol4_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaSymbol4_get_symIndexId(This,pRetVal) \ + ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) + +#define IDiaSymbol4_get_symTag(This,pRetVal) \ + ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) + +#define IDiaSymbol4_get_name(This,pRetVal) \ + ( (This)->lpVtbl -> get_name(This,pRetVal) ) + +#define IDiaSymbol4_get_lexicalParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) + +#define IDiaSymbol4_get_classParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) + +#define IDiaSymbol4_get_type(This,pRetVal) \ + ( (This)->lpVtbl -> get_type(This,pRetVal) ) + +#define IDiaSymbol4_get_dataKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) + +#define IDiaSymbol4_get_locationType(This,pRetVal) \ + ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) + +#define IDiaSymbol4_get_addressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) + +#define IDiaSymbol4_get_addressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) + +#define IDiaSymbol4_get_relativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol4_get_virtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) + +#define IDiaSymbol4_get_registerId(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) + +#define IDiaSymbol4_get_offset(This,pRetVal) \ + ( (This)->lpVtbl -> get_offset(This,pRetVal) ) + +#define IDiaSymbol4_get_length(This,pRetVal) \ + ( (This)->lpVtbl -> get_length(This,pRetVal) ) + +#define IDiaSymbol4_get_slot(This,pRetVal) \ + ( (This)->lpVtbl -> get_slot(This,pRetVal) ) + +#define IDiaSymbol4_get_volatileType(This,pRetVal) \ + ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) + +#define IDiaSymbol4_get_constType(This,pRetVal) \ + ( (This)->lpVtbl -> get_constType(This,pRetVal) ) + +#define IDiaSymbol4_get_unalignedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) + +#define IDiaSymbol4_get_access(This,pRetVal) \ + ( (This)->lpVtbl -> get_access(This,pRetVal) ) + +#define IDiaSymbol4_get_libraryName(This,pRetVal) \ + ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) + +#define IDiaSymbol4_get_platform(This,pRetVal) \ + ( (This)->lpVtbl -> get_platform(This,pRetVal) ) + +#define IDiaSymbol4_get_language(This,pRetVal) \ + ( (This)->lpVtbl -> get_language(This,pRetVal) ) + +#define IDiaSymbol4_get_editAndContinueEnabled(This,pRetVal) \ + ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) + +#define IDiaSymbol4_get_frontEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) + +#define IDiaSymbol4_get_frontEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) + +#define IDiaSymbol4_get_frontEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) + +#define IDiaSymbol4_get_backEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) + +#define IDiaSymbol4_get_backEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) + +#define IDiaSymbol4_get_backEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) + +#define IDiaSymbol4_get_sourceFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) + +#define IDiaSymbol4_get_unused(This,pRetVal) \ + ( (This)->lpVtbl -> get_unused(This,pRetVal) ) + +#define IDiaSymbol4_get_thunkOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) + +#define IDiaSymbol4_get_thisAdjust(This,pRetVal) \ + ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) + +#define IDiaSymbol4_get_virtualBaseOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) + +#define IDiaSymbol4_get_virtual(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) + +#define IDiaSymbol4_get_intro(This,pRetVal) \ + ( (This)->lpVtbl -> get_intro(This,pRetVal) ) + +#define IDiaSymbol4_get_pure(This,pRetVal) \ + ( (This)->lpVtbl -> get_pure(This,pRetVal) ) + +#define IDiaSymbol4_get_callingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) + +#define IDiaSymbol4_get_value(This,pRetVal) \ + ( (This)->lpVtbl -> get_value(This,pRetVal) ) + +#define IDiaSymbol4_get_baseType(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) + +#define IDiaSymbol4_get_token(This,pRetVal) \ + ( (This)->lpVtbl -> get_token(This,pRetVal) ) + +#define IDiaSymbol4_get_timeStamp(This,pRetVal) \ + ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) + +#define IDiaSymbol4_get_guid(This,pRetVal) \ + ( (This)->lpVtbl -> get_guid(This,pRetVal) ) + +#define IDiaSymbol4_get_symbolsFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) + +#define IDiaSymbol4_get_reference(This,pRetVal) \ + ( (This)->lpVtbl -> get_reference(This,pRetVal) ) + +#define IDiaSymbol4_get_count(This,pRetVal) \ + ( (This)->lpVtbl -> get_count(This,pRetVal) ) + +#define IDiaSymbol4_get_bitPosition(This,pRetVal) \ + ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) + +#define IDiaSymbol4_get_arrayIndexType(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) + +#define IDiaSymbol4_get_packed(This,pRetVal) \ + ( (This)->lpVtbl -> get_packed(This,pRetVal) ) + +#define IDiaSymbol4_get_constructor(This,pRetVal) \ + ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) + +#define IDiaSymbol4_get_overloadedOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) + +#define IDiaSymbol4_get_nested(This,pRetVal) \ + ( (This)->lpVtbl -> get_nested(This,pRetVal) ) + +#define IDiaSymbol4_get_hasNestedTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) + +#define IDiaSymbol4_get_hasAssignmentOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) + +#define IDiaSymbol4_get_hasCastOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) + +#define IDiaSymbol4_get_scoped(This,pRetVal) \ + ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) + +#define IDiaSymbol4_get_virtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol4_get_indirectVirtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol4_get_virtualBasePointerOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) + +#define IDiaSymbol4_get_virtualTableShape(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) + +#define IDiaSymbol4_get_lexicalParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) + +#define IDiaSymbol4_get_classParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) + +#define IDiaSymbol4_get_typeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) + +#define IDiaSymbol4_get_arrayIndexTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) + +#define IDiaSymbol4_get_virtualTableShapeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) + +#define IDiaSymbol4_get_code(This,pRetVal) \ + ( (This)->lpVtbl -> get_code(This,pRetVal) ) + +#define IDiaSymbol4_get_function(This,pRetVal) \ + ( (This)->lpVtbl -> get_function(This,pRetVal) ) + +#define IDiaSymbol4_get_managed(This,pRetVal) \ + ( (This)->lpVtbl -> get_managed(This,pRetVal) ) + +#define IDiaSymbol4_get_msil(This,pRetVal) \ + ( (This)->lpVtbl -> get_msil(This,pRetVal) ) + +#define IDiaSymbol4_get_virtualBaseDispIndex(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) + +#define IDiaSymbol4_get_undecoratedName(This,pRetVal) \ + ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) + +#define IDiaSymbol4_get_age(This,pRetVal) \ + ( (This)->lpVtbl -> get_age(This,pRetVal) ) + +#define IDiaSymbol4_get_signature(This,pRetVal) \ + ( (This)->lpVtbl -> get_signature(This,pRetVal) ) + +#define IDiaSymbol4_get_compilerGenerated(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) + +#define IDiaSymbol4_get_addressTaken(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) + +#define IDiaSymbol4_get_rank(This,pRetVal) \ + ( (This)->lpVtbl -> get_rank(This,pRetVal) ) + +#define IDiaSymbol4_get_lowerBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) + +#define IDiaSymbol4_get_upperBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) + +#define IDiaSymbol4_get_lowerBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) + +#define IDiaSymbol4_get_upperBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) + +#define IDiaSymbol4_get_dataBytes(This,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) + +#define IDiaSymbol4_findChildren(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol4_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol4_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) + +#define IDiaSymbol4_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) + +#define IDiaSymbol4_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) + +#define IDiaSymbol4_get_targetSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) + +#define IDiaSymbol4_get_targetOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) + +#define IDiaSymbol4_get_targetRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol4_get_targetVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol4_get_machineType(This,pRetVal) \ + ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) + +#define IDiaSymbol4_get_oemId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) + +#define IDiaSymbol4_get_oemSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) + +#define IDiaSymbol4_get_types(This,cTypes,pcTypes,pTypes) \ + ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) + +#define IDiaSymbol4_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ + ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) + +#define IDiaSymbol4_get_objectPointerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) + +#define IDiaSymbol4_get_udtKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) + +#define IDiaSymbol4_get_undecoratedNameEx(This,undecorateOptions,name) \ + ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) + +#define IDiaSymbol4_get_noReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) + +#define IDiaSymbol4_get_customCallingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) + +#define IDiaSymbol4_get_noInline(This,pRetVal) \ + ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) + +#define IDiaSymbol4_get_optimizedCodeDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) + +#define IDiaSymbol4_get_notReached(This,pRetVal) \ + ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) + +#define IDiaSymbol4_get_interruptReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) + +#define IDiaSymbol4_get_farReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) + +#define IDiaSymbol4_get_isStatic(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) + +#define IDiaSymbol4_get_hasDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) + +#define IDiaSymbol4_get_isLTCG(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) + +#define IDiaSymbol4_get_isDataAligned(This,pRetVal) \ + ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) + +#define IDiaSymbol4_get_hasSecurityChecks(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) + +#define IDiaSymbol4_get_compilerName(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) + +#define IDiaSymbol4_get_hasAlloca(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) + +#define IDiaSymbol4_get_hasSetJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) + +#define IDiaSymbol4_get_hasLongJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) + +#define IDiaSymbol4_get_hasInlAsm(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) + +#define IDiaSymbol4_get_hasEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) + +#define IDiaSymbol4_get_hasSEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) + +#define IDiaSymbol4_get_hasEHa(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) + +#define IDiaSymbol4_get_isNaked(This,pRetVal) \ + ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) + +#define IDiaSymbol4_get_isAggregated(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) + +#define IDiaSymbol4_get_isSplitted(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) + +#define IDiaSymbol4_get_container(This,pRetVal) \ + ( (This)->lpVtbl -> get_container(This,pRetVal) ) + +#define IDiaSymbol4_get_inlSpec(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) + +#define IDiaSymbol4_get_noStackOrdering(This,pRetVal) \ + ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) + +#define IDiaSymbol4_get_virtualBaseTableType(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) + +#define IDiaSymbol4_get_hasManagedCode(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) + +#define IDiaSymbol4_get_isHotpatchable(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) + +#define IDiaSymbol4_get_isCVTCIL(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) + +#define IDiaSymbol4_get_isMSILNetmodule(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) + +#define IDiaSymbol4_get_isCTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) + +#define IDiaSymbol4_get_isStripped(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) + +#define IDiaSymbol4_get_frontEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) + +#define IDiaSymbol4_get_backEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) + +#define IDiaSymbol4_get_wasInlined(This,pRetVal) \ + ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) + +#define IDiaSymbol4_get_strictGSCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) + +#define IDiaSymbol4_get_isCxxReturnUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) + +#define IDiaSymbol4_get_isConstructorVirtualBase(This,pRetVal) \ + ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) + +#define IDiaSymbol4_get_RValueReference(This,pRetVal) \ + ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) + +#define IDiaSymbol4_get_unmodifiedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) + +#define IDiaSymbol4_get_framePointerPresent(This,pRetVal) \ + ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) + +#define IDiaSymbol4_get_isSafeBuffers(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) + +#define IDiaSymbol4_get_intrinsic(This,pRetVal) \ + ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) + +#define IDiaSymbol4_get_sealed(This,pRetVal) \ + ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) + +#define IDiaSymbol4_get_hfaFloat(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) + +#define IDiaSymbol4_get_hfaDouble(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) + +#define IDiaSymbol4_get_liveRangeStartAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) + +#define IDiaSymbol4_get_liveRangeStartAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) + +#define IDiaSymbol4_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol4_get_countLiveRanges(This,pRetVal) \ + ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) + +#define IDiaSymbol4_get_liveRangeLength(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) + +#define IDiaSymbol4_get_offsetInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) + +#define IDiaSymbol4_get_paramBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol4_get_localBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol4_get_isLocationControlFlowDependent(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) + +#define IDiaSymbol4_get_stride(This,pRetVal) \ + ( (This)->lpVtbl -> get_stride(This,pRetVal) ) + +#define IDiaSymbol4_get_numberOfRows(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) + +#define IDiaSymbol4_get_numberOfColumns(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) + +#define IDiaSymbol4_get_isMatrixRowMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) + +#define IDiaSymbol4_get_numericProperties(This,cnt,pcnt,pProperties) \ + ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) + +#define IDiaSymbol4_get_modifierValues(This,cnt,pcnt,pModifiers) \ + ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) + +#define IDiaSymbol4_get_isReturnValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) + +#define IDiaSymbol4_get_isOptimizedAway(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) + +#define IDiaSymbol4_get_builtInKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) + +#define IDiaSymbol4_get_registerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) + +#define IDiaSymbol4_get_baseDataSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) + +#define IDiaSymbol4_get_baseDataOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) + +#define IDiaSymbol4_get_textureSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) + +#define IDiaSymbol4_get_samplerSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) + +#define IDiaSymbol4_get_uavSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) + +#define IDiaSymbol4_get_sizeInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) + +#define IDiaSymbol4_get_memorySpaceKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) + +#define IDiaSymbol4_get_unmodifiedTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) + +#define IDiaSymbol4_get_subTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) + +#define IDiaSymbol4_get_subType(This,pRetVal) \ + ( (This)->lpVtbl -> get_subType(This,pRetVal) ) + +#define IDiaSymbol4_get_numberOfModifiers(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) + +#define IDiaSymbol4_get_numberOfRegisterIndices(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) + +#define IDiaSymbol4_get_isHLSLData(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) + +#define IDiaSymbol4_get_isPointerToDataMember(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) + +#define IDiaSymbol4_get_isPointerToMemberFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) + +#define IDiaSymbol4_get_isSingleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) + +#define IDiaSymbol4_get_isMultipleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) + +#define IDiaSymbol4_get_isVirtualInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) + +#define IDiaSymbol4_get_restrictedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) + +#define IDiaSymbol4_get_isPointerBasedOnSymbolValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) + +#define IDiaSymbol4_get_baseSymbol(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) + +#define IDiaSymbol4_get_baseSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) + +#define IDiaSymbol4_get_objectFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) + +#define IDiaSymbol4_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) + +#define IDiaSymbol4_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) + +#define IDiaSymbol4_get_isAcceleratorStubFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) + +#define IDiaSymbol4_get_numberOfAcceleratorPointerTags(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) + +#define IDiaSymbol4_get_isSdl(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) + +#define IDiaSymbol4_get_isWinRTPointer(This,pRetVal) \ + ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) + +#define IDiaSymbol4_get_isRefUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) + +#define IDiaSymbol4_get_isValueUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) + +#define IDiaSymbol4_get_isInterfaceUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) + +#define IDiaSymbol4_findInlineFramesByAddr(This,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) + +#define IDiaSymbol4_findInlineFramesByRVA(This,rva,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) + +#define IDiaSymbol4_findInlineFramesByVA(This,va,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) + +#define IDiaSymbol4_findInlineeLines(This,ppResult) \ + ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) + +#define IDiaSymbol4_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) + +#define IDiaSymbol4_findInlineeLinesByRVA(This,rva,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) + +#define IDiaSymbol4_findInlineeLinesByVA(This,va,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) + +#define IDiaSymbol4_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ + ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) + +#define IDiaSymbol4_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ + ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) + +#define IDiaSymbol4_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ + ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) + +#define IDiaSymbol4_getSrcLineOnTypeDefn(This,ppResult) \ + ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) + +#define IDiaSymbol4_get_isPGO(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) + +#define IDiaSymbol4_get_hasValidPGOCounts(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) + +#define IDiaSymbol4_get_isOptimizedForSpeed(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) + +#define IDiaSymbol4_get_PGOEntryCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) + +#define IDiaSymbol4_get_PGOEdgeCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) + +#define IDiaSymbol4_get_PGODynamicInstructionCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) + +#define IDiaSymbol4_get_staticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) + +#define IDiaSymbol4_get_finalLiveStaticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) + +#define IDiaSymbol4_get_phaseName(This,pRetVal) \ + ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) + +#define IDiaSymbol4_get_hasControlFlowCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) + +#define IDiaSymbol4_get_constantExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) + +#define IDiaSymbol4_get_dataExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) + +#define IDiaSymbol4_get_privateExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) + +#define IDiaSymbol4_get_noNameExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) + +#define IDiaSymbol4_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) + +#define IDiaSymbol4_get_exportIsForwarder(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) + +#define IDiaSymbol4_get_ordinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) + +#define IDiaSymbol4_get_frameSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) + +#define IDiaSymbol4_get_exceptionHandlerAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) + +#define IDiaSymbol4_get_exceptionHandlerAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) + +#define IDiaSymbol4_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol4_get_exceptionHandlerVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol4_findInputAssemblyFile(This,ppResult) \ + ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) + +#define IDiaSymbol4_get_characteristics(This,pRetVal) \ + ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) + +#define IDiaSymbol4_get_coffGroup(This,pRetVal) \ + ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) + +#define IDiaSymbol4_get_bindID(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) + +#define IDiaSymbol4_get_bindSpace(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) + +#define IDiaSymbol4_get_bindSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) + + +#define IDiaSymbol4_get_isObjCClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) + +#define IDiaSymbol4_get_isObjCCategory(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) + +#define IDiaSymbol4_get_isObjCProtocol(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) + + +#define IDiaSymbol4_get_inlinee(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) + +#define IDiaSymbol4_get_inlineeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) + + +#define IDiaSymbol4_get_noexcept(This,pRetVal) \ + ( (This)->lpVtbl -> get_noexcept(This,pRetVal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol4_get_noexcept_Proxy( + IDiaSymbol4 * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol4_get_noexcept_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IDiaSymbol4_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaSymbol5_INTERFACE_DEFINED__ +#define __IDiaSymbol5_INTERFACE_DEFINED__ + +/* interface IDiaSymbol5 */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaSymbol5; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("abe2de00-dc2d-4793-af9a-ef1d90832644") + IDiaSymbol5 : public IDiaSymbol4 + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_hasAbsoluteAddress( + /* [retval][out] */ BOOL *pRetVal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaSymbol5Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaSymbol5 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaSymbol5 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaSymbol5 * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( + IDiaSymbol5 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( + IDiaSymbol5 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( + IDiaSymbol5 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( + IDiaSymbol5 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( + IDiaSymbol5 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( + IDiaSymbol5 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( + IDiaSymbol5 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( + IDiaSymbol5 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( + IDiaSymbol5 * This, + /* [retval][out] */ VARIANT *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( + IDiaSymbol5 * This, + /* [retval][out] */ GUID *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( + IDiaSymbol5 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( + IDiaSymbol5 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( + IDiaSymbol5 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( + IDiaSymbol5 * This, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *findChildren )( + IDiaSymbol5 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( + IDiaSymbol5 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( + IDiaSymbol5 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( + IDiaSymbol5 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( + IDiaSymbol5 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( + IDiaSymbol5 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_types )( + IDiaSymbol5 * This, + /* [in] */ DWORD cTypes, + /* [out] */ DWORD *pcTypes, + /* [size_is][size_is][out] */ IDiaSymbol **pTypes); + + HRESULT ( STDMETHODCALLTYPE *get_typeIds )( + IDiaSymbol5 * This, + /* [in] */ DWORD cTypeIds, + /* [out] */ DWORD *pcTypeIds, + /* [size_is][out] */ DWORD *pdwTypeIds); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( + IDiaSymbol5 * This, + /* [in] */ DWORD undecorateOptions, + /* [out] */ BSTR *name); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( + IDiaSymbol5 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( + IDiaSymbol5 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( + IDiaSymbol5 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pProperties); + + HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( + IDiaSymbol5 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ WORD *pModifiers); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( + IDiaSymbol5 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( + IDiaSymbol5 * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( + IDiaSymbol5 * This, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( + IDiaSymbol5 * This, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( + IDiaSymbol5 * This, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( + IDiaSymbol5 * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( + IDiaSymbol5 * This, + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( + IDiaSymbol5 * This, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( + IDiaSymbol5 * This, + /* [in] */ DWORD tagValue, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( + IDiaSymbol5 * This, + /* [in] */ DWORD tagValue, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( + IDiaSymbol5 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pPointerTags); + + HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( + IDiaSymbol5 * This, + /* [out] */ IDiaLineNumber **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( + IDiaSymbol5 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( + IDiaSymbol5 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( + IDiaSymbol5 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( + IDiaSymbol5 * This, + /* [out] */ IDiaInputAssemblyFile **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( + IDiaSymbol5 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( + IDiaSymbol5 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noexcept )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAbsoluteAddress )( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + END_INTERFACE + } IDiaSymbol5Vtbl; + + interface IDiaSymbol5 + { + CONST_VTBL struct IDiaSymbol5Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaSymbol5_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaSymbol5_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaSymbol5_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaSymbol5_get_symIndexId(This,pRetVal) \ + ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) + +#define IDiaSymbol5_get_symTag(This,pRetVal) \ + ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) + +#define IDiaSymbol5_get_name(This,pRetVal) \ + ( (This)->lpVtbl -> get_name(This,pRetVal) ) + +#define IDiaSymbol5_get_lexicalParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) + +#define IDiaSymbol5_get_classParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) + +#define IDiaSymbol5_get_type(This,pRetVal) \ + ( (This)->lpVtbl -> get_type(This,pRetVal) ) + +#define IDiaSymbol5_get_dataKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) + +#define IDiaSymbol5_get_locationType(This,pRetVal) \ + ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) + +#define IDiaSymbol5_get_addressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) + +#define IDiaSymbol5_get_addressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) + +#define IDiaSymbol5_get_relativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol5_get_virtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) + +#define IDiaSymbol5_get_registerId(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) + +#define IDiaSymbol5_get_offset(This,pRetVal) \ + ( (This)->lpVtbl -> get_offset(This,pRetVal) ) + +#define IDiaSymbol5_get_length(This,pRetVal) \ + ( (This)->lpVtbl -> get_length(This,pRetVal) ) + +#define IDiaSymbol5_get_slot(This,pRetVal) \ + ( (This)->lpVtbl -> get_slot(This,pRetVal) ) + +#define IDiaSymbol5_get_volatileType(This,pRetVal) \ + ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) + +#define IDiaSymbol5_get_constType(This,pRetVal) \ + ( (This)->lpVtbl -> get_constType(This,pRetVal) ) + +#define IDiaSymbol5_get_unalignedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) + +#define IDiaSymbol5_get_access(This,pRetVal) \ + ( (This)->lpVtbl -> get_access(This,pRetVal) ) + +#define IDiaSymbol5_get_libraryName(This,pRetVal) \ + ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) + +#define IDiaSymbol5_get_platform(This,pRetVal) \ + ( (This)->lpVtbl -> get_platform(This,pRetVal) ) + +#define IDiaSymbol5_get_language(This,pRetVal) \ + ( (This)->lpVtbl -> get_language(This,pRetVal) ) + +#define IDiaSymbol5_get_editAndContinueEnabled(This,pRetVal) \ + ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) + +#define IDiaSymbol5_get_frontEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) + +#define IDiaSymbol5_get_frontEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) + +#define IDiaSymbol5_get_frontEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) + +#define IDiaSymbol5_get_backEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) + +#define IDiaSymbol5_get_backEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) + +#define IDiaSymbol5_get_backEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) + +#define IDiaSymbol5_get_sourceFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) + +#define IDiaSymbol5_get_unused(This,pRetVal) \ + ( (This)->lpVtbl -> get_unused(This,pRetVal) ) + +#define IDiaSymbol5_get_thunkOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) + +#define IDiaSymbol5_get_thisAdjust(This,pRetVal) \ + ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) + +#define IDiaSymbol5_get_virtualBaseOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) + +#define IDiaSymbol5_get_virtual(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) + +#define IDiaSymbol5_get_intro(This,pRetVal) \ + ( (This)->lpVtbl -> get_intro(This,pRetVal) ) + +#define IDiaSymbol5_get_pure(This,pRetVal) \ + ( (This)->lpVtbl -> get_pure(This,pRetVal) ) + +#define IDiaSymbol5_get_callingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) + +#define IDiaSymbol5_get_value(This,pRetVal) \ + ( (This)->lpVtbl -> get_value(This,pRetVal) ) + +#define IDiaSymbol5_get_baseType(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) + +#define IDiaSymbol5_get_token(This,pRetVal) \ + ( (This)->lpVtbl -> get_token(This,pRetVal) ) + +#define IDiaSymbol5_get_timeStamp(This,pRetVal) \ + ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) + +#define IDiaSymbol5_get_guid(This,pRetVal) \ + ( (This)->lpVtbl -> get_guid(This,pRetVal) ) + +#define IDiaSymbol5_get_symbolsFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) + +#define IDiaSymbol5_get_reference(This,pRetVal) \ + ( (This)->lpVtbl -> get_reference(This,pRetVal) ) + +#define IDiaSymbol5_get_count(This,pRetVal) \ + ( (This)->lpVtbl -> get_count(This,pRetVal) ) + +#define IDiaSymbol5_get_bitPosition(This,pRetVal) \ + ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) + +#define IDiaSymbol5_get_arrayIndexType(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) + +#define IDiaSymbol5_get_packed(This,pRetVal) \ + ( (This)->lpVtbl -> get_packed(This,pRetVal) ) + +#define IDiaSymbol5_get_constructor(This,pRetVal) \ + ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) + +#define IDiaSymbol5_get_overloadedOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) + +#define IDiaSymbol5_get_nested(This,pRetVal) \ + ( (This)->lpVtbl -> get_nested(This,pRetVal) ) + +#define IDiaSymbol5_get_hasNestedTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) + +#define IDiaSymbol5_get_hasAssignmentOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) + +#define IDiaSymbol5_get_hasCastOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) + +#define IDiaSymbol5_get_scoped(This,pRetVal) \ + ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) + +#define IDiaSymbol5_get_virtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol5_get_indirectVirtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol5_get_virtualBasePointerOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) + +#define IDiaSymbol5_get_virtualTableShape(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) + +#define IDiaSymbol5_get_lexicalParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) + +#define IDiaSymbol5_get_classParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) + +#define IDiaSymbol5_get_typeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) + +#define IDiaSymbol5_get_arrayIndexTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) + +#define IDiaSymbol5_get_virtualTableShapeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) + +#define IDiaSymbol5_get_code(This,pRetVal) \ + ( (This)->lpVtbl -> get_code(This,pRetVal) ) + +#define IDiaSymbol5_get_function(This,pRetVal) \ + ( (This)->lpVtbl -> get_function(This,pRetVal) ) + +#define IDiaSymbol5_get_managed(This,pRetVal) \ + ( (This)->lpVtbl -> get_managed(This,pRetVal) ) + +#define IDiaSymbol5_get_msil(This,pRetVal) \ + ( (This)->lpVtbl -> get_msil(This,pRetVal) ) + +#define IDiaSymbol5_get_virtualBaseDispIndex(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) + +#define IDiaSymbol5_get_undecoratedName(This,pRetVal) \ + ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) + +#define IDiaSymbol5_get_age(This,pRetVal) \ + ( (This)->lpVtbl -> get_age(This,pRetVal) ) + +#define IDiaSymbol5_get_signature(This,pRetVal) \ + ( (This)->lpVtbl -> get_signature(This,pRetVal) ) + +#define IDiaSymbol5_get_compilerGenerated(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) + +#define IDiaSymbol5_get_addressTaken(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) + +#define IDiaSymbol5_get_rank(This,pRetVal) \ + ( (This)->lpVtbl -> get_rank(This,pRetVal) ) + +#define IDiaSymbol5_get_lowerBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) + +#define IDiaSymbol5_get_upperBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) + +#define IDiaSymbol5_get_lowerBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) + +#define IDiaSymbol5_get_upperBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) + +#define IDiaSymbol5_get_dataBytes(This,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) + +#define IDiaSymbol5_findChildren(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol5_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol5_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) + +#define IDiaSymbol5_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) + +#define IDiaSymbol5_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) + +#define IDiaSymbol5_get_targetSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) + +#define IDiaSymbol5_get_targetOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) + +#define IDiaSymbol5_get_targetRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol5_get_targetVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol5_get_machineType(This,pRetVal) \ + ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) + +#define IDiaSymbol5_get_oemId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) + +#define IDiaSymbol5_get_oemSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) + +#define IDiaSymbol5_get_types(This,cTypes,pcTypes,pTypes) \ + ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) + +#define IDiaSymbol5_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ + ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) + +#define IDiaSymbol5_get_objectPointerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) + +#define IDiaSymbol5_get_udtKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) + +#define IDiaSymbol5_get_undecoratedNameEx(This,undecorateOptions,name) \ + ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) + +#define IDiaSymbol5_get_noReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) + +#define IDiaSymbol5_get_customCallingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) + +#define IDiaSymbol5_get_noInline(This,pRetVal) \ + ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) + +#define IDiaSymbol5_get_optimizedCodeDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) + +#define IDiaSymbol5_get_notReached(This,pRetVal) \ + ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) + +#define IDiaSymbol5_get_interruptReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) + +#define IDiaSymbol5_get_farReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) + +#define IDiaSymbol5_get_isStatic(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) + +#define IDiaSymbol5_get_hasDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) + +#define IDiaSymbol5_get_isLTCG(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) + +#define IDiaSymbol5_get_isDataAligned(This,pRetVal) \ + ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) + +#define IDiaSymbol5_get_hasSecurityChecks(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) + +#define IDiaSymbol5_get_compilerName(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) + +#define IDiaSymbol5_get_hasAlloca(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) + +#define IDiaSymbol5_get_hasSetJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) + +#define IDiaSymbol5_get_hasLongJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) + +#define IDiaSymbol5_get_hasInlAsm(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) + +#define IDiaSymbol5_get_hasEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) + +#define IDiaSymbol5_get_hasSEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) + +#define IDiaSymbol5_get_hasEHa(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) + +#define IDiaSymbol5_get_isNaked(This,pRetVal) \ + ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) + +#define IDiaSymbol5_get_isAggregated(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) + +#define IDiaSymbol5_get_isSplitted(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) + +#define IDiaSymbol5_get_container(This,pRetVal) \ + ( (This)->lpVtbl -> get_container(This,pRetVal) ) + +#define IDiaSymbol5_get_inlSpec(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) + +#define IDiaSymbol5_get_noStackOrdering(This,pRetVal) \ + ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) + +#define IDiaSymbol5_get_virtualBaseTableType(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) + +#define IDiaSymbol5_get_hasManagedCode(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) + +#define IDiaSymbol5_get_isHotpatchable(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) + +#define IDiaSymbol5_get_isCVTCIL(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) + +#define IDiaSymbol5_get_isMSILNetmodule(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) + +#define IDiaSymbol5_get_isCTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) + +#define IDiaSymbol5_get_isStripped(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) + +#define IDiaSymbol5_get_frontEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) + +#define IDiaSymbol5_get_backEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) + +#define IDiaSymbol5_get_wasInlined(This,pRetVal) \ + ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) + +#define IDiaSymbol5_get_strictGSCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) + +#define IDiaSymbol5_get_isCxxReturnUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) + +#define IDiaSymbol5_get_isConstructorVirtualBase(This,pRetVal) \ + ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) + +#define IDiaSymbol5_get_RValueReference(This,pRetVal) \ + ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) + +#define IDiaSymbol5_get_unmodifiedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) + +#define IDiaSymbol5_get_framePointerPresent(This,pRetVal) \ + ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) + +#define IDiaSymbol5_get_isSafeBuffers(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) + +#define IDiaSymbol5_get_intrinsic(This,pRetVal) \ + ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) + +#define IDiaSymbol5_get_sealed(This,pRetVal) \ + ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) + +#define IDiaSymbol5_get_hfaFloat(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) + +#define IDiaSymbol5_get_hfaDouble(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) + +#define IDiaSymbol5_get_liveRangeStartAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) + +#define IDiaSymbol5_get_liveRangeStartAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) + +#define IDiaSymbol5_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol5_get_countLiveRanges(This,pRetVal) \ + ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) + +#define IDiaSymbol5_get_liveRangeLength(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) + +#define IDiaSymbol5_get_offsetInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) + +#define IDiaSymbol5_get_paramBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol5_get_localBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol5_get_isLocationControlFlowDependent(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) + +#define IDiaSymbol5_get_stride(This,pRetVal) \ + ( (This)->lpVtbl -> get_stride(This,pRetVal) ) + +#define IDiaSymbol5_get_numberOfRows(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) + +#define IDiaSymbol5_get_numberOfColumns(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) + +#define IDiaSymbol5_get_isMatrixRowMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) + +#define IDiaSymbol5_get_numericProperties(This,cnt,pcnt,pProperties) \ + ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) + +#define IDiaSymbol5_get_modifierValues(This,cnt,pcnt,pModifiers) \ + ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) + +#define IDiaSymbol5_get_isReturnValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) + +#define IDiaSymbol5_get_isOptimizedAway(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) + +#define IDiaSymbol5_get_builtInKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) + +#define IDiaSymbol5_get_registerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) + +#define IDiaSymbol5_get_baseDataSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) + +#define IDiaSymbol5_get_baseDataOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) + +#define IDiaSymbol5_get_textureSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) + +#define IDiaSymbol5_get_samplerSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) + +#define IDiaSymbol5_get_uavSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) + +#define IDiaSymbol5_get_sizeInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) + +#define IDiaSymbol5_get_memorySpaceKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) + +#define IDiaSymbol5_get_unmodifiedTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) + +#define IDiaSymbol5_get_subTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) + +#define IDiaSymbol5_get_subType(This,pRetVal) \ + ( (This)->lpVtbl -> get_subType(This,pRetVal) ) + +#define IDiaSymbol5_get_numberOfModifiers(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) + +#define IDiaSymbol5_get_numberOfRegisterIndices(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) + +#define IDiaSymbol5_get_isHLSLData(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) + +#define IDiaSymbol5_get_isPointerToDataMember(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) + +#define IDiaSymbol5_get_isPointerToMemberFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) + +#define IDiaSymbol5_get_isSingleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) + +#define IDiaSymbol5_get_isMultipleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) + +#define IDiaSymbol5_get_isVirtualInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) + +#define IDiaSymbol5_get_restrictedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) + +#define IDiaSymbol5_get_isPointerBasedOnSymbolValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) + +#define IDiaSymbol5_get_baseSymbol(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) + +#define IDiaSymbol5_get_baseSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) + +#define IDiaSymbol5_get_objectFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) + +#define IDiaSymbol5_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) + +#define IDiaSymbol5_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) + +#define IDiaSymbol5_get_isAcceleratorStubFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) + +#define IDiaSymbol5_get_numberOfAcceleratorPointerTags(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) + +#define IDiaSymbol5_get_isSdl(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) + +#define IDiaSymbol5_get_isWinRTPointer(This,pRetVal) \ + ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) + +#define IDiaSymbol5_get_isRefUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) + +#define IDiaSymbol5_get_isValueUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) + +#define IDiaSymbol5_get_isInterfaceUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) + +#define IDiaSymbol5_findInlineFramesByAddr(This,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) + +#define IDiaSymbol5_findInlineFramesByRVA(This,rva,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) + +#define IDiaSymbol5_findInlineFramesByVA(This,va,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) + +#define IDiaSymbol5_findInlineeLines(This,ppResult) \ + ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) + +#define IDiaSymbol5_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) + +#define IDiaSymbol5_findInlineeLinesByRVA(This,rva,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) + +#define IDiaSymbol5_findInlineeLinesByVA(This,va,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) + +#define IDiaSymbol5_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ + ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) + +#define IDiaSymbol5_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ + ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) + +#define IDiaSymbol5_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ + ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) + +#define IDiaSymbol5_getSrcLineOnTypeDefn(This,ppResult) \ + ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) + +#define IDiaSymbol5_get_isPGO(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) + +#define IDiaSymbol5_get_hasValidPGOCounts(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) + +#define IDiaSymbol5_get_isOptimizedForSpeed(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) + +#define IDiaSymbol5_get_PGOEntryCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) + +#define IDiaSymbol5_get_PGOEdgeCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) + +#define IDiaSymbol5_get_PGODynamicInstructionCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) + +#define IDiaSymbol5_get_staticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) + +#define IDiaSymbol5_get_finalLiveStaticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) + +#define IDiaSymbol5_get_phaseName(This,pRetVal) \ + ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) + +#define IDiaSymbol5_get_hasControlFlowCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) + +#define IDiaSymbol5_get_constantExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) + +#define IDiaSymbol5_get_dataExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) + +#define IDiaSymbol5_get_privateExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) + +#define IDiaSymbol5_get_noNameExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) + +#define IDiaSymbol5_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) + +#define IDiaSymbol5_get_exportIsForwarder(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) + +#define IDiaSymbol5_get_ordinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) + +#define IDiaSymbol5_get_frameSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) + +#define IDiaSymbol5_get_exceptionHandlerAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) + +#define IDiaSymbol5_get_exceptionHandlerAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) + +#define IDiaSymbol5_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol5_get_exceptionHandlerVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol5_findInputAssemblyFile(This,ppResult) \ + ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) + +#define IDiaSymbol5_get_characteristics(This,pRetVal) \ + ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) + +#define IDiaSymbol5_get_coffGroup(This,pRetVal) \ + ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) + +#define IDiaSymbol5_get_bindID(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) + +#define IDiaSymbol5_get_bindSpace(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) + +#define IDiaSymbol5_get_bindSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) + + +#define IDiaSymbol5_get_isObjCClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) + +#define IDiaSymbol5_get_isObjCCategory(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) + +#define IDiaSymbol5_get_isObjCProtocol(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) + + +#define IDiaSymbol5_get_inlinee(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) + +#define IDiaSymbol5_get_inlineeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) + + +#define IDiaSymbol5_get_noexcept(This,pRetVal) \ + ( (This)->lpVtbl -> get_noexcept(This,pRetVal) ) + + +#define IDiaSymbol5_get_hasAbsoluteAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAbsoluteAddress(This,pRetVal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol5_get_hasAbsoluteAddress_Proxy( + IDiaSymbol5 * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol5_get_hasAbsoluteAddress_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IDiaSymbol5_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaSymbol6_INTERFACE_DEFINED__ +#define __IDiaSymbol6_INTERFACE_DEFINED__ + +/* interface IDiaSymbol6 */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaSymbol6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8133dad3-75fe-4234-ac7e-f8e7a1d3cbb3") + IDiaSymbol6 : public IDiaSymbol5 + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isStaticMemberFunc( + /* [retval][out] */ BOOL *pRetVal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaSymbol6Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaSymbol6 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaSymbol6 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaSymbol6 * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( + IDiaSymbol6 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( + IDiaSymbol6 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( + IDiaSymbol6 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( + IDiaSymbol6 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( + IDiaSymbol6 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( + IDiaSymbol6 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( + IDiaSymbol6 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( + IDiaSymbol6 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( + IDiaSymbol6 * This, + /* [retval][out] */ VARIANT *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( + IDiaSymbol6 * This, + /* [retval][out] */ GUID *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( + IDiaSymbol6 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( + IDiaSymbol6 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( + IDiaSymbol6 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( + IDiaSymbol6 * This, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *findChildren )( + IDiaSymbol6 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( + IDiaSymbol6 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( + IDiaSymbol6 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( + IDiaSymbol6 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( + IDiaSymbol6 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( + IDiaSymbol6 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_types )( + IDiaSymbol6 * This, + /* [in] */ DWORD cTypes, + /* [out] */ DWORD *pcTypes, + /* [size_is][size_is][out] */ IDiaSymbol **pTypes); + + HRESULT ( STDMETHODCALLTYPE *get_typeIds )( + IDiaSymbol6 * This, + /* [in] */ DWORD cTypeIds, + /* [out] */ DWORD *pcTypeIds, + /* [size_is][out] */ DWORD *pdwTypeIds); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( + IDiaSymbol6 * This, + /* [in] */ DWORD undecorateOptions, + /* [out] */ BSTR *name); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( + IDiaSymbol6 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( + IDiaSymbol6 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( + IDiaSymbol6 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pProperties); + + HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( + IDiaSymbol6 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ WORD *pModifiers); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( + IDiaSymbol6 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( + IDiaSymbol6 * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( + IDiaSymbol6 * This, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( + IDiaSymbol6 * This, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( + IDiaSymbol6 * This, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( + IDiaSymbol6 * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( + IDiaSymbol6 * This, + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( + IDiaSymbol6 * This, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( + IDiaSymbol6 * This, + /* [in] */ DWORD tagValue, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( + IDiaSymbol6 * This, + /* [in] */ DWORD tagValue, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( + IDiaSymbol6 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pPointerTags); + + HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( + IDiaSymbol6 * This, + /* [out] */ IDiaLineNumber **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( + IDiaSymbol6 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( + IDiaSymbol6 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( + IDiaSymbol6 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( + IDiaSymbol6 * This, + /* [out] */ IDiaInputAssemblyFile **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( + IDiaSymbol6 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( + IDiaSymbol6 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noexcept )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAbsoluteAddress )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStaticMemberFunc )( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + END_INTERFACE + } IDiaSymbol6Vtbl; + + interface IDiaSymbol6 + { + CONST_VTBL struct IDiaSymbol6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaSymbol6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaSymbol6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaSymbol6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaSymbol6_get_symIndexId(This,pRetVal) \ + ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) + +#define IDiaSymbol6_get_symTag(This,pRetVal) \ + ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) + +#define IDiaSymbol6_get_name(This,pRetVal) \ + ( (This)->lpVtbl -> get_name(This,pRetVal) ) + +#define IDiaSymbol6_get_lexicalParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) + +#define IDiaSymbol6_get_classParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) + +#define IDiaSymbol6_get_type(This,pRetVal) \ + ( (This)->lpVtbl -> get_type(This,pRetVal) ) + +#define IDiaSymbol6_get_dataKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) + +#define IDiaSymbol6_get_locationType(This,pRetVal) \ + ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) + +#define IDiaSymbol6_get_addressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) + +#define IDiaSymbol6_get_addressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) + +#define IDiaSymbol6_get_relativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol6_get_virtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) + +#define IDiaSymbol6_get_registerId(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) + +#define IDiaSymbol6_get_offset(This,pRetVal) \ + ( (This)->lpVtbl -> get_offset(This,pRetVal) ) + +#define IDiaSymbol6_get_length(This,pRetVal) \ + ( (This)->lpVtbl -> get_length(This,pRetVal) ) + +#define IDiaSymbol6_get_slot(This,pRetVal) \ + ( (This)->lpVtbl -> get_slot(This,pRetVal) ) + +#define IDiaSymbol6_get_volatileType(This,pRetVal) \ + ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) + +#define IDiaSymbol6_get_constType(This,pRetVal) \ + ( (This)->lpVtbl -> get_constType(This,pRetVal) ) + +#define IDiaSymbol6_get_unalignedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) + +#define IDiaSymbol6_get_access(This,pRetVal) \ + ( (This)->lpVtbl -> get_access(This,pRetVal) ) + +#define IDiaSymbol6_get_libraryName(This,pRetVal) \ + ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) + +#define IDiaSymbol6_get_platform(This,pRetVal) \ + ( (This)->lpVtbl -> get_platform(This,pRetVal) ) + +#define IDiaSymbol6_get_language(This,pRetVal) \ + ( (This)->lpVtbl -> get_language(This,pRetVal) ) + +#define IDiaSymbol6_get_editAndContinueEnabled(This,pRetVal) \ + ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) + +#define IDiaSymbol6_get_frontEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) + +#define IDiaSymbol6_get_frontEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) + +#define IDiaSymbol6_get_frontEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) + +#define IDiaSymbol6_get_backEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) + +#define IDiaSymbol6_get_backEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) + +#define IDiaSymbol6_get_backEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) + +#define IDiaSymbol6_get_sourceFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) + +#define IDiaSymbol6_get_unused(This,pRetVal) \ + ( (This)->lpVtbl -> get_unused(This,pRetVal) ) + +#define IDiaSymbol6_get_thunkOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) + +#define IDiaSymbol6_get_thisAdjust(This,pRetVal) \ + ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) + +#define IDiaSymbol6_get_virtualBaseOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) + +#define IDiaSymbol6_get_virtual(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) + +#define IDiaSymbol6_get_intro(This,pRetVal) \ + ( (This)->lpVtbl -> get_intro(This,pRetVal) ) + +#define IDiaSymbol6_get_pure(This,pRetVal) \ + ( (This)->lpVtbl -> get_pure(This,pRetVal) ) + +#define IDiaSymbol6_get_callingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) + +#define IDiaSymbol6_get_value(This,pRetVal) \ + ( (This)->lpVtbl -> get_value(This,pRetVal) ) + +#define IDiaSymbol6_get_baseType(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) + +#define IDiaSymbol6_get_token(This,pRetVal) \ + ( (This)->lpVtbl -> get_token(This,pRetVal) ) + +#define IDiaSymbol6_get_timeStamp(This,pRetVal) \ + ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) + +#define IDiaSymbol6_get_guid(This,pRetVal) \ + ( (This)->lpVtbl -> get_guid(This,pRetVal) ) + +#define IDiaSymbol6_get_symbolsFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) + +#define IDiaSymbol6_get_reference(This,pRetVal) \ + ( (This)->lpVtbl -> get_reference(This,pRetVal) ) + +#define IDiaSymbol6_get_count(This,pRetVal) \ + ( (This)->lpVtbl -> get_count(This,pRetVal) ) + +#define IDiaSymbol6_get_bitPosition(This,pRetVal) \ + ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) + +#define IDiaSymbol6_get_arrayIndexType(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) + +#define IDiaSymbol6_get_packed(This,pRetVal) \ + ( (This)->lpVtbl -> get_packed(This,pRetVal) ) + +#define IDiaSymbol6_get_constructor(This,pRetVal) \ + ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) + +#define IDiaSymbol6_get_overloadedOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) + +#define IDiaSymbol6_get_nested(This,pRetVal) \ + ( (This)->lpVtbl -> get_nested(This,pRetVal) ) + +#define IDiaSymbol6_get_hasNestedTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) + +#define IDiaSymbol6_get_hasAssignmentOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) + +#define IDiaSymbol6_get_hasCastOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) + +#define IDiaSymbol6_get_scoped(This,pRetVal) \ + ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) + +#define IDiaSymbol6_get_virtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol6_get_indirectVirtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol6_get_virtualBasePointerOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) + +#define IDiaSymbol6_get_virtualTableShape(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) + +#define IDiaSymbol6_get_lexicalParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) + +#define IDiaSymbol6_get_classParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) + +#define IDiaSymbol6_get_typeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) + +#define IDiaSymbol6_get_arrayIndexTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) + +#define IDiaSymbol6_get_virtualTableShapeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) + +#define IDiaSymbol6_get_code(This,pRetVal) \ + ( (This)->lpVtbl -> get_code(This,pRetVal) ) + +#define IDiaSymbol6_get_function(This,pRetVal) \ + ( (This)->lpVtbl -> get_function(This,pRetVal) ) + +#define IDiaSymbol6_get_managed(This,pRetVal) \ + ( (This)->lpVtbl -> get_managed(This,pRetVal) ) + +#define IDiaSymbol6_get_msil(This,pRetVal) \ + ( (This)->lpVtbl -> get_msil(This,pRetVal) ) + +#define IDiaSymbol6_get_virtualBaseDispIndex(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) + +#define IDiaSymbol6_get_undecoratedName(This,pRetVal) \ + ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) + +#define IDiaSymbol6_get_age(This,pRetVal) \ + ( (This)->lpVtbl -> get_age(This,pRetVal) ) + +#define IDiaSymbol6_get_signature(This,pRetVal) \ + ( (This)->lpVtbl -> get_signature(This,pRetVal) ) + +#define IDiaSymbol6_get_compilerGenerated(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) + +#define IDiaSymbol6_get_addressTaken(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) + +#define IDiaSymbol6_get_rank(This,pRetVal) \ + ( (This)->lpVtbl -> get_rank(This,pRetVal) ) + +#define IDiaSymbol6_get_lowerBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) + +#define IDiaSymbol6_get_upperBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) + +#define IDiaSymbol6_get_lowerBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) + +#define IDiaSymbol6_get_upperBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) + +#define IDiaSymbol6_get_dataBytes(This,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) + +#define IDiaSymbol6_findChildren(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol6_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol6_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) + +#define IDiaSymbol6_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) + +#define IDiaSymbol6_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) + +#define IDiaSymbol6_get_targetSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) + +#define IDiaSymbol6_get_targetOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) + +#define IDiaSymbol6_get_targetRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol6_get_targetVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol6_get_machineType(This,pRetVal) \ + ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) + +#define IDiaSymbol6_get_oemId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) + +#define IDiaSymbol6_get_oemSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) + +#define IDiaSymbol6_get_types(This,cTypes,pcTypes,pTypes) \ + ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) + +#define IDiaSymbol6_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ + ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) + +#define IDiaSymbol6_get_objectPointerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) + +#define IDiaSymbol6_get_udtKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) + +#define IDiaSymbol6_get_undecoratedNameEx(This,undecorateOptions,name) \ + ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) + +#define IDiaSymbol6_get_noReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) + +#define IDiaSymbol6_get_customCallingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) + +#define IDiaSymbol6_get_noInline(This,pRetVal) \ + ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) + +#define IDiaSymbol6_get_optimizedCodeDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) + +#define IDiaSymbol6_get_notReached(This,pRetVal) \ + ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) + +#define IDiaSymbol6_get_interruptReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) + +#define IDiaSymbol6_get_farReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) + +#define IDiaSymbol6_get_isStatic(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) + +#define IDiaSymbol6_get_hasDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) + +#define IDiaSymbol6_get_isLTCG(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) + +#define IDiaSymbol6_get_isDataAligned(This,pRetVal) \ + ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) + +#define IDiaSymbol6_get_hasSecurityChecks(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) + +#define IDiaSymbol6_get_compilerName(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) + +#define IDiaSymbol6_get_hasAlloca(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) + +#define IDiaSymbol6_get_hasSetJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) + +#define IDiaSymbol6_get_hasLongJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) + +#define IDiaSymbol6_get_hasInlAsm(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) + +#define IDiaSymbol6_get_hasEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) + +#define IDiaSymbol6_get_hasSEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) + +#define IDiaSymbol6_get_hasEHa(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) + +#define IDiaSymbol6_get_isNaked(This,pRetVal) \ + ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) + +#define IDiaSymbol6_get_isAggregated(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) + +#define IDiaSymbol6_get_isSplitted(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) + +#define IDiaSymbol6_get_container(This,pRetVal) \ + ( (This)->lpVtbl -> get_container(This,pRetVal) ) + +#define IDiaSymbol6_get_inlSpec(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) + +#define IDiaSymbol6_get_noStackOrdering(This,pRetVal) \ + ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) + +#define IDiaSymbol6_get_virtualBaseTableType(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) + +#define IDiaSymbol6_get_hasManagedCode(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) + +#define IDiaSymbol6_get_isHotpatchable(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) + +#define IDiaSymbol6_get_isCVTCIL(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) + +#define IDiaSymbol6_get_isMSILNetmodule(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) + +#define IDiaSymbol6_get_isCTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) + +#define IDiaSymbol6_get_isStripped(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) + +#define IDiaSymbol6_get_frontEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) + +#define IDiaSymbol6_get_backEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) + +#define IDiaSymbol6_get_wasInlined(This,pRetVal) \ + ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) + +#define IDiaSymbol6_get_strictGSCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) + +#define IDiaSymbol6_get_isCxxReturnUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) + +#define IDiaSymbol6_get_isConstructorVirtualBase(This,pRetVal) \ + ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) + +#define IDiaSymbol6_get_RValueReference(This,pRetVal) \ + ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) + +#define IDiaSymbol6_get_unmodifiedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) + +#define IDiaSymbol6_get_framePointerPresent(This,pRetVal) \ + ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) + +#define IDiaSymbol6_get_isSafeBuffers(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) + +#define IDiaSymbol6_get_intrinsic(This,pRetVal) \ + ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) + +#define IDiaSymbol6_get_sealed(This,pRetVal) \ + ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) + +#define IDiaSymbol6_get_hfaFloat(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) + +#define IDiaSymbol6_get_hfaDouble(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) + +#define IDiaSymbol6_get_liveRangeStartAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) + +#define IDiaSymbol6_get_liveRangeStartAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) + +#define IDiaSymbol6_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol6_get_countLiveRanges(This,pRetVal) \ + ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) + +#define IDiaSymbol6_get_liveRangeLength(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) + +#define IDiaSymbol6_get_offsetInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) + +#define IDiaSymbol6_get_paramBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol6_get_localBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol6_get_isLocationControlFlowDependent(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) + +#define IDiaSymbol6_get_stride(This,pRetVal) \ + ( (This)->lpVtbl -> get_stride(This,pRetVal) ) + +#define IDiaSymbol6_get_numberOfRows(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) + +#define IDiaSymbol6_get_numberOfColumns(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) + +#define IDiaSymbol6_get_isMatrixRowMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) + +#define IDiaSymbol6_get_numericProperties(This,cnt,pcnt,pProperties) \ + ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) + +#define IDiaSymbol6_get_modifierValues(This,cnt,pcnt,pModifiers) \ + ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) + +#define IDiaSymbol6_get_isReturnValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) + +#define IDiaSymbol6_get_isOptimizedAway(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) + +#define IDiaSymbol6_get_builtInKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) + +#define IDiaSymbol6_get_registerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) + +#define IDiaSymbol6_get_baseDataSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) + +#define IDiaSymbol6_get_baseDataOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) + +#define IDiaSymbol6_get_textureSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) + +#define IDiaSymbol6_get_samplerSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) + +#define IDiaSymbol6_get_uavSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) + +#define IDiaSymbol6_get_sizeInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) + +#define IDiaSymbol6_get_memorySpaceKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) + +#define IDiaSymbol6_get_unmodifiedTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) + +#define IDiaSymbol6_get_subTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) + +#define IDiaSymbol6_get_subType(This,pRetVal) \ + ( (This)->lpVtbl -> get_subType(This,pRetVal) ) + +#define IDiaSymbol6_get_numberOfModifiers(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) + +#define IDiaSymbol6_get_numberOfRegisterIndices(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) + +#define IDiaSymbol6_get_isHLSLData(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) + +#define IDiaSymbol6_get_isPointerToDataMember(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) + +#define IDiaSymbol6_get_isPointerToMemberFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) + +#define IDiaSymbol6_get_isSingleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) + +#define IDiaSymbol6_get_isMultipleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) + +#define IDiaSymbol6_get_isVirtualInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) + +#define IDiaSymbol6_get_restrictedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) + +#define IDiaSymbol6_get_isPointerBasedOnSymbolValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) + +#define IDiaSymbol6_get_baseSymbol(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) + +#define IDiaSymbol6_get_baseSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) + +#define IDiaSymbol6_get_objectFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) + +#define IDiaSymbol6_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) + +#define IDiaSymbol6_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) + +#define IDiaSymbol6_get_isAcceleratorStubFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) + +#define IDiaSymbol6_get_numberOfAcceleratorPointerTags(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) + +#define IDiaSymbol6_get_isSdl(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) + +#define IDiaSymbol6_get_isWinRTPointer(This,pRetVal) \ + ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) + +#define IDiaSymbol6_get_isRefUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) + +#define IDiaSymbol6_get_isValueUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) + +#define IDiaSymbol6_get_isInterfaceUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) + +#define IDiaSymbol6_findInlineFramesByAddr(This,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) + +#define IDiaSymbol6_findInlineFramesByRVA(This,rva,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) + +#define IDiaSymbol6_findInlineFramesByVA(This,va,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) + +#define IDiaSymbol6_findInlineeLines(This,ppResult) \ + ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) + +#define IDiaSymbol6_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) + +#define IDiaSymbol6_findInlineeLinesByRVA(This,rva,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) + +#define IDiaSymbol6_findInlineeLinesByVA(This,va,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) + +#define IDiaSymbol6_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ + ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) + +#define IDiaSymbol6_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ + ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) + +#define IDiaSymbol6_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ + ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) + +#define IDiaSymbol6_getSrcLineOnTypeDefn(This,ppResult) \ + ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) + +#define IDiaSymbol6_get_isPGO(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) + +#define IDiaSymbol6_get_hasValidPGOCounts(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) + +#define IDiaSymbol6_get_isOptimizedForSpeed(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) + +#define IDiaSymbol6_get_PGOEntryCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) + +#define IDiaSymbol6_get_PGOEdgeCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) + +#define IDiaSymbol6_get_PGODynamicInstructionCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) + +#define IDiaSymbol6_get_staticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) + +#define IDiaSymbol6_get_finalLiveStaticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) + +#define IDiaSymbol6_get_phaseName(This,pRetVal) \ + ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) + +#define IDiaSymbol6_get_hasControlFlowCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) + +#define IDiaSymbol6_get_constantExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) + +#define IDiaSymbol6_get_dataExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) + +#define IDiaSymbol6_get_privateExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) + +#define IDiaSymbol6_get_noNameExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) + +#define IDiaSymbol6_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) + +#define IDiaSymbol6_get_exportIsForwarder(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) + +#define IDiaSymbol6_get_ordinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) + +#define IDiaSymbol6_get_frameSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) + +#define IDiaSymbol6_get_exceptionHandlerAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) + +#define IDiaSymbol6_get_exceptionHandlerAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) + +#define IDiaSymbol6_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol6_get_exceptionHandlerVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol6_findInputAssemblyFile(This,ppResult) \ + ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) + +#define IDiaSymbol6_get_characteristics(This,pRetVal) \ + ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) + +#define IDiaSymbol6_get_coffGroup(This,pRetVal) \ + ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) + +#define IDiaSymbol6_get_bindID(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) + +#define IDiaSymbol6_get_bindSpace(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) + +#define IDiaSymbol6_get_bindSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) + + +#define IDiaSymbol6_get_isObjCClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) + +#define IDiaSymbol6_get_isObjCCategory(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) + +#define IDiaSymbol6_get_isObjCProtocol(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) + + +#define IDiaSymbol6_get_inlinee(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) + +#define IDiaSymbol6_get_inlineeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) + + +#define IDiaSymbol6_get_noexcept(This,pRetVal) \ + ( (This)->lpVtbl -> get_noexcept(This,pRetVal) ) + + +#define IDiaSymbol6_get_hasAbsoluteAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAbsoluteAddress(This,pRetVal) ) + + +#define IDiaSymbol6_get_isStaticMemberFunc(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStaticMemberFunc(This,pRetVal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol6_get_isStaticMemberFunc_Proxy( + IDiaSymbol6 * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol6_get_isStaticMemberFunc_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IDiaSymbol6_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaSymbol7_INTERFACE_DEFINED__ +#define __IDiaSymbol7_INTERFACE_DEFINED__ + +/* interface IDiaSymbol7 */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaSymbol7; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("64ce6cd5-7315-4328-86d6-10e303e010b4") + IDiaSymbol7 : public IDiaSymbol6 + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_isSignRet( + /* [retval][out] */ BOOL *pRetVal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaSymbol7Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaSymbol7 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaSymbol7 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaSymbol7 * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symIndexId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symTag )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( + IDiaSymbol7 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParent )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParent )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataKind )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_locationType )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( + IDiaSymbol7 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( + IDiaSymbol7 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( + IDiaSymbol7 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_slot )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_volatileType )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constType )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unalignedType )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_access )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_libraryName )( + IDiaSymbol7 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_platform )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_language )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_editAndContinueEnabled )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMajor )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndMinor )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndBuild )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMajor )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndMinor )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndBuild )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileName )( + IDiaSymbol7 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unused )( + IDiaSymbol7 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thunkOrdinal )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_thisAdjust )( + IDiaSymbol7 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseOffset )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtual )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intro )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pure )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_callingConvention )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_value )( + IDiaSymbol7 * This, + /* [retval][out] */ VARIANT *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseType )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_token )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timeStamp )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_guid )( + IDiaSymbol7 * This, + /* [retval][out] */ GUID *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_symbolsFileName )( + IDiaSymbol7 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_reference )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_count )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bitPosition )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexType )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_packed )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constructor )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_overloadedOperator )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_nested )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasNestedTypes )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAssignmentOperator )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasCastOperator )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_scoped )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseClass )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_indirectVirtualBaseClass )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBasePointerOffset )( + IDiaSymbol7 * This, + /* [retval][out] */ LONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShape )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lexicalParentId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_classParentId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_typeId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_arrayIndexTypeId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualTableShapeId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_function )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_managed )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_msil )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseDispIndex )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_undecoratedName )( + IDiaSymbol7 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_age )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_signature )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerGenerated )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressTaken )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_rank )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBound )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBound )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lowerBoundId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_upperBoundId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_dataBytes )( + IDiaSymbol7 * This, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *findChildren )( + IDiaSymbol7 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenEx )( + IDiaSymbol7 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByAddr )( + IDiaSymbol7 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByVA )( + IDiaSymbol7 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findChildrenExByRVA )( + IDiaSymbol7 * This, + /* [in] */ enum SymTagEnum symtag, + /* [in] */ LPCOLESTR name, + /* [in] */ DWORD compareFlags, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetSection )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetOffset )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetRelativeVirtualAddress )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_targetVirtualAddress )( + IDiaSymbol7 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_machineType )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_oemSymbolId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_types )( + IDiaSymbol7 * This, + /* [in] */ DWORD cTypes, + /* [out] */ DWORD *pcTypes, + /* [size_is][size_is][out] */ IDiaSymbol **pTypes); + + HRESULT ( STDMETHODCALLTYPE *get_typeIds )( + IDiaSymbol7 * This, + /* [in] */ DWORD cTypeIds, + /* [out] */ DWORD *pcTypeIds, + /* [size_is][out] */ DWORD *pdwTypeIds); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectPointerType )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_udtKind )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_undecoratedNameEx )( + IDiaSymbol7 * This, + /* [in] */ DWORD undecorateOptions, + /* [out] */ BSTR *name); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noReturn )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_customCallingConvention )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noInline )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_optimizedCodeDebugInfo )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notReached )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_interruptReturn )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_farReturn )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStatic )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasDebugInfo )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLTCG )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isDataAligned )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSecurityChecks )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilerName )( + IDiaSymbol7 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAlloca )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSetJump )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasLongJump )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasInlAsm )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEH )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasSEH )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasEHa )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isNaked )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAggregated )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSplitted )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_container )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlSpec )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noStackOrdering )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualBaseTableType )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasManagedCode )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHotpatchable )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCVTCIL )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMSILNetmodule )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCTypes )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStripped )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frontEndQFE )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_backEndQFE )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_wasInlined )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_strictGSCheck )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isCxxReturnUdt )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isConstructorVirtualBase )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_RValueReference )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedType )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_framePointerPresent )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSafeBuffers )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_intrinsic )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sealed )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaFloat )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hfaDouble )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressSection )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartAddressOffset )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeStartRelativeVirtualAddress )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_countLiveRanges )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_liveRangeLength )( + IDiaSymbol7 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offsetInUdt )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_paramBasePointerRegisterId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localBasePointerRegisterId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isLocationControlFlowDependent )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_stride )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRows )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfColumns )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMatrixRowMajor )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_numericProperties )( + IDiaSymbol7 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pProperties); + + HRESULT ( STDMETHODCALLTYPE *get_modifierValues )( + IDiaSymbol7 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ WORD *pModifiers); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isReturnValue )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedAway )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_builtInKind )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerType )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataSlot )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseDataOffset )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_textureSlot )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_samplerSlot )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uavSlot )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sizeInUdt )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_memorySpaceKind )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_unmodifiedTypeId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subTypeId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_subType )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfModifiers )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfRegisterIndices )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isHLSLData )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToDataMember )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerToMemberFunction )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSingleInheritance )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isMultipleInheritance )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isVirtualInheritance )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_restrictedType )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPointerBasedOnSymbolValue )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbol )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_baseSymbolId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFileName )( + IDiaSymbol7 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorGroupSharedLocal )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorPointerTagLiveRange )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isAcceleratorStubFunction )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_numberOfAcceleratorPointerTags )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSdl )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isWinRTPointer )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isRefUdt )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isValueUdt )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isInterfaceUdt )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByAddr )( + IDiaSymbol7 * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByRVA )( + IDiaSymbol7 * This, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineFramesByVA )( + IDiaSymbol7 * This, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLines )( + IDiaSymbol7 * This, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByAddr )( + IDiaSymbol7 * This, + /* [in] */ DWORD isect, + /* [in] */ DWORD offset, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByRVA )( + IDiaSymbol7 * This, + /* [in] */ DWORD rva, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findInlineeLinesByVA )( + IDiaSymbol7 * This, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD length, + /* [out] */ IDiaEnumLineNumbers **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsForAcceleratorPointerTag )( + IDiaSymbol7 * This, + /* [in] */ DWORD tagValue, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *findSymbolsByRVAForAcceleratorPointerTag )( + IDiaSymbol7 * This, + /* [in] */ DWORD tagValue, + /* [in] */ DWORD rva, + /* [out] */ IDiaEnumSymbols **ppResult); + + HRESULT ( STDMETHODCALLTYPE *get_acceleratorPointerTags )( + IDiaSymbol7 * This, + /* [in] */ DWORD cnt, + /* [out] */ DWORD *pcnt, + /* [size_is][out] */ DWORD *pPointerTags); + + HRESULT ( STDMETHODCALLTYPE *getSrcLineOnTypeDefn )( + IDiaSymbol7 * This, + /* [out] */ IDiaLineNumber **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isPGO )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasValidPGOCounts )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isOptimizedForSpeed )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEntryCount )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGOEdgeCount )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_PGODynamicInstructionCount )( + IDiaSymbol7 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_staticSize )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_finalLiveStaticSize )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_phaseName )( + IDiaSymbol7 * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasControlFlowCheck )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_constantExport )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataExport )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_privateExport )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noNameExport )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportHasExplicitlyAssignedOrdinal )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exportIsForwarder )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_ordinal )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frameSize )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressSection )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerAddressOffset )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerRelativeVirtualAddress )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_exceptionHandlerVirtualAddress )( + IDiaSymbol7 * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *findInputAssemblyFile )( + IDiaSymbol7 * This, + /* [out] */ IDiaInputAssemblyFile **ppResult); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_characteristics )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_coffGroup )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindID )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSpace )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_bindSlot )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCClass )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCCategory )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isObjCProtocol )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlinee )( + IDiaSymbol7 * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_inlineeId )( + IDiaSymbol7 * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_noexcept )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_hasAbsoluteAddress )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isStaticMemberFunc )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_isSignRet )( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + END_INTERFACE + } IDiaSymbol7Vtbl; + + interface IDiaSymbol7 + { + CONST_VTBL struct IDiaSymbol7Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaSymbol7_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaSymbol7_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaSymbol7_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaSymbol7_get_symIndexId(This,pRetVal) \ + ( (This)->lpVtbl -> get_symIndexId(This,pRetVal) ) + +#define IDiaSymbol7_get_symTag(This,pRetVal) \ + ( (This)->lpVtbl -> get_symTag(This,pRetVal) ) + +#define IDiaSymbol7_get_name(This,pRetVal) \ + ( (This)->lpVtbl -> get_name(This,pRetVal) ) + +#define IDiaSymbol7_get_lexicalParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParent(This,pRetVal) ) + +#define IDiaSymbol7_get_classParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParent(This,pRetVal) ) + +#define IDiaSymbol7_get_type(This,pRetVal) \ + ( (This)->lpVtbl -> get_type(This,pRetVal) ) + +#define IDiaSymbol7_get_dataKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataKind(This,pRetVal) ) + +#define IDiaSymbol7_get_locationType(This,pRetVal) \ + ( (This)->lpVtbl -> get_locationType(This,pRetVal) ) + +#define IDiaSymbol7_get_addressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) + +#define IDiaSymbol7_get_addressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) + +#define IDiaSymbol7_get_relativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol7_get_virtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) + +#define IDiaSymbol7_get_registerId(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerId(This,pRetVal) ) + +#define IDiaSymbol7_get_offset(This,pRetVal) \ + ( (This)->lpVtbl -> get_offset(This,pRetVal) ) + +#define IDiaSymbol7_get_length(This,pRetVal) \ + ( (This)->lpVtbl -> get_length(This,pRetVal) ) + +#define IDiaSymbol7_get_slot(This,pRetVal) \ + ( (This)->lpVtbl -> get_slot(This,pRetVal) ) + +#define IDiaSymbol7_get_volatileType(This,pRetVal) \ + ( (This)->lpVtbl -> get_volatileType(This,pRetVal) ) + +#define IDiaSymbol7_get_constType(This,pRetVal) \ + ( (This)->lpVtbl -> get_constType(This,pRetVal) ) + +#define IDiaSymbol7_get_unalignedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unalignedType(This,pRetVal) ) + +#define IDiaSymbol7_get_access(This,pRetVal) \ + ( (This)->lpVtbl -> get_access(This,pRetVal) ) + +#define IDiaSymbol7_get_libraryName(This,pRetVal) \ + ( (This)->lpVtbl -> get_libraryName(This,pRetVal) ) + +#define IDiaSymbol7_get_platform(This,pRetVal) \ + ( (This)->lpVtbl -> get_platform(This,pRetVal) ) + +#define IDiaSymbol7_get_language(This,pRetVal) \ + ( (This)->lpVtbl -> get_language(This,pRetVal) ) + +#define IDiaSymbol7_get_editAndContinueEnabled(This,pRetVal) \ + ( (This)->lpVtbl -> get_editAndContinueEnabled(This,pRetVal) ) + +#define IDiaSymbol7_get_frontEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMajor(This,pRetVal) ) + +#define IDiaSymbol7_get_frontEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndMinor(This,pRetVal) ) + +#define IDiaSymbol7_get_frontEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndBuild(This,pRetVal) ) + +#define IDiaSymbol7_get_backEndMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMajor(This,pRetVal) ) + +#define IDiaSymbol7_get_backEndMinor(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndMinor(This,pRetVal) ) + +#define IDiaSymbol7_get_backEndBuild(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndBuild(This,pRetVal) ) + +#define IDiaSymbol7_get_sourceFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_sourceFileName(This,pRetVal) ) + +#define IDiaSymbol7_get_unused(This,pRetVal) \ + ( (This)->lpVtbl -> get_unused(This,pRetVal) ) + +#define IDiaSymbol7_get_thunkOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_thunkOrdinal(This,pRetVal) ) + +#define IDiaSymbol7_get_thisAdjust(This,pRetVal) \ + ( (This)->lpVtbl -> get_thisAdjust(This,pRetVal) ) + +#define IDiaSymbol7_get_virtualBaseOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseOffset(This,pRetVal) ) + +#define IDiaSymbol7_get_virtual(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtual(This,pRetVal) ) + +#define IDiaSymbol7_get_intro(This,pRetVal) \ + ( (This)->lpVtbl -> get_intro(This,pRetVal) ) + +#define IDiaSymbol7_get_pure(This,pRetVal) \ + ( (This)->lpVtbl -> get_pure(This,pRetVal) ) + +#define IDiaSymbol7_get_callingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_callingConvention(This,pRetVal) ) + +#define IDiaSymbol7_get_value(This,pRetVal) \ + ( (This)->lpVtbl -> get_value(This,pRetVal) ) + +#define IDiaSymbol7_get_baseType(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseType(This,pRetVal) ) + +#define IDiaSymbol7_get_token(This,pRetVal) \ + ( (This)->lpVtbl -> get_token(This,pRetVal) ) + +#define IDiaSymbol7_get_timeStamp(This,pRetVal) \ + ( (This)->lpVtbl -> get_timeStamp(This,pRetVal) ) + +#define IDiaSymbol7_get_guid(This,pRetVal) \ + ( (This)->lpVtbl -> get_guid(This,pRetVal) ) + +#define IDiaSymbol7_get_symbolsFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_symbolsFileName(This,pRetVal) ) + +#define IDiaSymbol7_get_reference(This,pRetVal) \ + ( (This)->lpVtbl -> get_reference(This,pRetVal) ) + +#define IDiaSymbol7_get_count(This,pRetVal) \ + ( (This)->lpVtbl -> get_count(This,pRetVal) ) + +#define IDiaSymbol7_get_bitPosition(This,pRetVal) \ + ( (This)->lpVtbl -> get_bitPosition(This,pRetVal) ) + +#define IDiaSymbol7_get_arrayIndexType(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexType(This,pRetVal) ) + +#define IDiaSymbol7_get_packed(This,pRetVal) \ + ( (This)->lpVtbl -> get_packed(This,pRetVal) ) + +#define IDiaSymbol7_get_constructor(This,pRetVal) \ + ( (This)->lpVtbl -> get_constructor(This,pRetVal) ) + +#define IDiaSymbol7_get_overloadedOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_overloadedOperator(This,pRetVal) ) + +#define IDiaSymbol7_get_nested(This,pRetVal) \ + ( (This)->lpVtbl -> get_nested(This,pRetVal) ) + +#define IDiaSymbol7_get_hasNestedTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasNestedTypes(This,pRetVal) ) + +#define IDiaSymbol7_get_hasAssignmentOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAssignmentOperator(This,pRetVal) ) + +#define IDiaSymbol7_get_hasCastOperator(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasCastOperator(This,pRetVal) ) + +#define IDiaSymbol7_get_scoped(This,pRetVal) \ + ( (This)->lpVtbl -> get_scoped(This,pRetVal) ) + +#define IDiaSymbol7_get_virtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol7_get_indirectVirtualBaseClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_indirectVirtualBaseClass(This,pRetVal) ) + +#define IDiaSymbol7_get_virtualBasePointerOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBasePointerOffset(This,pRetVal) ) + +#define IDiaSymbol7_get_virtualTableShape(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShape(This,pRetVal) ) + +#define IDiaSymbol7_get_lexicalParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lexicalParentId(This,pRetVal) ) + +#define IDiaSymbol7_get_classParentId(This,pRetVal) \ + ( (This)->lpVtbl -> get_classParentId(This,pRetVal) ) + +#define IDiaSymbol7_get_typeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_typeId(This,pRetVal) ) + +#define IDiaSymbol7_get_arrayIndexTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_arrayIndexTypeId(This,pRetVal) ) + +#define IDiaSymbol7_get_virtualTableShapeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualTableShapeId(This,pRetVal) ) + +#define IDiaSymbol7_get_code(This,pRetVal) \ + ( (This)->lpVtbl -> get_code(This,pRetVal) ) + +#define IDiaSymbol7_get_function(This,pRetVal) \ + ( (This)->lpVtbl -> get_function(This,pRetVal) ) + +#define IDiaSymbol7_get_managed(This,pRetVal) \ + ( (This)->lpVtbl -> get_managed(This,pRetVal) ) + +#define IDiaSymbol7_get_msil(This,pRetVal) \ + ( (This)->lpVtbl -> get_msil(This,pRetVal) ) + +#define IDiaSymbol7_get_virtualBaseDispIndex(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseDispIndex(This,pRetVal) ) + +#define IDiaSymbol7_get_undecoratedName(This,pRetVal) \ + ( (This)->lpVtbl -> get_undecoratedName(This,pRetVal) ) + +#define IDiaSymbol7_get_age(This,pRetVal) \ + ( (This)->lpVtbl -> get_age(This,pRetVal) ) + +#define IDiaSymbol7_get_signature(This,pRetVal) \ + ( (This)->lpVtbl -> get_signature(This,pRetVal) ) + +#define IDiaSymbol7_get_compilerGenerated(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerGenerated(This,pRetVal) ) + +#define IDiaSymbol7_get_addressTaken(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressTaken(This,pRetVal) ) + +#define IDiaSymbol7_get_rank(This,pRetVal) \ + ( (This)->lpVtbl -> get_rank(This,pRetVal) ) + +#define IDiaSymbol7_get_lowerBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBound(This,pRetVal) ) + +#define IDiaSymbol7_get_upperBound(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBound(This,pRetVal) ) + +#define IDiaSymbol7_get_lowerBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_lowerBoundId(This,pRetVal) ) + +#define IDiaSymbol7_get_upperBoundId(This,pRetVal) \ + ( (This)->lpVtbl -> get_upperBoundId(This,pRetVal) ) + +#define IDiaSymbol7_get_dataBytes(This,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> get_dataBytes(This,cbData,pcbData,pbData) ) + +#define IDiaSymbol7_findChildren(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildren(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol7_findChildrenEx(This,symtag,name,compareFlags,ppResult) \ + ( (This)->lpVtbl -> findChildrenEx(This,symtag,name,compareFlags,ppResult) ) + +#define IDiaSymbol7_findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByAddr(This,symtag,name,compareFlags,isect,offset,ppResult) ) + +#define IDiaSymbol7_findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByVA(This,symtag,name,compareFlags,va,ppResult) ) + +#define IDiaSymbol7_findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) \ + ( (This)->lpVtbl -> findChildrenExByRVA(This,symtag,name,compareFlags,rva,ppResult) ) + +#define IDiaSymbol7_get_targetSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetSection(This,pRetVal) ) + +#define IDiaSymbol7_get_targetOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetOffset(This,pRetVal) ) + +#define IDiaSymbol7_get_targetRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol7_get_targetVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_targetVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol7_get_machineType(This,pRetVal) \ + ( (This)->lpVtbl -> get_machineType(This,pRetVal) ) + +#define IDiaSymbol7_get_oemId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemId(This,pRetVal) ) + +#define IDiaSymbol7_get_oemSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_oemSymbolId(This,pRetVal) ) + +#define IDiaSymbol7_get_types(This,cTypes,pcTypes,pTypes) \ + ( (This)->lpVtbl -> get_types(This,cTypes,pcTypes,pTypes) ) + +#define IDiaSymbol7_get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) \ + ( (This)->lpVtbl -> get_typeIds(This,cTypeIds,pcTypeIds,pdwTypeIds) ) + +#define IDiaSymbol7_get_objectPointerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectPointerType(This,pRetVal) ) + +#define IDiaSymbol7_get_udtKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_udtKind(This,pRetVal) ) + +#define IDiaSymbol7_get_undecoratedNameEx(This,undecorateOptions,name) \ + ( (This)->lpVtbl -> get_undecoratedNameEx(This,undecorateOptions,name) ) + +#define IDiaSymbol7_get_noReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_noReturn(This,pRetVal) ) + +#define IDiaSymbol7_get_customCallingConvention(This,pRetVal) \ + ( (This)->lpVtbl -> get_customCallingConvention(This,pRetVal) ) + +#define IDiaSymbol7_get_noInline(This,pRetVal) \ + ( (This)->lpVtbl -> get_noInline(This,pRetVal) ) + +#define IDiaSymbol7_get_optimizedCodeDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_optimizedCodeDebugInfo(This,pRetVal) ) + +#define IDiaSymbol7_get_notReached(This,pRetVal) \ + ( (This)->lpVtbl -> get_notReached(This,pRetVal) ) + +#define IDiaSymbol7_get_interruptReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_interruptReturn(This,pRetVal) ) + +#define IDiaSymbol7_get_farReturn(This,pRetVal) \ + ( (This)->lpVtbl -> get_farReturn(This,pRetVal) ) + +#define IDiaSymbol7_get_isStatic(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStatic(This,pRetVal) ) + +#define IDiaSymbol7_get_hasDebugInfo(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasDebugInfo(This,pRetVal) ) + +#define IDiaSymbol7_get_isLTCG(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLTCG(This,pRetVal) ) + +#define IDiaSymbol7_get_isDataAligned(This,pRetVal) \ + ( (This)->lpVtbl -> get_isDataAligned(This,pRetVal) ) + +#define IDiaSymbol7_get_hasSecurityChecks(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSecurityChecks(This,pRetVal) ) + +#define IDiaSymbol7_get_compilerName(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilerName(This,pRetVal) ) + +#define IDiaSymbol7_get_hasAlloca(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAlloca(This,pRetVal) ) + +#define IDiaSymbol7_get_hasSetJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSetJump(This,pRetVal) ) + +#define IDiaSymbol7_get_hasLongJump(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasLongJump(This,pRetVal) ) + +#define IDiaSymbol7_get_hasInlAsm(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasInlAsm(This,pRetVal) ) + +#define IDiaSymbol7_get_hasEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEH(This,pRetVal) ) + +#define IDiaSymbol7_get_hasSEH(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasSEH(This,pRetVal) ) + +#define IDiaSymbol7_get_hasEHa(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasEHa(This,pRetVal) ) + +#define IDiaSymbol7_get_isNaked(This,pRetVal) \ + ( (This)->lpVtbl -> get_isNaked(This,pRetVal) ) + +#define IDiaSymbol7_get_isAggregated(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAggregated(This,pRetVal) ) + +#define IDiaSymbol7_get_isSplitted(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSplitted(This,pRetVal) ) + +#define IDiaSymbol7_get_container(This,pRetVal) \ + ( (This)->lpVtbl -> get_container(This,pRetVal) ) + +#define IDiaSymbol7_get_inlSpec(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlSpec(This,pRetVal) ) + +#define IDiaSymbol7_get_noStackOrdering(This,pRetVal) \ + ( (This)->lpVtbl -> get_noStackOrdering(This,pRetVal) ) + +#define IDiaSymbol7_get_virtualBaseTableType(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualBaseTableType(This,pRetVal) ) + +#define IDiaSymbol7_get_hasManagedCode(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasManagedCode(This,pRetVal) ) + +#define IDiaSymbol7_get_isHotpatchable(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHotpatchable(This,pRetVal) ) + +#define IDiaSymbol7_get_isCVTCIL(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCVTCIL(This,pRetVal) ) + +#define IDiaSymbol7_get_isMSILNetmodule(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMSILNetmodule(This,pRetVal) ) + +#define IDiaSymbol7_get_isCTypes(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCTypes(This,pRetVal) ) + +#define IDiaSymbol7_get_isStripped(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStripped(This,pRetVal) ) + +#define IDiaSymbol7_get_frontEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_frontEndQFE(This,pRetVal) ) + +#define IDiaSymbol7_get_backEndQFE(This,pRetVal) \ + ( (This)->lpVtbl -> get_backEndQFE(This,pRetVal) ) + +#define IDiaSymbol7_get_wasInlined(This,pRetVal) \ + ( (This)->lpVtbl -> get_wasInlined(This,pRetVal) ) + +#define IDiaSymbol7_get_strictGSCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_strictGSCheck(This,pRetVal) ) + +#define IDiaSymbol7_get_isCxxReturnUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isCxxReturnUdt(This,pRetVal) ) + +#define IDiaSymbol7_get_isConstructorVirtualBase(This,pRetVal) \ + ( (This)->lpVtbl -> get_isConstructorVirtualBase(This,pRetVal) ) + +#define IDiaSymbol7_get_RValueReference(This,pRetVal) \ + ( (This)->lpVtbl -> get_RValueReference(This,pRetVal) ) + +#define IDiaSymbol7_get_unmodifiedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedType(This,pRetVal) ) + +#define IDiaSymbol7_get_framePointerPresent(This,pRetVal) \ + ( (This)->lpVtbl -> get_framePointerPresent(This,pRetVal) ) + +#define IDiaSymbol7_get_isSafeBuffers(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSafeBuffers(This,pRetVal) ) + +#define IDiaSymbol7_get_intrinsic(This,pRetVal) \ + ( (This)->lpVtbl -> get_intrinsic(This,pRetVal) ) + +#define IDiaSymbol7_get_sealed(This,pRetVal) \ + ( (This)->lpVtbl -> get_sealed(This,pRetVal) ) + +#define IDiaSymbol7_get_hfaFloat(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaFloat(This,pRetVal) ) + +#define IDiaSymbol7_get_hfaDouble(This,pRetVal) \ + ( (This)->lpVtbl -> get_hfaDouble(This,pRetVal) ) + +#define IDiaSymbol7_get_liveRangeStartAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressSection(This,pRetVal) ) + +#define IDiaSymbol7_get_liveRangeStartAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartAddressOffset(This,pRetVal) ) + +#define IDiaSymbol7_get_liveRangeStartRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeStartRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol7_get_countLiveRanges(This,pRetVal) \ + ( (This)->lpVtbl -> get_countLiveRanges(This,pRetVal) ) + +#define IDiaSymbol7_get_liveRangeLength(This,pRetVal) \ + ( (This)->lpVtbl -> get_liveRangeLength(This,pRetVal) ) + +#define IDiaSymbol7_get_offsetInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_offsetInUdt(This,pRetVal) ) + +#define IDiaSymbol7_get_paramBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_paramBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol7_get_localBasePointerRegisterId(This,pRetVal) \ + ( (This)->lpVtbl -> get_localBasePointerRegisterId(This,pRetVal) ) + +#define IDiaSymbol7_get_isLocationControlFlowDependent(This,pRetVal) \ + ( (This)->lpVtbl -> get_isLocationControlFlowDependent(This,pRetVal) ) + +#define IDiaSymbol7_get_stride(This,pRetVal) \ + ( (This)->lpVtbl -> get_stride(This,pRetVal) ) + +#define IDiaSymbol7_get_numberOfRows(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRows(This,pRetVal) ) + +#define IDiaSymbol7_get_numberOfColumns(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfColumns(This,pRetVal) ) + +#define IDiaSymbol7_get_isMatrixRowMajor(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMatrixRowMajor(This,pRetVal) ) + +#define IDiaSymbol7_get_numericProperties(This,cnt,pcnt,pProperties) \ + ( (This)->lpVtbl -> get_numericProperties(This,cnt,pcnt,pProperties) ) + +#define IDiaSymbol7_get_modifierValues(This,cnt,pcnt,pModifiers) \ + ( (This)->lpVtbl -> get_modifierValues(This,cnt,pcnt,pModifiers) ) + +#define IDiaSymbol7_get_isReturnValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isReturnValue(This,pRetVal) ) + +#define IDiaSymbol7_get_isOptimizedAway(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedAway(This,pRetVal) ) + +#define IDiaSymbol7_get_builtInKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_builtInKind(This,pRetVal) ) + +#define IDiaSymbol7_get_registerType(This,pRetVal) \ + ( (This)->lpVtbl -> get_registerType(This,pRetVal) ) + +#define IDiaSymbol7_get_baseDataSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataSlot(This,pRetVal) ) + +#define IDiaSymbol7_get_baseDataOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseDataOffset(This,pRetVal) ) + +#define IDiaSymbol7_get_textureSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_textureSlot(This,pRetVal) ) + +#define IDiaSymbol7_get_samplerSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_samplerSlot(This,pRetVal) ) + +#define IDiaSymbol7_get_uavSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_uavSlot(This,pRetVal) ) + +#define IDiaSymbol7_get_sizeInUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_sizeInUdt(This,pRetVal) ) + +#define IDiaSymbol7_get_memorySpaceKind(This,pRetVal) \ + ( (This)->lpVtbl -> get_memorySpaceKind(This,pRetVal) ) + +#define IDiaSymbol7_get_unmodifiedTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_unmodifiedTypeId(This,pRetVal) ) + +#define IDiaSymbol7_get_subTypeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_subTypeId(This,pRetVal) ) + +#define IDiaSymbol7_get_subType(This,pRetVal) \ + ( (This)->lpVtbl -> get_subType(This,pRetVal) ) + +#define IDiaSymbol7_get_numberOfModifiers(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfModifiers(This,pRetVal) ) + +#define IDiaSymbol7_get_numberOfRegisterIndices(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfRegisterIndices(This,pRetVal) ) + +#define IDiaSymbol7_get_isHLSLData(This,pRetVal) \ + ( (This)->lpVtbl -> get_isHLSLData(This,pRetVal) ) + +#define IDiaSymbol7_get_isPointerToDataMember(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToDataMember(This,pRetVal) ) + +#define IDiaSymbol7_get_isPointerToMemberFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerToMemberFunction(This,pRetVal) ) + +#define IDiaSymbol7_get_isSingleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSingleInheritance(This,pRetVal) ) + +#define IDiaSymbol7_get_isMultipleInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isMultipleInheritance(This,pRetVal) ) + +#define IDiaSymbol7_get_isVirtualInheritance(This,pRetVal) \ + ( (This)->lpVtbl -> get_isVirtualInheritance(This,pRetVal) ) + +#define IDiaSymbol7_get_restrictedType(This,pRetVal) \ + ( (This)->lpVtbl -> get_restrictedType(This,pRetVal) ) + +#define IDiaSymbol7_get_isPointerBasedOnSymbolValue(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPointerBasedOnSymbolValue(This,pRetVal) ) + +#define IDiaSymbol7_get_baseSymbol(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbol(This,pRetVal) ) + +#define IDiaSymbol7_get_baseSymbolId(This,pRetVal) \ + ( (This)->lpVtbl -> get_baseSymbolId(This,pRetVal) ) + +#define IDiaSymbol7_get_objectFileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectFileName(This,pRetVal) ) + +#define IDiaSymbol7_get_isAcceleratorGroupSharedLocal(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorGroupSharedLocal(This,pRetVal) ) + +#define IDiaSymbol7_get_isAcceleratorPointerTagLiveRange(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorPointerTagLiveRange(This,pRetVal) ) + +#define IDiaSymbol7_get_isAcceleratorStubFunction(This,pRetVal) \ + ( (This)->lpVtbl -> get_isAcceleratorStubFunction(This,pRetVal) ) + +#define IDiaSymbol7_get_numberOfAcceleratorPointerTags(This,pRetVal) \ + ( (This)->lpVtbl -> get_numberOfAcceleratorPointerTags(This,pRetVal) ) + +#define IDiaSymbol7_get_isSdl(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSdl(This,pRetVal) ) + +#define IDiaSymbol7_get_isWinRTPointer(This,pRetVal) \ + ( (This)->lpVtbl -> get_isWinRTPointer(This,pRetVal) ) + +#define IDiaSymbol7_get_isRefUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isRefUdt(This,pRetVal) ) + +#define IDiaSymbol7_get_isValueUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isValueUdt(This,pRetVal) ) + +#define IDiaSymbol7_get_isInterfaceUdt(This,pRetVal) \ + ( (This)->lpVtbl -> get_isInterfaceUdt(This,pRetVal) ) + +#define IDiaSymbol7_findInlineFramesByAddr(This,isect,offset,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByAddr(This,isect,offset,ppResult) ) + +#define IDiaSymbol7_findInlineFramesByRVA(This,rva,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByRVA(This,rva,ppResult) ) + +#define IDiaSymbol7_findInlineFramesByVA(This,va,ppResult) \ + ( (This)->lpVtbl -> findInlineFramesByVA(This,va,ppResult) ) + +#define IDiaSymbol7_findInlineeLines(This,ppResult) \ + ( (This)->lpVtbl -> findInlineeLines(This,ppResult) ) + +#define IDiaSymbol7_findInlineeLinesByAddr(This,isect,offset,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByAddr(This,isect,offset,length,ppResult) ) + +#define IDiaSymbol7_findInlineeLinesByRVA(This,rva,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByRVA(This,rva,length,ppResult) ) + +#define IDiaSymbol7_findInlineeLinesByVA(This,va,length,ppResult) \ + ( (This)->lpVtbl -> findInlineeLinesByVA(This,va,length,ppResult) ) + +#define IDiaSymbol7_findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) \ + ( (This)->lpVtbl -> findSymbolsForAcceleratorPointerTag(This,tagValue,ppResult) ) + +#define IDiaSymbol7_findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) \ + ( (This)->lpVtbl -> findSymbolsByRVAForAcceleratorPointerTag(This,tagValue,rva,ppResult) ) + +#define IDiaSymbol7_get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) \ + ( (This)->lpVtbl -> get_acceleratorPointerTags(This,cnt,pcnt,pPointerTags) ) + +#define IDiaSymbol7_getSrcLineOnTypeDefn(This,ppResult) \ + ( (This)->lpVtbl -> getSrcLineOnTypeDefn(This,ppResult) ) + +#define IDiaSymbol7_get_isPGO(This,pRetVal) \ + ( (This)->lpVtbl -> get_isPGO(This,pRetVal) ) + +#define IDiaSymbol7_get_hasValidPGOCounts(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasValidPGOCounts(This,pRetVal) ) + +#define IDiaSymbol7_get_isOptimizedForSpeed(This,pRetVal) \ + ( (This)->lpVtbl -> get_isOptimizedForSpeed(This,pRetVal) ) + +#define IDiaSymbol7_get_PGOEntryCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEntryCount(This,pRetVal) ) + +#define IDiaSymbol7_get_PGOEdgeCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGOEdgeCount(This,pRetVal) ) + +#define IDiaSymbol7_get_PGODynamicInstructionCount(This,pRetVal) \ + ( (This)->lpVtbl -> get_PGODynamicInstructionCount(This,pRetVal) ) + +#define IDiaSymbol7_get_staticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_staticSize(This,pRetVal) ) + +#define IDiaSymbol7_get_finalLiveStaticSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_finalLiveStaticSize(This,pRetVal) ) + +#define IDiaSymbol7_get_phaseName(This,pRetVal) \ + ( (This)->lpVtbl -> get_phaseName(This,pRetVal) ) + +#define IDiaSymbol7_get_hasControlFlowCheck(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasControlFlowCheck(This,pRetVal) ) + +#define IDiaSymbol7_get_constantExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_constantExport(This,pRetVal) ) + +#define IDiaSymbol7_get_dataExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataExport(This,pRetVal) ) + +#define IDiaSymbol7_get_privateExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_privateExport(This,pRetVal) ) + +#define IDiaSymbol7_get_noNameExport(This,pRetVal) \ + ( (This)->lpVtbl -> get_noNameExport(This,pRetVal) ) + +#define IDiaSymbol7_get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportHasExplicitlyAssignedOrdinal(This,pRetVal) ) + +#define IDiaSymbol7_get_exportIsForwarder(This,pRetVal) \ + ( (This)->lpVtbl -> get_exportIsForwarder(This,pRetVal) ) + +#define IDiaSymbol7_get_ordinal(This,pRetVal) \ + ( (This)->lpVtbl -> get_ordinal(This,pRetVal) ) + +#define IDiaSymbol7_get_frameSize(This,pRetVal) \ + ( (This)->lpVtbl -> get_frameSize(This,pRetVal) ) + +#define IDiaSymbol7_get_exceptionHandlerAddressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressSection(This,pRetVal) ) + +#define IDiaSymbol7_get_exceptionHandlerAddressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerAddressOffset(This,pRetVal) ) + +#define IDiaSymbol7_get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerRelativeVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol7_get_exceptionHandlerVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_exceptionHandlerVirtualAddress(This,pRetVal) ) + +#define IDiaSymbol7_findInputAssemblyFile(This,ppResult) \ + ( (This)->lpVtbl -> findInputAssemblyFile(This,ppResult) ) + +#define IDiaSymbol7_get_characteristics(This,pRetVal) \ + ( (This)->lpVtbl -> get_characteristics(This,pRetVal) ) + +#define IDiaSymbol7_get_coffGroup(This,pRetVal) \ + ( (This)->lpVtbl -> get_coffGroup(This,pRetVal) ) + +#define IDiaSymbol7_get_bindID(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindID(This,pRetVal) ) + +#define IDiaSymbol7_get_bindSpace(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSpace(This,pRetVal) ) + +#define IDiaSymbol7_get_bindSlot(This,pRetVal) \ + ( (This)->lpVtbl -> get_bindSlot(This,pRetVal) ) + + +#define IDiaSymbol7_get_isObjCClass(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCClass(This,pRetVal) ) + +#define IDiaSymbol7_get_isObjCCategory(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCCategory(This,pRetVal) ) + +#define IDiaSymbol7_get_isObjCProtocol(This,pRetVal) \ + ( (This)->lpVtbl -> get_isObjCProtocol(This,pRetVal) ) + + +#define IDiaSymbol7_get_inlinee(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlinee(This,pRetVal) ) + +#define IDiaSymbol7_get_inlineeId(This,pRetVal) \ + ( (This)->lpVtbl -> get_inlineeId(This,pRetVal) ) + + +#define IDiaSymbol7_get_noexcept(This,pRetVal) \ + ( (This)->lpVtbl -> get_noexcept(This,pRetVal) ) + + +#define IDiaSymbol7_get_hasAbsoluteAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_hasAbsoluteAddress(This,pRetVal) ) + + +#define IDiaSymbol7_get_isStaticMemberFunc(This,pRetVal) \ + ( (This)->lpVtbl -> get_isStaticMemberFunc(This,pRetVal) ) + + +#define IDiaSymbol7_get_isSignRet(This,pRetVal) \ + ( (This)->lpVtbl -> get_isSignRet(This,pRetVal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE IDiaSymbol7_get_isSignRet_Proxy( + IDiaSymbol7 * This, + /* [retval][out] */ BOOL *pRetVal); + + +void __RPC_STUB IDiaSymbol7_get_isSignRet_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IDiaSymbol7_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaSourceFile_INTERFACE_DEFINED__ +#define __IDiaSourceFile_INTERFACE_DEFINED__ + +/* interface IDiaSourceFile */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaSourceFile; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A2EF5353-F5A8-4eb3-90D2-CB526ACB3CDD") + IDiaSourceFile : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_uniqueId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_fileName( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_checksumType( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilands( + /* [retval][out] */ IDiaEnumSymbols **pRetVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_checksum( + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaSourceFileVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaSourceFile * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaSourceFile * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaSourceFile * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uniqueId )( + IDiaSourceFile * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_fileName )( + IDiaSourceFile * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_checksumType )( + IDiaSourceFile * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilands )( + IDiaSourceFile * This, + /* [retval][out] */ IDiaEnumSymbols **pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_checksum )( + IDiaSourceFile * This, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + END_INTERFACE + } IDiaSourceFileVtbl; + + interface IDiaSourceFile + { + CONST_VTBL struct IDiaSourceFileVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaSourceFile_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaSourceFile_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaSourceFile_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaSourceFile_get_uniqueId(This,pRetVal) \ + ( (This)->lpVtbl -> get_uniqueId(This,pRetVal) ) + +#define IDiaSourceFile_get_fileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_fileName(This,pRetVal) ) + +#define IDiaSourceFile_get_checksumType(This,pRetVal) \ + ( (This)->lpVtbl -> get_checksumType(This,pRetVal) ) + +#define IDiaSourceFile_get_compilands(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilands(This,pRetVal) ) + +#define IDiaSourceFile_get_checksum(This,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> get_checksum(This,cbData,pcbData,pbData) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaSourceFile_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaInputAssemblyFile_INTERFACE_DEFINED__ +#define __IDiaInputAssemblyFile_INTERFACE_DEFINED__ + +/* interface IDiaInputAssemblyFile */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaInputAssemblyFile; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3BFE56B0-390C-4863-9430-1F3D083B7684") + IDiaInputAssemblyFile : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_uniqueId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_index( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_timestamp( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_pdbAvailableAtILMerge( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_fileName( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_version( + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaInputAssemblyFileVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaInputAssemblyFile * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaInputAssemblyFile * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaInputAssemblyFile * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uniqueId )( + IDiaInputAssemblyFile * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_index )( + IDiaInputAssemblyFile * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_timestamp )( + IDiaInputAssemblyFile * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_pdbAvailableAtILMerge )( + IDiaInputAssemblyFile * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_fileName )( + IDiaInputAssemblyFile * This, + /* [retval][out] */ BSTR *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_version )( + IDiaInputAssemblyFile * This, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + END_INTERFACE + } IDiaInputAssemblyFileVtbl; + + interface IDiaInputAssemblyFile + { + CONST_VTBL struct IDiaInputAssemblyFileVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaInputAssemblyFile_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaInputAssemblyFile_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaInputAssemblyFile_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaInputAssemblyFile_get_uniqueId(This,pRetVal) \ + ( (This)->lpVtbl -> get_uniqueId(This,pRetVal) ) + +#define IDiaInputAssemblyFile_get_index(This,pRetVal) \ + ( (This)->lpVtbl -> get_index(This,pRetVal) ) + +#define IDiaInputAssemblyFile_get_timestamp(This,pRetVal) \ + ( (This)->lpVtbl -> get_timestamp(This,pRetVal) ) + +#define IDiaInputAssemblyFile_get_pdbAvailableAtILMerge(This,pRetVal) \ + ( (This)->lpVtbl -> get_pdbAvailableAtILMerge(This,pRetVal) ) + +#define IDiaInputAssemblyFile_get_fileName(This,pRetVal) \ + ( (This)->lpVtbl -> get_fileName(This,pRetVal) ) + +#define IDiaInputAssemblyFile_get_version(This,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> get_version(This,cbData,pcbData,pbData) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaInputAssemblyFile_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaLineNumber_INTERFACE_DEFINED__ +#define __IDiaLineNumber_INTERFACE_DEFINED__ + +/* interface IDiaLineNumber */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaLineNumber; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("B388EB14-BE4D-421d-A8A1-6CF7AB057086") + IDiaLineNumber : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compiland( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sourceFile( + /* [retval][out] */ IDiaSourceFile **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lineNumber( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lineNumberEnd( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_columnNumber( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_columnNumberEnd( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressOffset( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sourceFileId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_statement( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilandId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaLineNumberVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaLineNumber * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaLineNumber * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaLineNumber * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compiland )( + IDiaLineNumber * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFile )( + IDiaLineNumber * This, + /* [retval][out] */ IDiaSourceFile **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lineNumber )( + IDiaLineNumber * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lineNumberEnd )( + IDiaLineNumber * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnNumber )( + IDiaLineNumber * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_columnNumberEnd )( + IDiaLineNumber * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( + IDiaLineNumber * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( + IDiaLineNumber * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( + IDiaLineNumber * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( + IDiaLineNumber * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( + IDiaLineNumber * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceFileId )( + IDiaLineNumber * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_statement )( + IDiaLineNumber * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilandId )( + IDiaLineNumber * This, + /* [retval][out] */ DWORD *pRetVal); + + END_INTERFACE + } IDiaLineNumberVtbl; + + interface IDiaLineNumber + { + CONST_VTBL struct IDiaLineNumberVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaLineNumber_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaLineNumber_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaLineNumber_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaLineNumber_get_compiland(This,pRetVal) \ + ( (This)->lpVtbl -> get_compiland(This,pRetVal) ) + +#define IDiaLineNumber_get_sourceFile(This,pRetVal) \ + ( (This)->lpVtbl -> get_sourceFile(This,pRetVal) ) + +#define IDiaLineNumber_get_lineNumber(This,pRetVal) \ + ( (This)->lpVtbl -> get_lineNumber(This,pRetVal) ) + +#define IDiaLineNumber_get_lineNumberEnd(This,pRetVal) \ + ( (This)->lpVtbl -> get_lineNumberEnd(This,pRetVal) ) + +#define IDiaLineNumber_get_columnNumber(This,pRetVal) \ + ( (This)->lpVtbl -> get_columnNumber(This,pRetVal) ) + +#define IDiaLineNumber_get_columnNumberEnd(This,pRetVal) \ + ( (This)->lpVtbl -> get_columnNumberEnd(This,pRetVal) ) + +#define IDiaLineNumber_get_addressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) + +#define IDiaLineNumber_get_addressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) + +#define IDiaLineNumber_get_relativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) + +#define IDiaLineNumber_get_virtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) + +#define IDiaLineNumber_get_length(This,pRetVal) \ + ( (This)->lpVtbl -> get_length(This,pRetVal) ) + +#define IDiaLineNumber_get_sourceFileId(This,pRetVal) \ + ( (This)->lpVtbl -> get_sourceFileId(This,pRetVal) ) + +#define IDiaLineNumber_get_statement(This,pRetVal) \ + ( (This)->lpVtbl -> get_statement(This,pRetVal) ) + +#define IDiaLineNumber_get_compilandId(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilandId(This,pRetVal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaLineNumber_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaSectionContrib_INTERFACE_DEFINED__ +#define __IDiaSectionContrib_INTERFACE_DEFINED__ + +/* interface IDiaSectionContrib */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaSectionContrib; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0CF4B60E-35B1-4c6c-BDD8-854B9C8E3857") + IDiaSectionContrib : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compiland( + /* [retval][out] */ IDiaSymbol **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressOffset( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_notPaged( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_code( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_initializedData( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_uninitializedData( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_remove( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_comdat( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_discardable( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_notCached( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_share( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_execute( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_read( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_write( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_dataCrc( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relocationsCrc( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_compilandId( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_code16bit( + /* [retval][out] */ BOOL *pRetVal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaSectionContribVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaSectionContrib * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaSectionContrib * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaSectionContrib * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compiland )( + IDiaSectionContrib * This, + /* [retval][out] */ IDiaSymbol **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( + IDiaSectionContrib * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( + IDiaSectionContrib * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( + IDiaSectionContrib * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( + IDiaSectionContrib * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( + IDiaSectionContrib * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notPaged )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_initializedData )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_uninitializedData )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_remove )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_comdat )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_discardable )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_notCached )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_share )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_execute )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_read )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_write )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_dataCrc )( + IDiaSectionContrib * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relocationsCrc )( + IDiaSectionContrib * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_compilandId )( + IDiaSectionContrib * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_code16bit )( + IDiaSectionContrib * This, + /* [retval][out] */ BOOL *pRetVal); + + END_INTERFACE + } IDiaSectionContribVtbl; + + interface IDiaSectionContrib + { + CONST_VTBL struct IDiaSectionContribVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaSectionContrib_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaSectionContrib_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaSectionContrib_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaSectionContrib_get_compiland(This,pRetVal) \ + ( (This)->lpVtbl -> get_compiland(This,pRetVal) ) + +#define IDiaSectionContrib_get_addressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) + +#define IDiaSectionContrib_get_addressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) + +#define IDiaSectionContrib_get_relativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) + +#define IDiaSectionContrib_get_virtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) + +#define IDiaSectionContrib_get_length(This,pRetVal) \ + ( (This)->lpVtbl -> get_length(This,pRetVal) ) + +#define IDiaSectionContrib_get_notPaged(This,pRetVal) \ + ( (This)->lpVtbl -> get_notPaged(This,pRetVal) ) + +#define IDiaSectionContrib_get_code(This,pRetVal) \ + ( (This)->lpVtbl -> get_code(This,pRetVal) ) + +#define IDiaSectionContrib_get_initializedData(This,pRetVal) \ + ( (This)->lpVtbl -> get_initializedData(This,pRetVal) ) + +#define IDiaSectionContrib_get_uninitializedData(This,pRetVal) \ + ( (This)->lpVtbl -> get_uninitializedData(This,pRetVal) ) + +#define IDiaSectionContrib_get_remove(This,pRetVal) \ + ( (This)->lpVtbl -> get_remove(This,pRetVal) ) + +#define IDiaSectionContrib_get_comdat(This,pRetVal) \ + ( (This)->lpVtbl -> get_comdat(This,pRetVal) ) + +#define IDiaSectionContrib_get_discardable(This,pRetVal) \ + ( (This)->lpVtbl -> get_discardable(This,pRetVal) ) + +#define IDiaSectionContrib_get_notCached(This,pRetVal) \ + ( (This)->lpVtbl -> get_notCached(This,pRetVal) ) + +#define IDiaSectionContrib_get_share(This,pRetVal) \ + ( (This)->lpVtbl -> get_share(This,pRetVal) ) + +#define IDiaSectionContrib_get_execute(This,pRetVal) \ + ( (This)->lpVtbl -> get_execute(This,pRetVal) ) + +#define IDiaSectionContrib_get_read(This,pRetVal) \ + ( (This)->lpVtbl -> get_read(This,pRetVal) ) + +#define IDiaSectionContrib_get_write(This,pRetVal) \ + ( (This)->lpVtbl -> get_write(This,pRetVal) ) + +#define IDiaSectionContrib_get_dataCrc(This,pRetVal) \ + ( (This)->lpVtbl -> get_dataCrc(This,pRetVal) ) + +#define IDiaSectionContrib_get_relocationsCrc(This,pRetVal) \ + ( (This)->lpVtbl -> get_relocationsCrc(This,pRetVal) ) + +#define IDiaSectionContrib_get_compilandId(This,pRetVal) \ + ( (This)->lpVtbl -> get_compilandId(This,pRetVal) ) + +#define IDiaSectionContrib_get_code16bit(This,pRetVal) \ + ( (This)->lpVtbl -> get_code16bit(This,pRetVal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaSectionContrib_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaSegment_INTERFACE_DEFINED__ +#define __IDiaSegment_INTERFACE_DEFINED__ + +/* interface IDiaSegment */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaSegment; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0775B784-C75B-4449-848B-B7BD3159545B") + IDiaSegment : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_frame( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_offset( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_read( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_write( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_execute( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaSegmentVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaSegment * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaSegment * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaSegment * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_frame )( + IDiaSegment * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_offset )( + IDiaSegment * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( + IDiaSegment * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_read )( + IDiaSegment * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_write )( + IDiaSegment * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_execute )( + IDiaSegment * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( + IDiaSegment * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( + IDiaSegment * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( + IDiaSegment * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + END_INTERFACE + } IDiaSegmentVtbl; + + interface IDiaSegment + { + CONST_VTBL struct IDiaSegmentVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaSegment_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaSegment_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaSegment_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaSegment_get_frame(This,pRetVal) \ + ( (This)->lpVtbl -> get_frame(This,pRetVal) ) + +#define IDiaSegment_get_offset(This,pRetVal) \ + ( (This)->lpVtbl -> get_offset(This,pRetVal) ) + +#define IDiaSegment_get_length(This,pRetVal) \ + ( (This)->lpVtbl -> get_length(This,pRetVal) ) + +#define IDiaSegment_get_read(This,pRetVal) \ + ( (This)->lpVtbl -> get_read(This,pRetVal) ) + +#define IDiaSegment_get_write(This,pRetVal) \ + ( (This)->lpVtbl -> get_write(This,pRetVal) ) + +#define IDiaSegment_get_execute(This,pRetVal) \ + ( (This)->lpVtbl -> get_execute(This,pRetVal) ) + +#define IDiaSegment_get_addressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) + +#define IDiaSegment_get_relativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) + +#define IDiaSegment_get_virtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaSegment_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaInjectedSource_INTERFACE_DEFINED__ +#define __IDiaInjectedSource_INTERFACE_DEFINED__ + +/* interface IDiaInjectedSource */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaInjectedSource; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("AE605CDC-8105-4a23-B710-3259F1E26112") + IDiaInjectedSource : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_crc( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_length( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_filename( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_objectFilename( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualFilename( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_sourceCompression( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_source( + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaInjectedSourceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaInjectedSource * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaInjectedSource * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaInjectedSource * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_crc )( + IDiaInjectedSource * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_length )( + IDiaInjectedSource * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_filename )( + IDiaInjectedSource * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_objectFilename )( + IDiaInjectedSource * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualFilename )( + IDiaInjectedSource * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_sourceCompression )( + IDiaInjectedSource * This, + /* [retval][out] */ DWORD *pRetVal); + + HRESULT ( STDMETHODCALLTYPE *get_source )( + IDiaInjectedSource * This, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + END_INTERFACE + } IDiaInjectedSourceVtbl; + + interface IDiaInjectedSource + { + CONST_VTBL struct IDiaInjectedSourceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaInjectedSource_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaInjectedSource_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaInjectedSource_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaInjectedSource_get_crc(This,pRetVal) \ + ( (This)->lpVtbl -> get_crc(This,pRetVal) ) + +#define IDiaInjectedSource_get_length(This,pRetVal) \ + ( (This)->lpVtbl -> get_length(This,pRetVal) ) + +#define IDiaInjectedSource_get_filename(This,pRetVal) \ + ( (This)->lpVtbl -> get_filename(This,pRetVal) ) + +#define IDiaInjectedSource_get_objectFilename(This,pRetVal) \ + ( (This)->lpVtbl -> get_objectFilename(This,pRetVal) ) + +#define IDiaInjectedSource_get_virtualFilename(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualFilename(This,pRetVal) ) + +#define IDiaInjectedSource_get_sourceCompression(This,pRetVal) \ + ( (This)->lpVtbl -> get_sourceCompression(This,pRetVal) ) + +#define IDiaInjectedSource_get_source(This,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> get_source(This,cbData,pcbData,pbData) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaInjectedSource_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_dia2_0000_0031 */ +/* [local] */ + + +enum __MIDL___MIDL_itf_dia2_0000_0031_0001 + { + E_DIA_INPROLOG = ( HRESULT )(( ( ( ( unsigned long )1 << 31 ) | ( ( unsigned long )( LONG )0x6d << 16 ) ) | ( unsigned long )100 ) ), + E_DIA_SYNTAX = ( E_DIA_INPROLOG + 1 ) , + E_DIA_FRAME_ACCESS = ( E_DIA_SYNTAX + 1 ) , + E_DIA_VALUE = ( E_DIA_FRAME_ACCESS + 1 ) + } ; + + +extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0031_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0031_v0_0_s_ifspec; + +#ifndef __IDiaStackWalkFrame_INTERFACE_DEFINED__ +#define __IDiaStackWalkFrame_INTERFACE_DEFINED__ + +/* interface IDiaStackWalkFrame */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaStackWalkFrame; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("07C590C1-438D-4F47-BDCD-4397BC81AD75") + IDiaStackWalkFrame : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerValue( + /* [in] */ DWORD index, + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_registerValue( + /* [in] */ DWORD index, + /* [in] */ ULONGLONG NewVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE readMemory( + /* [in] */ enum MemoryTypeEnum type, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData) = 0; + + virtual HRESULT STDMETHODCALLTYPE searchForReturnAddress( + /* [in] */ IDiaFrameData *frame, + /* [out] */ ULONGLONG *returnAddress) = 0; + + virtual HRESULT STDMETHODCALLTYPE searchForReturnAddressStart( + /* [in] */ IDiaFrameData *frame, + /* [in] */ ULONGLONG startAddress, + /* [out] */ ULONGLONG *returnAddress) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaStackWalkFrameVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaStackWalkFrame * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaStackWalkFrame * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaStackWalkFrame * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerValue )( + IDiaStackWalkFrame * This, + /* [in] */ DWORD index, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_registerValue )( + IDiaStackWalkFrame * This, + /* [in] */ DWORD index, + /* [in] */ ULONGLONG NewVal); + + HRESULT ( STDMETHODCALLTYPE *readMemory )( + IDiaStackWalkFrame * This, + /* [in] */ enum MemoryTypeEnum type, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *searchForReturnAddress )( + IDiaStackWalkFrame * This, + /* [in] */ IDiaFrameData *frame, + /* [out] */ ULONGLONG *returnAddress); + + HRESULT ( STDMETHODCALLTYPE *searchForReturnAddressStart )( + IDiaStackWalkFrame * This, + /* [in] */ IDiaFrameData *frame, + /* [in] */ ULONGLONG startAddress, + /* [out] */ ULONGLONG *returnAddress); + + END_INTERFACE + } IDiaStackWalkFrameVtbl; + + interface IDiaStackWalkFrame + { + CONST_VTBL struct IDiaStackWalkFrameVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaStackWalkFrame_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaStackWalkFrame_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaStackWalkFrame_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaStackWalkFrame_get_registerValue(This,index,pRetVal) \ + ( (This)->lpVtbl -> get_registerValue(This,index,pRetVal) ) + +#define IDiaStackWalkFrame_put_registerValue(This,index,NewVal) \ + ( (This)->lpVtbl -> put_registerValue(This,index,NewVal) ) + +#define IDiaStackWalkFrame_readMemory(This,type,va,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> readMemory(This,type,va,cbData,pcbData,pbData) ) + +#define IDiaStackWalkFrame_searchForReturnAddress(This,frame,returnAddress) \ + ( (This)->lpVtbl -> searchForReturnAddress(This,frame,returnAddress) ) + +#define IDiaStackWalkFrame_searchForReturnAddressStart(This,frame,startAddress,returnAddress) \ + ( (This)->lpVtbl -> searchForReturnAddressStart(This,frame,startAddress,returnAddress) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaStackWalkFrame_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaFrameData_INTERFACE_DEFINED__ +#define __IDiaFrameData_INTERFACE_DEFINED__ + +/* interface IDiaFrameData */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaFrameData; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A39184B7-6A36-42de-8EEC-7DF9F3F59F33") + IDiaFrameData : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressSection( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_addressOffset( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthBlock( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthLocals( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthParams( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_maxStack( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthProlog( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthSavedRegisters( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_program( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_systemExceptionHandling( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_cplusplusExceptionHandling( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_functionStart( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_allocatesBasePointer( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_type( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_functionParent( + /* [retval][out] */ IDiaFrameData **pRetVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE execute( + IDiaStackWalkFrame *frame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaFrameDataVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaFrameData * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaFrameData * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaFrameData * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressSection )( + IDiaFrameData * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_addressOffset )( + IDiaFrameData * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( + IDiaFrameData * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( + IDiaFrameData * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthBlock )( + IDiaFrameData * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthLocals )( + IDiaFrameData * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthParams )( + IDiaFrameData * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_maxStack )( + IDiaFrameData * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthProlog )( + IDiaFrameData * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthSavedRegisters )( + IDiaFrameData * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_program )( + IDiaFrameData * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_systemExceptionHandling )( + IDiaFrameData * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_cplusplusExceptionHandling )( + IDiaFrameData * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_functionStart )( + IDiaFrameData * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_allocatesBasePointer )( + IDiaFrameData * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( + IDiaFrameData * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_functionParent )( + IDiaFrameData * This, + /* [retval][out] */ IDiaFrameData **pRetVal); + + HRESULT ( STDMETHODCALLTYPE *execute )( + IDiaFrameData * This, + IDiaStackWalkFrame *frame); + + END_INTERFACE + } IDiaFrameDataVtbl; + + interface IDiaFrameData + { + CONST_VTBL struct IDiaFrameDataVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaFrameData_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaFrameData_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaFrameData_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaFrameData_get_addressSection(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressSection(This,pRetVal) ) + +#define IDiaFrameData_get_addressOffset(This,pRetVal) \ + ( (This)->lpVtbl -> get_addressOffset(This,pRetVal) ) + +#define IDiaFrameData_get_relativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) + +#define IDiaFrameData_get_virtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) + +#define IDiaFrameData_get_lengthBlock(This,pRetVal) \ + ( (This)->lpVtbl -> get_lengthBlock(This,pRetVal) ) + +#define IDiaFrameData_get_lengthLocals(This,pRetVal) \ + ( (This)->lpVtbl -> get_lengthLocals(This,pRetVal) ) + +#define IDiaFrameData_get_lengthParams(This,pRetVal) \ + ( (This)->lpVtbl -> get_lengthParams(This,pRetVal) ) + +#define IDiaFrameData_get_maxStack(This,pRetVal) \ + ( (This)->lpVtbl -> get_maxStack(This,pRetVal) ) + +#define IDiaFrameData_get_lengthProlog(This,pRetVal) \ + ( (This)->lpVtbl -> get_lengthProlog(This,pRetVal) ) + +#define IDiaFrameData_get_lengthSavedRegisters(This,pRetVal) \ + ( (This)->lpVtbl -> get_lengthSavedRegisters(This,pRetVal) ) + +#define IDiaFrameData_get_program(This,pRetVal) \ + ( (This)->lpVtbl -> get_program(This,pRetVal) ) + +#define IDiaFrameData_get_systemExceptionHandling(This,pRetVal) \ + ( (This)->lpVtbl -> get_systemExceptionHandling(This,pRetVal) ) + +#define IDiaFrameData_get_cplusplusExceptionHandling(This,pRetVal) \ + ( (This)->lpVtbl -> get_cplusplusExceptionHandling(This,pRetVal) ) + +#define IDiaFrameData_get_functionStart(This,pRetVal) \ + ( (This)->lpVtbl -> get_functionStart(This,pRetVal) ) + +#define IDiaFrameData_get_allocatesBasePointer(This,pRetVal) \ + ( (This)->lpVtbl -> get_allocatesBasePointer(This,pRetVal) ) + +#define IDiaFrameData_get_type(This,pRetVal) \ + ( (This)->lpVtbl -> get_type(This,pRetVal) ) + +#define IDiaFrameData_get_functionParent(This,pRetVal) \ + ( (This)->lpVtbl -> get_functionParent(This,pRetVal) ) + +#define IDiaFrameData_execute(This,frame) \ + ( (This)->lpVtbl -> execute(This,frame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaFrameData_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaImageData_INTERFACE_DEFINED__ +#define __IDiaImageData_INTERFACE_DEFINED__ + +/* interface IDiaImageData */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaImageData; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C8E40ED2-A1D9-4221-8692-3CE661184B44") + IDiaImageData : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_relativeVirtualAddress( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_virtualAddress( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_imageBase( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaImageDataVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaImageData * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaImageData * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaImageData * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_relativeVirtualAddress )( + IDiaImageData * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_virtualAddress )( + IDiaImageData * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_imageBase )( + IDiaImageData * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + END_INTERFACE + } IDiaImageDataVtbl; + + interface IDiaImageData + { + CONST_VTBL struct IDiaImageDataVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaImageData_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaImageData_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaImageData_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaImageData_get_relativeVirtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_relativeVirtualAddress(This,pRetVal) ) + +#define IDiaImageData_get_virtualAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_virtualAddress(This,pRetVal) ) + +#define IDiaImageData_get_imageBase(This,pRetVal) \ + ( (This)->lpVtbl -> get_imageBase(This,pRetVal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaImageData_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaTable_INTERFACE_DEFINED__ +#define __IDiaTable_INTERFACE_DEFINED__ + +/* interface IDiaTable */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaTable; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("4A59FB77-ABAC-469b-A30B-9ECC85BFEF14") + IDiaTable : public IEnumUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_name( + /* [retval][out] */ BSTR *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ DWORD index, + /* [retval][out] */ IUnknown **element) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaTableVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaTable * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaTable * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaTable * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaTable * This, + /* [annotation][in] */ + _In_ ULONG celt, + /* [annotation][out] */ + _Out_writes_to_(celt,*pceltFetched) IUnknown **rgelt, + /* [annotation][out] */ + _Out_opt_ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IDiaTable * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaTable * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaTable * This, + /* [out] */ IEnumUnknown **ppenum); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + IDiaTable * This, + /* [retval][out] */ IUnknown **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_name )( + IDiaTable * This, + /* [retval][out] */ BSTR *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + IDiaTable * This, + /* [retval][out] */ LONG *pRetVal); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + IDiaTable * This, + /* [in] */ DWORD index, + /* [retval][out] */ IUnknown **element); + + END_INTERFACE + } IDiaTableVtbl; + + interface IDiaTable + { + CONST_VTBL struct IDiaTableVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaTable_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaTable_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaTable_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaTable_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaTable_Skip(This,celt) \ + ( (This)->lpVtbl -> Skip(This,celt) ) + +#define IDiaTable_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#define IDiaTable_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + + +#define IDiaTable_get__NewEnum(This,pRetVal) \ + ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) + +#define IDiaTable_get_name(This,pRetVal) \ + ( (This)->lpVtbl -> get_name(This,pRetVal) ) + +#define IDiaTable_get_Count(This,pRetVal) \ + ( (This)->lpVtbl -> get_Count(This,pRetVal) ) + +#define IDiaTable_Item(This,index,element) \ + ( (This)->lpVtbl -> Item(This,index,element) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaTable_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumTables_INTERFACE_DEFINED__ +#define __IDiaEnumTables_INTERFACE_DEFINED__ + +/* interface IDiaEnumTables */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumTables; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C65C2B0A-1150-4d7a-AFCC-E05BF3DEE81E") + IDiaEnumTables : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get__NewEnum( + /* [retval][out] */ IUnknown **pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_Count( + /* [retval][out] */ LONG *pRetVal) = 0; + + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE Item( + /* [in] */ VARIANT index, + /* [retval][out] */ IDiaTable **table) = 0; + + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG celt, + IDiaTable **rgelt, + ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + /* [in] */ ULONG celt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IDiaEnumTables **ppenum) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumTablesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumTables * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumTables * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumTables * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )( + IDiaEnumTables * This, + /* [retval][out] */ IUnknown **pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_Count )( + IDiaEnumTables * This, + /* [retval][out] */ LONG *pRetVal); + + /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( + IDiaEnumTables * This, + /* [in] */ VARIANT index, + /* [retval][out] */ IDiaTable **table); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumTables * This, + ULONG celt, + IDiaTable **rgelt, + ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Skip )( + IDiaEnumTables * This, + /* [in] */ ULONG celt); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaEnumTables * This); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IDiaEnumTables * This, + /* [out] */ IDiaEnumTables **ppenum); + + END_INTERFACE + } IDiaEnumTablesVtbl; + + interface IDiaEnumTables + { + CONST_VTBL struct IDiaEnumTablesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumTables_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumTables_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumTables_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumTables_get__NewEnum(This,pRetVal) \ + ( (This)->lpVtbl -> get__NewEnum(This,pRetVal) ) + +#define IDiaEnumTables_get_Count(This,pRetVal) \ + ( (This)->lpVtbl -> get_Count(This,pRetVal) ) + +#define IDiaEnumTables_Item(This,index,table) \ + ( (This)->lpVtbl -> Item(This,index,table) ) + +#define IDiaEnumTables_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumTables_Skip(This,celt) \ + ( (This)->lpVtbl -> Skip(This,celt) ) + +#define IDiaEnumTables_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#define IDiaEnumTables_Clone(This,ppenum) \ + ( (This)->lpVtbl -> Clone(This,ppenum) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumTables_INTERFACE_DEFINED__ */ + + + +#ifndef __Dia2Lib_LIBRARY_DEFINED__ +#define __Dia2Lib_LIBRARY_DEFINED__ + +/* library Dia2Lib */ +/* [helpstring][version][uuid] */ + + + + + +EXTERN_C const IID LIBID_Dia2Lib; + +EXTERN_C const CLSID CLSID_DiaSource; + +#ifdef __cplusplus + +class DECLSPEC_UUID("e6756135-1e65-4d17-8576-610761398c3c") +DiaSource; +#endif + +EXTERN_C const CLSID CLSID_DiaSourceAlt; + +#ifdef __cplusplus + +class DECLSPEC_UUID("91904831-49ca-4766-b95c-25397e2dd6dc") +DiaSourceAlt; +#endif + +EXTERN_C const CLSID CLSID_DiaStackWalker; + +#ifdef __cplusplus + +class DECLSPEC_UUID("ce4a85db-5768-475b-a4e1-c0bca2112a6b") +DiaStackWalker; +#endif +#endif /* __Dia2Lib_LIBRARY_DEFINED__ */ + +/* interface __MIDL_itf_dia2_0000_0037 */ +/* [local] */ + +#define DiaTable_Symbols ( L"Symbols" ) + +#define DiaTable_Sections ( L"Sections" ) + +#define DiaTable_SrcFiles ( L"SourceFiles" ) + +#define DiaTable_LineNums ( L"LineNumbers" ) + +#define DiaTable_SegMap ( L"SegmentMap" ) + +#define DiaTable_Dbg ( L"Dbg" ) + +#define DiaTable_InjSrc ( L"InjectedSource" ) + +#define DiaTable_FrameData ( L"FrameData" ) + +#define DiaTable_InputAssemblyFiles ( L"InputAssemblyFiles" ) + + + +extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0037_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0037_v0_0_s_ifspec; + +#ifndef __IDiaPropertyStorage_INTERFACE_DEFINED__ +#define __IDiaPropertyStorage_INTERFACE_DEFINED__ + +/* interface IDiaPropertyStorage */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaPropertyStorage; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9d416f9c-e184-45b2-a4f0-ce517f719e9b") + IDiaPropertyStorage : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ReadMultiple( + /* [in] */ ULONG cpspec, + /* [size_is][in] */ const PROPSPEC *rgpspec, + /* [size_is][out] */ PROPVARIANT *rgvar) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReadPropertyNames( + /* [in] */ ULONG cpropid, + /* [size_is][in] */ const PROPID *rgpropid, + /* [size_is][out][in] */ BSTR *rglpwstrName) = 0; + + virtual HRESULT STDMETHODCALLTYPE Enum( + /* [out] */ IEnumSTATPROPSTG **ppenum) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReadDWORD( + /* [in] */ PROPID id, + /* [out] */ DWORD *pValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReadLONG( + /* [in] */ PROPID id, + /* [out] */ LONG *pValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReadBOOL( + /* [in] */ PROPID id, + /* [out] */ BOOL *pValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReadULONGLONG( + /* [in] */ PROPID id, + /* [out] */ ULONGLONG *pValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReadBSTR( + /* [in] */ PROPID id, + /* [out] */ BSTR *pValue) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaPropertyStorageVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaPropertyStorage * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaPropertyStorage * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaPropertyStorage * This); + + HRESULT ( STDMETHODCALLTYPE *ReadMultiple )( + IDiaPropertyStorage * This, + /* [in] */ ULONG cpspec, + /* [size_is][in] */ const PROPSPEC *rgpspec, + /* [size_is][out] */ PROPVARIANT *rgvar); + + HRESULT ( STDMETHODCALLTYPE *ReadPropertyNames )( + IDiaPropertyStorage * This, + /* [in] */ ULONG cpropid, + /* [size_is][in] */ const PROPID *rgpropid, + /* [size_is][out][in] */ BSTR *rglpwstrName); + + HRESULT ( STDMETHODCALLTYPE *Enum )( + IDiaPropertyStorage * This, + /* [out] */ IEnumSTATPROPSTG **ppenum); + + HRESULT ( STDMETHODCALLTYPE *ReadDWORD )( + IDiaPropertyStorage * This, + /* [in] */ PROPID id, + /* [out] */ DWORD *pValue); + + HRESULT ( STDMETHODCALLTYPE *ReadLONG )( + IDiaPropertyStorage * This, + /* [in] */ PROPID id, + /* [out] */ LONG *pValue); + + HRESULT ( STDMETHODCALLTYPE *ReadBOOL )( + IDiaPropertyStorage * This, + /* [in] */ PROPID id, + /* [out] */ BOOL *pValue); + + HRESULT ( STDMETHODCALLTYPE *ReadULONGLONG )( + IDiaPropertyStorage * This, + /* [in] */ PROPID id, + /* [out] */ ULONGLONG *pValue); + + HRESULT ( STDMETHODCALLTYPE *ReadBSTR )( + IDiaPropertyStorage * This, + /* [in] */ PROPID id, + /* [out] */ BSTR *pValue); + + END_INTERFACE + } IDiaPropertyStorageVtbl; + + interface IDiaPropertyStorage + { + CONST_VTBL struct IDiaPropertyStorageVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaPropertyStorage_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaPropertyStorage_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaPropertyStorage_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaPropertyStorage_ReadMultiple(This,cpspec,rgpspec,rgvar) \ + ( (This)->lpVtbl -> ReadMultiple(This,cpspec,rgpspec,rgvar) ) + +#define IDiaPropertyStorage_ReadPropertyNames(This,cpropid,rgpropid,rglpwstrName) \ + ( (This)->lpVtbl -> ReadPropertyNames(This,cpropid,rgpropid,rglpwstrName) ) + +#define IDiaPropertyStorage_Enum(This,ppenum) \ + ( (This)->lpVtbl -> Enum(This,ppenum) ) + +#define IDiaPropertyStorage_ReadDWORD(This,id,pValue) \ + ( (This)->lpVtbl -> ReadDWORD(This,id,pValue) ) + +#define IDiaPropertyStorage_ReadLONG(This,id,pValue) \ + ( (This)->lpVtbl -> ReadLONG(This,id,pValue) ) + +#define IDiaPropertyStorage_ReadBOOL(This,id,pValue) \ + ( (This)->lpVtbl -> ReadBOOL(This,id,pValue) ) + +#define IDiaPropertyStorage_ReadULONGLONG(This,id,pValue) \ + ( (This)->lpVtbl -> ReadULONGLONG(This,id,pValue) ) + +#define IDiaPropertyStorage_ReadBSTR(This,id,pValue) \ + ( (This)->lpVtbl -> ReadBSTR(This,id,pValue) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaPropertyStorage_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaStackFrame_INTERFACE_DEFINED__ +#define __IDiaStackFrame_INTERFACE_DEFINED__ + +/* interface IDiaStackFrame */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaStackFrame; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5edbc96d-cdd6-4792-afbe-cc89007d9610") + IDiaStackFrame : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_type( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_base( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_size( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_returnAddress( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_localsBase( + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthLocals( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthParams( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthProlog( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_lengthSavedRegisters( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_systemExceptionHandling( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_cplusplusExceptionHandling( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_functionStart( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_allocatesBasePointer( + /* [retval][out] */ BOOL *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_maxStack( + /* [retval][out] */ DWORD *pRetVal) = 0; + + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerValue( + /* [in] */ DWORD index, + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaStackFrameVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaStackFrame * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaStackFrame * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaStackFrame * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_type )( + IDiaStackFrame * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_base )( + IDiaStackFrame * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_size )( + IDiaStackFrame * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_returnAddress )( + IDiaStackFrame * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_localsBase )( + IDiaStackFrame * This, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthLocals )( + IDiaStackFrame * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthParams )( + IDiaStackFrame * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthProlog )( + IDiaStackFrame * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_lengthSavedRegisters )( + IDiaStackFrame * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_systemExceptionHandling )( + IDiaStackFrame * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_cplusplusExceptionHandling )( + IDiaStackFrame * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_functionStart )( + IDiaStackFrame * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_allocatesBasePointer )( + IDiaStackFrame * This, + /* [retval][out] */ BOOL *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_maxStack )( + IDiaStackFrame * This, + /* [retval][out] */ DWORD *pRetVal); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerValue )( + IDiaStackFrame * This, + /* [in] */ DWORD index, + /* [retval][out] */ ULONGLONG *pRetVal); + + END_INTERFACE + } IDiaStackFrameVtbl; + + interface IDiaStackFrame + { + CONST_VTBL struct IDiaStackFrameVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaStackFrame_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaStackFrame_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaStackFrame_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaStackFrame_get_type(This,pRetVal) \ + ( (This)->lpVtbl -> get_type(This,pRetVal) ) + +#define IDiaStackFrame_get_base(This,pRetVal) \ + ( (This)->lpVtbl -> get_base(This,pRetVal) ) + +#define IDiaStackFrame_get_size(This,pRetVal) \ + ( (This)->lpVtbl -> get_size(This,pRetVal) ) + +#define IDiaStackFrame_get_returnAddress(This,pRetVal) \ + ( (This)->lpVtbl -> get_returnAddress(This,pRetVal) ) + +#define IDiaStackFrame_get_localsBase(This,pRetVal) \ + ( (This)->lpVtbl -> get_localsBase(This,pRetVal) ) + +#define IDiaStackFrame_get_lengthLocals(This,pRetVal) \ + ( (This)->lpVtbl -> get_lengthLocals(This,pRetVal) ) + +#define IDiaStackFrame_get_lengthParams(This,pRetVal) \ + ( (This)->lpVtbl -> get_lengthParams(This,pRetVal) ) + +#define IDiaStackFrame_get_lengthProlog(This,pRetVal) \ + ( (This)->lpVtbl -> get_lengthProlog(This,pRetVal) ) + +#define IDiaStackFrame_get_lengthSavedRegisters(This,pRetVal) \ + ( (This)->lpVtbl -> get_lengthSavedRegisters(This,pRetVal) ) + +#define IDiaStackFrame_get_systemExceptionHandling(This,pRetVal) \ + ( (This)->lpVtbl -> get_systemExceptionHandling(This,pRetVal) ) + +#define IDiaStackFrame_get_cplusplusExceptionHandling(This,pRetVal) \ + ( (This)->lpVtbl -> get_cplusplusExceptionHandling(This,pRetVal) ) + +#define IDiaStackFrame_get_functionStart(This,pRetVal) \ + ( (This)->lpVtbl -> get_functionStart(This,pRetVal) ) + +#define IDiaStackFrame_get_allocatesBasePointer(This,pRetVal) \ + ( (This)->lpVtbl -> get_allocatesBasePointer(This,pRetVal) ) + +#define IDiaStackFrame_get_maxStack(This,pRetVal) \ + ( (This)->lpVtbl -> get_maxStack(This,pRetVal) ) + +#define IDiaStackFrame_get_registerValue(This,index,pRetVal) \ + ( (This)->lpVtbl -> get_registerValue(This,index,pRetVal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaStackFrame_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaEnumStackFrames_INTERFACE_DEFINED__ +#define __IDiaEnumStackFrames_INTERFACE_DEFINED__ + +/* interface IDiaEnumStackFrames */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaEnumStackFrames; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ec9d461d-ce74-4711-a020-7d8f9a1dd255") + IDiaEnumStackFrames : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Next( + /* [in] */ ULONG celt, + /* [out] */ IDiaStackFrame **rgelt, + /* [out] */ ULONG *pceltFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaEnumStackFramesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaEnumStackFrames * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaEnumStackFrames * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaEnumStackFrames * This); + + HRESULT ( STDMETHODCALLTYPE *Next )( + IDiaEnumStackFrames * This, + /* [in] */ ULONG celt, + /* [out] */ IDiaStackFrame **rgelt, + /* [out] */ ULONG *pceltFetched); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + IDiaEnumStackFrames * This); + + END_INTERFACE + } IDiaEnumStackFramesVtbl; + + interface IDiaEnumStackFrames + { + CONST_VTBL struct IDiaEnumStackFramesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaEnumStackFrames_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaEnumStackFrames_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaEnumStackFrames_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaEnumStackFrames_Next(This,celt,rgelt,pceltFetched) \ + ( (This)->lpVtbl -> Next(This,celt,rgelt,pceltFetched) ) + +#define IDiaEnumStackFrames_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaEnumStackFrames_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_dia2_0000_0040 */ +/* [local] */ + +typedef /* [public] */ struct __MIDL___MIDL_itf_dia2_0000_0040_0001 + { + DWORD ulOffStart; + DWORD cbProcSize; + DWORD cdwLocals; + WORD cdwParams; + WORD cdwFlags; + } FPODATA; + + + +extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0040_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_dia2_0000_0040_v0_0_s_ifspec; + +#ifndef __IDiaStackWalkHelper_INTERFACE_DEFINED__ +#define __IDiaStackWalkHelper_INTERFACE_DEFINED__ + +/* interface IDiaStackWalkHelper */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaStackWalkHelper; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("21F81B1B-C5BB-42A3-BC4F-CCBAA75B9F19") + IDiaStackWalkHelper : public IUnknown + { + public: + virtual /* [id][helpstring][propget] */ HRESULT STDMETHODCALLTYPE get_registerValue( + /* [in] */ DWORD index, + /* [retval][out] */ ULONGLONG *pRetVal) = 0; + + virtual /* [id][helpstring][propput] */ HRESULT STDMETHODCALLTYPE put_registerValue( + /* [in] */ DWORD index, + /* [in] */ ULONGLONG NewVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE readMemory( + /* [in] */ enum MemoryTypeEnum type, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData) = 0; + + virtual HRESULT STDMETHODCALLTYPE searchForReturnAddress( + /* [in] */ IDiaFrameData *frame, + /* [out] */ ULONGLONG *returnAddress) = 0; + + virtual HRESULT STDMETHODCALLTYPE searchForReturnAddressStart( + /* [in] */ IDiaFrameData *frame, + /* [in] */ ULONGLONG startAddress, + /* [out] */ ULONGLONG *returnAddress) = 0; + + virtual HRESULT STDMETHODCALLTYPE frameForVA( + /* [in] */ ULONGLONG va, + /* [out] */ IDiaFrameData **ppFrame) = 0; + + virtual HRESULT STDMETHODCALLTYPE symbolForVA( + /* [in] */ ULONGLONG va, + /* [out] */ IDiaSymbol **ppSymbol) = 0; + + virtual HRESULT STDMETHODCALLTYPE pdataForVA( + /* [in] */ ULONGLONG va, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData) = 0; + + virtual HRESULT STDMETHODCALLTYPE imageForVA( + /* [in] */ ULONGLONG vaContext, + /* [out] */ ULONGLONG *pvaImageStart) = 0; + + virtual HRESULT STDMETHODCALLTYPE addressForVA( + /* [in] */ ULONGLONG va, + /* [out] */ DWORD *pISect, + /* [out] */ DWORD *pOffset) = 0; + + virtual HRESULT STDMETHODCALLTYPE numberOfFunctionFragmentsForVA( + /* [in] */ ULONGLONG vaFunc, + /* [in] */ DWORD cbFunc, + /* [out] */ DWORD *pNumFragments) = 0; + + virtual HRESULT STDMETHODCALLTYPE functionFragmentsForVA( + /* [in] */ ULONGLONG vaFunc, + /* [in] */ DWORD cbFunc, + /* [in] */ DWORD cFragments, + /* [out] */ ULONGLONG *pVaFragment, + /* [out] */ DWORD *pLenFragment) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaStackWalkHelperVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaStackWalkHelper * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaStackWalkHelper * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaStackWalkHelper * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerValue )( + IDiaStackWalkHelper * This, + /* [in] */ DWORD index, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_registerValue )( + IDiaStackWalkHelper * This, + /* [in] */ DWORD index, + /* [in] */ ULONGLONG NewVal); + + HRESULT ( STDMETHODCALLTYPE *readMemory )( + IDiaStackWalkHelper * This, + /* [in] */ enum MemoryTypeEnum type, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *searchForReturnAddress )( + IDiaStackWalkHelper * This, + /* [in] */ IDiaFrameData *frame, + /* [out] */ ULONGLONG *returnAddress); + + HRESULT ( STDMETHODCALLTYPE *searchForReturnAddressStart )( + IDiaStackWalkHelper * This, + /* [in] */ IDiaFrameData *frame, + /* [in] */ ULONGLONG startAddress, + /* [out] */ ULONGLONG *returnAddress); + + HRESULT ( STDMETHODCALLTYPE *frameForVA )( + IDiaStackWalkHelper * This, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaFrameData **ppFrame); + + HRESULT ( STDMETHODCALLTYPE *symbolForVA )( + IDiaStackWalkHelper * This, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaSymbol **ppSymbol); + + HRESULT ( STDMETHODCALLTYPE *pdataForVA )( + IDiaStackWalkHelper * This, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *imageForVA )( + IDiaStackWalkHelper * This, + /* [in] */ ULONGLONG vaContext, + /* [out] */ ULONGLONG *pvaImageStart); + + HRESULT ( STDMETHODCALLTYPE *addressForVA )( + IDiaStackWalkHelper * This, + /* [in] */ ULONGLONG va, + /* [out] */ DWORD *pISect, + /* [out] */ DWORD *pOffset); + + HRESULT ( STDMETHODCALLTYPE *numberOfFunctionFragmentsForVA )( + IDiaStackWalkHelper * This, + /* [in] */ ULONGLONG vaFunc, + /* [in] */ DWORD cbFunc, + /* [out] */ DWORD *pNumFragments); + + HRESULT ( STDMETHODCALLTYPE *functionFragmentsForVA )( + IDiaStackWalkHelper * This, + /* [in] */ ULONGLONG vaFunc, + /* [in] */ DWORD cbFunc, + /* [in] */ DWORD cFragments, + /* [out] */ ULONGLONG *pVaFragment, + /* [out] */ DWORD *pLenFragment); + + END_INTERFACE + } IDiaStackWalkHelperVtbl; + + interface IDiaStackWalkHelper + { + CONST_VTBL struct IDiaStackWalkHelperVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaStackWalkHelper_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaStackWalkHelper_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaStackWalkHelper_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaStackWalkHelper_get_registerValue(This,index,pRetVal) \ + ( (This)->lpVtbl -> get_registerValue(This,index,pRetVal) ) + +#define IDiaStackWalkHelper_put_registerValue(This,index,NewVal) \ + ( (This)->lpVtbl -> put_registerValue(This,index,NewVal) ) + +#define IDiaStackWalkHelper_readMemory(This,type,va,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> readMemory(This,type,va,cbData,pcbData,pbData) ) + +#define IDiaStackWalkHelper_searchForReturnAddress(This,frame,returnAddress) \ + ( (This)->lpVtbl -> searchForReturnAddress(This,frame,returnAddress) ) + +#define IDiaStackWalkHelper_searchForReturnAddressStart(This,frame,startAddress,returnAddress) \ + ( (This)->lpVtbl -> searchForReturnAddressStart(This,frame,startAddress,returnAddress) ) + +#define IDiaStackWalkHelper_frameForVA(This,va,ppFrame) \ + ( (This)->lpVtbl -> frameForVA(This,va,ppFrame) ) + +#define IDiaStackWalkHelper_symbolForVA(This,va,ppSymbol) \ + ( (This)->lpVtbl -> symbolForVA(This,va,ppSymbol) ) + +#define IDiaStackWalkHelper_pdataForVA(This,va,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> pdataForVA(This,va,cbData,pcbData,pbData) ) + +#define IDiaStackWalkHelper_imageForVA(This,vaContext,pvaImageStart) \ + ( (This)->lpVtbl -> imageForVA(This,vaContext,pvaImageStart) ) + +#define IDiaStackWalkHelper_addressForVA(This,va,pISect,pOffset) \ + ( (This)->lpVtbl -> addressForVA(This,va,pISect,pOffset) ) + +#define IDiaStackWalkHelper_numberOfFunctionFragmentsForVA(This,vaFunc,cbFunc,pNumFragments) \ + ( (This)->lpVtbl -> numberOfFunctionFragmentsForVA(This,vaFunc,cbFunc,pNumFragments) ) + +#define IDiaStackWalkHelper_functionFragmentsForVA(This,vaFunc,cbFunc,cFragments,pVaFragment,pLenFragment) \ + ( (This)->lpVtbl -> functionFragmentsForVA(This,vaFunc,cbFunc,cFragments,pVaFragment,pLenFragment) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaStackWalkHelper_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaStackWalker_INTERFACE_DEFINED__ +#define __IDiaStackWalker_INTERFACE_DEFINED__ + +/* interface IDiaStackWalker */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaStackWalker; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5485216b-a54c-469f-9670-52b24d5229bb") + IDiaStackWalker : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE getEnumFrames( + /* [in] */ IDiaStackWalkHelper *pHelper, + /* [out] */ IDiaEnumStackFrames **ppEnum) = 0; + + virtual HRESULT STDMETHODCALLTYPE getEnumFrames2( + /* [in] */ enum CV_CPU_TYPE_e cpuid, + /* [in] */ IDiaStackWalkHelper *pHelper, + /* [out] */ IDiaEnumStackFrames **ppEnum) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IDiaStackWalkerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaStackWalker * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaStackWalker * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaStackWalker * This); + + HRESULT ( STDMETHODCALLTYPE *getEnumFrames )( + IDiaStackWalker * This, + /* [in] */ IDiaStackWalkHelper *pHelper, + /* [out] */ IDiaEnumStackFrames **ppEnum); + + HRESULT ( STDMETHODCALLTYPE *getEnumFrames2 )( + IDiaStackWalker * This, + /* [in] */ enum CV_CPU_TYPE_e cpuid, + /* [in] */ IDiaStackWalkHelper *pHelper, + /* [out] */ IDiaEnumStackFrames **ppEnum); + + END_INTERFACE + } IDiaStackWalkerVtbl; + + interface IDiaStackWalker + { + CONST_VTBL struct IDiaStackWalkerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaStackWalker_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaStackWalker_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaStackWalker_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaStackWalker_getEnumFrames(This,pHelper,ppEnum) \ + ( (This)->lpVtbl -> getEnumFrames(This,pHelper,ppEnum) ) + +#define IDiaStackWalker_getEnumFrames2(This,cpuid,pHelper,ppEnum) \ + ( (This)->lpVtbl -> getEnumFrames2(This,cpuid,pHelper,ppEnum) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaStackWalker_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaStackWalkHelper2_INTERFACE_DEFINED__ +#define __IDiaStackWalkHelper2_INTERFACE_DEFINED__ + +/* interface IDiaStackWalkHelper2 */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaStackWalkHelper2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8222c490-507b-4bef-b3bd-41dca7b5934c") + IDiaStackWalkHelper2 : public IDiaStackWalkHelper + { + public: + }; + + +#else /* C style interface */ + + typedef struct IDiaStackWalkHelper2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaStackWalkHelper2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaStackWalkHelper2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaStackWalkHelper2 * This); + + /* [id][helpstring][propget] */ HRESULT ( STDMETHODCALLTYPE *get_registerValue )( + IDiaStackWalkHelper2 * This, + /* [in] */ DWORD index, + /* [retval][out] */ ULONGLONG *pRetVal); + + /* [id][helpstring][propput] */ HRESULT ( STDMETHODCALLTYPE *put_registerValue )( + IDiaStackWalkHelper2 * This, + /* [in] */ DWORD index, + /* [in] */ ULONGLONG NewVal); + + HRESULT ( STDMETHODCALLTYPE *readMemory )( + IDiaStackWalkHelper2 * This, + /* [in] */ enum MemoryTypeEnum type, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *searchForReturnAddress )( + IDiaStackWalkHelper2 * This, + /* [in] */ IDiaFrameData *frame, + /* [out] */ ULONGLONG *returnAddress); + + HRESULT ( STDMETHODCALLTYPE *searchForReturnAddressStart )( + IDiaStackWalkHelper2 * This, + /* [in] */ IDiaFrameData *frame, + /* [in] */ ULONGLONG startAddress, + /* [out] */ ULONGLONG *returnAddress); + + HRESULT ( STDMETHODCALLTYPE *frameForVA )( + IDiaStackWalkHelper2 * This, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaFrameData **ppFrame); + + HRESULT ( STDMETHODCALLTYPE *symbolForVA )( + IDiaStackWalkHelper2 * This, + /* [in] */ ULONGLONG va, + /* [out] */ IDiaSymbol **ppSymbol); + + HRESULT ( STDMETHODCALLTYPE *pdataForVA )( + IDiaStackWalkHelper2 * This, + /* [in] */ ULONGLONG va, + /* [in] */ DWORD cbData, + /* [out] */ DWORD *pcbData, + /* [size_is][out] */ BYTE *pbData); + + HRESULT ( STDMETHODCALLTYPE *imageForVA )( + IDiaStackWalkHelper2 * This, + /* [in] */ ULONGLONG vaContext, + /* [out] */ ULONGLONG *pvaImageStart); + + HRESULT ( STDMETHODCALLTYPE *addressForVA )( + IDiaStackWalkHelper2 * This, + /* [in] */ ULONGLONG va, + /* [out] */ DWORD *pISect, + /* [out] */ DWORD *pOffset); + + HRESULT ( STDMETHODCALLTYPE *numberOfFunctionFragmentsForVA )( + IDiaStackWalkHelper2 * This, + /* [in] */ ULONGLONG vaFunc, + /* [in] */ DWORD cbFunc, + /* [out] */ DWORD *pNumFragments); + + HRESULT ( STDMETHODCALLTYPE *functionFragmentsForVA )( + IDiaStackWalkHelper2 * This, + /* [in] */ ULONGLONG vaFunc, + /* [in] */ DWORD cbFunc, + /* [in] */ DWORD cFragments, + /* [out] */ ULONGLONG *pVaFragment, + /* [out] */ DWORD *pLenFragment); + + END_INTERFACE + } IDiaStackWalkHelper2Vtbl; + + interface IDiaStackWalkHelper2 + { + CONST_VTBL struct IDiaStackWalkHelper2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaStackWalkHelper2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaStackWalkHelper2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaStackWalkHelper2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaStackWalkHelper2_get_registerValue(This,index,pRetVal) \ + ( (This)->lpVtbl -> get_registerValue(This,index,pRetVal) ) + +#define IDiaStackWalkHelper2_put_registerValue(This,index,NewVal) \ + ( (This)->lpVtbl -> put_registerValue(This,index,NewVal) ) + +#define IDiaStackWalkHelper2_readMemory(This,type,va,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> readMemory(This,type,va,cbData,pcbData,pbData) ) + +#define IDiaStackWalkHelper2_searchForReturnAddress(This,frame,returnAddress) \ + ( (This)->lpVtbl -> searchForReturnAddress(This,frame,returnAddress) ) + +#define IDiaStackWalkHelper2_searchForReturnAddressStart(This,frame,startAddress,returnAddress) \ + ( (This)->lpVtbl -> searchForReturnAddressStart(This,frame,startAddress,returnAddress) ) + +#define IDiaStackWalkHelper2_frameForVA(This,va,ppFrame) \ + ( (This)->lpVtbl -> frameForVA(This,va,ppFrame) ) + +#define IDiaStackWalkHelper2_symbolForVA(This,va,ppSymbol) \ + ( (This)->lpVtbl -> symbolForVA(This,va,ppSymbol) ) + +#define IDiaStackWalkHelper2_pdataForVA(This,va,cbData,pcbData,pbData) \ + ( (This)->lpVtbl -> pdataForVA(This,va,cbData,pcbData,pbData) ) + +#define IDiaStackWalkHelper2_imageForVA(This,vaContext,pvaImageStart) \ + ( (This)->lpVtbl -> imageForVA(This,vaContext,pvaImageStart) ) + +#define IDiaStackWalkHelper2_addressForVA(This,va,pISect,pOffset) \ + ( (This)->lpVtbl -> addressForVA(This,va,pISect,pOffset) ) + +#define IDiaStackWalkHelper2_numberOfFunctionFragmentsForVA(This,vaFunc,cbFunc,pNumFragments) \ + ( (This)->lpVtbl -> numberOfFunctionFragmentsForVA(This,vaFunc,cbFunc,pNumFragments) ) + +#define IDiaStackWalkHelper2_functionFragmentsForVA(This,vaFunc,cbFunc,cFragments,pVaFragment,pLenFragment) \ + ( (This)->lpVtbl -> functionFragmentsForVA(This,vaFunc,cbFunc,cFragments,pVaFragment,pLenFragment) ) + + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaStackWalkHelper2_INTERFACE_DEFINED__ */ + + +#ifndef __IDiaStackWalker2_INTERFACE_DEFINED__ +#define __IDiaStackWalker2_INTERFACE_DEFINED__ + +/* interface IDiaStackWalker2 */ +/* [unique][helpstring][local][uuid][object] */ + + +EXTERN_C const IID IID_IDiaStackWalker2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7c185885-a015-4cac-9411-0f4fb39b1f3a") + IDiaStackWalker2 : public IDiaStackWalker + { + public: + }; + + +#else /* C style interface */ + + typedef struct IDiaStackWalker2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IDiaStackWalker2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IDiaStackWalker2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IDiaStackWalker2 * This); + + HRESULT ( STDMETHODCALLTYPE *getEnumFrames )( + IDiaStackWalker2 * This, + /* [in] */ IDiaStackWalkHelper *pHelper, + /* [out] */ IDiaEnumStackFrames **ppEnum); + + HRESULT ( STDMETHODCALLTYPE *getEnumFrames2 )( + IDiaStackWalker2 * This, + /* [in] */ enum CV_CPU_TYPE_e cpuid, + /* [in] */ IDiaStackWalkHelper *pHelper, + /* [out] */ IDiaEnumStackFrames **ppEnum); + + END_INTERFACE + } IDiaStackWalker2Vtbl; + + interface IDiaStackWalker2 + { + CONST_VTBL struct IDiaStackWalker2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IDiaStackWalker2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IDiaStackWalker2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IDiaStackWalker2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IDiaStackWalker2_getEnumFrames(This,pHelper,ppEnum) \ + ( (This)->lpVtbl -> getEnumFrames(This,pHelper,ppEnum) ) + +#define IDiaStackWalker2_getEnumFrames2(This,cpuid,pHelper,ppEnum) \ + ( (This)->lpVtbl -> getEnumFrames2(This,cpuid,pHelper,ppEnum) ) + + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IDiaStackWalker2_INTERFACE_DEFINED__ */ + + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/libraries/dia/diacreate.h b/libraries/dia/diacreate.h new file mode 100644 index 0000000..fac6668 --- /dev/null +++ b/libraries/dia/diacreate.h @@ -0,0 +1,42 @@ +// diacreate.h - creation helper functions for DIA initialization +//----------------------------------------------------------------- +// +// Copyright Microsoft Corporation. All Rights Reserved. +// +//--------------------------------------------------------------- +#ifndef _DIACREATE_H_ +#define _DIACREATE_H_ + +// +// Create a dia data source object from the dia dll (by dll name - does not access the registry). +// + +HRESULT STDMETHODCALLTYPE NoRegCoCreate( const __wchar_t *dllName, + REFCLSID rclsid, + REFIID riid, + void **ppv); + +#ifndef _NATIVE_WCHAR_T_DEFINED +#ifdef __cplusplus + +HRESULT STDMETHODCALLTYPE NoRegCoCreate( const wchar_t *dllName, + REFCLSID rclsid, + REFIID riid, + void **ppv) +{ + return NoRegCoCreate( (const __wchar_t *)dllName, rclsid, riid, ppv ); +} + +#endif +#endif + + + +// +// Create a dia data source object from the dia dll (looks up the class id in the registry). +// +HRESULT STDMETHODCALLTYPE NoOleCoCreate( REFCLSID rclsid, + REFIID riid, + void **ppv); + +#endif diff --git a/libraries/dia/lib/amd64/diaguids.lib b/libraries/dia/lib/amd64/diaguids.lib new file mode 100644 index 0000000000000000000000000000000000000000..077b0c6b04fa181f947e9c8a15dad99c8cc70e8a GIT binary patch literal 1716242 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
    1pZd!L}GN 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

    PXRv+9787j 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