I am trying to build a cross-compiling toolchain based on gcc, glibc and binutils.
In all the howto's and tutorials I can find patches are applied to said packages, although
never the same patches it seems like.

The comments in most of these patches indicate that the patch fixes some bug or adds some functionality.

My question is: Does the patch fix or implements the functionality only for that version/release of the package and is it then absorbed into the package meaning that a new version of the package needs not be patched again.

Can someone please explain this to me or at least shed some light on the subject?

Thanks

Well ultimately a patch may or may not be accepted my the main application developers. There are often very good reasons why a patch isn't integrated, it may be an "optimization" that may only work under certain circumstances, and might otherwise reduce performance. just an example of course.

Unless you really want something the patch does, it is really pointless. I've had programs that wouldn't compile without a patch. You pretty much have to patch with those. I usually don't bother with patches, except kernel patches in debian.

I think I see what you mean - if the patch fixes something or improves the package for a supported platform it will probably be integrated into the package, like for example: "fixes crash in glibc if ... so and so" let say on a ARM processor.

Else if it only let say implements soft-float for ARM in gcc it might not make it in.

Thanks for your insight guys... The release notes will probably also shed light on the subject....

Henry