File poke-dwarf-0.1~git20231115.obscpio of Package poke-dwarf

Overview Repositories Revisions Requests Users Attributes Meta

File poke-dwarf-0.1~git20231115.obscpio of Package poke-dwarf

07070100000000000081A40000000000000000000000016554D9F600000085000000000000000000000000000000000000002600000000poke-dwarf-0.1~git20231115/.gitignore*~
Makefile.in
aclocal.m4
autom4te.cache/
/build-aux
configure
install-sh
mdate-sh
missing
*.info
stamp-vti
texinfo.tex
version.texi
07070100000001000081A40000000000000000000000016554D9F600000029000000000000000000000000000000000000002300000000poke-dwarf-0.1~git20231115/AUTHORSJose E. Marchesi <jose.marchesi@gnu.org>
07070100000002000081A40000000000000000000000016554D9F60000894B000000000000000000000000000000000000002300000000poke-dwarf-0.1~git20231115/COPYING                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 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.

<one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

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 <http://www.gnu.org/licenses/>.

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:

<program>  Copyright (C) <year>  <name of author>
    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
<http://www.gnu.org/licenses/>.

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
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
07070100000003000081A40000000000000000000000016554D9F6000001A0000000000000000000000000000000000000002300000000poke-dwarf-0.1~git20231115/HACKINGTo build poke-dwarf you need a working installation of poke.  Then after
getting the git-dwarf sources, you can run:

,----
  | $ autoreconf -I /usr/local/share/aclocal/ -i
  | $ ./configure ...
  `----

where the (optional) -I points to the directory containing your aclocal.m4
(depending on the poke configure prefix). Finally, run the test suite and
install:

,----
  | $ make check && make install
  `----

07070100000004000081A40000000000000000000000016554D9F600000733000000000000000000000000000000000000002700000000poke-dwarf-0.1~git20231115/Makefile.am# DWARF pickle for GNU poke

# 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 <http://www.gnu.org/licenses/>.

picklesdir = $(datadir)/poke/pickles
dist_pickles_DATA = dwarf.pk \
                    dwarf-abbrev.pk \
                    dwarf-common.pk \
                    dwarf-config.pk \
                    dwarf-expr.pk \
                    dwarf-frame.pk \
                    dwarf-info.pk \
                    dwarf-line.pk \
                    dwarf-pubnames.pk \
                    dwarf-types.pk

info_TEXINFOS = poke-dwarf.texi
AM_MAKEINFOFLAGS = --set-customization-variable CHECK_NORMAL_MENU_STRUCTURE=true
EXTRA_DIST = dwarf-build.pk.in

# Running the testsuite.
#
# Note that it is important to invoke POKE from the same directory
# where the pickle's .pk files are, so they are picked up before the
# system-installed pickles.

EXTRA_DIST += test-dwarf.pk.in

if RUN_TESTS
TEST_LOG_DRIVER = env AM_TAP_AWK='$(AWK)' \
                  $(SHELL) $(top_srcdir)/build-aux/tap-driver.sh
TESTS_ENVIRONMENT = POKE_LOAD_PATH=$(top_srcdir)
TESTS = test-dwarf.pk
endif

# If we won't clean test-dwarf.pk, a common mistake will be that user
# edits it, and their edits can be consequently rewritten by automake.
CLEANFILES = test-dwarf.pk
07070100000005000081A40000000000000000000000016554D9F6000001FF000000000000000000000000000000000000002200000000poke-dwarf-0.1~git20231115/READMEpoke-dwarf is a GNU poke[1] pickle for editing DWARF debug
information.  It covers Call Frame Information, DIE tree, debug types,
expressions, and much more.

This pickle is part of the GNU poke project.

