Interface to GCC's debugging output
Ctalk Project
Do any of the experts here know if there's been attempts at
an interface to GCC's .stabs debugging format, apart from
the gdb program itself.
The gdb manual states that libgdb versions 1.0 and 2.0 are
either abandoned or ongoing projects. I would prefer not to
write libraries from the ground up, but can do that if I
have to.
Thanks for any assistance.
--
Ctalk Home Page: http://www.ctalklang.org
Kaz Kylheku
>
> Do any of the experts here know if there's been attempts at
> an interface to GCC's .stabs debugging format, apart from
> the gdb program itself.
Here is one: http://bc.tech.coop/blog/080229.html
Crushed_Ice
think of reciprocals, where each language can call the other or reciprocal
interdependence. Another aspect of your architecture is named integration.
It involves two diverging specialties (less filling - tastes great) and a
differentiation index involving feedback, and choices of an architecture
where the design is based upon the architecture. See Lawrence and Lorsch
where the issue is an evaluation of specialization factors.
A reference might be on a topic of implementation of information systems,
related to above. I am working with written materials from the 1970's.
Consider that the formal architecture falls away. The informal patterns of
use will be utiized. To accomplish the final project, the architecture
itself has to be trimmed to suit your generic design. And from your generic
language concept, processes will be instantiated. I am specializing in
generic computer platforms (clone computers) because the're much cheaper.
"Ctalk Project" <ct...@ctalklang.org> wrote in message
news:m2zl5tw...@pop.earthlink.net...
Crushed_Ice
bought this book by Chris Britton 2001 copyright Unisys Corp. where there is
all types of suggestions about calling processes, and the allure of
specialization. The diagrams show CORBA, DCOM RPC, EJB (java bean) ADO,
OLE, ASP, DHTML, SQL and the integration of those. From computer to
computer and between user and computer. The author is a Borroughs/Unisys
employee from decades past. Didn't they invent the UNIVAC? This book also
describes email. But you have to organize the flow of methods firstly,
which this book describes well. He mentions the strawman a for user target
architectures. DNA and J2EE offer message queuing and transaction services.
The issue is also brought up as DNA. With Windows where I learned about
this (author Christian Gross) he discusses the design of an operating system
that can manage other devices (printers, conference telephones, languages)
and interface with them. It is standardization protocol and evolves into
plug and play, as well as other Windows features.
"Crushed_Ice" <slipan...@yahoo.com> wrote in message
news:UJCdnRnVMKXPO4PW...@hbci.com...
Robbert Haarman
Some additional info:
The page mentions as one of the problems that "C++ name-mangling has to
be worked out on a per-compiler basis since it isn't standardized across
C++ compilers". This is true, but many newer compilers now employ name
mangling as described in the Itanium C++ ABI (even on non-IA64
platforms). This name mangling scheme is described at
http://www.codesourcery.com/public/cxx-abi/abi.html#mangling among other
places.
The stabs format is documented at
http://sourceware.org/gdb/current/onlinedocs/stabs.html among other
places (but most places I've found are actually that same document). However,
I am not sure how much stabs is still used by modern tools; it seems to
have been largely replaced by DWARF, specifically DWARF2 and DWARF3
The DWARF debugging standard is described at
http://www.dwarfstd.org/ There is a library called libdwarf that supports
reading DWARF2 and DWARF3 debug information, which is used by various
projects.
Good luck!
Bob
--
All generalizations are false.
Crushed_Ice
Modern Organization Theory
The various approaches to effective organizations, and the study of the
organization, have no absolute unifying theory. We are confronted with
different ideas about organizations and the way that they operate. Yet we
have a sophisticated basis for an underlying assumption behind the
assortment of theories and assumptions, or classic views, transitional
views, and modern vews. The discussion is found in chapter 1, of Lucas,
Jr., analysis and Design for Implementing of Information Systems.
Some realistic approaches to underlying assumptions about organizations, and
problems within organizations, concern the affect (asumption golive), as we
implement it using the design and operation of information systems.
Take note of individuals - the psychological needs and wants of the
individual of the organization should be considered. Psychological models
of people have been developed. People are social-beings and their
motivations for working are involved with the fulfillment of social needs.
Maslow proposed a needs hierarchy, a basis for understanding individuals in
organizations (Schlein, 1970). Maslow suggests five levels of human needs,
as follows:
1 - Safety, security,and survival needs
2 - Social and affiliative needs
3 - Ego satisfaction and self-esteem needs
4 - Autonomy and independence
5 - Self-actualization
The Maslow theory proposes that lower-order needs must be satisfied before a
human is interested in higher-order needs (Schlein, 1970). For example,
thirst and hunger needs must be filled before ego satisfaction becomes
salient. For many people, one of the primary reasons for work is to satisfy
social needs. It is assumed that most lower-order needs, i.e., safety and
survival were met (before you applied for employment). I understand if some
who are working actually should not be forced to attempt it. The
proposition of not being employed is so threatening to them, as individuals.
The worst case would present military subscription in the light of "fight or
starve". These levels involvement and the type of social feedback were
studied by Lawrence and Lorsch (1967). They support the idea of social
integration which involves increased complexity (a pattern which recognizes
specialization and its limits), but recognizes the transparent quality of
esteem, and independence. That license and intimidating control are
maliciously misapplied as political institutions concerns many of us.
Some workers also receive ego satisfaction from their jobs as well as the
satisfaction of some autonomy and independence needs. Possibly a few
authors, artists, and others are able to operate at the level of
self-actualization; on the highest portion of the needs scale. But
employment is not equivalent to organizational charters. The results of
submerging the goals of society below the needs of unfit workers should be
better explored in theory, but not tested as an assumption.about primitive
minds. Let the floats parade roll and the drums beat a march for military
madness.
"Robbert Haarman" <comp.la...@inglorion.net> wrote in message
news:2009120821...@yoda.inglorion.net...
Ctalk Project
Stabs looks like its much more convenient to read symbol
table, line information, and so forth directly from the
binary. Haven't looked at libdwarf yet, though that may
help with the DWARF format information. However, you're
correct - I just checked, and more recent GCC's on Linux at
least seem to use DWARF2 as the default (the compiler people
say they are only actively developing GCC 4.3 and more
recent versions), although stabs is still an option.
Earlier versions seem to add stabs information the binary as
the default for debugging.
Ctalk Project
> The question would be what level is their development progam? I would
> think of reciprocals, where each language can call the other or reciprocal
> interdependence. Another aspect of your architecture is named integration.
> It involves two diverging specialties (less filling - tastes great) and a
> differentiation index involving feedback, and choices of an architecture
> where the design is based upon the architecture. See Lawrence and Lorsch
> where the issue is an evaluation of specialization factors.
>
> A reference might be on a topic of implementation of information systems,
> related to above. I am working with written materials from the 1970's.
> Consider that the formal architecture falls away. The informal patterns of
> use will be utiized. To accomplish the final project, the architecture
> itself has to be trimmed to suit your generic design. And from your generic
> language concept, processes will be instantiated. I am specializing in
> generic computer platforms (clone computers) because the're much cheaper.
Using a simulator in normal use is still impractical,
though, especially when the OOP system overhead is added in.
It's more workable for the moment to keep the generated code
as vanilla as possible, and that should minimize
architecture dependencies now and in the future, especially
considering that languages tend to develop and still need to
DTRT, even when users consider them to be already mature
enough for everyday use.
Alan Curry
Ctalk Project <ct...@ctalklang.org> wrote:
>
>Do any of the experts here know if there's been attempts at
>an interface to GCC's .stabs debugging format, apart from
>the gdb program itself.
It's not gcc's stabs format, it's Unix's stabs format. It's at least
theoretically compatible with the Unix debugger dbx that was gdb's
predecessor.
dbx is still available from Sun, but I wouldn't want to guess whether it
still supports the old formats.
--
Alan Curry
Ian Collins
It supports either.
--
Ian Collins
Ctalk Project
It seems that stabs is still useful for languages that do
not have access to internal compiler information like symbol
tables and call stacks. That would not be useful for binary
degugging anyway. Stabs is correctly UNIX format, I'm told,
though with compiler-specific extensions.
I seem to recall a discussion I had about gdb's binary file
interfaces. The bfd's are what make gdb work with various
binary formats, most of which seem not to be entirely
compatible with each other. So the expression, "GCC's
stabs," format is meant guardedly.
Sun GCC 4.2.1 packages have the bit debugger instead of dbx,
though I haven't tried it yet. Sun cc and gcc are not
compatible for debugging, if memory serves, so debugging
tools again need to be compiler specific.
This entire thread hasn't been cross-posted. Apologies for
that.
Phil Carmody
> Modern Organization Theory
[SNIP - off-topic bollocks]
Can you keep this off-topic crap off c.l.c, please?
I'm not even sure it's on topic for c.l.m, so have set followups
appropriately.
Phil
--
Any true emperor never needs to wear clothes. -- Devany on r.a.s.f1
BGB / cr88192
> an interface to GCC's .stabs debugging format, apart from
> the gdb program itself.
>
> The gdb manual states that libgdb versions 1.0 and 2.0 are
> either abandoned or ongoing projects. I would prefer not to
> write libraries from the ground up, but can do that if I
> have to.
>
> Thanks for any assistance.
>
well, I will add a minor comment here:
generally, GCC uses stabs with COFF based targets (such as on Windows), but
not with ELF. for ELF-based targets (such as Linux) the format used is
DWARF2.
and neither is the format used by MSVC, which has its own debugging format,
...
part of the question may be, for what reason you want debugging info.
for many of the cases one might think they want it, there are other, less
painful, routes.
Ctalk Project
Well, running a binary under a simulator would assist in
rapid development - you could see the symbol table, call
stack, source code, and so forth, but that would be unweildy
in everyday use. Debuggers aren't really meant to be
simulators, although the latest gdb releases have some
simulator-type features.
There's probably a correlation between the need for such a
debugging API and the simplicity of the language itself.
However, debugging formats almost always mean working at an
intermediate code level when implementing a useful API.
It helps when coping with every great idea that some random
programmer might throw at a language, and helps leverage the
synergy (tm) of OOP dialects. It's like a simulation mode
that dae programmer can turn on or off whenever necessary.
Crushed_Ice
does not ring a bell, most of them output in a series of binaries which go
to the linker. My recollection is that the header of each source file was
the key to integrating the binaries, which follows from a level of
specialization of each binary, hence a need for integrators (linking).
Planning for a simulator involves understanding some level of anticipation
which should be part of the source for routing of the flow between the
objects. If you've ever done one of those programs which loops through a
digraph, then you might be able to set up a control system to catch some
commands from a user or a machine, using a diverse routing pattern. Link
this command executable separately with each alternative. The compile all
of the binaries. I once programmed a version of the game program called
Life in C which used a simulation framework. The Life game is based upon a
pattern generation. If two adjacent cells are on, then some condition is
tested and the point is an evolving pattern depending upon the rules for
this pattern. Life is somewhat like evolution of cells in an organizm I
think. I am getting back to programming at the level of the code, now that
I understand a alittle more about industrial programming styles. I like the
compiler by Microware. Alot of them dont work for me. But I think for C++
you can try the Sybase code generator named Power++. It is a drag and drop
compiler which I have a copy of in the early version Optima++ by Sybase.
This program will generate code in C++ and you can modify that code which is
implemented for a Watcom compiler. I bought a book on object-oriented
architecure design (design and architecture) by Yun-Tung Lau, PHd. 2001.
Work on one of the old machines and recompile for the new chip using the
special upgrade compiler. You gotta check the expiration date on them.
----- Original Message -----
From: "Crushed_Ice" <slipan...@yahoo.com>
Newsgroups: comp.lang.c,comp.lang.misc
Sent: Tuesday, December 08, 2009 1:16 PM
Subject: Re: Interface to GCC's debugging output
> The question would be what level is their development progam? I would
> think of reciprocals, where each language can call the other or reciprocal
> interdependence. Another aspect of your architecture is named
integration.
> It involves two diverging specialties (less filling - tastes great) and a
> differentiation index involving feedback, and choices of an architecture
> where the design is based upon the architecture. See Lawrence and Lorsch
> where the issue is an evaluation of specialization factors.
>
> A reference might be on a topic of implementation of information systems,
> related to above. I am working with written materials from the 1970's.
> Consider that the formal architecture falls away. The informal patterns of
> use will be utiized. To accomplish the final project, the architecture
> itself has to be trimmed to suit your generic design. And from your
generic
> language concept, processes will be instantiated. I am specializing in
> generic computer platforms (clone computers) because the're much cheaper.
>
> "Ctalk Project" <ct...@ctalklang.org> wrote in message
> news:m2zl5tw...@pop.earthlink.net...
> >
> > Do any of the experts here know if there's been attempts at
> > an interface to GCC's .stabs debugging format, apart from
> > the gdb program itself.
> >
> > The gdb manual states that libgdb versions 1.0 and 2.0 are
> > either abandoned or ongoing projects. I would prefer not to
> > write libraries from the ground up, but can do that if I
> > have to.
> >
> > Thanks for any assistance
"Ctalk Project" <ct...@ctalklang.org> wrote in message
news:m2my1to...@pop.earthlink.net...
Ctalk Project
<snip>
This has nothing to do with the linking. It's the
information contained in the binary, accessible on demand.
I know it's a terrible imposition, but I will just have to
write a debug reader library API myself.
Crushed_Ice
each library is. You do not have to write a library yoreself.
The library files often end with the filename extension .lib. And I would
be curious, but what was the filename extension that you were going to
utilize for such a library which you were planning to write? You can
modify and work with the library that comes with the compiler, if you want.
You just make a copy, and then make a copy of the source code for it.
Rename both of them so that they have the same filename, and the correct
filename extensions, Then you can make some alterations. All of this would
be covered in some documentation for the compiler's make command. If they
don't document that too well, then purchase a book for any compiler which
has a good section on the make command for it. Try to use the same computer
language compiler as the language that your library is written for. If your
source file, that you've written does not have a header which directs the
conditional compilation according to whether you are in debug mode, and
listing libraries options under those compiler debug conditions, then turn
the computer off. Don't write us we'll call you back..news:m2ocm3s...@pop.earthlink.net...
BGB / cr88192
but, are you sure you are talking to a real person?...
the sort of rambling OT incoherence, could be a HMM...