ObjFW  Diff

Differences From Artifact [9fc0378e5d]:

• File src/OFObject.h — part of check-in [57fb5578cc] at 2009-04-19 17:37:52 on branch trunk — Remove forwarding methods. See long commit message for details.

  There are two resons for removing it:

  First, OFPlugin does not need forwarding anymore. Second is that
  forwarding is broken in both, the GNU and the Apple runtime.

  In GNU libobjc, objc_msg_sendv is implemented using __builtin_apply,
  which is broken on many platforms, including x86_64. If forwarding is
  used, the application will just crash. To work around that, I'd need to
  parse the type encoding and use libffi to call the method instead of
  using objc_msg_sendv.

  Now the Apple runtime has a similar problem: There is no objc_msgSendv
  for PPC64 and x86_64 as it's only in ObjC1 and on ARM (iPhone), it's
  broken (most likely because the iPhone uses only ObjC2 - I was confused
  that objc_msgSendv was even in the libobjc there). So I'd need to write
  an ASM implementation for these 3.

  Writing those 3 ASM implementations (or 5, so we don't depend on ObjC1
  stuff on PPC32 and x86 as well) wouldn't be a problem, but there is a
  problem the GNU libobjc and the Apple runtime got in common, which
  originates from the early ObjC implementations:

  forward:: and performv:: were only designed to return scalar types. But
  today, it's possible to return floats, structs and unions as well. What
  Apple and GNU use here is a very hacky workaround and it's just luck
  that it works. forward:: and performv:: both return an id (Apple) or
  void* (GNU). forward:: is called by the runtime if you called a method
  that is not implemented. The compiler does not know at compile time
  that it is not implemented, therefore expects a float as a return. On
  x86, floats are returned in sp0. The runtime now notices that the
  called method is not implemented and calls forward::. Forward then
  calls performv:: to call the right method. The method returns a float
  and stores it in sp0. Remember that both, forward:: and performv::
  return an id / void*. performv:: returns now and after that, forward::
  returns. The return of those was always put into eax, as that's how
  scalar values are returned on x86. The original caller of the method
  does not expect any return value in eax, but in sp0. This works, as
  no code touched sp0. However, you can not rely on sp0 not being
  touched. It's just luck that the compiler generates code that does not
  touch sp0.

  While this works for forwarding due to the ABI on x86 (and the ABIs on
  many other platforms allow this hack as well), this fails if you call
  performv:: directly on a method returning a float. In this case, the
  compiler does not expect a return value in sp0, but in eax, as
  performv:: is expected to return id / void*. Therefore the bogus value
  in eax will be casted to float and the result will be useless.

  This is why I decided to remove forwarding and performv:: from libobjfw
  for now. If I encounter a situation where I need forwarding, I'm going
  to implement it in a sane way and NOT the objc way. The forwarding
  methods this commit removes did it the objc way, which is IMO just
  wrong. (That way was ok back then when you only had scalar return
  types, but today you're not limited to scalar return types anymore.) (user: js, size: 4765) [annotate] [blame] [check-ins using]

To Artifact [84bfaf3d9b]:

• File src/OFObject.h — part of check-in [348b389736] at 2009-04-19 20:19:54 on branch trunk — Actually, it makes sense that - release returns self.
  This way, you can check if the object has been free'd, for example
  using if ((obj = [obj release]) == nil). (user: js, size: 4759) [annotate] [blame] [check-ins using]

194
195
196
197
198
199
200
201
202
203
204
205
206
207

 * \return The retain count
 */
- (size_t)retainCount;

/**
 * Decreases the retain cound and frees the object if it reaches 0.
 */
- (void)release;

/**
 * Frees the object and also frees all memory allocated via its memory pool.
 */
- free;
@end

|

194
195
196
197
198
199
200
201
202
203
204
205
206
207

 * \return The retain count
 */
- (size_t)retainCount;

/**
 * Decreases the retain cound and frees the object if it reaches 0.
 */
- release;

/**
 * Frees the object and also frees all memory allocated via its memory pool.
 */
- free;
@end