[1] GNU poke (https://jemarch.net/poke) is an interactive, extensible
    editor for binary data.  Not limited to editing basic entities
    such as bits and bytes, it provides a full-fledged procedural,
    interactive programming language designed to describe data
    structures and to operate on them.
07070100000006000081A40000000000000000000000016554D9F600000722000000000000000000000000000000000000002800000000poke-dwarf-0.1~git20231115/configure.acdnl configure.ac for the poke DWARF pickle
dnl
dnl Please process this file with autoconf to get a 'configure'
dnl script.

dnl This program is free software: you can redistribute it and/or modify
dnl it under the terms of the GNU General Public License as published by
dnl the Free Software Foundation, either version 3 of the License, or
dnl (at your option) any later version.
dnl
dnl This program is distributed in the hope that it will be useful,
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
dnl GNU General Public License for more details.
dnl
dnl You should have received a copy of the GNU General Public License
dnl along with this program.  If not, see <http://www.gnu.org/licenses/>.

AC_INIT([poke-dwarf], [0.1], [poke-devel@gnu.org], [poke-dwarf],
        [https://www.jemarch.net/poke-dwarf])
AC_CONFIG_AUX_DIR([build-aux])

AM_INIT_AUTOMAKE([foreign])
AC_REQUIRE_AUX_FILE([tap-driver.sh])

dnl Check for an installed poke, and minimum required version to test
dnl this pickle.  If found, it puts the absolute path in the POKE
dnl variable, and AC_SUBST it.  If not found, it sets POKE to :.

run_pickle_tests=no
PK_PROG_POKE([POKE],[3.0-dev-12])

if test "x$POKE" != "x:"; then
   dnl pktest is also required to run the testsuite.
   have_pktest=no
   PK_CHECK_PICKLE([$POKE],[pktest.pk],[run_pickle_tests=yes])
fi

AM_CONDITIONAL([RUN_TESTS], [test "x$run_pickle_tests" = "xyes"])

dnl Configure and output files.

AC_CONFIG_FILES([Makefile dwarf-build.pk])
AC_CONFIG_FILES([test-dwarf.pk], [chmod +x test-dwarf.pk])
AC_OUTPUT

dnl Emit some diagnostics at the end.

if test "x$POKE" = "x:"; then
  AC_MSG_WARN([poke >= 3.0-dev-12 is required to run this pickle's testsuite])
fi
07070100000007000081A40000000000000000000000016554D9F600000C5B000000000000000000000000000000000000002B00000000poke-dwarf-0.1~git20231115/dwarf-abbrev.pk/* dwarf-abbrev.pk - DWARF abbrev tables support for GNU poke.  */

/* 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 <http://www.gnu.org/licenses/>.
 */

/*
 * 7.5.3 Abbreviations Tables @ https://dwarfstd.org/doc/DWARF5.pdf
 *
 * Elfutils example .debug_abbrev parser in libdw/dwarf_getabbrev.c (l~40)
 * https://sourceware.org/git/?p=elfutils.git;a=blob;f=libdw/dwarf_getabbrev.c#l38
 *
 * Binutils example .debug_abbrev parser in binutils/dwarf.c (l~980)
 * https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=binutils/dwarf.c#l975
 */

load leb128;
load "dwarf-info.pk";

type Dwarf_Abbrev_Table_Hdr =
  struct
  {
    /*
     * 7.5.3 Abbreviations Tables
     * [...] Each declaration begins with an unsigned LEB128 number
     * representing the abbreviation code itself.  [...]  The
     * abbreviation code is followed by another unsigned LEB128
     * number that encodes the entry's tag.  [...]
     */

ULEB128 code : code.value != 0;
     ULEB128 tag : dw_cfg.entry_p ("dw-tag", tag.value);

/*
     * [...] Following the tag encoding is a 1-byte value that
     * determines whether a debugging information entry using this
     * abbreviation has child entries or not. [...]
     */

uint<8> children;

method _print = void:
       {
         printf ("#<%u64d, %s, %s>", code.value,
                                     dw_cfg.get_name ("dw-tag", tag.value),
                                     dw_cfg.get_name ("dw-children", children));
       }
  };

type Dwarf_Abbrev_Table_Entry =
  struct
  {
    /*
     * 7.5.3 Abbreviations Tables
     * [...] Finally, the child encoding is followed by a series of
     * attribute specifications. Each attribute specification
     * consists of two parts. The first part is an unsigned LEB128
     * number representing the attribute's name. The second part is
     * an unsigned LEB128 number representing the attribute's form.
     */

ULEB128 name : dw_cfg.entry_p ("dw-at", name.value);
     ULEB128 form : dw_cfg.entry_p ("dw-form", form.value);

method _print = void:
       {
        printf("#<%s, %s>", dw_cfg.get_name ("dw-at", name.value),
                            dw_cfg.get_name ("dw-form", form.value));
       }
  };

type Dwarf_Abbrev_Table =
  struct
  {
    Dwarf_Abbrev_Table_Hdr header;
    Dwarf_Abbrev_Table_Entry[] entries;

/*
     * A set of Dwarf_Abbrev_Table_Entry items is terminated by
     * a null_name and a null_form.
     */

ULEB128 null_name : null_name.value == 0;
    ULEB128 null_form : null_form.value == 0;
  };
07070100000008000081A40000000000000000000000016554D9F60000031D000000000000000000000000000000000000002D00000000poke-dwarf-0.1~git20231115/dwarf-build.pk.in/* dwarf-build.pk - DWARF implementation for GNU poke.  */

var dwarf_version = "@PACKAGE_VERSION@";
07070100000009000081A40000000000000000000000016554D9F600000B11000000000000000000000000000000000000002B00000000poke-dwarf-0.1~git20231115/dwarf-common.pk/* dwarf-common.pk - DWARF implementation for GNU poke.
                     Common bits.  */

/* The following globals shall be set to the intended values before
   mapping many of the DWARF structures.  For example, if the data in
   the several sections is to be interpreted as 64-bit DWARF 5,
   dwarf_bits shall be set to 64 and dwarf_version to 5.  */

var dwarf_bits = 64;
var dwarf_version = 4;

/* The dwarf_bits and dwarf_version globals can be updated directly,
   but the following couple of functions provide a more convenient way
   to do so in constraint expressions.  */

fun dwarf_set_bits = (int bits) int: { dwarf_bits = bits; return 1; }
fun dwarf_set_version = (int ver) int: { dwarf_version = ver; return 1; }

type Dwarf_Initial_Length =
  union
  {
    struct
    {
      uint<32> marker : (marker == 0xffff_ffff
                         && dwarf_set_bits (64));
      offset<uint<64>,B> length;
    } l64;

offset<uint<32>,B> l32 : (l32 < 0xffff_fff0#B
                              && dwarf_set_bits (32));

method value = offset<uint<64>,B>:
      {
        try return l32;
        catch if E_elem { return l64.length; }
      }

method _print = void:
      {
        print ("#<");
        try printf ("%v", l64.length);
        catch if E_elem { printf ("%v", l32); }
        print (">");
      }
  };

type Dwarf_Address =
  union
  {
    uint<32> a32 : dwarf_bits == 32;
    uint<64> a64;

method value = uint<64>:
      {
        try return a32;
        catch if E_elem { return a64; }
      }

method _print = void:
      {
        print ("#<");
        try printf ("%v", a32);
        catch if E_elem { printf ("%v", a64); }
        print (">");
      }
  };

type Dwarf_Section_Offset =
  union
  {
    offset<uint<32>,B> o32 : dwarf_bits == 32;
    offset<uint<64>,B> o64;

method value = offset<uint<64>,B>:
      {
        try return o32;
        catch if E_elem { return o64; }
      }

method _print = void:
      {
        print ("#<");
        try printf ("%v", o32);
        catch if E_elem { printf ("%v", o64); }
        print (">");
      }
  };
0707010000000A000081A40000000000000000000000016554D9F600000815000000000000000000000000000000000000002B00000000poke-dwarf-0.1~git20231115/dwarf-config.pk/* dwarf-config.pk - The DWARF configuration parameters.  */

/*
 * 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 <http://www.gnu.org/licenses/>.
 */

/*
 * This file implements a type Dwarf_Config holding various DWARF
 * configuration parameters
 */

type Dwarf_Config =
  struct
  {
    type Entry =
      struct
        {
          string class;
          uint<64> tag;
          string name;
          string doc;
        };

Entry[] entries = Entry[]();

method add = (string class, uint<64> tag, string name, string doc = name) void:
        {
          apush (entries, Entry { class = class,
                                  tag = tag,
                                  name = name,
                                  doc = doc });
        }

method get_name = (string class, uint<64> tag) string:
        {
          for (entry in entries where entry.class == class && entry.tag == tag)
            return entry.name;
          raise E_inval;
        }

method get_doc = (string class, uint<64> tag) string:
        {
          for (entry in entries where entry.class == class && entry.tag == tag)
            return entry.doc;
          raise E_inval;
        }

method entry_p = (string class, uint<64> tag) int<32>:
        {
          var entry = "";

try entry = get_name (class, tag);
          catch if E_inval { return 0; }

return entry'length;
        }
  };

var dw_cfg = Dwarf_Config {};
0707010000000B000081A40000000000000000000000016554D9F600005866000000000000000000000000000000000000002900000000poke-dwarf-0.1~git20231115/dwarf-expr.pk/* dwarf-expr.pk - DWARF implementation for GNU poke.
                   Expressions.  */

load leb128;

/* Opcodes.  */

var DW_OP_FIRST                = 0x03 as uint<8>,
    DW_OP_addr                 = 0x03 as uint<8>,
    DW_OP_deref                = 0x06 as uint<8>,
    DW_OP_const1u              = 0x08 as uint<8>,
    DW_OP_const1s              = 0x09 as uint<8>,
    DW_OP_const2u              = 0x0a as uint<8>,
    DW_OP_const2s              = 0x0b as uint<8>,
    DW_OP_const4u              = 0x0c as uint<8>,
    DW_OP_const4s              = 0x0d as uint<8>,
    DW_OP_const8u              = 0x0e as uint<8>,
    DW_OP_const8s              = 0x0f as uint<8>,
    DW_OP_constu               = 0x10 as uint<8>,
    DW_OP_consts               = 0x11 as uint<8>,
    DW_OP_dup                  = 0x12 as uint<8>,
    DW_OP_drop                 = 0x13 as uint<8>,
    DW_OP_over                 = 0x14 as uint<8>,
    DW_OP_pick                 = 0x15 as uint<8>,
    DW_OP_swap                 = 0x16 as uint<8>,
    DW_OP_rot                  = 0x17 as uint<8>,
    DW_OP_xderef               = 0x18 as uint<8>,
    DW_OP_abs                  = 0x19 as uint<8>,
    DW_OP_and                  = 0x1a as uint<8>,
    DW_OP_div                  = 0x1b as uint<8>,
    DW_OP_minus                = 0x1c as uint<8>,
    DW_OP_mod                  = 0x1d as uint<8>,
    DW_OP_mul                  = 0x1e as uint<8>,
    DW_OP_neg                  = 0x1f as uint<8>,
    DW_OP_not                  = 0x20 as uint<8>,
    DW_OP_or                   = 0x21 as uint<8>,
    DW_OP_plus                 = 0x22 as uint<8>,
    DW_OP_plus_uconst          = 0x23 as uint<8>,
    DW_OP_shl                  = 0x24 as uint<8>,
    DW_OP_shr                  = 0x25 as uint<8>,
    DW_OP_shra                 = 0x26 as uint<8>,
    DW_OP_xor                  = 0x27 as uint<8>,
    DW_OP_bra                  = 0x28 as uint<8>,
    DW_OP_eq                   = 0x29 as uint<8>,
    DW_OP_ge                   = 0x2a as uint<8>,
    DW_OP_gt                   = 0x2b as uint<8>,
    DW_OP_le                   = 0x2c as uint<8>,
    DW_OP_lt                   = 0x2d as uint<8>,
    DW_OP_ne                   = 0x2e as uint<8>,
    DW_OP_skip                 = 0x2f as uint<8>,
    DW_OP_lit0                 = 0x30 as uint<8>,
    DW_OP_lit1                 = 0x31 as uint<8>,
    DW_OP_lit2                 = 0x32 as uint<8>,
    DW_OP_lit3                 = 0x33 as uint<8>,
    DW_OP_lit4                 = 0x34 as uint<8>,
    DW_OP_lit5                 = 0x35 as uint<8>,
    DW_OP_lit6                 = 0x36 as uint<8>,
    DW_OP_lit7                 = 0x37 as uint<8>,
    DW_OP_lit8                 = 0x38 as uint<8>,
    DW_OP_lit9                 = 0x39 as uint<8>,
    DW_OP_lit10                = 0x3a as uint<8>,
    DW_OP_lit11                = 0x3b as uint<8>,
    DW_OP_lit12                = 0x3c as uint<8>,
    DW_OP_lit13                = 0x3d as uint<8>,
    DW_OP_lit14                = 0x3e as uint<8>,
    DW_OP_lit15                = 0x3f as uint<8>,
    DW_OP_lit16                = 0x40 as uint<8>,
    DW_OP_lit17                = 0x41 as uint<8>,
    DW_OP_lit18                = 0x42 as uint<8>,
    DW_OP_lit19                = 0x43 as uint<8>,
    DW_OP_lit20                = 0x44 as uint<8>,
    DW_OP_lit21                = 0x45 as uint<8>,
    DW_OP_lit22                = 0x46 as uint<8>,
    DW_OP_lit23                = 0x47 as uint<8>,
    DW_OP_lit24                = 0x48 as uint<8>,
    DW_OP_lit25                = 0x49 as uint<8>,
    DW_OP_lit26                = 0x4a as uint<8>,
    DW_OP_lit27                = 0x4b as uint<8>,
    DW_OP_lit28                = 0x4c as uint<8>,
    DW_OP_lit29                = 0x4d as uint<8>,
    DW_OP_lit30                = 0x4e as uint<8>,
    DW_OP_lit31                = 0x4f as uint<8>,
    DW_OP_reg0                 = 0x50 as uint<8>,
    DW_OP_reg1                 = 0x51 as uint<8>,
    DW_OP_reg2                 = 0x52 as uint<8>,
    DW_OP_reg3                 = 0x53 as uint<8>,
    DW_OP_reg4                 = 0x54 as uint<8>,
    DW_OP_reg5                 = 0x55 as uint<8>,
    DW_OP_reg6                 = 0x56 as uint<8>,
    DW_OP_reg7                 = 0x57 as uint<8>,
    DW_OP_reg8                 = 0x58 as uint<8>,
    DW_OP_reg9                 = 0x59 as uint<8>,
    DW_OP_reg10                = 0x5a as uint<8>,
    DW_OP_reg11                = 0x5b as uint<8>,
    DW_OP_reg12                = 0x5c as uint<8>,
    DW_OP_reg13                = 0x5d as uint<8>,
    DW_OP_reg14                = 0x5e as uint<8>,
    DW_OP_reg15                = 0x5f as uint<8>,
    DW_OP_reg16                = 0x60 as uint<8>,
    DW_OP_reg17                = 0x61 as uint<8>,
    DW_OP_reg18                = 0x62 as uint<8>,
    DW_OP_reg19                = 0x63 as uint<8>,
    DW_OP_reg20                = 0x64 as uint<8>,
    DW_OP_reg21                = 0x65 as uint<8>,
    DW_OP_reg22                = 0x66 as uint<8>,
    DW_OP_reg23                = 0x67 as uint<8>,
    DW_OP_reg24                = 0x68 as uint<8>,
    DW_OP_reg25                = 0x69 as uint<8>,
    DW_OP_reg26                = 0x6a as uint<8>,
    DW_OP_reg27                = 0x6b as uint<8>,
    DW_OP_reg28                = 0x6c as uint<8>,
    DW_OP_reg29                = 0x6d as uint<8>,
    DW_OP_reg30                = 0x6e as uint<8>,
    DW_OP_reg31                = 0x6f as uint<8>,
    DW_OP_breg0                = 0x70 as uint<8>,
    DW_OP_breg1                = 0x71 as uint<8>,
    DW_OP_breg2                = 0x72 as uint<8>,
    DW_OP_breg3                = 0x73 as uint<8>,
    DW_OP_breg4                = 0x74 as uint<8>,
    DW_OP_breg5                = 0x75 as uint<8>,
    DW_OP_breg6                = 0x76 as uint<8>,
    DW_OP_breg7                = 0x77 as uint<8>,
    DW_OP_breg8                = 0x78 as uint<8>,
    DW_OP_breg9                = 0x79 as uint<8>,
    DW_OP_breg10               = 0x7a as uint<8>,
    DW_OP_breg11               = 0x7b as uint<8>,
    DW_OP_breg12               = 0x7c as uint<8>,
    DW_OP_breg13               = 0x7d as uint<8>,
    DW_OP_breg14               = 0x7e as uint<8>,
    DW_OP_breg15               = 0x7f as uint<8>,
    DW_OP_breg16               = 0x80 as uint<8>,
    DW_OP_breg17               = 0x81 as uint<8>,
    DW_OP_breg18               = 0x82 as uint<8>,
    DW_OP_breg19               = 0x83 as uint<8>,
    DW_OP_breg20               = 0x84 as uint<8>,
    DW_OP_breg21               = 0x85 as uint<8>,
    DW_OP_breg22               = 0x86 as uint<8>,
    DW_OP_breg23               = 0x87 as uint<8>,
    DW_OP_breg24               = 0x88 as uint<8>,
    DW_OP_breg25               = 0x89 as uint<8>,
    DW_OP_breg26               = 0x8a as uint<8>,
    DW_OP_breg27               = 0x8b as uint<8>,
    DW_OP_breg28               = 0x8c as uint<8>,
    DW_OP_breg29               = 0x8d as uint<8>,
    DW_OP_breg30               = 0x8e as uint<8>,
    DW_OP_breg31               = 0x8f as uint<8>,
    DW_OP_regx                 = 0x90 as uint<8>,
    DW_OP_fbreg                = 0x91 as uint<8>,
    DW_OP_bregx                = 0x92 as uint<8>,
    DW_OP_piece                = 0x93 as uint<8>,
    DW_OP_deref_size           = 0x94 as uint<8>,
    DW_OP_xderef_size          = 0x95 as uint<8>,
    DW_OP_nop                  = 0x96 as uint<8>,
    DW_OP_push_object_address  = 0x97 as uint<8>,
    DW_OP_call2                = 0x98 as uint<8>,
    DW_OP_call4                = 0x99 as uint<8>,
    DW_OP_call_ref             = 0x9a as uint<8>,
    DW_OP_form_tls_address     = 0x9b as uint<8>,
    DW_OP_call_frame_cfa       = 0x9c as uint<8>,
    DW_OP_bit_piece            = 0x9d as uint<8>,
    DW_OP_implicit_value       = 0x9e as uint<8>,
    DW_OP_stack_value          = 0x9f as uint<8>,
    DW_OP_implicit_pointer     = 0xa0 as uint<8>,
    DW_OP_addrx                = 0xa1 as uint<8>,
    DW_OP_constx               = 0xa2 as uint<8>,
    DW_OP_entry_value          = 0xa3 as uint<8>,
    DW_OP_const_type           = 0xa4 as uint<8>,
    DW_OP_regval_type          = 0xa5 as uint<8>,
    DW_OP_deref_type           = 0xa6 as uint<8>,
    DW_OP_xderef_type          = 0xa7 as uint<8>,
    DW_OP_convert              = 0xa8 as uint<8>,
    DW_OP_reinterpret          = 0xa9 as uint<8>,
    /* GNU extensions.  */
    DW_OP_GNU_push_tls_address = 0xe0 as uint<8>,
    DW_OP_GNU_uninit           = 0xf0 as uint<8>,
    DW_OP_GNU_encoded_addr     = 0xf1 as uint<8>,
    DW_OP_GNU_implicit_pointer = 0xf2 as uint<8>,
    DW_OP_GNU_entry_value      = 0xf3 as uint<8>,
    DW_OP_GNU_const_type       = 0xf4 as uint<8>,
    DW_OP_GNU_regval_type      = 0xf5 as uint<8>,
    DW_OP_GNU_deref_type       = 0xf6 as uint<8>,
    DW_OP_GNU_convert          = 0xf7 as uint<8>,
    DW_OP_GNU_reinterpret      = 0xf9 as uint<8>,
    DW_OP_GNU_parameter_ref    = 0xfa as uint<8>,
    /* GNU Debug Fission extensions.  */
    DW_OP_GNU_addr_index       = 0xfb as uint<8>,
    DW_OP_GNU_const_index      = 0xfc as uint<8>,
    DW_OP_GNU_variable_value   = 0xfd as uint<8>,
    DW_OP_lo_user              = 0xe0 as uint<8>,
    DW_OP_hi_user              = 0xff as uint<8>,
    DW_OP_LAST                 = DW_OP_hi_user;

dw_cfg.add :class "dw-tag" :tag DW_OP_addr :name "addr";
dw_cfg.add :class "dw-tag" :tag DW_OP_deref :name "deref";
dw_cfg.add :class "dw-tag" :tag DW_OP_const1u :name "const1u";
dw_cfg.add :class "dw-tag" :tag DW_OP_const1s :name "const1s";
dw_cfg.add :class "dw-tag" :tag DW_OP_const2u :name "const2u";
dw_cfg.add :class "dw-tag" :tag DW_OP_const2s :name "const2s";
dw_cfg.add :class "dw-tag" :tag DW_OP_const4u :name "const4u";
dw_cfg.add :class "dw-tag" :tag DW_OP_const4s :name "const4s";
dw_cfg.add :class "dw-tag" :tag DW_OP_const8u :name "const8u";
dw_cfg.add :class "dw-tag" :tag DW_OP_const8s :name "const8s";
dw_cfg.add :class "dw-tag" :tag DW_OP_constu :name "constu";
dw_cfg.add :class "dw-tag" :tag DW_OP_consts :name "consts";
dw_cfg.add :class "dw-tag" :tag DW_OP_dup :name "dup";
dw_cfg.add :class "dw-tag" :tag DW_OP_drop :name "drop";
dw_cfg.add :class "dw-tag" :tag DW_OP_over :name "over";
dw_cfg.add :class "dw-tag" :tag DW_OP_pick :name "pick";
dw_cfg.add :class "dw-tag" :tag DW_OP_swap :name "swap";
dw_cfg.add :class "dw-tag" :tag DW_OP_rot :name "rot";
dw_cfg.add :class "dw-tag" :tag DW_OP_xderef :name "xderef";
dw_cfg.add :class "dw-tag" :tag DW_OP_abs :name "abs";
dw_cfg.add :class "dw-tag" :tag DW_OP_and :name "and";
dw_cfg.add :class "dw-tag" :tag DW_OP_div :name "div";
dw_cfg.add :class "dw-tag" :tag DW_OP_minus :name "minus";
dw_cfg.add :class "dw-tag" :tag DW_OP_mod :name "mod";
dw_cfg.add :class "dw-tag" :tag DW_OP_mul :name "mul";
dw_cfg.add :class "dw-tag" :tag DW_OP_neg :name "neg";
dw_cfg.add :class "dw-tag" :tag DW_OP_not :name "not";
dw_cfg.add :class "dw-tag" :tag DW_OP_or :name "or";
dw_cfg.add :class "dw-tag" :tag DW_OP_plus :name "plus";
dw_cfg.add :class "dw-tag" :tag DW_OP_plus_uconst :name "plus_uconst";
dw_cfg.add :class "dw-tag" :tag DW_OP_shl :name "shl";
dw_cfg.add :class "dw-tag" :tag DW_OP_shr :name "shr";
dw_cfg.add :class "dw-tag" :tag DW_OP_shra :name "shra";
dw_cfg.add :class "dw-tag" :tag DW_OP_xor :name "xor";
dw_cfg.add :class "dw-tag" :tag DW_OP_bra :name "bra";
dw_cfg.add :class "dw-tag" :tag DW_OP_eq :name "eq";
dw_cfg.add :class "dw-tag" :tag DW_OP_ge :name "ge";
dw_cfg.add :class "dw-tag" :tag DW_OP_gt :name "gt";
dw_cfg.add :class "dw-tag" :tag DW_OP_le :name "le";
dw_cfg.add :class "dw-tag" :tag DW_OP_lt :name "lt";
dw_cfg.add :class "dw-tag" :tag DW_OP_ne :name "ne";
dw_cfg.add :class "dw-tag" :tag DW_OP_skip :name "skip";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit0 :name "lit0";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit1 :name "lit1";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit2 :name "lit2";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit3 :name "lit3";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit4 :name "lit4";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit5 :name "lit5";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit6 :name "lit6";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit7 :name "lit7";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit8 :name "lit8";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit9 :name "lit9";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit10 :name "lit10";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit11 :name "lit11";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit12 :name "lit12";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit13 :name "lit13";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit14 :name "lit14";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit15 :name "lit15";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit16 :name "lit16";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit17 :name "lit17";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit18 :name "lit18";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit19 :name "lit19";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit20 :name "lit20";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit21 :name "lit21";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit22 :name "lit22";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit23 :name "lit23";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit24 :name "lit24";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit25 :name "lit25";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit26 :name "lit26";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit27 :name "lit27";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit28 :name "lit28";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit29 :name "lit29";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit30 :name "lit30";
dw_cfg.add :class "dw-tag" :tag DW_OP_lit31 :name "lit31";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg0 :name "reg0";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg1 :name "reg1";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg2 :name "reg2";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg3 :name "reg3";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg4 :name "reg4";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg5 :name "reg5";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg6 :name "reg6";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg7 :name "reg7";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg8 :name "reg8";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg9 :name "reg9";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg10 :name "reg10";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg11 :name "reg11";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg12 :name "reg12";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg13 :name "reg13";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg14 :name "reg14";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg15 :name "reg15";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg16 :name "reg16";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg17 :name "reg17";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg18 :name "reg18";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg19 :name "reg19";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg20 :name "reg20";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg21 :name "reg21";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg22 :name "reg22";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg23 :name "reg23";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg24 :name "reg24";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg25 :name "reg25";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg26 :name "reg26";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg27 :name "reg27";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg28 :name "reg28";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg29 :name "reg29";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg30 :name "reg30";
dw_cfg.add :class "dw-tag" :tag DW_OP_reg31 :name "reg31";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg0 :name "breg0";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg1 :name "breg1";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg2 :name "breg2";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg3 :name "breg3";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg4 :name "breg4";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg5 :name "breg5";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg6 :name "breg6";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg7 :name "breg7";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg8 :name "breg8";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg9 :name "breg9";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg10 :name "breg10";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg11 :name "breg11";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg12 :name "breg12";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg13 :name "breg13";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg14 :name "breg14";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg15 :name "breg15";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg16 :name "breg16";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg17 :name "breg17";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg18 :name "breg18";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg19 :name "breg19";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg20 :name "breg20";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg21 :name "breg21";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg22 :name "breg22";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg23 :name "breg23";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg24 :name "breg24";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg25 :name "breg25";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg26 :name "breg26";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg27 :name "breg27";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg28 :name "breg28";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg29 :name "breg29";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg30 :name "breg30";
dw_cfg.add :class "dw-tag" :tag DW_OP_breg31 :name "breg31";
dw_cfg.add :class "dw-tag" :tag DW_OP_regx :name "regx";
dw_cfg.add :class "dw-tag" :tag DW_OP_fbreg :name "fbreg";
dw_cfg.add :class "dw-tag" :tag DW_OP_bregx :name "bregx";
dw_cfg.add :class "dw-tag" :tag DW_OP_piece :name "piece";
dw_cfg.add :class "dw-tag" :tag DW_OP_deref_size :name "deref_size";
dw_cfg.add :class "dw-tag" :tag DW_OP_xderef_size :name "xderef_size";
dw_cfg.add :class "dw-tag" :tag DW_OP_nop :name "nop";
dw_cfg.add :class "dw-tag" :tag DW_OP_push_object_address :name "push_object_address";
dw_cfg.add :class "dw-tag" :tag DW_OP_call2 :name "call2";
dw_cfg.add :class "dw-tag" :tag DW_OP_call4 :name "call4";
dw_cfg.add :class "dw-tag" :tag DW_OP_call_ref :name "call_ref";
dw_cfg.add :class "dw-tag" :tag DW_OP_form_tls_address :name "form_tls_address";
dw_cfg.add :class "dw-tag" :tag DW_OP_call_frame_cfa :name "call_frame_cfa";
dw_cfg.add :class "dw-tag" :tag DW_OP_bit_piece :name "bit_piece";
dw_cfg.add :class "dw-tag" :tag DW_OP_implicit_value :name "implicit_value";
dw_cfg.add :class "dw-tag" :tag DW_OP_stack_value :name "stack_value";
dw_cfg.add :class "dw-tag" :tag DW_OP_implicit_pointer :name "implicit_pointer";
dw_cfg.add :class "dw-tag" :tag DW_OP_addrx :name "addrx";
dw_cfg.add :class "dw-tag" :tag DW_OP_constx :name "constx";
dw_cfg.add :class "dw-tag" :tag DW_OP_entry_value :name "entry_value";
dw_cfg.add :class "dw-tag" :tag DW_OP_const_type :name "const_type";
dw_cfg.add :class "dw-tag" :tag DW_OP_regval_type :name "regval_type";
dw_cfg.add :class "dw-tag" :tag DW_OP_deref_type :name "deref_type";
dw_cfg.add :class "dw-tag" :tag DW_OP_xderef_type :name "xderef_type";
dw_cfg.add :class "dw-tag" :tag DW_OP_convert :name "convert";
dw_cfg.add :class "dw-tag" :tag DW_OP_reinterpret :name "reinterpret";
    /* GNU extensions.  */
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_push_tls_address :name "GNU_push_tls_address";
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_uninit :name "GNU_uninit";
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_encoded_addr :name "GNU_encoded_addr";
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_implicit_pointer :name "GNU_implicit_pointe";
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_entry_value :name "GNU_entry_value";
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_const_type :name "GNU_const_type";
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_regval_type :name "GNU_regval_type";
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_deref_type :name "GNU_deref_type";
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_convert :name "GNU_convert";
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_reinterpret :name "GNU_reinterpret";
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_parameter_ref :name "GNU_parameter_ref";
    /* GNU Debug Fission extensions.  */
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_addr_index :name "GNU_addr_index";
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_const_index :name "GNU_const_index";
dw_cfg.add :class "dw-tag" :tag DW_OP_GNU_variable_value :name "GNU_variable_value";
dw_cfg.add :class "dw-tag" :tag DW_OP_lo_user :name "lo_user";
dw_cfg.add :class "dw-tag" :tag DW_OP_hi_user :name "hi_user";

/* Each DWARF operation contains a 1-byte opcode that identifies the
   operation; followed by a variable number of arguments.  */

type Dwarf_Op =
  struct
  {
    uint<8> code : dw_cfg.entry_p ("dw-tag", code);
    union
    {
      uint<8>  u8 : code in [DW_OP_const1u, DW_OP_pick,
                             DW_OP_deref_size, DW_OP_xderef_size];
      int<8>   i8 : code == DW_OP_const1s;

uint<16> u16 : code in [DW_OP_const2u, DW_OP_call2];
      int<16>  i16 : code in [DW_OP_const2s, DW_OP_skip, DW_OP_bra];

uint<32> u32 : code in [DW_OP_const4u, DW_OP_call4];
      int<32>  i32 : code == DW_OP_const4s;

uint<64> u64 : code == DW_OP_const8u;
      int<64>  i64 : code == DW_OP_const8s;

ULEB128 u128 : (code in [DW_OP_constu, DW_OP_plus_uconst,
                               DW_OP_fbreg, DW_OP_regx, DW_OP_piece]
                      || (code >= DW_OP_breg0 && code <= DW_OP_breg31));

struct
      {
        ULEB128 reg;
        LEB128 offset;
      } reg_offset : code in [DW_OP_bregx, DW_OP_bit_piece];

struct
      {
        ULEB128 length;
        byte[length.value] block;
      } size : code == DW_OP_implicit_value;

Dwarf_Address addr : code == DW_OP_addr;
      Dwarf_Section_Offset offset : code == DW_OP_call_ref;

/* Other operations have no arguments.  */
      struct {} nothing;
    } arg;

method _print_code = void:
    {
      printf "<#%s>", dw_cfg.get_name ("dw-tag", code);
    }
  };
0707010000000C000081A40000000000000000000000016554D9F600001DF7000000000000000000000000000000000000002A00000000poke-dwarf-0.1~git20231115/dwarf-frame.pk/* dwarf-frame.pk - DWARF implementation for GNU poke.
                    Call Frame Information.  */

load leb128;
load "dwarf-common.pk";
load "dwarf-expr.pk"; /* For Dwarf_Op  */

/* Call Frame Instructions.  */

var DW_CFA_advance_loc                  = 0x40 as uint<6>,
    DW_CFA_offset                       = 0x80 as uint<6>,
    DW_CFA_restore                      = 0xc0 as uint<6>,
    DW_CFA_extended                     = 0x00 as uint<6>,
    DW_CFA_nop                          = 0x00 as uint<6>,
    DW_CFA_set_loc                      = 0x01 as uint<6>,
    DW_CFA_advance_loc1                 = 0x02 as uint<6>,
    DW_CFA_advance_loc2                 = 0x03 as uint<6>,
    DW_CFA_advance_loc4                 = 0x04 as uint<6>,
    DW_CFA_offset_extended              = 0x05 as uint<6>,
    DW_CFA_restore_extended             = 0x06 as uint<6>,
    DW_CFA_undefined                    = 0x07 as uint<6>,
    DW_CFA_same_value                   = 0x08 as uint<6>,
    DW_CFA_register                     = 0x09 as uint<6>,
    DW_CFA_remember_state               = 0x0a as uint<6>,
    DW_CFA_restore_state                = 0x0b as uint<6>,
    DW_CFA_def_cfa                      = 0x0c as uint<6>,
    DW_CFA_def_cfa_register             = 0x0d as uint<6>,
    DW_CFA_def_cfa_offset               = 0x0e as uint<6>,
    DW_CFA_def_cfa_expression           = 0x0f as uint<6>,
    DW_CFA_expression                   = 0x10 as uint<6>,
    DW_CFA_offset_extended_sf           = 0x11 as uint<6>,
    DW_CFA_def_cfa_sf                   = 0x12 as uint<6>,
    DW_CFA_def_cfa_offset_sf            = 0x13 as uint<6>,
    DW_CFA_val_offset                   = 0x14 as uint<6>,
    DW_CFA_val_offset_sf                = 0x15 as uint<6>,
    DW_CFA_val_expression               = 0x16 as uint<6>,
    DW_CFA_low_user                     = 0x1c as uint<6>,
    DW_CFA_MIPS_advance_loc8            = 0x1d as uint<6>,
    DW_CFA_GNU_window_save              = 0x2d as uint<6>,
    DW_CFA_GNU_args_size                = 0x2e as uint<6>,
    DW_CFA_GNU_negative_offset_extended = 0x2f as uint<6>,
    DW_CFA_high_user                    = 0x3f as uint<6>;

type Dwarf_CFI =
  struct
  {
    struct uint<8>
    {
      uint<2> primary;
      uint<6> extop;
    } code;

var ecode = code.extop;

/* Off-opcode arguments follow.  */
    union
    {
      ULEB128 u128      : ecode == DW_CFA_offset;
      Dwarf_Address addr : ecode == DW_CFA_set_loc;
      /* XXX: offsets for advance_locN? */
      uint<8> u8        : ecode == DW_CFA_advance_loc1;
      uint<16> u16      : ecode == DW_CFA_advance_loc2;
      uint<32> u32      : ecode == DW_CFA_advance_loc4;
      uint<64> u64      : ecode == DW_CFA_MIPS_advance_loc8;

struct
      {
        ULEB128 reg;
        ULEB128 off;
      } reg_offset      : ecode in [DW_CFA_offset_extended,
                                    DW_CFA_def_cfa,
                                    DW_CFA_val_offset];

struct
      {
        ULEB128 reg;
        LEB128 off;
      } reg_soffset     : ecode in [DW_CFA_offset_extended_sf,
                                    DW_CFA_def_cfa_sf,
                                    DW_CFA_val_offset_sf];

ULEB128 reg       : ecode in [DW_CFA_restore_extended,
                                    DW_CFA_undefined,
                                    DW_CFA_same_value,
                                    DW_CFA_def_cfa_register];

ULEB128[2] regs   : ecode == DW_CFA_register;

ULEB128 offset    : ecode == DW_CFA_def_cfa_offset;
      LEB128 soffset    : ecode == DW_CFA_def_cfa_offset_sf;

struct
      {
        ULEB128 size;
        Dwarf_Op[size.value#B] ops;
      } exp             : ecode == DW_CFA_def_cfa_expression;

struct
      {
        ULEB128 reg;
        ULEB128 size;
        Dwarf_Op[size.value#B] ops;
      } reg_exp       : ecode in [DW_CFA_expression,
                                  DW_CFA_val_expression];

/* Other instructions have no operands. */
      struct {} nothing;
    } ops;
  };

/* DWARF Common Information Entry (CIE)

There is at least one CIE in every non-empty .debug_frame
   section.  */

type Dwarf_CIE =
  struct
  {
    /* Size of the CIE structure, not including the `length' field
       itself.  */
    Dwarf_Initial_Length length;

/* Constant used to distinguish CIEs from FDEs.  */
    union
    {
      uint<32> u32 : (dwarf_bits == 32
                      && u32 == 0xffff_ffff);
      uint<64> u64 : u64 == 0xffff_ffff_ffff_ffffLU;
    } cie_id;

/* This version number is specific to the call frame information
       and is independent of the DWARF version number.  */
    uint<8> version : ((dwarf_version == 2 && version == 1)
                       || (dwarf_version == 3 && version == 3)
                       || (dwarf_version == 4 && version == 4)
                       || version == 1 /* GAS generates version 1.  */);

/* UTF-8 string that identifies the augmentation to this CIE or to
       the FDEs that use it.  If there is no augmentation this value
       is a zero byte.  */
    string augmentation;

/* Size of a target address in this CIE and any FDEs that use it.
       If a CU exists for this frame, its address size must match the
       address size here.  */
    offset<uint<8>,B> address_size;

/* Size of a segment selector in this CIE and any FDEs that use
       it.  */
    offset<uint<8>,B> segment_size;

/* A constant that is factored out of all advance location
       instructions.  */
    ULEB128 code_alignment_factor;

/* A constant that is factored out of certain offset
       instructions.  */
    LEB128 data_alignment_factor;

/* Constant that indicates which column in the rule table
       represents the return address of the function.  */
    ULEB128 return_address_register;

var insn_size = (length.value - OFFSET - length'size);
    Dwarf_CFI[insn_size] initial_instructions;
  };

/* DWARF FDE.
   Description of a frame for a given function.  */

type Dwarf_FDE =
  struct
  {
    /* Size of the header and instruction stream for this function,
       not including the `length' field itself.  */
    Dwarf_Initial_Length length;

/* Offset into the .debug_frame section that denotes the CIE that
       is associated with this FDE.  */
    Dwarf_Section_Offset cie_pointer;

/* XXX initial_location (segment selector and target address)  */
    Dwarf_Address initial_location;

/* Number of bytes of program instructions described by this
       entry.  */
    Dwarf_Address address_range;

var padding = (length.value
                      - (cie_pointer'size + initial_location'size
                         + address_range'size + address_range.value()#B));

Dwarf_CFI[address_range.value()#B + padding] instructions;
  };

/* Call Frame Information.  */

type Dwarf_Call_Frame_Entry =
  union
  {
    Dwarf_CIE cie;
    Dwarf_FDE fde;
  };
0707010000000D000081A40000000000000000000000016554D9F60000BC95000000000000000000000000000000000000002900000000poke-dwarf-0.1~git20231115/dwarf-info.pk/* dwarf-info.pk - DWARF implementation for GNU poke.
                   Data in .debug_info  */

/* DWARF DIE children encoding.  */

var DW_CHILDREN_no = 0x00,
    DW_CHILDREN_yes = 0x01;

dw_cfg.add
  :class "dw-children"
  :tag DW_CHILDREN_no
  :name "DW_CHILDREN_no"
  :doc "DIE not having children";
dw_cfg.add
  :class "dw-children"
  :tag DW_CHILDREN_yes
  :name "DW_CHILDREN_yes"
  :doc "DIE having children";

/* DWARF Tags.  */

var DW_TAG_array_type = 0x01,
    DW_TAG_class_type = 0x02,
    DW_TAG_entry_point = 0x03,
    DW_TAG_enumeration_type = 0x04,
    DW_TAG_formal_parameter = 0x05,
    /* 0x06 reserved.  */
    /* 0x07 reserved.  */
    DW_TAG_imported_declaration = 0x08,
    /* 0x09 reserved.  */
    DW_TAG_label = 0x0a,
    DW_TAG_lexical_block = 0x0b,
    /* 0x0c reserved.  */
    DW_TAG_member = 0x0d,
    /* 0x0e reserved.  */
    DW_TAG_pointer_type = 0x0f,
    DW_TAG_reference_type = 0x10,
    DW_TAG_compile_unit = 0x11,
    DW_TAG_string_type = 0x12,
    DW_TAG_structure_type = 0x13,
    /* 0x14 reserved.  */
    DW_TAG_subroutine_type = 0x15,
    DW_TAG_typedef = 0x16,
    DW_TAG_union_type = 0x17,
    DW_TAG_unspecified_parameters = 0x18,
    DW_TAG_variant = 0x19,
    DW_TAG_common_block = 0x1a,
    DW_TAG_common_inclusion = 0x1b,
    DW_TAG_inheritance = 0x1c,
    DW_TAG_inlined_subroutine = 0x1d,
    DW_TAG_module = 0x1e,
    DW_TAG_ptr_to_member_type = 0x1f,
    DW_TAG_set_type = 0x20,
    DW_TAG_subrange_type = 0x21,
    DW_TAG_with_stmt = 0x22,
    DW_TAG_access_declaration = 0x23,
    DW_TAG_base_type = 0x24,
    DW_TAG_catch_block = 0x25,
    DW_TAG_const_type = 0x26,
    DW_TAG_constant = 0x27,
    DW_TAG_enumerator = 0x28,
    DW_TAG_file_type = 0x29,
    DW_TAG_friend = 0x2a,
    DW_TAG_namelist = 0x2b,
    DW_TAG_namelist_item = 0x2c,
    DW_TAG_packed_type = 0x2d,
    DW_TAG_subprogram = 0x2e,
    DW_TAG_template_type_parameter = 0x2f,
    DW_TAG_template_value_parameter = 0x30,
    DW_TAG_thrown_type = 0x31,
    DW_TAG_try_block = 0x32,
    DW_TAG_variant_part = 0x33,
    DW_TAG_variable = 0x34,
    DW_TAG_volatile_type = 0x35,
    DW_TAG_dwarf_procedure = 0x36,
    DW_TAG_restrict_type = 0x37,
    DW_TAG_interface_type = 0x38,
    DW_TAG_namespace = 0x39,
    DW_TAG_imported_module = 0x3a,
    DW_TAG_unspecified_type = 0x3b,
    DW_TAG_partial_unit = 0x3c,
    DW_TAG_imported_unit = 0x3d,
    /* 0x3e reserved.  Was DW_TAG_mutable_type.  */
    DW_TAG_condition = 0x3f,
    DW_TAG_shared_type = 0x40,
    DW_TAG_type_unit = 0x41,
    DW_TAG_rvalue_reference_type = 0x42,
    DW_TAG_template_alias = 0x43,
    DW_TAG_coarray_type = 0x44,
    DW_TAG_generic_subrange = 0x45,
    DW_TAG_dynamic_type = 0x46,
    DW_TAG_atomic_type = 0x47,
    DW_TAG_call_site = 0x48,
    DW_TAG_call_site_parameter = 0x49,
    DW_TAG_skeleton_unit = 0x4a,
    DW_TAG_immutable_type = 0x4b,
    DW_TAG_lo_user = 0x4080,
    DW_TAG_MIPS_loop = 0x4081,
    DW_TAG_format_label = 0x4101,
    DW_TAG_function_template = 0x4102,
    DW_TAG_class_template = 0x4103,
    DW_TAG_GNU_BINCL = 0x4104,
    DW_TAG_GNU_EINCL = 0x4105,
    DW_TAG_GNU_template_template_param = 0x4106,
    DW_TAG_GNU_template_parameter_pack = 0x4107,
    DW_TAG_GNU_formal_parameter_pack = 0x4108,
    DW_TAG_GNU_call_site = 0x4109,
    DW_TAG_GNU_call_site_parameter = 0x410a,
    DW_TAG_hi_user = 0xffff;

/* DWARF Tags  */

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_access_declaration :name "DW_TAG_access_declaration";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_array_type :name "DW_TAG_array_type" :doc "Describes array types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_atomic_type :name "DW_TAG_atomic_type" :doc "Represents atomic types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_base_type :name "DW_TAG_base_type" :doc "Describes basic data types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_call_site :name "DW_TAG_call_site" :doc "Represents a call site";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_call_site_parameter :name "DW_TAG_call_site_parameter"
  :doc "Describes parameters at a call site";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_catch_block :name "DW_TAG_catch_block" :doc "Represents catch blocks";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_class_template :name "DW_TAG_class_template";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_class_type :name "DW_TAG_class_type" :doc "Represents class types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_coarray_type :name "DW_TAG_coarray_type" :doc "Describes coarray types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_common_block :name "DW_TAG_common_block" :doc "Represents common blocks";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_common_inclusion :name "DW_TAG_common_inclusion"
  :doc "Represents common block inclusions";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_compile_unit :name "DW_TAG_compile_unit" :doc "Represents compilation units";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_condition :name "DW_TAG_condition" :doc "Represents conditions";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_constant :name "DW_TAG_constant" :doc "Represents constants";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_const_type :name "DW_TAG_const_type" :doc "Describes constant types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_dwarf_procedure :name "DW_TAG_dwarf_procedure" :doc "Describes Dwarf procedures";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_dynamic_type :name "DW_TAG_dynamic_type" :doc "Describes dynamic types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_entry_point :name "DW_TAG_entry_point" :doc "Represents entry points";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_enumeration_type :name "DW_TAG_enumeration_type" :doc "Describes enumeration types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_enumerator :name "DW_TAG_enumerator" :doc "Represents enumerators";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_file_type :name "DW_TAG_file_type" :doc "Describes file types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_formal_parameter :name "DW_TAG_formal_parameter" :doc "Describes formal parameters";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_format_label :name "DW_TAG_format_label";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_friend :name "DW_TAG_friend" :doc "Describes friend declarations";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_function_template :name "DW_TAG_function_template";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_generic_subrange :name "DW_TAG_generic_subrange" :doc "Describes generic subranges";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_GNU_BINCL :name "DW_TAG_GNU_BINCL";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_GNU_call_site :name "DW_TAG_GNU_call_site";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_GNU_call_site_parameter :name "DW_TAG_GNU_call_site_parameter";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_GNU_EINCL :name "DW_TAG_GNU_EINCL";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_GNU_formal_parameter_pack :name "DW_TAG_GNU_formal_parameter_pack";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_GNU_template_parameter_pack :name "DW_TAG_GNU_template_parameter_pack";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_GNU_template_template_param :name "DW_TAG_GNU_template_template_param";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_hi_user :name "DW_TAG_hi_user";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_immutable_type :name "DW_TAG_immutable_type" :doc "Describes immutable types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_imported_declaration :name "DW_TAG_imported_declaration" :doc "Represents imported declarations";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_imported_module :name "DW_TAG_imported_module" :doc "Represents imported modules";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_imported_unit :name "DW_TAG_imported_unit" :doc "Represents imported units";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_inheritance :name "DW_TAG_inheritance" :doc "Describes inheritance relationships";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_inlined_subroutine :name "DW_TAG_inlined_subroutine" :doc "Represents inlined subroutines";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_interface_type :name "DW_TAG_interface_type" :doc "Describes interface types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_label :name "DW_TAG_label" :doc "Represents labels";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_lexical_block :name "DW_TAG_lexical_block" :doc "Describes lexical blocks";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_lo_user :name "DW_TAG_lo_user";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_member :name "DW_TAG_member" :doc "Represents members of a class";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_MIPS_loop :name "DW_TAG_MIPS_loop";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_module :name "DW_TAG_module" :doc "Describes modules";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_namelist_item :name "DW_TAG_namelist_item" :doc "Represents namelist items";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_namelist :name "DW_TAG_namelist" :doc "Represents namelists";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_namespace :name "DW_TAG_namespace" :doc "Describes namespaces";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_packed_type :name "DW_TAG_packed_type" :doc "Describes packed types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_partial_unit :name "DW_TAG_partial_unit" :doc "Represents partial compilation units";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_pointer_type :name "DW_TAG_pointer_type" :doc "Describes pointer types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_ptr_to_member_type :name "DW_TAG_ptr_to_member_type" :doc "Describes pointer-to-member types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_reference_type :name "DW_TAG_reference_type" :doc "Describes reference types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_restrict_type :name "DW_TAG_restrict_type" :doc "Describes restrict-qualified types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_rvalue_reference_type :name "DW_TAG_rvalue_reference_type"
  :doc "Describes rvalue reference types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_set_type :name "DW_TAG_set_type" :doc "Describes set types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_shared_type :name "DW_TAG_shared_type" :doc "Describes shared types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_skeleton_unit :name "DW_TAG_skeleton_unit" :doc "Represents skeleton compilation units";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_string_type :name "DW_TAG_string_type" :doc "Describes string types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_structure_type :name "DW_TAG_structure_type" :doc "Represents structure types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_subprogram :name "DW_TAG_subprogram" :doc "Describes subprograms (functions/methods)";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_subrange_type :name "DW_TAG_subrange_type" :doc "Describes subrange types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_subroutine_type :name "DW_TAG_subroutine_type" :doc "Describes subroutine types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_template_alias :name "DW_TAG_template_alias" :doc "Represents template aliases";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_template_type_parameter :name "DW_TAG_template_type_parameter"
  :doc "Describes template type parameters";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_template_value_parameter :name "DW_TAG_template_value_parameter"
  :doc "Describes template value parameters";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_thrown_type :name "DW_TAG_thrown_type" :doc "Describes thrown types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_try_block :name "DW_TAG_try_block" :doc "Represents try blocks in exception handling";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_typedef :name "DW_TAG_typedef" :doc "Describes typedefs";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_type_unit :name "DW_TAG_type_unit" :doc "Represents type units";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_union_type :name "DW_TAG_union_type" :doc "Represents union types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_unspecified_parameters :name "DW_TAG_unspecified_parameters"
  :doc "Describes unspecified function parameters";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_unspecified_type :name "DW_TAG_unspecified_type" :doc "Represents unspecified types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_variable :name "DW_TAG_variable" :doc "Describes variables";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_variant :name "DW_TAG_variant" :doc "Represents variants";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_variant_part :name "DW_TAG_variant_part" :doc "Describes variant parts";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_volatile_type :name "DW_TAG_volatile_type" :doc "Describes volatile-qualified types";

dw_cfg.add
  :class "dw-tag"
  :tag DW_TAG_with_stmt :name "DW_TAG_with_stmt" :doc "Represents 'with' statements";

/* DWARF Attributes.  */

var DW_AT_sibling = 0x01,
    DW_AT_location = 0x02,
    DW_AT_name = 0x03,
    /* 0x04 reserved.  */
    /* 0x05 reserved.  */
    /* 0x06 reserved.  */
    /* 0x07 reserved.  */
    /* 0x08 reserved.  */
    DW_AT_ordering = 0x09,
    /* 0x0a reserved.  */
    DW_AT_byte_size = 0x0b,
    DW_AT_bit_offset = 0x0c,
    DW_AT_bit_size = 0x0d,
    /* 0x0e reserved.  */
    /* 0x0f reserved.  */
    DW_AT_stmt_list = 0x10,
    DW_AT_low_pc = 0x11,
    DW_AT_high_pc = 0x12,
    DW_AT_language = 0x13,
    /* 0x14 reserved.  */
    DW_AT_discr = 0x15,
    DW_AT_discr_value = 0x16,
    DW_AT_visibility = 0x17,
    DW_AT_import = 0x18,
    DW_AT_string_length = 0x19,
    DW_AT_common_reference = 0x1a,
    DW_AT_comp_dir = 0x1b,
    DW_AT_const_value = 0x1c,
    DW_AT_containing_type = 0x1d,
    DW_AT_default_value = 0x1e,
    /* 0x1f reserved.  */
    DW_AT_inline = 0x20,
    DW_AT_is_optional = 0x21,
    DW_AT_lower_bound = 0x22,
    /* 0x23 reserved.  */
    /* 0x24 reserved.  */
    DW_AT_producer = 0x25,
    /* 0x26 reserved.  */
    DW_AT_prototyped = 0x27,
    /* 0x28 reserved.  */
    /* 0x29 reserved.  */
    DW_AT_return_addr = 0x2a,
    /* 0x2b reserved.  */
    DW_AT_start_scope = 0x2c,
    /* 0x2d reserved.  */
    DW_AT_bit_stride = 0x2e,
    DW_AT_upper_bound = 0x2f,
    /* 0x30 reserved.  */
    DW_AT_abstract_origin = 0x31,
    DW_AT_accessibility = 0x32,
    DW_AT_address_class = 0x33,
    DW_AT_artificial = 0x34,
    DW_AT_base_types = 0x35,
    DW_AT_calling_convention = 0x36,
    DW_AT_count = 0x37,
    DW_AT_data_member_location = 0x38,
    DW_AT_decl_column = 0x39,
    DW_AT_decl_file = 0x3a,
    DW_AT_decl_line = 0x3b,
    DW_AT_declaration = 0x3c,
    DW_AT_discr_list = 0x3d,
    DW_AT_encoding = 0x3e,
    DW_AT_external = 0x3f,
    DW_AT_frame_base = 0x40,
    DW_AT_friend = 0x41,
    DW_AT_identifier_case = 0x42,
    DW_AT_macro_info = 0x43,
    DW_AT_namelist_item = 0x44,
    DW_AT_priority = 0x45,
    DW_AT_segment = 0x46,
    DW_AT_specification = 0x47,
    DW_AT_static_link = 0x48,
    DW_AT_type = 0x49,
    DW_AT_use_location = 0x4a,
    DW_AT_variable_parameter = 0x4b,
    DW_AT_virtuality = 0x4c,
    DW_AT_vtable_elem_location = 0x4d,
    DW_AT_allocated = 0x4e,
    DW_AT_associated = 0x4f,
    DW_AT_data_location = 0x50,
    DW_AT_byte_stride = 0x51,
    DW_AT_entry_pc = 0x52,
    DW_AT_use_UTF8 = 0x53,
    DW_AT_extension = 0x54,
    DW_AT_ranges = 0x55,
    DW_AT_trampoline = 0x56,
    DW_AT_call_column = 0x57,
    DW_AT_call_file = 0x58,
    DW_AT_call_line = 0x59,
    DW_AT_description = 0x5a,
    DW_AT_binary_scale = 0x5b,
    DW_AT_decimal_scale = 0x5c,
    DW_AT_small = 0x5d,
    DW_AT_decimal_sign = 0x5e,
    DW_AT_digit_count = 0x5f,
    DW_AT_picture_string = 0x60,
    DW_AT_mutable = 0x61,
    DW_AT_threads_scaled = 0x62,
    DW_AT_explicit = 0x63,
    DW_AT_object_pointer = 0x64,
    DW_AT_endianity = 0x65,
    DW_AT_elemental = 0x66,
    DW_AT_pure = 0x67,
    DW_AT_recursive = 0x68,
    DW_AT_signature = 0x69,
    DW_AT_main_subprogram = 0x6a,
    DW_AT_data_bit_offset = 0x6b,
    DW_AT_const_expr = 0x6c,
    DW_AT_enum_class = 0x6d,
    DW_AT_linkage_name = 0x6e,
    DW_AT_string_length_bit_size = 0x6f,
    DW_AT_string_length_byte_size = 0x70,
    DW_AT_rank = 0x71,
    DW_AT_str_offsets_base = 0x72,
    DW_AT_addr_base = 0x73,
    DW_AT_rnglists_base = 0x74,
    /* 0x75 reserved.  */
    DW_AT_dwo_name = 0x76,
    DW_AT_reference = 0x77,
    DW_AT_rvalue_reference = 0x78,
    DW_AT_macros = 0x79,
    DW_AT_call_all_calls = 0x7a,
    DW_AT_call_all_source_calls = 0x7b,
    DW_AT_call_all_tail_calls = 0x7c,
    DW_AT_call_return_pc = 0x7d,
    DW_AT_call_value = 0x7e,
    DW_AT_call_origin = 0x7f,
    DW_AT_call_parameter = 0x80,
    DW_AT_call_pc = 0x81,
    DW_AT_call_tail_call = 0x82,
    DW_AT_call_target = 0x83,
    DW_AT_call_target_clobbered = 0x84,
    DW_AT_call_data_location = 0x85,
    DW_AT_call_data_value = 0x86,
    DW_AT_noreturn = 0x87,
    DW_AT_alignment = 0x88,
    DW_AT_export_symbols = 0x89,
    DW_AT_deleted = 0x8a,
    DW_AT_defaulted = 0x8b,
    DW_AT_loclists_base = 0x8c,
    DW_AT_lo_user = 0x2000,
    DW_AT_MIPS_fde = 0x2001,
    DW_AT_MIPS_loop_begin = 0x2002,
    DW_AT_MIPS_tail_loop_begin = 0x2003,
    DW_AT_MIPS_epilog_begin = 0x2004,
    DW_AT_MIPS_loop_unroll_factor = 0x2005,
    DW_AT_MIPS_software_pipeline_depth = 0x2006,
    DW_AT_MIPS_linkage_name = 0x2007,
    DW_AT_MIPS_stride = 0x2008,
    DW_AT_MIPS_abstract_name = 0x2009,
    DW_AT_MIPS_clone_origin = 0x200a,
    DW_AT_MIPS_has_inlines = 0x200b,
    DW_AT_MIPS_stride_byte = 0x200c,
    DW_AT_MIPS_stride_elem = 0x200d,
    DW_AT_MIPS_ptr_dopetype = 0x200e,
    DW_AT_MIPS_allocatable_dopetype = 0x200f,
    DW_AT_MIPS_assumed_shape_dopetype = 0x2010,
    DW_AT_MIPS_assumed_size = 0x2011,
    /* GNU extensions.  */
    DW_AT_sf_names = 0x2101,
    DW_AT_src_info = 0x2102,
    DW_AT_mac_info = 0x2103,
    DW_AT_src_coords = 0x2104,
    DW_AT_body_begin = 0x2105,
    DW_AT_body_end = 0x2106,
    DW_AT_GNU_vector = 0x2107,
    DW_AT_GNU_guarded_by = 0x2108,
    DW_AT_GNU_pt_guarded_by = 0x2109,
    DW_AT_GNU_guarded = 0x210a,
    DW_AT_GNU_pt_guarded = 0x210b,
    DW_AT_GNU_locks_excluded = 0x210c,
    DW_AT_GNU_exclusive_locks_required = 0x210d,
    DW_AT_GNU_shared_locks_required = 0x210e,
    DW_AT_GNU_odr_signature = 0x210f,
    DW_AT_GNU_template_name = 0x2110,
    DW_AT_GNU_call_site_value = 0x2111,
    DW_AT_GNU_call_site_data_value = 0x2112,
    DW_AT_GNU_call_site_target = 0x2113,
    DW_AT_GNU_call_site_target_clobbered = 0x2114,
    DW_AT_GNU_tail_call = 0x2115,
    DW_AT_GNU_all_tail_call_sites = 0x2116,
    DW_AT_GNU_all_call_sites = 0x2117,
    DW_AT_GNU_all_source_call_sites = 0x2118,
    DW_AT_GNU_locviews = 0x2137,
    DW_AT_GNU_entry_view = 0x2138,
    DW_AT_GNU_macros = 0x2119,
    DW_AT_GNU_deleted = 0x211a,
    /* GNU Debug Fission extensions.  */
    DW_AT_GNU_dwo_name = 0x2130,
    DW_AT_GNU_dwo_id = 0x2131,
    DW_AT_GNU_ranges_base = 0x2132,
    DW_AT_GNU_addr_base = 0x2133,
    DW_AT_GNU_pubnames = 0x2134,
    DW_AT_GNU_pubtypes = 0x2135,
    /* https://gcc.gnu.org/wiki/DW_AT_GNU_numerator_denominator  */
    DW_AT_GNU_numerator = 0x2303,
    DW_AT_GNU_denominator = 0x2304,
    /* https://gcc.gnu.org/wiki/DW_AT_GNU_bias  */
    DW_AT_GNU_bias = 0x2305,
    DW_AT_hi_user = 0x3ff;

/* DWARF Attributes  */

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_abstract_origin
  :name "DW_AT_abstract_origin"
  :doc "Inline instances of inline subprograms Out-of-line instances of inline \
subprograms";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_accessibility
  :name "DW_AT_accessibility"
  :doc "Access declaration (C++, Ada), Accessibility of base or inherited class \
(C++), Accessibility of data member or member function";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_addr_base
  :name "DW_AT_addr_base"
  :doc "Base offset for address table";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_address_class
  :name "DW_AT_address_class"
  :doc "Pointer or reference typesi, Subroutine or subroutine type";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_alignment
  :name "DW_AT_alignment"
  :doc "Non-default alignment of type, subprogram or variable";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_allocated
  :name "DW_AT_allocated"
  :doc "Allocation status of types";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_artificial
  :name "DW_AT_artificial"
  :doc "Objects or types that are not actually declared in the source";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_associated
  :name "DW_AT_associated"
  :doc "Association status of types";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_base_types
  :name "DW_AT_base_types"
  :doc "Primitive data types of compilation unit";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_binary_scale
  :name "DW_AT_binary_scale"
  :doc "Binary scale factor for fixed-point type";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_bit_offset
  :name "DW_AT_bit_offset";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_bit_size
  :name "DW_AT_bit_size"
  :doc "Size of a base type in bits, Size of a data member in bits";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_bit_stride
  :name "DW_AT_bit_stride"
  :doc "Array element stride (of array type), Subrange stride (dimension of \
array type), Enumeration stride (dimension of array type)";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_body_begin
  :name "DW_AT_body_begin";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_body_end
  :name "DW_AT_body_end";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_byte_size
  :name "DW_AT_byte_size"
  :doc "Size of a data object or data type in bytes";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_byte_stride
  :name "DW_AT_byte_stride"
  :doc "Array element stride (of array type), Subrange stride (dimension of \
array type), Enumeration stride (dimension of array type)";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_all_calls
  :name "DW_AT_call_all_calls"
  :doc "All tail and normal calls in a subprogram are described by call site \
entries";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_all_source_calls
  :name "DW_AT_call_all_source_calls"
  :doc "All tail, normal and inlined calls in a subprogram are described by \
call site and inlined subprogram entries";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_all_tail_calls
  :name "DW_AT_call_all_tail_calls"
  :doc "All tail calls in a subprogram are described by call site entries";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_column
  :name "DW_AT_call_column"
  :doc "Column position of inlined subroutine call, Column position of call \
site of non-inlined call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_data_location
  :name "DW_AT_call_data_location"
  :doc "Address of the value pointed to by an argument passed in a call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_data_value
  :name "DW_AT_call_data_value"
  :doc "Value pointed to by an argument passed in a call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_file
  :name "DW_AT_call_file"
  :doc "File containing inlined subroutine call, File containing call site of \
non-inlined call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_calling_convention
  :name "DW_AT_calling_convention";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_line
  :name "DW_AT_call_line"
  :doc "Line number of inlined subroutine call, Line containing call site of \
non-inlined call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_origin
  :name "DW_AT_call_origin"
  :doc "Subprogram called in a call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_parameter
  :name "DW_AT_call_parameter"
  :doc "Parameter entry in a call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_pc
  :name "DW_AT_call_pc"
  :doc "Address of the call instruction in a call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_return_pc
  :name "DW_AT_call_return_pc"
  :doc "Return address from a call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_tail_call
  :name "DW_AT_call_tail_call"
  :doc "Call is a tail call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_target_clobbered
  :name "DW_AT_call_target_clobbered"
  :doc "Address of called routine, which may be clobbered, in a call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_target
  :name "DW_AT_call_target"
  :doc "Address of called routine in a call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_call_value
  :name "DW_AT_call_value"
  :doc "Argument value passed in a call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_common_reference
  :name "DW_AT_common_reference"
  :doc "Common block usage";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_comp_dir
  :name "DW_AT_comp_dir"
  :doc "Compilation directory";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_const_expr
  :name "DW_AT_const_expr"
  :doc "Compile-time constant object, Compile-time constant function";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_const_value
  :name "DW_AT_const_value"
  :doc "Constant object, Enumeration literal value, Template value parameter";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_containing_type
  :name "DW_AT_containing_type"
  :doc "Containing type of pointer to member type";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_count
  :name "DW_AT_count"
  :doc "Elements of subrange type";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_data_bit_offset
  :name "DW_AT_data_bit_offset"
  :doc "Base type bit location, Data member bit location";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_data_location
  :name "DW_AT_data_location"
  :doc "Indirection to actual data";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_data_member_location
  :name "DW_AT_data_member_location"
  :doc "Data member location, Inherited member location";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_decimal_scale
  :name "DW_AT_decimal_scale"
  :doc "Decimal scale factor";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_decimal_sign
  :name "DW_AT_decimal_sign"
  :doc "Decimal sign representation";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_declaration
  :name "DW_AT_declaration"
  :doc "Incomplete, non-defining, or separate entity, declaration";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_decl_column
  :name "DW_AT_decl_column"
  :doc "Column position of source declaration";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_decl_file
  :name "DW_AT_decl_file"
  :doc "File containing source declaration";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_decl_line
  :name "DW_AT_decl_line"
  :doc "Line number of source declaration";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_defaulted
  :name "DW_AT_defaulted"
  :doc "Whether a member function has been declared as default";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_default_value
  :name "DW_AT_default_value"
  :doc "Default value of parameter";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_deleted
  :name "DW_AT_deleted"
  :doc "Whether a member has been declared as deleted";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_description
  :name "DW_AT_description"
  :doc "Artificial name or description";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_digit_count
  :name "DW_AT_digit_count"
  :doc "Digit count for packed decimal or numeric string type";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_discr_list
  :name "DW_AT_discr_list"
  :doc "List of discriminant values";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_discr
  :name "DW_AT_discr"
  :doc "Discriminant of variant part";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_discr_value
  :name "DW_AT_discr_value"
  :doc "Discriminant value";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_dwo_name
  :name "DW_AT_dwo_name"
  :doc "Name of split DWARF object file";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_elemental
  :name "DW_AT_elemental"
  :doc "Elemental property of a subroutine";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_encoding
  :name "DW_AT_encoding"
  :doc "Encoding of base type";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_endianity
  :name "DW_AT_endianity"
  :doc "Endianity of data";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_entry_pc
  :name "DW_AT_entry_pc"
  :doc "Entry address of a scope (compilation unit, subprogram, and so on)";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_enum_class
  :name "DW_AT_enum_class"
  :doc "Type safe enumeration definition";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_explicit
  :name "DW_AT_explicit"
  :doc "Explicit property of member function";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_export_symbols
  :name "DW_AT_export_symbols"
  :doc "Export (inline) symbols of namespace, Export symbols of a structure, \
union or class";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_extension
  :name "DW_AT_extension"
  :doc "Previous namespace extension or original namespace";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_external
  :name "DW_AT_external"
  :doc "External subroutine, External variable";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_frame_base
  :name "DW_AT_frame_base"
  :doc "Subroutine frame base address";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_friend
  :name "DW_AT_friend"
  :doc "Friend relationship";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_addr_base
  :name "DW_AT_GNU_addr_base";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_all_call_sites
  :name "DW_AT_GNU_all_call_sites";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_all_source_call_sites
  :name "DW_AT_GNU_all_source_call_sites";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_all_tail_call_sites
  :name "DW_AT_GNU_all_tail_call_sites";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_bias
  :name "DW_AT_GNU_bias";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_call_site_data_value
  :name "DW_AT_GNU_call_site_data_value";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_call_site_target_clobbered
  :name "DW_AT_GNU_call_site_target_clobbered";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_call_site_target
  :name "DW_AT_GNU_call_site_target";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_call_site_value
  :name "DW_AT_GNU_call_site_value";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_deleted
  :name "DW_AT_GNU_deleted";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_denominator
  :name "DW_AT_GNU_denominator";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_dwo_id
  :name "DW_AT_GNU_dwo_id";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_dwo_name
  :name "DW_AT_GNU_dwo_name";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_entry_view
  :name "DW_AT_GNU_entry_view";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_exclusive_locks_required
  :name "DW_AT_GNU_exclusive_locks_required";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_guarded_by
  :name "DW_AT_GNU_guarded_by";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_guarded
  :name "DW_AT_GNU_guarded";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_locks_excluded
  :name "DW_AT_GNU_locks_excluded";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_locviews
  :name "DW_AT_GNU_locviews";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_macros
  :name "DW_AT_GNU_macros";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_numerator
  :name "DW_AT_GNU_numerator";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_odr_signature
  :name "DW_AT_GNU_odr_signature";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_pt_guarded_by
  :name "DW_AT_GNU_pt_guarded_by";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_pt_guarded
  :name "DW_AT_GNU_pt_guarded";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_pubnames
  :name "DW_AT_GNU_pubnames";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_pubtypes
  :name "DW_AT_GNU_pubtypes";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_ranges_base
  :name "DW_AT_GNU_ranges_base";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_shared_locks_required
  :name "DW_AT_GNU_shared_locks_required";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_tail_call
  :name "DW_AT_GNU_tail_call";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_template_name
  :name "DW_AT_GNU_template_name";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_GNU_vector
  :name "DW_AT_GNU_vector";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_high_pc
  :name "DW_AT_high_pc"
  :doc "Contiguous range of code addresses";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_hi_user
  :name "DW_AT_hi_user";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_identifier_case
  :name "DW_AT_identifier_case"
  :doc "Identifier case rule";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_import
  :name "DW_AT_import"
  :doc "Imported declaration, Imported unit, Namespace alias, Namespace using \
declaration, Namespace using directive";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_inline
  :name "DW_AT_inline"
  :doc "Abstract instance, Inlined subroutine";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_is_optional
  :name "DW_AT_is_optional"
  :doc "Optional parameter";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_language
  :name "DW_AT_language"
  :doc "Programming language";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_linkage_name
  :name "DW_AT_linkage_name"
  :doc "Object file linkage name of an entity";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_location
  :name "DW_AT_location"
  :doc "Data object location";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_loclists_base
  :name "DW_AT_loclists_base"
  :doc "Location lists base";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_lo_user
  :name "DW_AT_lo_user";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_lower_bound
  :name "DW_AT_lower_bound"
  :doc "Lower bound of subrange";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_low_pc
  :name "DW_AT_low_pc"
  :doc "Code address or range of addresses, Base address of scope";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_mac_info
  :name "DW_AT_mac_info";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_macro_info
  :name "DW_AT_macro_info"
  :doc "Macro preprocessor information (legacy), (reserved for coexistence \
with DWARF Version 4, and earlier)";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_macros
  :name "DW_AT_macros"
  :doc "Macro preprocessor information (#define, #undef, and so on in C, C++ \
and similar languages)";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_main_subprogram
  :name "DW_AT_main_subprogram"
  :doc "Main or starting subprogram, Unit containing main or starting subprogram";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_abstract_name
  :name "DW_AT_MIPS_abstract_name";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_allocatable_dopetype
  :name "DW_AT_MIPS_allocatable_dopetype";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_assumed_shape_dopetype
  :name "DW_AT_MIPS_assumed_shape_dopetype";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_assumed_size
  :name "DW_AT_MIPS_assumed_size";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_clone_origin
  :name "DW_AT_MIPS_clone_origin";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_epilog_begin
  :name "DW_AT_MIPS_epilog_begin";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_fde
  :name "DW_AT_MIPS_fde";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_has_inlines
  :name "DW_AT_MIPS_has_inlines";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_linkage_name
  :name "DW_AT_MIPS_linkage_name";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_loop_begin
  :name "DW_AT_MIPS_loop_begin";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_loop_unroll_factor
  :name "DW_AT_MIPS_loop_unroll_factor";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_ptr_dopetype
  :name "DW_AT_MIPS_ptr_dopetype";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_software_pipeline_depth
  :name "DW_AT_MIPS_software_pipeline_depth";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_stride_byte
  :name "DW_AT_MIPS_stride_byte";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_stride_elem
  :name "DW_AT_MIPS_stride_elem";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_stride
  :name "DW_AT_MIPS_stride";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_MIPS_tail_loop_begin
  :name "DW_AT_MIPS_tail_loop_begin";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_mutable
  :name "DW_AT_mutable"
  :doc "Mutable property of member data";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_namelist_item
  :name "DW_AT_namelist_item"
  :doc "Namelist item";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_name
  :name "DW_AT_name"
  :doc "Name of declaration, Path name of compilation source";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_noreturn
  :name "DW_AT_noreturn"
  :doc "“no return” property of a subprogram";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_object_pointer
  :name "DW_AT_object_pointer"
  :doc "Object (this, self) pointer of member function";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_ordering
  :name "DW_AT_ordering"
  :doc "Array row/column ordering";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_picture_string
  :name "DW_AT_picture_string"
  :doc "Picture string for numeric string type";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_priority
  :name "DW_AT_priority"
  :doc "Module priority";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_producer
  :name "DW_AT_producer"
  :doc "Compiler identification";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_prototyped
  :name "DW_AT_prototyped"
  :doc "Subroutine prototype";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_pure
  :name "DW_AT_pure"
  :doc "Pure property of a subroutine";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_ranges
  :name "DW_AT_ranges"
  :doc "Non-contiguous range of code addresses";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_rank
  :name "DW_AT_rank"
  :doc "Dynamic number of array dimensions";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_recursive
  :name "DW_AT_recursive"
  :doc "Recursive property of a subroutine";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_reference
  :name "DW_AT_reference"
  :doc "&-qualified non-static member function (C++)";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_return_addr
  :name "DW_AT_return_addr"
  :doc "Subroutine return address save location";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_rnglists_base
  :name "DW_AT_rnglists_base"
  :doc "Base offset for range lists";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_rvalue_reference
  :name "DW_AT_rvalue_reference"
  :doc "&&-qualified non-static member function (C++)";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_segment
  :name "DW_AT_segment"
  :doc "Addressing information";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_sf_names
  :name "DW_AT_sf_names";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_sibling
  :name "DW_AT_sibling"
  :doc "Debugging information entry relationship";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_signature
  :name "DW_AT_signature"
  :doc "Type signature";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_small
  :name "DW_AT_small"
  :doc "Scale factor for fixed-point type";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_specification
  :name "DW_AT_specification"
  :doc "Incomplete, non-defining, or separate declaration corresponding \
to a declaration";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_src_coords
  :name "DW_AT_src_coords";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_src_info
  :name "DW_AT_src_info";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_start_scope
  :name "DW_AT_start_scope"
  :doc "Reduced scope of declaration";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_static_link
  :name "DW_AT_static_link"
  :doc "Location of uplevel frame";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_stmt_list
  :name "DW_AT_stmt_list"
  :doc "Line number information for unit";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_string_length_bit_size
  :name "DW_AT_string_length_bit_size"
  :doc "Size of string length of string type";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_string_length_byte_size
  :name "DW_AT_string_length_byte_size"
  :doc "Size of string length of string type";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_string_length
  :name "DW_AT_string_length"
  :doc "String length of string type";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_str_offsets_base
  :name "DW_AT_str_offsets_base"
  :doc "Base of string offsets table";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_threads_scaled
  :name "DW_AT_threads_scaled"
  :doc "Array bound THREADS scale factor (UPC)";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_trampoline
  :name "DW_AT_trampoline"
  :doc "Target subroutine";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_type
  :name "DW_AT_type"
  :doc "Type of call site, Type of string type components, Type of subroutine \
return, Type of declaration";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_upper_bound
  :name "DW_AT_upper_bound"
  :doc "Upper bound of subrange";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_use_location
  :name "DW_AT_use_location"
  :doc "Member location for pointer to member type";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_use_UTF8
  :name "DW_AT_use_UTF8"
  :doc "Compilation unit uses UTF-8 strings";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_variable_parameter
  :name "DW_AT_variable_parameter"
  :doc "Non-constant parameter flag";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_virtuality
  :name "DW_AT_virtuality"
  :doc "Virtuality attribute";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_visibility
  :name "DW_AT_visibility"
  :doc "Visibility of declaration";

dw_cfg.add
  :class "dw-at"
  :tag DW_AT_vtable_elem_location
  :name "DW_AT_vtable_elem_location"
  :doc "Virtual function vtable slot";

/* DWARF form encodings.  */

var DW_FORM_addr = 0x01,
    DW_FORM_block2 = 0x03,
    DW_FORM_block4 = 0x04,
    DW_FORM_data2 = 0x05,
    DW_FORM_data4 = 0x06,
    DW_FORM_data8 = 0x07,
    DW_FORM_string = 0x08,
    DW_FORM_block = 0x09,
    DW_FORM_block1 = 0x0a,
    DW_FORM_data1 = 0x0b,
    DW_FORM_flag = 0x0c,
    DW_FORM_sdata = 0x0d,
    DW_FORM_strp = 0x0e,
    DW_FORM_udata = 0x0f,
    DW_FORM_ref_addr = 0x10,
    DW_FORM_ref1 = 0x11,
    DW_FORM_ref2 = 0x12,
    DW_FORM_ref4 = 0x13,
    DW_FORM_ref8 = 0x14,
    DW_FORM_ref_udata = 0x15,
    DW_FORM_indirect = 0x16,
    DW_FORM_sec_offset = 0x17,
    DW_FORM_exprloc = 0x18,
    DW_FORM_flag_present = 0x19,
    DW_FORM_strx = 0x1a,
    DW_FORM_addrx = 0x1b,
    DW_FORM_ref_sup4 = 0x1c,
    DW_FORM_strp_sup = 0x1d,
    DW_FORM_data16 = 0x1e,
    DW_FORM_line_strp = 0x1f,
    DW_FORM_ref_sig8 = 0x20,
    DW_FORM_implicit_const = 0x21,
    DW_FORM_loclistx = 0x22,
    DW_FORM_rnglistx = 0x23,
    DW_FORM_ref_sup8 = 0x24,
    DW_FORM_strx1 = 0x25,
    DW_FORM_strx2 = 0x26,
    DW_FORM_strx3 = 0x27,
    DW_FORM_strx4 = 0x28,
    DW_FORM_addrx1 = 0x29,
    DW_FORM_addrx2 = 0x2a,
    DW_FORM_addrx3 = 0x2b,
    DW_FORM_addrx4 = 0x2c,
    /* GNU Debug Fission extensions.  */
    DW_FORM_GNU_addr_index = 0x1f01,
    DW_FORM_GNU_str_index = 0x1f02,
    DW_FORM_GNU_ref_alt = 0x1f20,
    DW_FORM_GNU_strp_alt = 0x1f21;

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_addr :name "DW_FORM_addr" :doc "Address";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_addrx1 :name "DW_FORM_addrx1" :doc "Address";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_addrx2 :name "DW_FORM_addrx2" :doc "Address";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_addrx3 :name "DW_FORM_addrx3" :doc "Address";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_addrx4 :name "DW_FORM_addrx4" :doc "Address";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_addrx :name "DW_FORM_addrx" :doc "Address";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_block1 :name "DW_FORM_block1" :doc "Block";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_block2 :name "DW_FORM_block2" :doc "Block";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_block4 :name "DW_FORM_block4" :doc "Block";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_block :name "DW_FORM_block" :doc "Block";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_data16 :name "DW_FORM_data16" :doc "Data";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_data1 :name "DW_FORM_data1" :doc "Data";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_data2 :name "DW_FORM_data2" :doc "Data";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_data4 :name "DW_FORM_data4" :doc "Data";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_data8 :name "DW_FORM_data8" :doc "Data";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_exprloc :name "DW_FORM_exprloc" :doc "Expression Location";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_flag :name "DW_FORM_flag" :doc "Flag";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_flag_present :name "DW_FORM_flag_present" :doc "Flag (Implicitly present)";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_GNU_addr_index :name "DW_FORM_GNU_addr_index";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_GNU_ref_alt :name "DW_FORM_GNU_ref_alt";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_GNU_str_index :name "DW_FORM_GNU_str_index";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_GNU_strp_alt :name "DW_FORM_GNU_strp_alt";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_implicit_const :name "DW_FORM_implicit_const" :doc "Implicit Constant";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_indirect :name "DW_FORM_indirect" :doc "Indirect Form";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_line_strp :name "DW_FORM_line_strp" :doc "Offset into a string table";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_loclistx :name "DW_FORM_loclistx" :doc "Index into the .debug_loclists section";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_ref1 :name "DW_FORM_ref1" :doc "Reference";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_ref2 :name "DW_FORM_ref2" :doc "Reference";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_ref4 :name "DW_FORM_ref4" :doc "Reference";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_ref8 :name "DW_FORM_ref8" :doc "Reference";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_ref_addr :name "DW_FORM_ref_addr" :doc "Reference Address";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_ref_sig8 :name "DW_FORM_ref_sig8" :doc "Reference Signature";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_ref_sup4 :name "DW_FORM_ref_sup4" :doc "Reference Supplemental Data 4";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_ref_sup8 :name "DW_FORM_ref_sup8" :doc "Reference Supplemental Data 8";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_ref_udata :name "DW_FORM_ref_udata" :doc "Reference (Unsigned)";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_rnglistx :name "DW_FORM_rnglistx" :doc "Range List";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_sdata :name "DW_FORM_sdata" :doc "Signed Data";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_sec_offset :name "DW_FORM_sec_offset" :doc "Section Offset";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_string :name "DW_FORM_string" :doc "String";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_strp :name "DW_FORM_strp" :doc "As an offset into a string table";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_strp_sup :name "DW_FORM_strp_sup" :doc "String Pointer (Supplementary)";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_strx1 :name "DW_FORM_strx1" :doc "Indirect offset into the string table";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_strx2 :name "DW_FORM_strx2" :doc "Indirect offset into the string table";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_strx3 :name "DW_FORM_strx3" :doc "Indirect offset into the string table";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_strx4 :name "DW_FORM_strx4" :doc "Indirect offset into the string table";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_strx :name "DW_FORM_strx" :doc "Indirect offset into the string table";

dw_cfg.add
  :class "dw-form"
  :tag DW_FORM_udata :name "DW_FORM_udata" :doc "Data";

/* Contributions are stored in .debug_info sections.  */

type Dwarf_CU_Header =
  struct
  {
    /* Length of the .debug_info contribution for this CU, not
       including the length field itself.  */
    Dwarf_Initial_Length unit_length;

/* Version of the DWARF information for the compilation unit.  */
    uint<16> version : (version in [2UH, 3UH, 4UH, 5UH]
                        && dwarf_set_version (version));

/* Offset into the .debug_abbrev section that associates the
       compilation unit with a particular set of debugging information
       entry abbreviations.  */
    Dwarf_Section_Offset debug_abbrev_offset;

/* Size of an address on the target architecture.  */
    offset<uint<8>,B> address_size;
  };
0707010000000E000081A40000000000000000000000016554D9F6000028F4000000000000000000000000000000000000002900000000poke-dwarf-0.1~git20231115/dwarf-line.pk/* dwarf-line.pk - DWARF abbrev tables support for GNU poke.  */

load leb128;
load elf;
load "dwarf-info.pk";

/* Line number header entry format encodings */

var DW_LNCT_path = 0x1,
    DW_LNCT_directory_index = 0x2,
    DW_LNCT_timestamp = 0x3,
    DW_LNCT_size = 0x4,
    DW_LNCT_MD5 = 0x5,
    DW_LNCT_lo_user = 0x2000,
    DW_LNCT_hi_user = 0x3f;

dw_cfg.add
  :class "dw-lnct"
  :tag DW_LNCT_path :name "DW_LNCT_path";

dw_cfg.add
  :class "dw-lnct"
  :tag DW_LNCT_directory_index :name "DW_LNCT_directory_index";

dw_cfg.add
  :class "dw-lnct"
  :tag DW_LNCT_timestamp :name "DW_LNCT_timestamp";

dw_cfg.add
  :class "dw-lnct"
  :tag DW_LNCT_size :name "DW_LNCT_size";

dw_cfg.add
  :class "dw-lnct"
  :tag DW_LNCT_MD5 :name "DW_LNCT_MD5";

dw_cfg.add
  :class "dw-lnct"
  :tag DW_LNCT_lo_user :name "DW_LNCT_lo_user";

dw_cfg.add
  :class "dw-lnct"
  :tag DW_LNCT_hi_user :name "DW_LNCT_hi_user";

/* Standard Opcodes */

var DW_LNS_copy = 0x01,
    DW_LNS_advance_pc = 0x02,
    DW_LNS_advance_line = 0x03,
    DW_LNS_set_file = 0x04,
    DW_LNS_set_column = 0x05,
    DW_LNS_negate_stmt = 0x06,
    DW_LNS_set_basic_block = 0x07,
    DW_LNS_const_add_pc = 0x08,
    DW_LNS_fixed_advance_pc = 0x09,
    DW_LNS_set_prologue_end = 0x0a,
    DW_LNS_set_epilogue_begin = 0x0b,
    DW_LNS_set_isa = 0x0c;

dw_cfg.add
  :class "dw-lns"
  :tag DW_LNS_copy :name "DW_LNS_copy";

dw_cfg.add
  :class "dw-lns"
  :tag DW_LNS_advance_pc :name "DW_LNS_advance_pc";

dw_cfg.add
  :class "dw-lns"
  :tag DW_LNS_advance_line :name "DW_LNS_advance_line";

dw_cfg.add
  :class "dw-lns"
  :tag DW_LNS_set_file :name "DW_LNS_set_file";

dw_cfg.add
  :class "dw-lns"
  :tag DW_LNS_set_column :name "DW_LNS_set_column";

dw_cfg.add
  :class "dw-lns"
  :tag DW_LNS_negate_stmt :name "DW_LNS_negate_stmt";

dw_cfg.add
  :class "dw-lns"
  :tag DW_LNS_set_basic_block :name "DW_LNS_set_basic_block";

dw_cfg.add
  :class "dw-lns"
  :tag DW_LNS_const_add_pc :name "DW_LNS_const_add_pc";

dw_cfg.add
  :class "dw-lns"
  :tag DW_LNS_fixed_advance_pc :name "DW_LNS_fixed_advance_pc";

dw_cfg.add
  :class "dw-lns"
  :tag DW_LNS_set_prologue_end :name "DW_LNS_set_prologue_end";

dw_cfg.add
  :class "dw-lns"
  :tag DW_LNS_set_epilogue_begin :name "DW_LNS_set_epilogue_begin";

dw_cfg.add
  :class "dw-lns"
  :tag DW_LNS_set_isa :name "DW_LNS_set_isa";

type Dwarf_Line_Entry_Fmt =
  struct
  {
    ULEB128 content_type : dw_cfg.entry_p ("dw-lnct", content_type.value);
    ULEB128 form_code : dw_cfg.entry_p ("dw-form", form_code.value);

method _print = void:
      {
        printf("#<%s, %s>", dw_cfg.get_name ("dw-lnct", content_type.value),
                            dw_cfg.get_name ("dw-form", form_code.value));
      }
  };

type Dwarf_Line_Hdr_V5 =
  struct
  {
    uint<32> unit_length;
    uint<16> version : version == 5;
    offset<uint<8>,B> address_size ;
    offset<uint<8>,B> segment_selector_size;
    offset<uint<32>,B> header_length;
    offset<uint<8>,B> minimum_instruction_length;
    uint<8> maximum_operations_per_instruction;
    uint<8> default_is_stmt;
    int<8> line_base;
    uint<8> line_range;
    uint<8> opcode_base : dw_cfg.entry_p("dw-lns", opcode_base) ||
                           opcode_base >= 13;
    uint<8>[opcode_base - 1] standard_opcode_lengths;
    uint<8> directory_entry_format_count;
    Dwarf_Line_Entry_Fmt[directory_entry_format_count] directory_entry_format;
    ULEB128 directories_count;
    fun dirs_payload_size = uint<8>:
      {
        var payload_bytes = 0;
        for (var i = 0; i < directories_count.value; i++)
          for (var j = 0; j < directory_entry_format_count; j++)
            {
              var ct = directory_entry_format[j].content_type.value;
              var fc = directory_entry_format[j].form_code.value;
              if ((ct == DW_LNCT_path) && (fc == DW_FORM_line_strp))
                payload_bytes += 4;
              else
                raise Exception { code = 256,
                                  msg = format("unknown file name entry format (dw-lnct 0x%u8x, dw-form 0x%u8x)", ct, fc) };
            }
          return payload_bytes;
      }
    // Directory Payload
    uint<8>[dirs_payload_size];
    uint<8> file_name_entry_format_count;
    Dwarf_Line_Entry_Fmt[file_name_entry_format_count] file_name_entry_format; // offset: 39, size: 4
    ULEB128 file_names_count;
    fun files_payload_size = uint<8>:
      {
        var payload_bytes = 0;
        for (var i = 0; i < file_names_count.value; i++)
          for (var j = 0; j < file_name_entry_format_count; j++)
            {
              var ct = file_name_entry_format[j].content_type.value;
              var fc = file_name_entry_format[j].form_code.value;
              if ((ct == DW_LNCT_path) && (fc == DW_FORM_line_strp))
                payload_bytes += 4;
              else if ((ct == DW_LNCT_directory_index) && (fc == DW_FORM_udata))
                payload_bytes += 1;
              else if ((ct == DW_LNCT_MD5) && (fc == DW_FORM_data16))
                // This is how clang encodes the md5sum
                payload_bytes += 16;
              else
                raise Exception { code = 257,
                                  msg = format("unknown file name entry format (dw-lnct 0x%u8x, dw-form 0x%u8x)", ct, fc) };
            }
            return payload_bytes;
      }
    // Files Payload
    uint<8>[files_payload_size];

/* Given an offset into the ELF file's .debug_line_str section, return
     * the source file directories as array of strings.  The array index
     * will express the DWARF directory index, and helps to match the source
     * file with its respective path. */
    method get_dirs = (Elf64_Off offset) string[]:
      {
        var retval = string[directories_count.value]();
        var _tmp_string = "";
        var off = directories_count'offset + directories_count'size;
        for (var i = 0; i < directories_count.value; i++)
          {
            _tmp_string = "";
            for (var j = 0; j < directory_entry_format_count; j++)
              {
                var ct = directory_entry_format[j].content_type.value;
                var fc = directory_entry_format[j].form_code.value;
                if ((ct == DW_LNCT_path) && (fc == DW_FORM_line_strp))
                  {
                    var strtab_off = offset<uint<32>,B> @ off;
                    _tmp_string = string @ offset + strtab_off;
                  }
                if (_tmp_string != "")
                    retval[i] = _tmp_string;
                else
                  raise Exception { code = 258, msg = format("Failed getting source dir #%u8d\n", i) };
              }
          }
          return retval;
      }

/* Given an offset into the ELF file's .debug_line_str section, return
     * the source files as array of strings. */
    method get_files = (Elf64_Off offset) string[]:
      {
        // The upper limit for the source files count is 256.  This aligns to
        // elfutil's readelf.c where we have struct encpair enc[256];
        var retval = string[file_names_count.value]();
        var _tmp_off = file_names_count'offset + file_names_count'size;
        var _file_name = "";
        var _dir_index_unset = -1;
        var _dir_index = _dir_index_unset;
         for (var i = 0; i < file_names_count.value; i++)
           {
           _file_name = "";
           _dir_index = _dir_index_unset;
           for (var j = 0; j < file_name_entry_format_count; j++)
             {
               var ct = file_name_entry_format[j].content_type.value;
               var fc = file_name_entry_format[j].form_code.value;
               if ((ct == DW_LNCT_path) && (fc == DW_FORM_line_strp))
                 {
                   var _strtab_off = offset<uint<32>,B> @ _tmp_off;
                   _tmp_off += _strtab_off'size;
                   _file_name = string @ offset + _strtab_off;
                 }
               if ((ct == DW_LNCT_directory_index) && (fc == DW_FORM_udata))
                 {
                   var _tmp_dirindex = ULEB128 @ _tmp_off;
                   _tmp_off += _tmp_dirindex'size;
                   _dir_index = _tmp_dirindex.value;
                 }
               if ((ct == DW_LNCT_MD5) && (fc == DW_FORM_data16))
                 {
                   // This is how clang encodes the md5sum, skip it
                  _tmp_off += 16#B;
                 }
             }
             if ((_file_name != "") && (_dir_index != _dir_index_unset))
               {
                 var _tmp_dir = string[directories_count.value]();
                 _tmp_dir = get_dirs(offset);
                 retval[i] = _tmp_dir[_dir_index] + "/" + _file_name;
               }
             else
              raise Exception { code = 259, msg = format("Failed getting source file #%u8d\n", i) };
           }
        return retval;
      }
    };

type Dwarf_Line_Hdr_V4 =
  struct
    {
      type Nonempty_String =
        struct
          {
            string item : item != "";
          };
      uint<32> unit_length;
      uint<16> version : version == 4;
      offset<uint<32>,B> header_length;
      offset<uint<8>,B> minimum_instruction_length;
      uint<8> maximum_operations_per_instruction;
      uint<8> default_is_stmt;
      int<8> line_base;
      uint<8> line_range;
      uint<8> opcode_base : dw_cfg.entry_p("dw-lns", opcode_base) ||
                             opcode_base >= 13;
      uint<8>[opcode_base - 1] standard_opcode_lengths;
      Nonempty_String[] directories;
      uint<8> nullchar1 == '\0'; // Null character terminator
      Nonempty_String[] files;
      uint<8> nullchar2 == '\0'; // Null character terminator
    };

type Dwarf_Line_Hdr =
  union
    {
      Dwarf_Line_Hdr_V5 v5;
      Dwarf_Line_Hdr_V4 v4;
    };
0707010000000F000081A40000000000000000000000016554D9F600000845000000000000000000000000000000000000002D00000000poke-dwarf-0.1~git20231115/dwarf-pubnames.pk/* dwarf-pubnames.pk - DWARF implementation for GNU poke.
                       Name lookup tables.  */

load leb128;
load "dwarf-common.pk";

/* The sections .debug_pubnames and .debug_pubtypes contain a name
   lookup table each.  */

type Dwarf_Name_Lookup_Table =
  struct
  {
    /* Length of the set of entries for this CU, not including the
       length field itself.  */
    Dwarf_Initial_Length unit_length;

uint<16> version : (dwarf_version >= 3 && version == 2);

/* Offset into the .debug_info section of the CU header.  */
    Dwarf_Section_Offset debug_info_offset;

/* Size of the contents of the .debug_info section generated to
       represent this CU.  */
    Dwarf_Initial_Length debug_info_length;

/* The header is followed by a set of entries, which are finished
       by an offset containing the value 0.  */

type Global_Name =
      struct
      {
        Dwarf_Section_Offset offset : offset.value != 0#B;
        string name;
      };

Global_Name[] names;
    Dwarf_Section_Offset terminator : terminator.value == 0#B;

/* Return the offset in .debug_info of the object with name NAME.
       If no such object is stored in the table, raise E_generic.  */
    method lookup = (string str) offset<uint<64>,B>:
      {
        for (name in names where name.name == str)
          return name.offset.value;
        raise E_generic;
      }
  };
07070100000010000081A40000000000000000000000016554D9F60000072E000000000000000000000000000000000000002A00000000poke-dwarf-0.1~git20231115/dwarf-types.pk/* dwarf-frame.pk - DWARF implementation for GNU poke.
                    Debug types.  */

load leb128;
load "dwarf-common.pk";

/* The Dwarf_Type_Unit_Header is the header for the series of DIEs
   conforming a type that has been stored in the .debug_types
   section.  */

type Dwarf_Type_Unit_Header =
  struct
  {
    /* Length of the .debug_types contribution for this CU, not
       including the length field itself.  */
    Dwarf_Initial_Length unit_length;

/* Version of the DWARF information in this CU.  */
    uint<16> version : version == 4;

/* Offset into the .debug_abbrev section that associates this CU
       with a particular set of debugging information entry
       abbreviations.  */
    Dwarf_Section_Offset debug_abbrev_offset;

/* Size of an address on the target architecture.  */
    offset<uint<8>,B> address_size;

/* Unique signature of the type described in this type unit.  */
    uint<64> type_signature;

/* Offset relative to the beginning of the type unit header,
       referring to the DIE that describes the type.  */
    Dwarf_Section_Offset type_offset;
  };
07070100000011000081A40000000000000000000000016554D9F6000003D2000000000000000000000000000000000000002400000000poke-dwarf-0.1~git20231115/dwarf.pk/* dwarf.pk - DWARF implementation for GNU poke.  */

load "dwarf-common.pk";
load "dwarf-config.pk";
load "dwarf-abbrev.pk";
load "dwarf-line.pk";
load "dwarf-info.pk";
load "dwarf-expr.pk";
load "dwarf-frame.pk";
load "dwarf-pubnames.pk";
load "dwarf-types.pk";
07070100000012000081A40000000000000000000000016554D9F6000020C0000000000000000000000000000000000000002B00000000poke-dwarf-0.1~git20231115/poke-dwarf.texi\input texinfo
@comment %**start of header
@setfilename poke-dwarf.info
@include version.texi
@settitle DWARF pickles for GNU poke
@afourpaper
@defcodeindex pv
@comment %**end of header

@quotation
You can redistribute it and/or modify this manual 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.
@end quotation
@end copying

@dircategory GNU poke
@direntry
* poke-dwarf: (poke-dwarf). DWARF pickles for GNU poke.
@end direntry

@titlepage
@title DWARF pickles for GNU poke
@author by Jose E. Marchesi
@page
@vskip 0pt plus 1filll
@insertcopying
@end titlepage

@contents

@ifnottex
@node Top
@top Editing DWARF debug info with GNU poke

@insertcopying
@end ifnottex

GNU poke is an interactive, extensible editor for binary data.  Not
limited to editing basic entities such as bits and bytes, it provides
a full-fledged procedural, interactive programming language designed
to describe data structures and to operate on them.

This manual explains how to use the DWARF pickles distributed at
@url{https://jemarch.net/poke-dwarf}.

@menu
Getting Started
* Introduction::                  How to use this manual.
* Installation::                  Installing the poke-dwarf pickles.
* Pickles Overview::              Know your pickles.

Poking at DWARF
@c * DWARF Sections::                DWARF info is distributed in several ELF sections.
@c * DWARF Info::                    DWARF compilation units and the DIE tree.
@c * DWARF Debug Types::             DWARF ``debug types''.
@c * DWARF Frame Info::              DWARF Call Frame Information.
@c * DWARF Name Lookup Tables::      DWARF fast indexes.

Appendices
* Indices::			  List of indices in this document.
@end menu

@node Introduction
@chapter Introduction

This manual documents the pickles shipped in the poke-dwarf package.
It not only describes the data structures implemented in these
pickles, but also shows examples of techniques to how to make best use
of the pickles.

@section Who is this manual for?

This manual assumes that the reader is familiar with both the
@command{poke} program and the Poke programming language.

@section Approach used to describe Poke data structures

When describing Poke types (such as for example @code{Dwarf_FDE})
this manual takes the approach of first showing a simplified or
stripped-out version of the type, like this:

@example
type Dwarf_FDE =
  struct
  @{
    Dwarf_Initial_Length length;
    Dwarf_Section_Offset cie_pointer;
    Dwarf_Address initial_location;
    Dwarf_Address address_range;
    Dwarf_CFI[address_range.value()#B + padding] instructions;
  @};
@end example

@noindent
Generally speaking, these stripped versions of the type do not contain
comments, constraints, variables, functions nor methods.  However,
there are exceptions to this rule in the particular cases where we
want to draw your attention to some particular aspect involving some
constraint, method, etc.

Following the simplified version of the type, its fields get discussed
in detail.  Then, the overall data structure gets discussed, and
examples on how to use it to poke at data are shown.  Finally, the
methods offered by the type, if any, are described in detail along
with usage examples.

@node Installation
@chapter Installation

Welcome!  This section should get you up and running to enjoy poking
at DWARF debug info in no time.

@section Build Requirements

These are the build requirements if you are building from a
distribution source tarball:

@itemize @minus
@item
A recent enough version of GNU poke is necessary in order to run the
test suite of this package.  This is checked at configure time.  If no
suitable poke is found, the test suite is not run.
@end itemize

@section Fetching and unpacking poke-dwarf

The first step to install @code{poke-dwarf} is to fetch a copy of it.
Like all GNU poke pickles, @code{poke-dwarf} releases are distributed
as source tarballs:

@example
$ wget https://ftp.gnu.org/gnu/poke/poke-dwarf-@var{version}.tar.gz
@end example

@noindent
Where @var{version} is the version you want to install.  Next step is
to untar the tarball.  It will expand to a
@file{poke-dwarf-@var{version}} directory:

@example
$ tar xvf poke-dwarf-@var{version}.tar.gz
$ cd poke-dwarf-@var{version}/
@end example

@section Configuring the sources

@noindent
It is time now to configure the sources.  You do that by invoking the
@code{configure} script that is in the root directory of the
distribution.

@example
$ ./configure
@end example

@noindent
By default the @code{configure} script will configure the source in
order to be installed under @file{/usr/local}, which is a system
location.  If you want to install the pickles in some other location,
you can pass a @option{--prefix} command line option to the script.
For example:

@example
$ ./configure --prefix=$HOME/.poke.d
@end example

@noindent
Now that the sources are configured, it is time to build them and
check the distribution.  To do so:

@section Building and checking

@example
$ make
$ make check
@end example

@noindent
There should be no errors.  If any of the tests fail, please re-run
@command{make check} but this time enabling verbose output:

@example
$ make check VERBOSE=1
@end example

@noindent
And file a bug report at @url{https://sourceware.org/bugilla}
including both the contents of your @file{config.log} file and the
output you get on the terminal when you run @command{make check}.
Please file the bug report for product ``poke'' and component
``dwarf-pickle''.

@noindent
Note that the testsuite will only be executed if a recent enough
@command{poke} was found during configure.

@section Installing

@noindent
The last step is to install the pickles in your system:

@example
$ make install
@end example

@cindex @code{POKE_LOAD_PATH}
@noindent
Note that the installed poke will find the installed pickles only if
these are installed under the same prefix than poke.  If you install
the pickles in some other location (like under @file{~/.poke.d} for
example, you will have to set the environment variable
@code{POKE_LOAD_PATH}.  Just put something like this in your
@file{.bashrc} or similar file:

@example
export POKE_LOAD_PATH=$HOME/.poke.d
@end example

@noindent
And that's it!  Now run poke, load the pickles and enjoy!

@example
$ poke /bin/ls
(poke) load elf
(poke) load dwarf
(poke) var elf = Elf64_File @@ 0#B
(poke) var debug_info_sec = elf.get_sections_by_name (".debug_info")[0]
(poke) var dwarf_cu = Dwarf_CU_Header @@ debug_info_sec.sh_offset
...
@end example

@node Pickles Overview
@chapter Pickles Overview
@cindex overview, pickles

This chapter provides an high-level overview of all the pickles
distributed by this package.  These are all developed in subsequent
chapters.

@table @file
@item dwarf.pk
This is the main DWARF pickle, and the one that is intended to be
loaded by the user.  As with the main ELF pickle, this one just loads
the rest of the @file{dwarf-*} pickles in the right order.

@item dwarf-info.pk
This pickle contains definitions for DWARF DIEs, attributes and
compilation units.

@item dwarf-expr.pk
This pickle contains definitions for DWARF expressions, which are
arbitrary programs of different opcodes.  An little interpreter for
DWARF expressions is also provided.

Note: DWARF expressions interpreter not implemented yet.

@item dwarf-frame.pk
This pickle contains definitions for the DWARF call frame information
(CFI) structures, including DIEs and FDEs.  The DWARF CFI is actually
sort of a program to be executed to replicate the logic of a
conceptual big table, and this pickle also provides a little
interpreter to do that.

Note: DWARF CFI interpreter not implemented yet.

@item dwarf-pubnames.pk
This pickle contains definitions for DWARF name lookup tables, which
are fast indices to certain debug information, such as types and
entity names.

@item dwarf-types.pk
This pickle contains definitions for DWARF @dfn{debug types}, which is
a compact and stand-alone (in the sense it is out of the DIEs tree)
representation of source language types.
@end table

@node Indices
@appendix Indices

@menu
* Concept Index::               General concept index
@end menu

@node Concept Index
@appendixsec Concept Index

@printindex cp

@bye
07070100000013000081A40000000000000000000000016554D9F600001D59000000000000000000000000000000000000002C00000000poke-dwarf-0.1~git20231115/test-dwarf.pk.in#!@POKE@ -L
!#

/* test-dwarf.pk - Tests for the DWARF poke pickle.  */

load pktest;
load dwarf;

var data = open ("*data*"),
    data1 = open("*data1*"),
    data2 = open("*data2*");

set_endian (ENDIAN_LITTLE);

uint<8>[19] @ data : 0#B = [
  0x01UB, 0x11UB, 0x01UB, 0x25UB, 0x0eUB, 0x13UB, 0x0bUB, 0x03UB, 0x1fUB,
  0x1bUB, 0x1fUB, 0x11UB, 0x01UB, 0x12UB, 0x07UB, 0x10UB, 0x17UB, 0x00UB,
  0x00UB
];

// Here, we combine the .debug_line section (first 79 bytes) and the
// .debug_line_str section (following 39 bytes).
uint<8>[79 + 39] @ data1 : 0#B = [
  // Fitst, the .debug_line section
  0x4bUB, 0x00UB, 0x00UB, 0x00UB, 0x05UB, 0x00UB, 0x08UB, 0x00UB, 0x2aUB,
  0x00UB, 0x00UB, 0x00UB, 0x01UB, 0x01UB, 0x01UB, 0xfbUB, 0x0eUB, 0x0dUB,
  0x00UB, 0x01UB, 0x01UB, 0x01UB, 0x01UB, 0x00UB, 0x00UB, 0x00UB, 0x01UB,
  0x00UB, 0x00UB, 0x01UB, 0x01UB, 0x01UB, 0x1fUB, 0x01UB, 0x07UB, 0x00UB,
  0x00UB, 0x00UB, 0x02UB, 0x01UB, 0x1fUB, 0x02UB, 0x0fUB, 0x02UB, 0x00UB,
  0x00UB, 0x00UB, 0x00UB, 0x00UB, 0x00UB, 0x00UB, 0x00UB, 0x00UB, 0x00UB,
  0x05UB, 0x01UB, 0x00UB, 0x09UB, 0x02UB, 0x06UB, 0x11UB, 0x40UB, 0x00UB,
  0x00UB, 0x00UB, 0x00UB, 0x00UB, 0x13UB, 0x05UB, 0x0cUB, 0x4bUB, 0x05UB,
  0x01UB, 0x59UB, 0x02UB, 0x02UB, 0x00UB, 0x01UB, 0x01UB,
  // Second, the .debug_line_str section
  0x74UB, 0x65UB, 0x73UB, 0x74UB, 0x2eUB, 0x63UB, 0x00UB, 0x2fUB, 0x68UB,
  0x6fUB, 0x6dUB, 0x65UB, 0x2fUB, 0x6dUB, 0x63UB, 0x65UB, 0x72UB, 0x6dUB,
  0x61UB, 0x6bUB, 0x2fUB, 0x57UB, 0x4fUB, 0x52UB, 0x4bUB, 0x2fUB, 0x70UB,
  0x6fUB, 0x6bUB, 0x65UB, 0x2fUB, 0x73UB, 0x61UB, 0x6eUB, 0x64UB, 0x62UB,
  0x6fUB, 0x78UB, 0x00UB
];

uint<8>[65] @ data2 : 0#B = [
  0x3dUB, 0x00UB, 0x00UB, 0x00UB, 0x04UB, 0x00UB, 0x1eUB, 0x00UB, 0x00UB,
  0x00UB, 0x01UB, 0x01UB, 0x01UB, 0xfbUB, 0x0eUB, 0x0dUB, 0x00UB, 0x01UB,
  0x01UB, 0x01UB, 0x01UB, 0x00UB, 0x00UB, 0x00UB, 0x01UB, 0x00UB, 0x00UB,
  0x01UB, 0x00UB, 0x74UB, 0x65UB, 0x73UB, 0x74UB, 0x2eUB, 0x63UB, 0x00UB,
  0x00UB, 0x00UB, 0x00UB, 0x00UB, 0x05UB, 0x01UB, 0x00UB, 0x09UB, 0x02UB,
  0x06UB, 0x11UB, 0x40UB, 0x00UB, 0x00UB, 0x00UB, 0x00UB, 0x00UB, 0x13UB,
  0x05UB, 0x0cUB, 0x4bUB, 0x05UB, 0x01UB, 0x59UB, 0x02UB, 0x02UB, 0x00UB,
  0x01UB, 0x01UB
];

var tests = [
  PkTest {
    name = "dwarf-abbrev test",
    todo = "WIP",
    func = lambda (string name) void:
      {
        var tbl = Dwarf_Abbrev_Table[] @ data: 0#B;
        var h = tbl[0].header;
        var e = tbl[0].entries;

assert (h.code.value == 1);
        assert (dw_cfg.get_name ("dw-tag", h.tag.value) == "DW_TAG_compile_unit");
        assert (dw_cfg.get_name ("dw-children", h.children) == "DW_CHILDREN_yes");

assert (dw_cfg.get_name ("dw-at", e[0].name.value) == "DW_AT_producer");
        assert (dw_cfg.get_name ("dw-form", e[0].form.value) == "DW_FORM_strp");

assert (dw_cfg.get_name ("dw-at", e[1].name.value) == "DW_AT_language");
        assert (dw_cfg.get_name ("dw-form", e[1].form.value) == "DW_FORM_data1");

assert (dw_cfg.get_name ("dw-at", e[2].name.value) == "DW_AT_name");
        assert (dw_cfg.get_name ("dw-form", e[2].form.value) == "DW_FORM_line_strp");

assert (dw_cfg.get_name ("dw-at", e[3].name.value) == "DW_AT_comp_dir");
        assert (dw_cfg.get_name ("dw-form", e[3].form.value) == "DW_FORM_line_strp");

assert (dw_cfg.get_name ("dw-at", e[4].name.value) == "DW_AT_low_pc");
        assert (dw_cfg.get_name ("dw-form", e[4].form.value) == "DW_FORM_addr");

assert (dw_cfg.get_name ("dw-at", e[5].name.value) == "DW_AT_high_pc");
        assert (dw_cfg.get_name ("dw-form", e[5].form.value) == "DW_FORM_data8");

assert (dw_cfg.get_name ("dw-at", e[6].name.value) == "DW_AT_stmt_list");
        assert (dw_cfg.get_name ("dw-form", e[6].form.value) == "DW_FORM_sec_offset");
      }
    },

PkTest {
    name = "dwarf-line (test dwarf v5)",
    todo = "WIP",
    func = lambda (string name) void:
      {
        var l = Dwarf_Line_Hdr_V5 @ data1: 0#B;
        var off = 79#B;
        set_ios (data1);
        var str = l.get_files(off);
        var s1 = str[0];
        var s2 = str[1];

assert ( l.unit_length == 75U );
        assert ( l.version == 5UH );
        assert ( l.address_size == 8UB#B );
        assert ( l.segment_selector_size == 0UB#B );
        assert ( l.header_length == 42U#B );
        assert ( l.minimum_instruction_length == 1UB#B );
        assert ( l.maximum_operations_per_instruction == 1UB );
        assert ( l.default_is_stmt == 1UB );
        assert ( l.line_base == -5B );
        assert ( l.line_range == 14UB );
        assert ( l.opcode_base == 13UB );
        assert ( l.standard_opcode_lengths == [0UB,1UB,1UB,1UB,1UB,0UB,0UB,0UB,1UB,0UB,0UB,1UB] );
        assert ( l.directory_entry_format_count == 1UB );
        assert ( l.directory_entry_format[0].content_type.last == 1UB );
        assert ( l.directory_entry_format[0].content_type.last == DW_LNCT_path );
        assert ( l.directory_entry_format[0].form_code.last == 31UB );
        assert ( l.directory_entry_format[0].form_code.last == DW_FORM_line_strp );
        assert ( l.directories_count.value == 1 );
        assert ( l.file_name_entry_format_count == 2UB );
        assert ( l.file_name_entry_format[0].content_type.last == 1UB );
        assert ( l.file_name_entry_format[0].content_type.last == DW_LNCT_path );
        assert ( l.file_name_entry_format[0].form_code.last == 31UB );
        assert ( l.file_name_entry_format[0].form_code.last == DW_FORM_line_strp );
        assert ( l.file_name_entry_format[1].content_type.last == 2UB );
        assert ( l.file_name_entry_format[1].content_type.last == DW_LNCT_directory_index );
        assert ( l.file_name_entry_format[1].form_code.last == 15UB );
        assert ( l.file_name_entry_format[1].form_code.last == DW_FORM_udata );
        assert ( l.file_names_count.value == 2 );
        assert ( s1 == "/home/mcermak/WORK/poke/sandbox/test.c");
        assert ( s2 == s1 );
      }
  },

PkTest {
    name = "dwarf-line (test dwarf v4)",
    todo = "WIP",
    func = lambda (string name) void:
      {
        var l = Dwarf_Line_Hdr_V4 @ data2: 0#B;
        assert ( l.unit_length == 61U );
        assert ( l.version == 4UH );
        assert ( l.header_length == 30U#B );
        assert ( l.minimum_instruction_length == 1UB#B );
        assert ( l.maximum_operations_per_instruction == 1UB );
        assert ( l.default_is_stmt == 1UB );
        assert ( l.line_base == -5B );
        assert ( l.line_range == 14UB );
        assert ( l.opcode_base == 13UB );
        assert ( l.standard_opcode_lengths == [0UB,1UB,1UB,1UB,1UB,0UB,0UB,0UB,1UB,0UB,0UB,1UB] );
        assert ( l.directories'length == 0 );
        assert ( l.files'length == 1 );
        assert ( l.files[0].item == "test.c" );
      }
  }];

exit (pktest_run (tests) ? 0 : 1);
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!317 blocks

Places

File poke-dwarf-0.1~git20231115.obscpio of Package poke-dwarf

Places