[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: bug in gnustep-make / my last mail (pantomime)
From: |
Nicola Pero |
Subject: |
Re: bug in gnustep-make / my last mail (pantomime) |
Date: |
Fri, 9 Aug 2002 09:58:42 +0100 (BST) |
> hmm, I found the "bug". I build pantomime twice (for a static and a
> dynamic library). However when building with shared=no, the
> dynamically loadable bundle is built with -fPIC, which is definitely
> wrong.
The 'dynamically loadable bundle' is the SSL bundle in the Pantomime
library I suppose ?
I'm not sure what the meaning of 'shared' vs 'static' is for a dynamically
loadable bundle ... I don't think gnustep-make makes any difference
between them.
Thinking about it, it looks correct - I don't think it's useful to make a
difference between them :-)
Maybe the difference would be that a 'shared' loadable bundle is like a
shared library object, but loaded into an already running executable,
while a 'static' loadable bundle would be like a static (non-shared)
library object, but loaded into an already running executable ?
In other words, that a 'shared' loadable bundle object, when loaded
multiple times from different applications, is shared between them, while
a 'static' loadable bundle object, when loaded multiple times from
multiple applications, is not shared ?
Well I don't see the point of making this complicated distinction, since
the 'static' loadable bundle object is always more inefficient and gives
no benefits :-) I assume it would be used automatically on platforms which
don't support the shared one.
I'm not even sure platforms allow you to make such a distinction.
While for libraries there might be a reason to use static libraries (have
an executable which is self-contained without having to depend on anything
from the outside; more efficient executable code) - static libraries are
`merged' into the executable, I'm not quite sure what the point would be
in a 'static loadable object'. Even if 'static', the object must be
loaded from outside. So what's the point of having it 'static' ? I think
if you are using a 'loadable object', you always want the more efficient
implementation the environment supports of that concept :-)
So, I think you should always build dynamically loadable bundles only once
- and no matter if you specify shared=yes or shared=no, they should be
built with the same flags (the more efficient and better way of building
dynamically loadable objects on that platform).
I beg you pardon in advance if I missed your point - the mail was quite
short and it wasn't easy to guess what you were meaning. :-)
- Re: bug in gnustep-make / my last mail (pantomime),
Nicola Pero <=