Commit 7fd7221e authored by Patrick Lam's avatar Patrick Lam

Add *NeededBytesAlign(), which overestimates the padding which is later

    added by the new ALIGN macro. Fix alignment problems on ia64 and s390
    by bumping up block_ptr appropriately. (Earlier version by Andreas
    Schwab).
Use sysconf to determine proper PAGESIZE value; this appears to be
    POSIX-compliant. (reported by Andreas Schwab)
reviewed by: plam
parent 82f35f8b
2005-11-16 Patrick Lam <plam@mit.edu>
* src/fccache.c (FcDirCacheProduce):
* src/fccharset.c (FcCharSetDistributeBytes):
* src/fcfs.c (FcFontSetDistributeBytes):
* src/fcint.h:
* src/fclang.c (FcLangSetDistributeBytes):
* src/fcname.c (FcObjectDistributeBytes):
* src/fcpat.c (FcPatternNeededBytes, FcValueListNeededBytes,
FcStrNeededBytes):
Add *NeededBytesAlign(), which overestimates the padding which is
later added by the new ALIGN macro. Fix alignment problems on
ia64 and s390 by bumping up block_ptr appropriately. (Earlier
version by Andreas Schwab).
2005-11-16 Stephan Kulow <coolo@kde.org>
reviewed by: plam
* src/fccache.c:
Use sysconf to determine proper PAGESIZE value; this
appears to be POSIX-compliant. (reported by Andreas Schwab)
2005-11-04 Patrick Lam <plam@mit.edu>
* fc-lang/fc-lang.c:
* src/fccharset.c:
......
......@@ -30,9 +30,10 @@
#include <sys/types.h>
#include <unistd.h>
#include "fcint.h"
#include <unistd.h>
#define ENDIAN_TEST 0x12345678
#define MACHINE_SIGNATURE_SIZE 9 + 5*19 + 1
#define MACHINE_SIGNATURE_SIZE 9 + 5*20 + 1
static off_t
FcCacheSkipToArch (int fd, const char * arch);
......@@ -417,7 +418,6 @@ FcGlobalCacheSave (FcGlobalCache *cache,
return FcFalse;
}
#define PAGESIZE 8192
/*
* Find the next presumably-mmapable offset after the supplied file
* position.
......@@ -425,10 +425,13 @@ FcGlobalCacheSave (FcGlobalCache *cache,
static int
FcCacheNextOffset(off_t w)
{
if (w % PAGESIZE == 0)
static long pagesize = -1;
if (pagesize == -1)
pagesize = sysconf(_SC_PAGESIZE);
if (w % pagesize == 0)
return w;
else
return ((w / PAGESIZE)+1)*PAGESIZE;
return ((w / pagesize)+1)*pagesize;
}
/* return the address of the segment for the provided arch,
......@@ -801,7 +804,8 @@ FcDirCacheProduce (FcFontSet *set, FcCache *metadata)
memset (metadata, 0, sizeof(FcCache));
FcFontSetNewBank();
metadata->count = FcFontSetNeededBytes (set);
metadata->count = FcFontSetNeededBytes (set) +
FcFontSetNeededBytesAlign ();
metadata->magic = FC_CACHE_MAGIC;
metadata->bank = bank;
......@@ -943,12 +947,12 @@ static char *
FcCacheMachineSignature ()
{
static char buf[MACHINE_SIGNATURE_SIZE];
int magic = ENDIAN_TEST;
int32_t magic = ENDIAN_TEST;
char * m = (char *)&magic;
sprintf (buf, "%2x%2x%2x%2x "
"%4x %4x %4x %4x %4x %4x %4x %4x %4x %4x %4x %4x "
"%4x %4x %4x %4x %4x %4x %4x\n",
"%4x %4x %4x %4x %4x %4x %4x %4x\n",
m[0], m[1], m[2], m[3],
(unsigned int)sizeof (char),
(unsigned int)sizeof (char *),
......@@ -968,7 +972,8 @@ FcCacheMachineSignature ()
(unsigned int)sizeof (FcChar16),
(unsigned int)sizeof (FcCharLeaf),
(unsigned int)sizeof (FcChar32),
(unsigned int)sizeof (FcCache));
(unsigned int)sizeof (FcCache),
(unsigned int)sysconf(_SC_PAGESIZE));
return buf;
}
......
......@@ -1331,6 +1331,13 @@ FcCharSetNeededBytes (const FcCharSet *c)
sizeof (FcChar16) * c->num; /* number */
}
int
FcCharSetNeededBytesAlign (void)
{
return __alignof__ (FcCharSet) + __alignof__ (int) +
__alignof__ (FcCharLeaf) + __alignof__ (FcChar16);
}
static FcBool
FcCharSetEnsureBank (int bi)
{
......@@ -1373,15 +1380,19 @@ FcCharSetDistributeBytes (FcCache * metadata, void * block_ptr)
return 0;
charsets[bi] = (FcCharSet *)block_ptr;
block_ptr = ALIGN (block_ptr, FcCharSet);
block_ptr = (void *)((char *)block_ptr +
(sizeof (FcCharSet) * charset_count));
numbers[bi] = (FcChar16 *)block_ptr;
block_ptr = ALIGN (block_ptr, FcChar16);
block_ptr = (void *)((char *)block_ptr +
(sizeof(FcChar16) * charset_numbers_count));
leaves[bi] = (FcCharLeaf *)block_ptr;
block_ptr = ALIGN (block_ptr, FcCharLeaf);
block_ptr = (void *)((char *)block_ptr +
(sizeof(FcCharLeaf) * charset_leaf_count));
leaf_idx[bi] = (int *)block_ptr;
block_ptr = ALIGN (block_ptr, int);
block_ptr = (void *)((char *)block_ptr +
(sizeof(int) * charset_leaf_idx_count));
......
......@@ -108,9 +108,19 @@ FcFontSetNeededBytes (FcFontSet *s)
return 0;
}
/* Returns an overestimate of the number of bytes that
* might later get eaten up by padding in the ALIGN macro. */
int
FcFontSetNeededBytesAlign (void)
{
return __alignof__(int) +
FcPatternNeededBytesAlign () + FcObjectNeededBytesAlign ();
}
void *
FcFontSetDistributeBytes (FcCache * metadata, void * block_ptr)
{
block_ptr = ALIGN (block_ptr, int);
fcfs_pat_count = (int *)block_ptr;
block_ptr = (int *)block_ptr + 1;
// we don't consume any bytes for the fontset itself,
......
......@@ -27,6 +27,7 @@
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
......@@ -415,6 +416,8 @@ typedef struct _FcFileTime {
typedef struct _FcCharMap FcCharMap;
#define ALIGN(v,type) ((__typeof__(v))(((uintptr_t)(v) + __alignof__(type) - 1) & ~(__alignof__(type) - 1)))
/* fcblanks.c */
/* fccache.c */
......@@ -550,6 +553,9 @@ FcCharSetNewBank (void);
int
FcCharSetNeededBytes (const FcCharSet *c);
int
FcCharSetNeededBytesAlign (void);
void *
FcCharSetDistributeBytes (FcCache * metadata,
void * block_ptr);
......@@ -646,6 +652,9 @@ FcFontSetNewBank (void);
int
FcFontSetNeededBytes (FcFontSet *s);
int
FcFontSetNeededBytesAlign (void);
void *
FcFontSetDistributeBytes (FcCache * metadata, void * block_ptr);
......@@ -741,6 +750,9 @@ FcLangSetNewBank (void);
int
FcLangSetNeededBytes (const FcLangSet *l);
int
FcLangSetNeededBytesAlign (void);
void *
FcLangSetDistributeBytes (FcCache * metadata,
void * block_ptr);
......@@ -774,6 +786,9 @@ FcObjectToPtr (const char * si);
int
FcObjectNeededBytes (void);
int
FcObjectNeededBytesAlign (void);
void *
FcObjectUnserialize (FcCache metadata, void *block_ptr);
......@@ -837,6 +852,9 @@ FcPatternNewBank (void);
int
FcPatternNeededBytes (FcPattern *p);
int
FcPatternNeededBytesAlign (void);
void *
FcPatternDistributeBytes (FcCache * metadata, void * block_ptr);
......
......@@ -721,6 +721,12 @@ FcLangSetNeededBytes (const FcLangSet *l)
return sizeof (FcLangSet);
}
int
FcLangSetNeededBytesAlign (void)
{
return __alignof__ (FcLangSet);
}
static FcBool
FcLangSetEnsureBank (int bi)
{
......@@ -749,6 +755,7 @@ FcLangSetDistributeBytes (FcCache * metadata, void * block_ptr)
if (!FcLangSetEnsureBank(bi))
return 0;
block_ptr = ALIGN(block_ptr, FcLangSet);
langsets[bi] = block_ptr;
block_ptr = (void *)((char *)block_ptr +
langset_count * sizeof(FcLangSet));
......@@ -778,6 +785,7 @@ FcLangSetUnserialize (FcCache metadata, void *block_ptr)
return 0;
FcMemAlloc (FC_MEM_LANGSET, metadata.langset_count * sizeof(FcLangSet));
block_ptr = ALIGN(block_ptr, FcLangSet);
langsets[bi] = (FcLangSet *)block_ptr;
block_ptr = (void *)((char *)block_ptr +
metadata.langset_count * sizeof(FcLangSet));
......
......@@ -332,12 +332,20 @@ FcObjectNeededBytes ()
return num + sizeof(int);
}
int
FcObjectNeededBytesAlign (void)
{
return __alignof__ (int) + __alignof__ (char);
}
void *
FcObjectDistributeBytes (FcCache * metadata, void * block_ptr)
{
*(int *)block_ptr = biggest_known_ntypes;
block_ptr = ALIGN (block_ptr, int);
block_ptr = (int *) block_ptr + 1;
biggest_ptr = block_ptr;
block_ptr = ALIGN (block_ptr, char);
block_ptr = (char *) block_ptr + biggest_known_count;
return block_ptr;
}
......
......@@ -1430,6 +1430,8 @@ static void
FcStrNewBank (void);
static int
FcStrNeededBytes (const FcChar8 * s);
static int
FcStrNeededBytesAlign (void);
static void *
FcStrDistributeBytes (FcCache * metadata, void * block_ptr);
static const FcChar8 *
......@@ -1441,6 +1443,8 @@ static void
FcValueListNewBank (void);
static int
FcValueListNeededBytes (FcValueList * vl);
static int
FcValueListNeededBytesAlign (void);
static void *
FcValueListDistributeBytes (FcCache * metadata, void *block_ptr);
static FcValueListPtr
......@@ -1479,6 +1483,13 @@ FcPatternNeededBytes (FcPattern * p)
return cum + sizeof (FcPattern) + sizeof(FcPatternElt)*p->num;
}
int
FcPatternNeededBytesAlign (void)
{
return __alignof__ (FcPattern) + __alignof__ (FcPatternElt) +
FcValueListNeededBytesAlign ();
}
static FcBool
FcPatternEnsureBank (int bi)
{
......@@ -1525,12 +1536,14 @@ FcPatternDistributeBytes (FcCache * metadata, void * block_ptr)
return 0;
fcpattern_ptr = 0;
block_ptr = ALIGN(block_ptr, FcPattern);
fcpatterns[bi] = (FcPattern *)block_ptr;
block_ptr = (void *)((char *)block_ptr +
(sizeof (FcPattern) * fcpattern_count));
FcMemAlloc (FC_MEM_PATELT, sizeof (FcPatternElt) * fcpatternelt_count);
fcpatternelt_ptr = 0;
block_ptr = ALIGN(block_ptr, FcPatternElt);
fcpatternelts[bi] = (FcPatternElt *)block_ptr;
block_ptr = (void *)((char *)block_ptr +
(sizeof (FcPatternElt) * fcpatternelt_count));
......@@ -1603,12 +1616,14 @@ FcPatternUnserialize (FcCache metadata, void *block_ptr)
return FcFalse;
FcMemAlloc (FC_MEM_PATTERN, sizeof (FcPattern) * metadata.pattern_count);
block_ptr = ALIGN(block_ptr, FcPattern);
fcpatterns[bi] = (FcPattern *)block_ptr;
block_ptr = (void *)((char *)block_ptr +
(sizeof (FcPattern) * metadata.pattern_count));
FcMemAlloc (FC_MEM_PATELT,
sizeof (FcPatternElt) * metadata.patternelt_count);
block_ptr = ALIGN(block_ptr, FcPatternElt);
fcpatternelts[bi] = (FcPatternElt *)block_ptr;
block_ptr = (void *)((char *)block_ptr +
(sizeof (FcPatternElt) * metadata.patternelt_count));
......@@ -1660,6 +1675,13 @@ FcValueListNeededBytes (FcValueList *p)
return cum;
}
static int
FcValueListNeededBytesAlign (void)
{
return FcCharSetNeededBytesAlign() + FcLangSetNeededBytesAlign() +
FcStrNeededBytesAlign() + __alignof__ (FcValueList);
}
static FcBool
FcValueListEnsureBank (int bi)
{
......@@ -1694,6 +1716,7 @@ FcValueListDistributeBytes (FcCache * metadata, void *block_ptr)
FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList) * fcvaluelist_count);
fcvaluelist_ptr = 0;
block_ptr = ALIGN(block_ptr, FcValueList);
fcvaluelists[bi] = (FcValueList *)block_ptr;
block_ptr = (void *)((char *)block_ptr +
(sizeof (FcValueList) * fcvaluelist_count));
......@@ -1774,6 +1797,7 @@ FcValueListUnserialize (FcCache metadata, void *block_ptr)
FcMemAlloc (FC_MEM_VALLIST,
sizeof (FcValueList) * metadata.valuelist_count);
block_ptr = ALIGN(block_ptr, FcValueList);
fcvaluelists[bi] = (FcValueList *)block_ptr;
block_ptr = (void *)((char *)block_ptr +
(sizeof (FcValueList) * metadata.valuelist_count));
......@@ -1850,6 +1874,11 @@ FcStrNeededBytes (const FcChar8 * s)
b->next = 0;
b->hash = hash;
strcpy ((char *) (b + 1), (char *)s);
/* Yes, the following line is convoluted. However, it is
* incorrect to replace the with a memset, because the C
* specification doesn't guarantee that the null pointer is
* the same as the zero bit pattern. */
*(char **)((char *) (b + 1) + strlen((char *)s) + 1) = 0;
*p = b;
......@@ -1857,6 +1886,12 @@ FcStrNeededBytes (const FcChar8 * s)
return strlen((char *)s) + 1;
}
static int
FcStrNeededBytesAlign (void)
{
return __alignof__ (char);
}
static FcBool
FcStrEnsureBank (int bi)
{
......@@ -1887,6 +1922,7 @@ FcStrDistributeBytes (FcCache * metadata, void * block_ptr)
return 0;
FcMemAlloc (FC_MEM_STRING, sizeof (char) * fcstr_count);
block_ptr = ALIGN (block_ptr, FcChar8);
static_strs[bi] = (FcChar8 *)block_ptr;
block_ptr = (void *)((char *)block_ptr + (sizeof (char) * fcstr_count));
metadata->str_count = fcstr_count;
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment