[packages/openssl102: 218/432] - hack to compile openssl with gcc-4.2

adwol adwol at pld-linux.org
Sat Sep 29 01:19:54 CEST 2018


commit a1ca6ba5676aba23a35276260122e2b7911d69c5
Author: Jacek Konieczny <jajcus at pld-linux.org>
Date:   Thu Nov 9 14:36:11 2006 +0000

    - hack to compile openssl with gcc-4.2
    
    Changed files:
        openssl-gcc_4_2.patch -> 1.1

 openssl-gcc_4_2.patch | 230 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 230 insertions(+)
---
diff --git a/openssl-gcc_4_2.patch b/openssl-gcc_4_2.patch
new file mode 100644
index 0000000..f9c6838
--- /dev/null
+++ b/openssl-gcc_4_2.patch
@@ -0,0 +1,230 @@
+From: b... at arklinux.org (Bernhard Rosenkraenzer)
+Newsgroups: mailing.openssl.dev
+Subject: Re: OpenSSL breaks with gcc 4.2
+Date: Thu, 9 Nov 2006 01:56:49 +0800 (CST)
+Organization: NCTU CSIE FreeBSD Server
+Message-ID: <eit5p1$4mi$1 at FreeBSD.csie.nctu.edu.tw>
+
+On Tuesday, 7. November 2006 15:54, Dr. Stephen Henson wrote:
+> On Tue, Nov 07, 2006, Bernhard Rosenkraenzer wrote:
+> > gcc 4.2 no longer allows function casting - which is used rather heavily
+> > by openssl. (To make things worse, it compiles but inserts abort()
+> > statements resulting in app crashes).
+>
+> Ugh, I would've thought that flagging a compiliation error would make more
+> sense rather that outputting bad code...
+
+Agreed... Unfortunately sometimes gcc developers' decisions make much sense 
+from the point of the compiler implementor than from that of someone actually 
+using it.
+
+> > Is there a fix to make OpenSSL compatible with gcc 4.2/4.3 yet?
+>
+> No there isn't yet, some technique will be needed to make this still work
+> by tweaking some of the macros. Does casting a function to (void *) first
+> then the function cast work?
+
+Yes, but only in a really really ugly way.
+I've attached a patch that make it compile (and work), but I can't say I like 
+it.
+I've tried all sorts of other things (like putting the void* cast directly 
+into the defines, or even adding a (char*) cast and running +1-1 type 
+arithmetics on it), but gcc's optimizer is too smart and throws it away, and 
+errors out just as if it wasn't there), but the attached patch is the only 
+quick fix that works.
+
+I hope someone can come up with a better idea...
+
+--- openssl-0.9.8d/crypto/asn1/asn1.h.ark	2006-11-08 19:03:36.000000000 +0100
++++ openssl-0.9.8d/crypto/asn1/asn1.h	2006-11-08 19:32:10.000000000 +0100
+@@ -902,23 +902,26 @@
+ 
+ /* Used to implement other functions */
+ void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, char *x);
++static void * __attribute__((unused)) __ASN1_dup=openssl_fcast(ASN1_dup);
+ #define ASN1_dup_of(type,i2d,d2i,x) \
+-	((type *(*)(I2D_OF(type),D2I_OF(type),type *))openssl_fcast(ASN1_dup))(i2d,d2i,x)
++	((type *(*)(I2D_OF(type),D2I_OF(type),type *))__ASN1_dup)(i2d,d2i,x)
+ #define ASN1_dup_of_const(type,i2d,d2i,x) \
+-	((type *(*)(I2D_OF_const(type),D2I_OF(type),type *))openssl_fcast(ASN1_dup))(i2d,d2i,x)
++	((type *(*)(I2D_OF_const(type),D2I_OF(type),type *))__ASN1_dup)(i2d,d2i,x)
+ 
+ void *ASN1_item_dup(const ASN1_ITEM *it, void *x);
+ 
+ #ifndef OPENSSL_NO_FP_API
+ void *ASN1_d2i_fp(void *(*xnew)(void), d2i_of_void *d2i, FILE *in, void **x);
++static void * __attribute__((unused)) __ASN1_d2i_fp=openssl_fcast(ASN1_d2i_fp);
+ #define ASN1_d2i_fp_of(type,xnew,d2i,in,x) \
+-	((type *(*)(type *(*)(void),D2I_OF(type),FILE *,type **))openssl_fcast(ASN1_d2i_fp))(xnew,d2i,in,x)
++	((type *(*)(type *(*)(void),D2I_OF(type),FILE *,type **))__ASN1_d2i_fp)(xnew,d2i,in,x)
+ void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x);
+ int ASN1_i2d_fp(i2d_of_void *i2d,FILE *out,void *x);
++static void * __attribute__((unused)) __ASN1_i2d_fp=openssl_fcast(ASN1_i2d_fp);
+ #define ASN1_i2d_fp_of(type,i2d,out,x) \
+-	((int (*)(I2D_OF(type),FILE *,type *))openssl_fcast(ASN1_i2d_fp))(i2d,out,x)
++	((int (*)(I2D_OF(type),FILE *,type *))__ASN1_i2d_fp)(i2d,out,x)
+ #define ASN1_i2d_fp_of_const(type,i2d,out,x) \
+-	((int (*)(I2D_OF_const(type),FILE *,type *))openssl_fcast(ASN1_i2d_fp))(i2d,out,x)
++	((int (*)(I2D_OF_const(type),FILE *,type *))__ASN1_i2d_fp)(i2d,out,x)
+ int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x);
+ int ASN1_STRING_print_ex_fp(FILE *fp, ASN1_STRING *str, unsigned long flags);
+ #endif
+@@ -927,14 +930,16 @@
+ 
+ #ifndef OPENSSL_NO_BIO
+ void *ASN1_d2i_bio(void *(*xnew)(void), d2i_of_void *d2i, BIO *in, void **x);
++static void * __attribute__((unused)) __ASN1_d2i_bio=openssl_fcast(ASN1_d2i_bio);
+ #define ASN1_d2i_bio_of(type,xnew,d2i,in,x) \
+-	((type *(*)(type *(*)(void),D2I_OF(type),BIO *,type **))openssl_fcast(ASN1_d2i_bio))(xnew,d2i,in,x)
++	((type *(*)(type *(*)(void),D2I_OF(type),BIO *,type **))__ASN1_d2i_bio)(xnew,d2i,in,x)
+ void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x);
+ int ASN1_i2d_bio(i2d_of_void *i2d,BIO *out, unsigned char *x);
++static void * __attribute__((unused)) __ASN1_i2d_bio=openssl_fcast(ASN1_i2d_bio);
+ #define ASN1_i2d_bio_of(type,i2d,out,x) \
+-	((int (*)(I2D_OF(type),BIO *,type *))openssl_fcast(ASN1_i2d_bio))(i2d,out,x)
++	((int (*)(I2D_OF(type),BIO *,type *))__ASN1_i2d_bio)(i2d,out,x)
+ #define ASN1_i2d_bio_of_const(type,i2d,out,x) \
+-	((int (*)(I2D_OF_const(type),BIO *,const type *))openssl_fcast(ASN1_i2d_bio))(i2d,out,x)
++	((int (*)(I2D_OF_const(type),BIO *,const type *))__ASN1_i2d_bio)(i2d,out,x)
+ int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x);
+ int ASN1_UTCTIME_print(BIO *fp,ASN1_UTCTIME *a);
+ int ASN1_GENERALIZEDTIME_print(BIO *fp,ASN1_GENERALIZEDTIME *a);
+@@ -977,8 +982,9 @@
+ void *ASN1_item_unpack(ASN1_STRING *oct, const ASN1_ITEM *it);
+ ASN1_STRING *ASN1_pack_string(void *obj, i2d_of_void *i2d,
+ 			      ASN1_OCTET_STRING **oct);
++static void * __attribute__((unused)) __ASN1_pack_string=openssl_fcast(ASN1_pack_string);
+ #define ASN1_pack_string_of(type,obj,i2d,oct) \
+-	((ASN1_STRING *(*)(type *,I2D_OF(type),ASN1_OCTET_STRING **))openssl_fcast(ASN1_pack_string))(obj,i2d,oct)
++	((ASN1_STRING *(*)(type *,I2D_OF(type),ASN1_OCTET_STRING **))__ASN1_pack_string)(obj,i2d,oct)
+ ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it, ASN1_OCTET_STRING **oct);
+ 
+ void ASN1_STRING_set_default_mask(unsigned long mask);
+--- openssl-0.9.8d/crypto/ocsp/ocsp.h.ark	2006-11-08 19:28:48.000000000 +0100
++++ openssl-0.9.8d/crypto/ocsp/ocsp.h	2006-11-08 19:29:47.000000000 +0100
+@@ -468,8 +468,9 @@
+ 
+ ASN1_STRING *ASN1_STRING_encode(ASN1_STRING *s, i2d_of_void *i2d,
+ 				void *data, STACK_OF(ASN1_OBJECT) *sk);
++static void * __attribute__((unused)) __ASN1_STRING_encode=openssl_fcast(ASN1_STRING_encode);
+ #define ASN1_STRING_encode_of(type,s,i2d,data,sk) \
+-((ASN1_STRING *(*)(ASN1_STRING *,I2D_OF(type),type *,STACK_OF(ASN1_OBJECT) *))openssl_fcast(ASN1_STRING_encode))(s,i2d,data,sk)
++((ASN1_STRING *(*)(ASN1_STRING *,I2D_OF(type),type *,STACK_OF(ASN1_OBJECT) *))__ASN1_STRING_encode)(s,i2d,data,sk)
+ 
+ X509_EXTENSION *OCSP_crlID_new(char *url, long *n, char *tim);
+ 
+--- openssl-0.9.8d/crypto/pem/pem.h.ark	2006-11-08 19:09:51.000000000 +0100
++++ openssl-0.9.8d/crypto/pem/pem.h	2006-11-08 19:43:45.000000000 +0100
+@@ -220,19 +220,22 @@
+ #define IMPLEMENT_PEM_read_fp(name, type, str, asn1) \
+ type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u)\
+ { \
+-return(((type *(*)(D2I_OF(type),char *,FILE *,type **,pem_password_cb *,void *))openssl_fcast(PEM_ASN1_read))(d2i_##asn1, str,fp,x,cb,u)); \
++static void *__PEM_ASN1_read=openssl_fcast(PEM_ASN1_read); \
++return(((type *(*)(D2I_OF(type),char *,FILE *,type **,pem_password_cb *,void *))__PEM_ASN1_read)(d2i_##asn1, str,fp,x,cb,u)); \
+ } \
+ 
+ #define IMPLEMENT_PEM_write_fp(name, type, str, asn1) \
+ int PEM_write_##name(FILE *fp, type *x) \
+ { \
+-return(((int (*)(I2D_OF(type),const char *,FILE *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write))(i2d_##asn1,str,fp,x,NULL,NULL,0,NULL,NULL)); \
++static void *__PEM_ASN1_write=openssl_fcast(PEM_ASN1_write); \
++return(((int (*)(I2D_OF(type),const char *,FILE *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))__PEM_ASN1_write)(i2d_##asn1,str,fp,x,NULL,NULL,0,NULL,NULL)); \
+ }
+ 
+ #define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \
+ int PEM_write_##name(FILE *fp, const type *x) \
+ { \
+-return(((int (*)(I2D_OF_const(type),const char *,FILE *, const type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write))(i2d_##asn1,str,fp,x,NULL,NULL,0,NULL,NULL)); \
++static void *__PEM_ASN1_write=openssl_fcast(PEM_ASN1_write); \
++return(((int (*)(I2D_OF_const(type),const char *,FILE *, const type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))__PEM_ASN1_write)(i2d_##asn1,str,fp,x,NULL,NULL,0,NULL,NULL)); \
+ }
+ 
+ #define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) \
+@@ -240,7 +243,8 @@
+ 	     unsigned char *kstr, int klen, pem_password_cb *cb, \
+ 		  void *u) \
+ 	{ \
+-	return(((int (*)(I2D_OF(type),const char *,FILE *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write))(i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u)); \
++	static void *__PEM_ASN1_write=openssl_fcast(PEM_ASN1_write); \
++	return(((int (*)(I2D_OF(type),const char *,FILE *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))__PEM_ASN1_write)(i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u)); \
+ 	}
+ 
+ #define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \
+@@ -248,7 +252,8 @@
+ 	     unsigned char *kstr, int klen, pem_password_cb *cb, \
+ 		  void *u) \
+ 	{ \
+-	return(((int (*)(I2D_OF_const(type),const char *,FILE *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write))(i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u)); \
++	static void *__PEM_ASN1_write=openssl_fcast(PEM_ASN1_write); \
++	return(((int (*)(I2D_OF_const(type),const char *,FILE *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))__PEM_ASN1_write)(i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u)); \
+ 	}
+ 
+ #endif
+@@ -256,33 +261,38 @@
+ #define IMPLEMENT_PEM_read_bio(name, type, str, asn1) \
+ type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u)\
+ { \
+-return(((type *(*)(D2I_OF(type),const char *,BIO *,type **,pem_password_cb *,void *))openssl_fcast(PEM_ASN1_read_bio))(d2i_##asn1, str,bp,x,cb,u)); \
++static void *__PEM_ASN1_read_bio=openssl_fcast(PEM_ASN1_read_bio); \
++return(((type *(*)(D2I_OF(type),const char *,BIO *,type **,pem_password_cb *,void *))__PEM_ASN1_read_bio)(d2i_##asn1, str,bp,x,cb,u)); \
+ }
+ 
+ #define IMPLEMENT_PEM_write_bio(name, type, str, asn1) \
+ int PEM_write_bio_##name(BIO *bp, type *x) \
+ { \
+-return(((int (*)(I2D_OF(type),const char *,BIO *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write_bio))(i2d_##asn1,str,bp,x,NULL,NULL,0,NULL,NULL)); \
++static void *__PEM_ASN1_write_bio=openssl_fcast(PEM_ASN1_write_bio); \
++return(((int (*)(I2D_OF(type),const char *,BIO *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))__PEM_ASN1_write_bio)(i2d_##asn1,str,bp,x,NULL,NULL,0,NULL,NULL)); \
+ }
+ 
+ #define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \
+ int PEM_write_bio_##name(BIO *bp, const type *x) \
+ { \
+-return(((int (*)(I2D_OF_const(type),const char *,BIO *,const type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write_bio))(i2d_##asn1,str,bp,x,NULL,NULL,0,NULL,NULL)); \
++static void *__PEM_ASN1_write_bio=openssl_fcast(PEM_ASN1_write_bio); \
++return(((int (*)(I2D_OF_const(type),const char *,BIO *,const type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))__PEM_ASN1_write_bio)(i2d_##asn1,str,bp,x,NULL,NULL,0,NULL,NULL)); \
+ }
+ 
+ #define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \
+ int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \
+ 	     unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \
+ 	{ \
+-	return(((int (*)(I2D_OF(type),const char *,BIO *,type *,const EVP_CIPHER *,unsigned char *,int,pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write_bio))(i2d_##asn1,str,bp,x,enc,kstr,klen,cb,u)); \
++	static void *__PEM_ASN1_write_bio=openssl_fcast(PEM_ASN1_write_bio); \
++	return(((int (*)(I2D_OF(type),const char *,BIO *,type *,const EVP_CIPHER *,unsigned char *,int,pem_password_cb *,void *))__PEM_ASN1_write_bio)(i2d_##asn1,str,bp,x,enc,kstr,klen,cb,u)); \
+ 	}
+ 
+ #define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \
+ int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \
+ 	     unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \
+ 	{ \
+-	return(((int (*)(I2D_OF_const(type),const char *,BIO *,type *,const EVP_CIPHER *,unsigned char *,int,pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write_bio))(i2d_##asn1,str,bp,x,enc,kstr,klen,cb,u)); \
++	static void *__PEM_ASN1_write_bio=openssl_fcast(PEM_ASN1_write_bio); \
++	return(((int (*)(I2D_OF_const(type),const char *,BIO *,type *,const EVP_CIPHER *,unsigned char *,int,pem_password_cb *,void *))__PEM_ASN1_write_bio)(i2d_##asn1,str,bp,x,enc,kstr,klen,cb,u)); \
+ 	}
+ 
+ #define IMPLEMENT_PEM_write(name, type, str, asn1) \
+@@ -545,13 +555,15 @@
+ 	     pem_password_cb *cb, void *u);
+ void *	PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp,
+ 			  void **x, pem_password_cb *cb, void *u);
++static void * __attribute__((unused)) __PEM_ASN1_read_bio=openssl_fcast(PEM_ASN1_read_bio);
+ #define PEM_ASN1_read_bio_of(type,d2i,name,bp,x,cb,u) \
+-((type *(*)(D2I_OF(type),const char *,BIO *,type **,pem_password_cb *,void *))openssl_fcast(PEM_ASN1_read_bio))(d2i,name,bp,x,cb,u)
++((type *(*)(D2I_OF(type),const char *,BIO *,type **,pem_password_cb *,void *))__PEM_ASN1_read_bio)(d2i,name,bp,x,cb,u)
+ int	PEM_ASN1_write_bio(i2d_of_void *i2d,const char *name,BIO *bp,char *x,
+ 			   const EVP_CIPHER *enc,unsigned char *kstr,int klen,
+ 			   pem_password_cb *cb, void *u);
++static void * __attribute__((unused)) __PEM_ASN1_write_bio=openssl_fcast(PEM_ASN1_write_bio);
+ #define PEM_ASN1_write_bio_of(type,i2d,name,bp,x,enc,kstr,klen,cb,u) \
+-	((int (*)(I2D_OF(type),const char *,BIO *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write_bio))(i2d,name,bp,x,enc,kstr,klen,cb,u)
++	((int (*)(I2D_OF(type),const char *,BIO *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))__PEM_ASN1_write_bio)(i2d,name,bp,x,enc,kstr,klen,cb,u)
+ 
+ STACK_OF(X509_INFO) *	PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb, void *u);
+ int	PEM_X509_INFO_write_bio(BIO *bp,X509_INFO *xi, EVP_CIPHER *enc,
+
+______________________________________________________________________
+OpenSSL Project                                 http://www.openssl.org
+Development Mailing List                       openssl-... at openssl.org
+Automated List Manager                           majord... at openssl.org
================================================================

---- gitweb:

http://git.pld-linux.org/gitweb.cgi/packages/openssl102.git/commitdiff/9fc1b1b87b259e8a327c99835865e91a391efc9e



More information about the pld-cvs-commit mailing list