开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
align_test.c
资源名称：cdrdao-1.1.3.src.tar.gz　[点击查看]
上传用户：weiliju62
上传日期：2007-01-06
资源大小：619k
文件大小：13k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

align_test.c：源码内容
  1. /* @(#)align_test.c 1.10 99/08/30 Copyright 1995 J. Schilling */
  2. #ifndef lint
  3. static char sccsid[] =
  4. "@(#)align_test.c 1.10 99/08/30 Copyright 1995 J. Schilling";
  5. #endif
  6. /*
  7.  * Generate machine dependant align.h
  8.  *
  9.  * Copyright (c) 1995 J. Schilling
  10.  */
  11. /*
  12.  * This program is free software; you can redistribute it and/or modify
  13.  * it under the terms of the GNU General Public License as published by
  14.  * the Free Software Foundation; either version 2, or (at your option)
  15.  * any later version.
  16.  *
  17.  * This program is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.  * GNU General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU General Public License
  23.  * along with this program; see the file COPYING.  If not, write to
  24.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  25.  */
  27. #include <mconfig.h>
  28. #include <stdio.h>
  29. #include <standard.h>
  31. /*#define FORCE_ALIGN*/
  32. /*#define OFF_ALIGN*/
  33. /*#define CHECK_ALIGN*/
  35. EXPORT int main __PR((int ac, char** av));
  37. #if !defined(FORCE_ALIGN) && !defined(OFF_ALIGN) && !defined(CHECK_ALIGN)
  38. #define OFF_ALIGN
  39. #endif
  41. char buf[8192+1024];
  42. char *buf_aligned;
  44. #ifdef FORCE_ALIGN
  45. # undef CHECK_ALIGN
  46. # undef OFF_ALIGN
  47. #endif
  49. #ifdef CHECK_ALIGN
  50. # undef FORCE_ALIGN
  51. # undef OFF_ALIGN
  52. #endif
  54. #ifdef OFF_ALIGN
  55. # undef FORCE_ALIGN
  56. # undef CHECK_ALIGN
  57. #endif
  60. #ifdef FORCE_ALIGN
  62. #define ALIGN_short sizeof (short)
  63. #define ALIGN_int sizeof (int)
  64. #define ALIGN_long sizeof (long)
  65. #define ALIGN_longlong sizeof (long long)
  66. #define ALIGN_float sizeof (float)
  67. #define ALIGN_double sizeof (double)
  68. #define ALIGN_ptr sizeof (char *)
  70. #endif
  72. #ifdef CHECK_ALIGN
  74. #include <signal.h>
  75. #include <setjmp.h>
  76. LOCAL jmp_buf jb;
  78. LOCAL int check_align __PR((int (*)(char*, int), void (*)(char*, int), int));
  79. LOCAL int check_short __PR((char *, int));
  80. LOCAL int check_int __PR((char *, int));
  81. LOCAL int check_long __PR((char *, int));
  82. LOCAL int check_longlong __PR((char *, int));
  83. LOCAL int check_float __PR((char *, int));
  84. LOCAL int check_double __PR((char *, int));
  85. LOCAL int check_ptr __PR((char *, int));
  87. LOCAL int speed_check __PR((char *, void (*)(char*, int), int));
  88. LOCAL void speed_short __PR((char *, int));
  89. LOCAL void speed_int __PR((char *, int));
  90. LOCAL void speed_long __PR((char *, int));
  91. LOCAL void speed_longlong __PR((char *, int));
  92. LOCAL void speed_float __PR((char *, int));
  93. LOCAL void speed_double __PR((char *, int));
  94. LOCAL void speed_ptr __PR((char *, int));
  96. #define ALIGN_short check_align(check_short, speed_short, sizeof (short))
  97. #define ALIGN_int check_align(check_int, speed_int, sizeof (int))
  98. #define ALIGN_long check_align(check_long, speed_long, sizeof (long))
  99. #define ALIGN_longlong check_align(check_longlong, speed_longlong, sizeof (long long))
  100. #define ALIGN_float check_align(check_float, speed_float, sizeof (float))
  101. #define ALIGN_double check_align(check_double, speed_double, sizeof (double))
  102. #define ALIGN_ptr check_align(check_ptr, speed_ptr, sizeof (char *))
  104. #endif
  106. #ifdef OFF_ALIGN
  108. #define sm_off(s, m) ((int)&((s)0)->m)
  110. LOCAL int off_short __PR((void));
  111. LOCAL int off_int __PR((void));
  112. LOCAL int off_long __PR((void));
  113. LOCAL int off_longlong __PR((void));
  114. LOCAL int off_float __PR((void));
  115. LOCAL int off_double __PR((void));
  116. LOCAL int off_ptr __PR((void));
  118. #define ALIGN_short off_short()
  119. #define ALIGN_int off_int()
  120. #define ALIGN_long off_long()
  121. #define ALIGN_longlong off_longlong()
  122. #define ALIGN_float off_float()
  123. #define ALIGN_double off_double()
  124. #define ALIGN_ptr off_ptr()
  126. #endif
  128. LOCAL void printmacs __PR((void));
  130. #ifdef CHECK_ALIGN
  131. LOCAL void sig __PR((int));
  133. LOCAL void
  134. sig(signo)
  135. int signo;
  136. {
  137. signal(signo, sig);
  138. longjmp(jb, 1);
  139. }
  140. #endif
  142. #if defined(mc68000) || defined(mc68020)
  143. #define MIN_ALIGN 2
  144. #else
  145. #define MIN_ALIGN 2
  146. #endif
  149. #define min_align(i) (((i) < MIN_ALIGN) ? MIN_ALIGN : (i))
  151. char al[] = "alignment value for ";
  152. char ms[] = "alignment mask  for ";
  153. char so[] = "sizeof ";
  154. char sh[] = "short";
  155. char in[] = "int";
  156. char lo[] = "long";
  157. char ll[] = "long long";
  158. char fl[] = "float";
  159. char db[] = "double";
  160. char pt[] = "pointer";
  162. #define xalign(x, a, m) ( ((char *)(x)) + ( (a) - (((int)(x))&(m))) )
  164. EXPORT int
  165. main(ac, av)
  166. int ac;
  167. char **av;
  168. {
  169. char *p;
  170. int i;
  171. int s;
  173. #ifdef CHECK_ALIGN
  174. signal(SIGBUS, sig);
  175. #endif
  177. i = ((int)buf) % 1024;
  178. i = 1024 - i;
  179. p = &buf[i];
  180. buf_aligned = p;
  182. #ifdef DEBUG
  183. printf("buf: %lX %lXn",
  184. (unsigned long)buf, (unsigned long)xalign(buf, 1024, 1023));
  185. #endif
  187. printf("/*n");
  188. printf(" * This file has been generated automaticallyn");
  189. printf(" * by %sn", sccsid);
  190. printf(" * do not edit by hand.n");
  191. printf(" */n");
  193. s = sizeof(short);
  194. i  = ALIGN_short;
  195. i = min_align(i);
  196. printf("n");
  197. printf("#define ALIGN_SHORT %dt/* %s(%s *)t*/n", i, al, sh);
  198. printf("#define ALIGN_SMASK %dt/* %s(%s *)t*/n", i-1, ms, sh);
  199. printf("#define SIZE_SHORT %dt/* %s(%s)ttt*/n", s, so, sh);
  201. s = sizeof(int);
  202. i  = ALIGN_int;
  203. i = min_align(i);
  204. printf("n");
  205. printf("#define ALIGN_INT %dt/* %s(%s *)tt*/n", i, al, in);
  206. printf("#define ALIGN_IMASK %dt/* %s(%s *)tt*/n", i-1, ms, in);
  207. printf("#define SIZE_INT %dt/* %s(%s)tttt*/n", s, so, in);
  209. s = sizeof(long);
  210. i  = ALIGN_long;
  211. i = min_align(i);
  212. printf("n");
  213. printf("#define ALIGN_LONG %dt/* %s(%s *)tt*/n", i, al, lo);
  214. printf("#define ALIGN_LMASK %dt/* %s(%s *)tt*/n", i-1, ms, lo);
  215. printf("#define SIZE_LONG %dt/* %s(%s)ttt*/n", s, so, lo);
  217. #ifdef HAVE_LONGLONG
  218. s = sizeof(long long);
  219. i  = ALIGN_longlong;
  220. i = min_align(i);
  221. #endif
  222. printf("n");
  223. printf("#define ALIGN_LLONG %dt/* %s(%s *)t*/n", i, al, ll);
  224. printf("#define ALIGN_LLMASK %dt/* %s(%s *)t*/n", i-1, ms, ll);
  225. printf("#define SIZE_LLONG %dt/* %s(%s)ttt*/n", s, so, ll);
  227. s = sizeof(float);
  228. i  = ALIGN_float;
  229. i = min_align(i);
  230. printf("n");
  231. printf("#define ALIGN_FLOAT %dt/* %s(%s *)t*/n", i, al, fl);
  232. printf("#define ALIGN_FMASK %dt/* %s(%s *)t*/n", i-1, ms, fl);
  233. printf("#define SIZE_FLOAT %dt/* %s(%s)ttt*/n", s, so, fl);
  235. s = sizeof(double);
  236. i  = ALIGN_double;
  237. i = min_align(i);
  238. printf("n");
  239. printf("#define ALIGN_DOUBLE %dt/* %s(%s *)t*/n", i, al, db);
  240. printf("#define ALIGN_DMASK %dt/* %s(%s *)t*/n", i-1, ms, db);
  241. printf("#define SIZE_DOUBLE %dt/* %s(%s)ttt*/n", s, so, db);
  243. s = sizeof(char *);
  244. i  = ALIGN_ptr;
  245. i = min_align(i);
  246. printf("n");
  247. printf("#define ALIGN_PTR %dt/* %s(%s *)t*/n", i, al, pt);
  248. printf("#define ALIGN_PMASK %dt/* %s(%s *)t*/n", i-1, ms, pt);
  249. printf("#define SIZE_PTR %dt/* %s(%s)ttt*/n", s, so, pt);
  251. printmacs();
  252. return (0);
  253. }
  255. LOCAL void
  256. printmacs()
  257. {
  258. printf("n");
  259. printf("#define xaligned(a, s) ((((int)(a)) & s) == 0 )n");
  260. printf("#define x2aligned(a, b, s) (((((int)(a)) | ((int)(b))) & s) == 0 )n");
  261. printf("n");
  262. printf("#define saligned(a) xaligned(a, ALIGN_SMASK)n");
  263. printf("#define s2aligned(a, b) x2aligned(a, b, ALIGN_SMASK)n");
  264. printf("n");
  265. printf("#define ialigned(a) xaligned(a, ALIGN_IMASK)n");
  266. printf("#define i2aligned(a, b) x2aligned(a, b, ALIGN_IMASK)n");
  267. printf("n");
  268. printf("#define laligned(a) xaligned(a, ALIGN_LMASK)n");
  269. printf("#define l2aligned(a, b) x2aligned(a, b, ALIGN_LMASK)n");
  270. printf("n");
  271. printf("#define llaligned(a) xaligned(a, ALIGN_LLMASK)n");
  272. printf("#define ll2aligned(a, b) x2aligned(a, b, ALIGN_LLMASK)n");
  273. printf("n");
  274. printf("#define faligned(a) xaligned(a, ALIGN_FMASK)n");
  275. printf("#define f2aligned(a, b) x2aligned(a, b, ALIGN_FMASK)n");
  276. printf("n");
  277. printf("#define daligned(a) xaligned(a, ALIGN_DMASK)n");
  278. printf("#define d2aligned(a, b) x2aligned(a, b, ALIGN_DMASK)n");
  279. printf("n");
  280. printf("#define paligned(a) xaligned(a, ALIGN_PMASK)n");
  281. printf("#define p2aligned(a, b) x2aligned(a, b, ALIGN_PMASK)n");
  283. printf("nn");
  284. printf("/*n * I know excatly what I am doing here!n * The warning message from GCC is wrong.n");
  285. printf(" * Believe me that this macro would even be usable if I would cast to short.n */n");
  286. printf("#define xalign(x, a, m) ( ((char *)(x)) + ( (a) - (((int)(x))&(m))) )n");
  287. printf("n");
  288. printf("#define salign(x) xalign((x), ALIGN_SHORT, ALIGN_SMASK)n");
  289. printf("#define ialign(x) xalign((x), ALIGN_INT, ALIGN_IMASK)n");
  290. printf("#define lalign(x) xalign((x), ALIGN_LONG, ALIGN_LMASK)n");
  291. printf("#define llalign(x) xalign((x), ALIGN_LLONG, ALIGN_LLMASK)n");
  292. printf("#define falign(x) xalign((x), ALIGN_FLOAT, ALIGN_FMASK)n");
  293. printf("#define dalign(x) xalign((x), ALIGN_DOUBLE, ALIGN_DMASK)n");
  294. printf("#define palign(x) xalign((x), ALIGN_PTR, ALIGN_PMASK)n");
  295. }
  297. #ifdef CHECK_ALIGN
  298. /*
  299.  * Routines to compute the alignement by checking if the assignement
  300.  * causes a bus error.
  301.  * Some systems (e.g. Linux on DEC Aplha) will allow to fetch any
  302.  * type from any address. On these systems we must check the speed
  303.  * because unaligned fetches will take more time.
  304.  */
  305. LOCAL int
  306. check_align(cfunc, sfunc, tsize)
  307. int (*cfunc)();
  308. void (*sfunc)();
  309. int tsize;
  310. {
  311.  int calign;
  312.  int align;
  313.  int tcheck;
  314.  int t;
  315. register int i;
  316. register char *p = buf_aligned;
  318. for (i=1; i < 128; i++) {
  319. if (!setjmp(jb)) {
  320. (cfunc)(p, i);
  321. break;
  322. }
  323. }
  324. #ifdef DEBUG
  325. printf("i: %d tsize: %dn", i, tsize);
  326. #endif
  327. if (i == tsize)
  328. return (i);
  330. align = calign = i;
  331. tcheck = speed_check(p, sfunc, i);
  332. #ifdef DEBUG
  333. printf("tcheck: %dn", tcheck);
  334. #endif
  336. for (i = calign*2; i <= tsize; i *= 2) {
  337. t = speed_check(p, sfunc, i);
  338. #ifdef DEBUG
  339. printf("tcheck: %d t: %d i: %dn", tcheck, t, i);
  340. printf("tcheck - t: %d ... * 3: %dn",  (tcheck - t), (tcheck - t) * 3);
  341. #endif
  342. if (((tcheck - t) > 0) && ((tcheck - t) * 3) > tcheck) {
  343. #ifdef DEBUG
  344. printf("kleinern");
  345. #endif
  346. align = i;
  347. tcheck = t;
  348. }
  349. }
  350. return (align);
  351. }
  353. LOCAL int
  354. check_short(p, i)
  355. char *p;
  356. int i;
  357. {
  358. short *sp;
  360. sp = (short *)&p[i];
  361. *sp = 1;
  362. return (0);
  363. }
  365. LOCAL int
  366. check_int(p, i)
  367. char *p;
  368. int i;
  369. {
  370. int *ip;
  372. ip = (int *)&p[i];
  373. *ip = 1;
  374. return (0);
  375. }
  377. LOCAL int
  378. check_long(p, i)
  379. char *p;
  380. int i;
  381. {
  382. long *lp;
  384. lp = (long *)&p[i];
  385. *lp = 1;
  386. return (0);
  387. }
  389. #ifdef HAVE_LONGLONG
  390. LOCAL int
  391. check_longlong(p, i)
  392. char *p;
  393. int i;
  394. {
  395. long long *llp;
  397. llp = (long long *)&p[i];
  398. *llp = 1;
  399. return (0);
  400. }
  401. #endif
  403. LOCAL int
  404. check_float(p, i)
  405. char *p;
  406. int i;
  407. {
  408. float *fp;
  410. fp = (float *)&p[i];
  411. *fp = 1.0;
  412. return (0);
  413. }
  415. LOCAL int
  416. check_double(p, i)
  417. char *p;
  418. int i;
  419. {
  420. double *dp;
  422. dp = (double *)&p[i];
  423. *dp = 1.0;
  424. return (0);
  425. }
  427. LOCAL int
  428. check_ptr(p, i)
  429. char *p;
  430. int i;
  431. {
  432. char **pp;
  434. pp = (char  **)&p[i];
  435. *pp = (char *)1;
  436. return (0);
  437. }
  439. /*
  440.  * Routines to compute the alignement by checking the speed of the
  441.  * assignement.
  442.  * Some systems (e.g. Linux on DEC Aplha) will allow to fetch any
  443.  * type from any address. On these systems we must check the speed
  444.  * because unaligned fetches will take more time.
  445.  */
  446. LOCAL void
  447. speed_short(p, n)
  448. char *p;
  449. int n;
  450. {
  451. short *sp;
  452. int i;
  454. sp = (short *)&p[n];
  456. for (i = 1000000; --i >= 0;)
  457. *sp = i;
  458. }
  460. LOCAL void
  461. speed_int(p, n)
  462. char *p;
  463. int n;
  464. {
  465. int *ip;
  466. int i;
  468. ip = (int *)&p[n];
  470. for (i = 1000000; --i >= 0;)
  471. *ip = i;
  472. }
  474. LOCAL void
  475. speed_long(p, n)
  476. char *p;
  477. int n;
  478. {
  479. long *lp;
  480. int i;
  482. lp = (long *)&p[n];
  484. for (i = 1000000; --i >= 0;)
  485. *lp = i;
  486. }
  488. #ifdef HAVE_LONGLONG
  489. LOCAL void
  490. speed_longlong(p, n)
  491. char *p;
  492. int n;
  493. {
  494. long long *llp;
  495. int i;
  497. llp = (long long *)&p[n];
  499. for (i = 1000000; --i >= 0;)
  500. *llp = i;
  501. }
  502. #endif
  504. LOCAL void
  505. speed_float(p, n)
  506. char *p;
  507. int n;
  508. {
  509. float *fp;
  510. int i;
  512. fp = (float *)&p[n];
  514. for (i = 1000000; --i >= 0;)
  515. *fp = i;
  516. }
  518. LOCAL void
  519. speed_double(p, n)
  520. char *p;
  521. int n;
  522. {
  523. double *dp;
  524. int i;
  526. dp = (double *)&p[n];
  528. for (i = 1000000; --i >= 0;)
  529. *dp = i;
  530. }
  532. LOCAL void
  533. speed_ptr(p, n)
  534. char *p;
  535. int n;
  536. {
  537. char **pp;
  538. int i;
  540. pp = (char **)&p[n];
  542. for (i = 1000000; --i >= 0;)
  543. *pp = (char *)i;
  544. }
  546. #include <sys/times.h>
  547. LOCAL int
  548. speed_check(p, sfunc, n)
  549. char *p;
  550. void (*sfunc)();
  551. int n;
  552. {
  553. struct tms tm1;
  554. struct tms tm2;
  556. times(&tm1);
  557. (*sfunc)(p, n);
  558. times(&tm2);
  560. #ifdef DEBUG
  561. printf("t1: %ldn", (long) tm2.tms_utime-tm1.tms_utime);
  562. #endif
  564. return ((int) tm2.tms_utime-tm1.tms_utime);
  565. }
  567. #endif /* CHECK_ALIGN */
  569. #ifdef OFF_ALIGN
  570. /*
  571.  * Routines to compute the alignement by using the knowledge
  572.  * of the C-compiler.
  573.  * We define a structure and check the padding that has been inserted
  574.  * by the compiler to keep the apropriate type on a properly aligned
  575.  * address.
  576.  */
  577. LOCAL int
  578. off_short()
  579. {
  580. struct ss {
  581. char c;
  582. short s;
  583. } ss;
  584. ss.c = 0; /* fool C-compiler */
  586. return (sm_off(struct ss *, s));
  587. }
  589. LOCAL int
  590. off_int()
  591. {
  592. struct si {
  593. char c;
  594. int i;
  595. } si;
  596. si.c = 0; /* fool C-compiler */
  598. return (sm_off(struct si *, i));
  599. }
  601. LOCAL int
  602. off_long()
  603. {
  604. struct sl {
  605. char c;
  606. long l;
  607. } sl;
  608. sl.c = 0; /* fool C-compiler */
  610. return (sm_off(struct sl *, l));
  611. }
  613. #ifdef HAVE_LONGLONG
  614. LOCAL int
  615. off_longlong()
  616. {
  617. struct sll {
  618. char c;
  619. long long ll;
  620. } sll;
  621. sll.c = 0; /* fool C-compiler */
  623. return (sm_off(struct sll *, ll));
  624. }
  625. #endif
  627. LOCAL int
  628. off_float()
  629. {
  630. struct sf {
  631. char c;
  632. float f;
  633. } sf;
  634. sf.c = 0; /* fool C-compiler */
  636. return (sm_off(struct sf *, f));
  637. }
  639. LOCAL int
  640. off_double()
  641. {
  642. struct sd {
  643. char c;
  644. double d;
  645. } sd;
  646. sd.c = 0; /* fool C-compiler */
  648. return (sm_off(struct sd *, d));
  649. }
  651. LOCAL int
  652. off_ptr()
  653. {
  654. struct sp {
  655. char c;
  656. char *p;
  657. } sp;
  658. sp.c = 0; /* fool C-compiler */
  660. return (sm_off(struct sp *, p));
  661. }
  663. #endif /* OFF_ALIGN */