From f07afca523ad174acd3c56fc43111a09b7a5243e Mon Sep 17 00:00:00 2001 From: marha Date: Tue, 5 Oct 2010 06:01:27 +0000 Subject: xserver pixman git update 5/10/2010 --- pixman/pixman/pixman-arm-neon-asm.S | 103 ++++++++++++++++++++++++ pixman/pixman/pixman-arm-neon.c | 8 ++ pixman/pixman/pixman-bits-image.c | 3 +- pixman/pixman/pixman-compiler.h | 3 +- pixman/pixman/pixman-fast-path.h | 4 +- pixman/pixman/pixman-image.c | 17 +--- pixman/pixman/pixman-private.h | 58 ++++++-------- pixman/pixman/pixman.c | 152 ++++++------------------------------ pixman/test/utils.c | 27 ++----- 9 files changed, 175 insertions(+), 200 deletions(-) (limited to 'pixman') diff --git a/pixman/pixman/pixman-arm-neon-asm.S b/pixman/pixman/pixman-arm-neon-asm.S index 108abacd1..8ddbefc87 100644 --- a/pixman/pixman/pixman-arm-neon-asm.S +++ b/pixman/pixman/pixman-arm-neon-asm.S @@ -388,6 +388,7 @@ generate_composite_function \ vld1.16 {d4, d5}, [DST_R, :128]! vst1.16 {d28, d29}, [DST_W, :128]! pixman_composite_over_n_0565_process_pixblock_head + cache_preload 8, 8 .endm .macro pixman_composite_over_n_0565_init @@ -710,6 +711,7 @@ generate_composite_function_single_scanline \ vld4.8 {d4, d5, d6, d7}, [DST_R, :128]! vst4.8 {d28, d29, d30, d31}, [DST_W, :128]! pixman_composite_over_8888_8888_process_pixblock_head + cache_preload 8, 8 .endm .macro pixman_composite_over_n_8888_init @@ -1870,3 +1872,104 @@ generate_composite_function \ 10, /* dst_r_basereg */ \ 8, /* src_basereg */ \ 15 /* mask_basereg */ + +/******************************************************************************/ + +.macro pixman_composite_add_0565_8_0565_process_pixblock_head + /* mask is in d15 */ + convert_0565_to_x888 q4, d2, d1, d0 + convert_0565_to_x888 q5, d6, d5, d4 + /* source pixel data is in {d0, d1, d2, XX} */ + /* destination pixel data is in {d4, d5, d6, XX} */ + vmull.u8 q6, d15, d2 + vmull.u8 q5, d15, d1 + vmull.u8 q4, d15, d0 + vrshr.u16 q12, q6, #8 + vrshr.u16 q11, q5, #8 + vrshr.u16 q10, q4, #8 + vraddhn.u16 d2, q6, q12 + vraddhn.u16 d1, q5, q11 + vraddhn.u16 d0, q4, q10 +.endm + +.macro pixman_composite_add_0565_8_0565_process_pixblock_tail + vqadd.u8 q0, q0, q2 + vqadd.u8 q1, q1, q3 + /* 32bpp result is in {d0, d1, d2, XX} */ + convert_8888_to_0565 d2, d1, d0, q14, q15, q3 +.endm + +/* TODO: expand macros and do better instructions scheduling */ +.macro pixman_composite_add_0565_8_0565_process_pixblock_tail_head + vld1.8 {d15}, [MASK]! + pixman_composite_add_0565_8_0565_process_pixblock_tail + vld1.16 {d8, d9}, [SRC]! + vld1.16 {d10, d11}, [DST_R, :128]! + cache_preload 8, 8 + pixman_composite_add_0565_8_0565_process_pixblock_head + vst1.16 {d28, d29}, [DST_W, :128]! +.endm + +generate_composite_function \ + pixman_composite_add_0565_8_0565_asm_neon, 16, 8, 16, \ + FLAG_DST_READWRITE, \ + 8, /* number of pixels, processed in a single block */ \ + 5, /* prefetch distance */ \ + default_init_need_all_regs, \ + default_cleanup_need_all_regs, \ + pixman_composite_add_0565_8_0565_process_pixblock_head, \ + pixman_composite_add_0565_8_0565_process_pixblock_tail, \ + pixman_composite_add_0565_8_0565_process_pixblock_tail_head, \ + 28, /* dst_w_basereg */ \ + 10, /* dst_r_basereg */ \ + 8, /* src_basereg */ \ + 15 /* mask_basereg */ + +/******************************************************************************/ + +.macro pixman_composite_out_reverse_8_0565_process_pixblock_head + /* mask is in d15 */ + convert_0565_to_x888 q5, d6, d5, d4 + /* destination pixel data is in {d4, d5, d6, xx} */ + vmvn.8 d24, d15 /* get inverted alpha */ + /* now do alpha blending */ + vmull.u8 q8, d24, d4 + vmull.u8 q9, d24, d5 + vmull.u8 q10, d24, d6 +.endm + +.macro pixman_composite_out_reverse_8_0565_process_pixblock_tail + vrshr.u16 q14, q8, #8 + vrshr.u16 q15, q9, #8 + vrshr.u16 q12, q10, #8 + vraddhn.u16 d0, q14, q8 + vraddhn.u16 d1, q15, q9 + vraddhn.u16 d2, q12, q10 + /* 32bpp result is in {d0, d1, d2, XX} */ + convert_8888_to_0565 d2, d1, d0, q14, q15, q3 +.endm + +/* TODO: expand macros and do better instructions scheduling */ +.macro pixman_composite_out_reverse_8_0565_process_pixblock_tail_head + vld1.8 {d15}, [SRC]! + pixman_composite_out_reverse_8_0565_process_pixblock_tail + vld1.16 {d10, d11}, [DST_R, :128]! + cache_preload 8, 8 + pixman_composite_out_reverse_8_0565_process_pixblock_head + vst1.16 {d28, d29}, [DST_W, :128]! +.endm + +generate_composite_function \ + pixman_composite_out_reverse_8_0565_asm_neon, 8, 0, 16, \ + FLAG_DST_READWRITE, \ + 8, /* number of pixels, processed in a single block */ \ + 5, /* prefetch distance */ \ + default_init_need_all_regs, \ + default_cleanup_need_all_regs, \ + pixman_composite_out_reverse_8_0565_process_pixblock_head, \ + pixman_composite_out_reverse_8_0565_process_pixblock_tail, \ + pixman_composite_out_reverse_8_0565_process_pixblock_tail_head, \ + 28, /* dst_w_basereg */ \ + 10, /* dst_r_basereg */ \ + 15, /* src_basereg */ \ + 0 /* mask_basereg */ diff --git a/pixman/pixman/pixman-arm-neon.c b/pixman/pixman/pixman-arm-neon.c index 231a183aa..40f7b6a60 100644 --- a/pixman/pixman/pixman-arm-neon.c +++ b/pixman/pixman/pixman-arm-neon.c @@ -60,6 +60,8 @@ PIXMAN_ARM_BIND_FAST_PATH_SRC_DST (neon, over_8888_0565, uint32_t, 1, uint16_t, 1) PIXMAN_ARM_BIND_FAST_PATH_SRC_DST (neon, over_8888_8888, uint32_t, 1, uint32_t, 1) +PIXMAN_ARM_BIND_FAST_PATH_SRC_DST (neon, out_reverse_8_0565, + uint8_t, 1, uint16_t, 1) PIXMAN_ARM_BIND_FAST_PATH_N_DST (neon, over_n_0565, uint16_t, 1) @@ -82,6 +84,8 @@ PIXMAN_ARM_BIND_FAST_PATH_SRC_N_DST (neon, over_8888_n_8888, PIXMAN_ARM_BIND_FAST_PATH_SRC_MASK_DST (neon, add_8_8_8, uint8_t, 1, uint8_t, 1, uint8_t, 1) +PIXMAN_ARM_BIND_FAST_PATH_SRC_MASK_DST (neon, add_0565_8_0565, + uint16_t, 1, uint8_t, 1, uint16_t, 1) PIXMAN_ARM_BIND_FAST_PATH_SRC_MASK_DST (neon, add_8888_8888_8888, uint32_t, 1, uint32_t, 1, uint32_t, 1) PIXMAN_ARM_BIND_FAST_PATH_SRC_MASK_DST (neon, over_8888_8_8888, @@ -256,12 +260,16 @@ static const pixman_fast_path_t arm_neon_fast_paths[] = PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, null, a8b8g8r8, neon_composite_src_x888_8888), PIXMAN_STD_FAST_PATH (ADD, solid, a8, a8, neon_composite_add_n_8_8), PIXMAN_STD_FAST_PATH (ADD, a8, a8, a8, neon_composite_add_8_8_8), + PIXMAN_STD_FAST_PATH (ADD, r5g6b5, a8, r5g6b5, neon_composite_add_0565_8_0565), + PIXMAN_STD_FAST_PATH (ADD, b5g6r5, a8, b5g6r5, neon_composite_add_0565_8_0565), PIXMAN_STD_FAST_PATH (ADD, a8r8g8b8, a8r8g8b8, a8r8g8b8, neon_composite_add_8888_8888_8888), PIXMAN_STD_FAST_PATH (ADD, a8, null, a8, neon_composite_add_8_8), PIXMAN_STD_FAST_PATH (ADD, a8r8g8b8, null, a8r8g8b8, neon_composite_add_8888_8888), PIXMAN_STD_FAST_PATH (ADD, a8b8g8r8, null, a8b8g8r8, neon_composite_add_8888_8888), PIXMAN_STD_FAST_PATH (OVER_REVERSE, solid, null, a8r8g8b8, neon_composite_over_reverse_n_8888), PIXMAN_STD_FAST_PATH (OVER_REVERSE, solid, null, a8b8g8r8, neon_composite_over_reverse_n_8888), + PIXMAN_STD_FAST_PATH (OUT_REVERSE, a8, null, r5g6b5, neon_composite_out_reverse_8_0565), + PIXMAN_STD_FAST_PATH (OUT_REVERSE, a8, null, b5g6r5, neon_composite_out_reverse_8_0565), { PIXMAN_OP_NONE }, }; diff --git a/pixman/pixman/pixman-bits-image.c b/pixman/pixman/pixman-bits-image.c index 1f023b826..1a3a3ea76 100644 --- a/pixman/pixman/pixman-bits-image.c +++ b/pixman/pixman/pixman-bits-image.c @@ -944,7 +944,8 @@ convert_r5g6b5 (const uint8_t *row, int x) convert_ ## format, \ PIXMAN_ ## format, \ repeat_mode); \ - } + } \ + extern int no_such_variable MAKE_BILINEAR_FETCHER (pad_a8r8g8b8, a8r8g8b8, PIXMAN_REPEAT_PAD); MAKE_BILINEAR_FETCHER (none_a8r8g8b8, a8r8g8b8, PIXMAN_REPEAT_NONE); diff --git a/pixman/pixman/pixman-compiler.h b/pixman/pixman/pixman-compiler.h index 36b71fd1d..32698e007 100644 --- a/pixman/pixman/pixman-compiler.h +++ b/pixman/pixman/pixman-compiler.h @@ -191,7 +191,8 @@ value = tls_ ## name ## _alloc (); \ } \ return value; \ - } + } \ + extern int no_such_variable # define PIXMAN_GET_THREAD_LOCAL(name) \ tls_ ## name ## _get () diff --git a/pixman/pixman/pixman-fast-path.h b/pixman/pixman/pixman-fast-path.h index 0f47ff77c..f7c986cab 100644 --- a/pixman/pixman/pixman-fast-path.h +++ b/pixman/pixman/pixman-fast-path.h @@ -381,7 +381,9 @@ fast_composite_scaled_nearest_ ## scale_func_name (pixman_implementation_t *imp, OP, repeat_mode) \ FAST_NEAREST_MAINLOOP(scale_func_name##_##OP, \ scaled_nearest_scanline_ ## scale_func_name ## _ ## OP, \ - src_type_t, dst_type_t, repeat_mode) + src_type_t, dst_type_t, repeat_mode) \ + \ + extern int no_such_variable #define SCALED_NEAREST_FLAGS \ diff --git a/pixman/pixman/pixman-image.c b/pixman/pixman/pixman-image.c index 1b243979a..17d87216e 100644 --- a/pixman/pixman/pixman-image.c +++ b/pixman/pixman/pixman-image.c @@ -363,24 +363,21 @@ compute_image_info (pixman_image_t *image) flags |= FAST_PATH_NO_PAD_REPEAT | FAST_PATH_NO_NONE_REPEAT | - FAST_PATH_NO_NORMAL_REPEAT | - FAST_PATH_COVERS_CLIP; + FAST_PATH_NO_NORMAL_REPEAT; break; case PIXMAN_REPEAT_PAD: flags |= FAST_PATH_NO_REFLECT_REPEAT | FAST_PATH_NO_NONE_REPEAT | - FAST_PATH_NO_NORMAL_REPEAT | - FAST_PATH_COVERS_CLIP; + FAST_PATH_NO_NORMAL_REPEAT; break; default: flags |= FAST_PATH_NO_REFLECT_REPEAT | FAST_PATH_NO_PAD_REPEAT | - FAST_PATH_NO_NONE_REPEAT | - FAST_PATH_COVERS_CLIP; + FAST_PATH_NO_NONE_REPEAT; break; } @@ -400,8 +397,6 @@ compute_image_info (pixman_image_t *image) if (image->solid.color.alpha == 0xffff) flags |= FAST_PATH_IS_OPAQUE; - - flags |= FAST_PATH_COVERS_CLIP; break; case BITS: @@ -414,12 +409,6 @@ compute_image_info (pixman_image_t *image) else { code = image->bits.format; - - if (!image->common.transform && - image->common.repeat == PIXMAN_REPEAT_NORMAL) - { - flags |= FAST_PATH_SIMPLE_REPEAT; - } } if (!PIXMAN_FORMAT_A (image->bits.format) && diff --git a/pixman/pixman/pixman-private.h b/pixman/pixman/pixman-private.h index 8c68304dc..8250d1f7a 100644 --- a/pixman/pixman/pixman-private.h +++ b/pixman/pixman/pixman-private.h @@ -554,13 +554,13 @@ _pixman_choose_implementation (void); #define FAST_PATH_NO_PAD_REPEAT (1 << 3) #define FAST_PATH_NO_REFLECT_REPEAT (1 << 4) #define FAST_PATH_NO_ACCESSORS (1 << 5) -#define FAST_PATH_NARROW_FORMAT (1 << 6) -#define FAST_PATH_COVERS_CLIP (1 << 7) +#define FAST_PATH_NARROW_FORMAT (1 << 6) #define FAST_PATH_COMPONENT_ALPHA (1 << 8) +#define FAST_PATH_SAMPLES_OPAQUE (1 << 7) #define FAST_PATH_UNIFIED_ALPHA (1 << 9) #define FAST_PATH_SCALE_TRANSFORM (1 << 10) #define FAST_PATH_NEAREST_FILTER (1 << 11) -#define FAST_PATH_SIMPLE_REPEAT (1 << 12) +#define FAST_PATH_HAS_TRANSFORM (1 << 12) #define FAST_PATH_IS_OPAQUE (1 << 13) #define FAST_PATH_NEEDS_WORKAROUND (1 << 14) #define FAST_PATH_NO_NONE_REPEAT (1 << 15) @@ -570,8 +570,6 @@ _pixman_choose_implementation (void); #define FAST_PATH_Y_UNIT_ZERO (1 << 19) #define FAST_PATH_BILINEAR_FILTER (1 << 20) #define FAST_PATH_NO_NORMAL_REPEAT (1 << 21) -#define FAST_PATH_HAS_TRANSFORM (1 << 22) -#define FAST_PATH_SAMPLES_OPAQUE (1 << 23) #define FAST_PATH_PAD_REPEAT \ (FAST_PATH_NO_NONE_REPEAT | \ @@ -593,29 +591,25 @@ _pixman_choose_implementation (void); FAST_PATH_NO_NORMAL_REPEAT | \ FAST_PATH_NO_PAD_REPEAT) -#define _FAST_PATH_STANDARD_FLAGS \ - (FAST_PATH_ID_TRANSFORM | \ - FAST_PATH_NO_ALPHA_MAP | \ - FAST_PATH_NO_CONVOLUTION_FILTER | \ - FAST_PATH_NO_PAD_REPEAT | \ - FAST_PATH_NO_REFLECT_REPEAT | \ +#define FAST_PATH_STANDARD_FLAGS \ + (FAST_PATH_NO_CONVOLUTION_FILTER | \ FAST_PATH_NO_ACCESSORS | \ - FAST_PATH_NARROW_FORMAT | \ - FAST_PATH_COVERS_CLIP) - -#define FAST_PATH_STD_SRC_FLAGS \ - _FAST_PATH_STANDARD_FLAGS -#define FAST_PATH_STD_MASK_U_FLAGS \ - (_FAST_PATH_STANDARD_FLAGS | \ - FAST_PATH_UNIFIED_ALPHA) -#define FAST_PATH_STD_MASK_CA_FLAGS \ - (_FAST_PATH_STANDARD_FLAGS | \ - FAST_PATH_COMPONENT_ALPHA) + FAST_PATH_NO_ALPHA_MAP | \ + FAST_PATH_NARROW_FORMAT) + #define FAST_PATH_STD_DEST_FLAGS \ (FAST_PATH_NO_ACCESSORS | \ FAST_PATH_NO_ALPHA_MAP | \ FAST_PATH_NARROW_FORMAT) +#define SOURCE_FLAGS(format) \ + (FAST_PATH_STANDARD_FLAGS | \ + ((PIXMAN_ ## format == PIXMAN_solid) ? \ + 0 : (FAST_PATH_SAMPLES_COVER_CLIP | FAST_PATH_ID_TRANSFORM))) + +#define MASK_FLAGS(format, extra) \ + ((PIXMAN_ ## format == PIXMAN_null) ? 0 : (SOURCE_FLAGS (format) | extra)) + #define FAST_PATH(op, src, src_flags, mask, mask_flags, dest, dest_flags, func) \ PIXMAN_OP_ ## op, \ PIXMAN_ ## src, \ @@ -628,19 +622,19 @@ _pixman_choose_implementation (void); #define PIXMAN_STD_FAST_PATH(op, src, mask, dest, func) \ { FAST_PATH ( \ - op, \ - src, FAST_PATH_STD_SRC_FLAGS, \ - mask, (PIXMAN_ ## mask) ? FAST_PATH_STD_MASK_U_FLAGS : 0, \ - dest, FAST_PATH_STD_DEST_FLAGS, \ - func) } + op, \ + src, SOURCE_FLAGS (src), \ + mask, MASK_FLAGS (mask, FAST_PATH_UNIFIED_ALPHA), \ + dest, FAST_PATH_STD_DEST_FLAGS, \ + func) } #define PIXMAN_STD_FAST_PATH_CA(op, src, mask, dest, func) \ { FAST_PATH ( \ - op, \ - src, FAST_PATH_STD_SRC_FLAGS, \ - mask, FAST_PATH_STD_MASK_CA_FLAGS, \ - dest, FAST_PATH_STD_DEST_FLAGS, \ - func) } + op, \ + src, SOURCE_FLAGS (src), \ + mask, MASK_FLAGS (mask, FAST_PATH_COMPONENT_ALPHA), \ + dest, FAST_PATH_STD_DEST_FLAGS, \ + func) } /* Memory allocation helpers */ void * diff --git a/pixman/pixman/pixman.c b/pixman/pixman/pixman.c index f2565ca01..4857e30ce 100644 --- a/pixman/pixman/pixman.c +++ b/pixman/pixman/pixman.c @@ -377,126 +377,6 @@ pixman_compute_composite_region32 (pixman_region32_t * region, return TRUE; } -static void -walk_region_internal (pixman_implementation_t *imp, - pixman_op_t op, - pixman_image_t * src_image, - pixman_image_t * mask_image, - pixman_image_t * dst_image, - int32_t src_x, - int32_t src_y, - int32_t mask_x, - int32_t mask_y, - int32_t dest_x, - int32_t dest_y, - int32_t width, - int32_t height, - pixman_bool_t src_repeat, - pixman_bool_t mask_repeat, - pixman_region32_t * region, - pixman_composite_func_t composite_rect) -{ - int w, h, w_this, h_this; - int x_msk, y_msk, x_src, y_src, x_dst, y_dst; - int src_dy = src_y - dest_y; - int src_dx = src_x - dest_x; - int mask_dy = mask_y - dest_y; - int mask_dx = mask_x - dest_x; - const pixman_box32_t *pbox; - int n; - - pbox = pixman_region32_rectangles (region, &n); - - /* Fast path for non-repeating sources */ - if (!src_repeat && !mask_repeat) - { - while (n--) - { - (*composite_rect) (imp, op, - src_image, mask_image, dst_image, - pbox->x1 + src_dx, - pbox->y1 + src_dy, - pbox->x1 + mask_dx, - pbox->y1 + mask_dy, - pbox->x1, - pbox->y1, - pbox->x2 - pbox->x1, - pbox->y2 - pbox->y1); - - pbox++; - } - - return; - } - - while (n--) - { - h = pbox->y2 - pbox->y1; - y_src = pbox->y1 + src_dy; - y_msk = pbox->y1 + mask_dy; - y_dst = pbox->y1; - - while (h) - { - h_this = h; - w = pbox->x2 - pbox->x1; - x_src = pbox->x1 + src_dx; - x_msk = pbox->x1 + mask_dx; - x_dst = pbox->x1; - - if (mask_repeat) - { - y_msk = MOD (y_msk, mask_image->bits.height); - if (h_this > mask_image->bits.height - y_msk) - h_this = mask_image->bits.height - y_msk; - } - - if (src_repeat) - { - y_src = MOD (y_src, src_image->bits.height); - if (h_this > src_image->bits.height - y_src) - h_this = src_image->bits.height - y_src; - } - - while (w) - { - w_this = w; - - if (mask_repeat) - { - x_msk = MOD (x_msk, mask_image->bits.width); - if (w_this > mask_image->bits.width - x_msk) - w_this = mask_image->bits.width - x_msk; - } - - if (src_repeat) - { - x_src = MOD (x_src, src_image->bits.width); - if (w_this > src_image->bits.width - x_src) - w_this = src_image->bits.width - x_src; - } - - (*composite_rect) (imp, op, - src_image, mask_image, dst_image, - x_src, y_src, x_msk, y_msk, x_dst, y_dst, - w_this, h_this); - w -= w_this; - - x_src += w_this; - x_msk += w_this; - x_dst += w_this; - } - - h -= h_this; - y_src += h_this; - y_msk += h_this; - y_dst += h_this; - } - - pbox++; - } -} - #define N_CACHED_FAST_PATHS 8 typedef struct @@ -746,7 +626,7 @@ analyze_extent (pixman_image_t *image, int x, int y, extents->x2 - x <= image->bits.width && extents->y2 - y <= image->bits.height) { - *flags |= (FAST_PATH_SAMPLES_COVER_CLIP | FAST_PATH_COVERS_CLIP); + *flags |= FAST_PATH_SAMPLES_COVER_CLIP; return TRUE; } @@ -789,7 +669,7 @@ analyze_extent (pixman_image_t *image, int x, int y, ex.x1 >= 0 && ex.y1 >= 0 && ex.x2 <= image->bits.width && ex.y2 <= image->bits.height) { - *flags |= (FAST_PATH_SAMPLES_COVER_CLIP | FAST_PATH_COVERS_CLIP); + *flags |= FAST_PATH_SAMPLES_COVER_CLIP; } } else @@ -949,14 +829,26 @@ pixman_image_composite32 (pixman_op_t op, dest_format, dest_flags, &imp, &func)) { - walk_region_internal (imp, op, - src, mask, dest, - src_x, src_y, mask_x, mask_y, - dest_x, dest_y, - width, height, - (src_flags & FAST_PATH_SIMPLE_REPEAT), - (mask_flags & FAST_PATH_SIMPLE_REPEAT), - ®ion, func); + const pixman_box32_t *pbox; + int n; + + pbox = pixman_region32_rectangles (®ion, &n); + + while (n--) + { + func (imp, op, + src, mask, dest, + pbox->x1 + src_x - dest_x, + pbox->y1 + src_y - dest_y, + pbox->x1 + mask_x - dest_x, + pbox->y1 + mask_y - dest_y, + pbox->x1, + pbox->y1, + pbox->x2 - pbox->x1, + pbox->y2 - pbox->y1); + + pbox++; + } } out: diff --git a/pixman/test/utils.c b/pixman/test/utils.c index d7038a36e..acf494938 100644 --- a/pixman/test/utils.c +++ b/pixman/test/utils.c @@ -243,7 +243,7 @@ fence_malloc (uint32_t len) addr = mmap (NULL, n_bytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); - if (addr == (void *)MAP_FAILED) + if (addr == MAP_FAILED) { printf ("mmap failed on %u %u\n", len, n_bytes); return NULL; @@ -259,20 +259,12 @@ fence_malloc (uint32_t len) ((info_t *)initial_page)->trailing = trailing_protected; ((info_t *)initial_page)->n_bytes = n_bytes; - if (mprotect (leading_protected, N_LEADING_PROTECTED * page_size, - PROT_NONE) == -1) + if ((mprotect (leading_protected, N_LEADING_PROTECTED * page_size, + PROT_NONE) == -1) || + (mprotect (trailing_protected, N_TRAILING_PROTECTED * page_size, + PROT_NONE) == -1)) { - free (addr); - return NULL; - } - - if (mprotect (trailing_protected, N_TRAILING_PROTECTED * page_size, - PROT_NONE) == -1) - { - mprotect (leading_protected, N_LEADING_PROTECTED * page_size, - PROT_READ | PROT_WRITE); - - free (addr); + munmap (addr, n_bytes); return NULL; } @@ -287,13 +279,6 @@ fence_free (void *data) uint8_t *leading_protected = payload - N_LEADING_PROTECTED * page_size; uint8_t *initial_page = leading_protected - page_size; info_t *info = (info_t *)initial_page; - uint8_t *trailing_protected = info->trailing; - - mprotect (leading_protected, N_LEADING_PROTECTED * page_size, - PROT_READ | PROT_WRITE); - - mprotect (trailing_protected, N_LEADING_PROTECTED * page_size, - PROT_READ | PROT_WRITE); munmap (info->addr, info->n_bytes); } -- cgit v1.2.3