[PATCH 4/4] libsframe: rename encoder to ectx for readability
Indu Bhagat
indu.bhagat@oracle.com
Mon Nov 3 19:52:08 GMT 2025
Addressing a (old) review comment suggesting this housekeeping item. Use
consistent naming style in libsframe. sframe_decoder_ctx objects are
named 'dctx', so use 'ectx' for sframe_encoder_ctx objects.
Make necessary changes in both the declaration and definition.
---
include/sframe-api.h | 41 +++++-----
libsframe/sframe.c | 181 +++++++++++++++++++++----------------------
2 files changed, 111 insertions(+), 111 deletions(-)
diff --git a/include/sframe-api.h b/include/sframe-api.h
index 375e1decf5e..ae16b0fe8bd 100644
--- a/include/sframe-api.h
+++ b/include/sframe-api.h
@@ -103,10 +103,10 @@ sframe_calc_fre_type (size_t func_size);
/* The SFrame Decoder. */
-/* Decode the specified SFrame buffer CF_BUF of size CF_SIZE and return the
+/* Decode the specified SFrame buffer SF_BUF of size SF_SIZE and return the
new SFrame decoder context. Sets ERRP for the caller if any error. */
extern sframe_decoder_ctx *
-sframe_decode (const char *cf_buf, size_t cf_size, int *errp);
+sframe_decode (const char *sf_buf, size_t sf_size, int *errp);
/* Free the decoder context. */
extern void
@@ -235,62 +235,63 @@ sframe_encode (uint8_t ver, uint8_t flags, uint8_t abi_arch,
/* Free the encoder context. */
extern void
-sframe_encoder_free (sframe_encoder_ctx **encoder);
+sframe_encoder_free (sframe_encoder_ctx **ectxp);
-/* Get the size of the SFrame header from the encoder ctx ENCODER. */
+/* Get the size of the SFrame header from the encoder ctx ECTX. */
extern unsigned int
-sframe_encoder_get_hdr_size (sframe_encoder_ctx *encoder);
+sframe_encoder_get_hdr_size (sframe_encoder_ctx *ectx);
-/* Get the abi/arch info from the SFrame encoder context CTX. */
+/* Get the abi/arch info from the SFrame encoder context ECTX. */
extern uint8_t
-sframe_encoder_get_abi_arch (sframe_encoder_ctx *encoder);
+sframe_encoder_get_abi_arch (sframe_encoder_ctx *ectx);
-/* Get the format version from the SFrame encoder context ENCODER. */
+/* Get the format version from the SFrame encoder context ECTX. */
extern uint8_t
-sframe_encoder_get_version (sframe_encoder_ctx *encoder);
+sframe_encoder_get_version (sframe_encoder_ctx *ectx);
-/* Get the section flags from the SFrame encoder context ENCODER. */
+/* Get the section flags from the SFrame encoder context ECTX. */
extern uint8_t
-sframe_encoder_get_flags (sframe_encoder_ctx *encoder);
+sframe_encoder_get_flags (sframe_encoder_ctx *ectx);
/* Get the offset of the sfde_func_start_address field (from the start of the
on-disk layout of the SFrame section) of the FDE at FUNC_IDX in the encoder
- context ENCODER.
+ context ECTX.
If FUNC_IDX is more than the number of SFrame FDEs in the section, sets
error code in ERRP, but returns the (hypothetical) offset. This is useful
for the linker when arranging input FDEs into the output section to be
emitted. */
uint32_t
-sframe_encoder_get_offsetof_fde_start_addr (sframe_encoder_ctx *encoder,
+sframe_encoder_get_offsetof_fde_start_addr (sframe_encoder_ctx *ectx,
uint32_t func_idx, int *errp);
/* Return the number of function descriptor entries in the SFrame encoder
- ENCODER. */
+ ECTX. */
extern uint32_t
-sframe_encoder_get_num_fidx (sframe_encoder_ctx *encoder);
+sframe_encoder_get_num_fidx (sframe_encoder_ctx *ectx);
/* Add an FRE to function at FUNC_IDX'th function descriptor index entry in
the encoder context. */
extern int
-sframe_encoder_add_fre (sframe_encoder_ctx *encoder,
+sframe_encoder_add_fre (sframe_encoder_ctx *ectx,
unsigned int func_idx,
sframe_frame_row_entry *frep);
/* Add a new function descriptor entry with START_ADDR, FUNC_SIZE, FUNC_INFO
and REP_BLOCK_SIZE to the encoder. */
extern int
-sframe_encoder_add_funcdesc_v2 (sframe_encoder_ctx *encoder,
+sframe_encoder_add_funcdesc_v2 (sframe_encoder_ctx *ectx,
int32_t start_addr,
uint32_t func_size,
unsigned char func_info,
uint8_t rep_block_size,
uint32_t num_fres);
-/* Serialize the contents of the encoder and return the buffer. ENCODED_SIZE
- is updated to the size of the buffer. Sets ERRP if failure. */
+/* Serialize the contents of the encoder object ECTX and return the buffer.
+ ENCODED_SIZE is updated to the size of the buffer.
+ Sets ERRP if failure. */
extern char *
-sframe_encoder_write (sframe_encoder_ctx *encoder,
+sframe_encoder_write (sframe_encoder_ctx *ectx,
size_t *encoded_size, int *errp);
#ifdef __cplusplus
diff --git a/libsframe/sframe.c b/libsframe/sframe.c
index c09a736e88a..75e376d9165 100644
--- a/libsframe/sframe.c
+++ b/libsframe/sframe.c
@@ -1460,25 +1460,25 @@ sframe_decoder_get_fre (sframe_decoder_ctx *ctx,
/* SFrame Encoder. */
-/* Get a reference to the ENCODER's SFrame header. */
+/* Get a reference to the ECTX's SFrame header. */
static sframe_header *
-sframe_encoder_get_header (sframe_encoder_ctx *encoder)
+sframe_encoder_get_header (sframe_encoder_ctx *ectx)
{
sframe_header *hp = NULL;
- if (encoder)
- hp = &encoder->sfe_header;
+ if (ectx)
+ hp = &ectx->sfe_header;
return hp;
}
static sframe_func_desc_entry *
-sframe_encoder_get_funcdesc_at_index (sframe_encoder_ctx *encoder,
+sframe_encoder_get_funcdesc_at_index (sframe_encoder_ctx *ectx,
uint32_t func_idx)
{
sframe_func_desc_entry *fde = NULL;
- if (func_idx < sframe_encoder_get_num_fidx (encoder))
+ if (func_idx < sframe_encoder_get_num_fidx (ectx))
{
- sf_fde_tbl *func_tbl = encoder->sfe_funcdesc;
+ sf_fde_tbl *func_tbl = ectx->sfe_funcdesc;
fde = func_tbl->entry + func_idx;
}
return fde;
@@ -1493,18 +1493,18 @@ sframe_encode (uint8_t ver, uint8_t flags, uint8_t abi_arch,
int8_t fixed_fp_offset, int8_t fixed_ra_offset, int *errp)
{
sframe_header *hp;
- sframe_encoder_ctx *encoder;
+ sframe_encoder_ctx *ectx;
if (ver != SFRAME_VERSION)
return sframe_ret_set_errno (errp, SFRAME_ERR_VERSION_INVAL);
- if ((encoder = malloc (sizeof (sframe_encoder_ctx))) == NULL)
+ if ((ectx = malloc (sizeof (sframe_encoder_ctx))) == NULL)
return sframe_ret_set_errno (errp, SFRAME_ERR_NOMEM);
- memset (encoder, 0, sizeof (sframe_encoder_ctx));
+ memset (ectx, 0, sizeof (sframe_encoder_ctx));
/* Get the SFrame header and update it. */
- hp = sframe_encoder_get_header (encoder);
+ hp = sframe_encoder_get_header (ectx);
hp->sfh_preamble.sfp_version = ver;
hp->sfh_preamble.sfp_magic = SFRAME_MAGIC;
hp->sfh_preamble.sfp_flags = flags;
@@ -1519,17 +1519,17 @@ sframe_encode (uint8_t ver, uint8_t flags, uint8_t abi_arch,
hp->sfh_cfa_fixed_fp_offset = fixed_fp_offset;
hp->sfh_cfa_fixed_ra_offset = fixed_ra_offset;
- return encoder;
+ return ectx;
}
/* Free the encoder context. */
void
-sframe_encoder_free (sframe_encoder_ctx **encoder)
+sframe_encoder_free (sframe_encoder_ctx **ectxp)
{
- if (encoder != NULL)
+ if (ectxp != NULL)
{
- sframe_encoder_ctx *ectx = *encoder;
+ sframe_encoder_ctx *ectx = *ectxp;
if (ectx == NULL)
return;
@@ -1549,58 +1549,58 @@ sframe_encoder_free (sframe_encoder_ctx **encoder)
ectx->sfe_data = NULL;
}
- free (*encoder);
- *encoder = NULL;
+ free (*ectxp);
+ *ectxp = NULL;
}
}
-/* Get the size of the SFrame header from the encoder ctx ENCODER. */
+/* Get the size of the SFrame header from the encoder ctx ECTX. */
unsigned int
-sframe_encoder_get_hdr_size (sframe_encoder_ctx *encoder)
+sframe_encoder_get_hdr_size (sframe_encoder_ctx *ectx)
{
- const sframe_header *ehp = sframe_encoder_get_header (encoder);
+ const sframe_header *ehp = sframe_encoder_get_header (ectx);
return sframe_get_hdr_size (ehp);
}
-/* Get the abi/arch info from the SFrame encoder context ENCODER. */
+/* Get the abi/arch info from the SFrame encoder context ECTX. */
uint8_t
-sframe_encoder_get_abi_arch (sframe_encoder_ctx *encoder)
+sframe_encoder_get_abi_arch (sframe_encoder_ctx *ectx)
{
uint8_t abi_arch = 0;
- const sframe_header *ehp = sframe_encoder_get_header (encoder);
+ const sframe_header *ehp = sframe_encoder_get_header (ectx);
if (ehp)
abi_arch = ehp->sfh_abi_arch;
return abi_arch;
}
-/* Get the format version from the SFrame encoder context ENCODER. */
+/* Get the format version from the SFrame encoder context ECTX. */
uint8_t
-sframe_encoder_get_version (sframe_encoder_ctx *encoder)
+sframe_encoder_get_version (sframe_encoder_ctx *ectx)
{
- const sframe_header *ehp = sframe_encoder_get_header (encoder);
+ const sframe_header *ehp = sframe_encoder_get_header (ectx);
return ehp->sfh_preamble.sfp_version;
}
-/* Get the section flags from the SFrame encoder context ENCODER. */
+/* Get the section flags from the SFrame encoder context ECTX. */
uint8_t
-sframe_encoder_get_flags (sframe_encoder_ctx *encoder)
+sframe_encoder_get_flags (sframe_encoder_ctx *ectx)
{
- const sframe_header *ehp = sframe_encoder_get_header (encoder);
+ const sframe_header *ehp = sframe_encoder_get_header (ectx);
return ehp->sfh_preamble.sfp_flags;
}
/* Return the number of function descriptor entries in the SFrame encoder
- ENCODER. */
+ ECTX. */
uint32_t
-sframe_encoder_get_num_fidx (sframe_encoder_ctx *encoder)
+sframe_encoder_get_num_fidx (sframe_encoder_ctx *ectx)
{
uint32_t num_fdes = 0;
- const sframe_header *ehp = sframe_encoder_get_header (encoder);
+ const sframe_header *ehp = sframe_encoder_get_header (ectx);
if (ehp)
num_fdes = ehp->sfh_num_fdes;
return num_fdes;
@@ -1608,7 +1608,7 @@ sframe_encoder_get_num_fidx (sframe_encoder_ctx *encoder)
/* Get the offset of the sfde_func_start_address field (from the start of the
on-disk layout of the SFrame section) of the FDE at FUNC_IDX in the encoder
- context ENCODER.
+ context ECTX.
If FUNC_IDX is more than the number of SFrame FDEs in the section, sets
error code in ERRP, but returns the (hypothetical) offset. This is useful
@@ -1616,15 +1616,15 @@ sframe_encoder_get_num_fidx (sframe_encoder_ctx *encoder)
emitted. */
uint32_t
-sframe_encoder_get_offsetof_fde_start_addr (sframe_encoder_ctx *encoder,
+sframe_encoder_get_offsetof_fde_start_addr (sframe_encoder_ctx *ectx,
uint32_t func_idx, int *errp)
{
- if (func_idx >= sframe_encoder_get_num_fidx (encoder))
+ if (func_idx >= sframe_encoder_get_num_fidx (ectx))
sframe_ret_set_errno (errp, SFRAME_ERR_FDE_INVAL);
else if (errp)
*errp = 0;
- return (sframe_encoder_get_hdr_size (encoder)
+ return (sframe_encoder_get_hdr_size (ectx)
+ func_idx * sizeof (sframe_func_desc_entry)
+ offsetof (sframe_func_desc_entry, sfde_func_start_address));
}
@@ -1633,7 +1633,7 @@ sframe_encoder_get_offsetof_fde_start_addr (sframe_encoder_ctx *encoder,
the encoder context. */
int
-sframe_encoder_add_fre (sframe_encoder_ctx *encoder,
+sframe_encoder_add_fre (sframe_encoder_ctx *ectx,
unsigned int func_idx,
sframe_frame_row_entry *frep)
{
@@ -1645,19 +1645,19 @@ sframe_encoder_add_fre (sframe_encoder_ctx *encoder,
size_t fre_tbl_sz;
int err = 0;
- if (encoder == NULL || frep == NULL)
+ if (ectx == NULL || frep == NULL)
return sframe_set_errno (&err, SFRAME_ERR_INVAL);
if (!sframe_fre_sanity_check_p (frep))
return sframe_set_errno (&err, SFRAME_ERR_FRE_INVAL);
/* Use func_idx to gather the function descriptor entry. */
- fdep = sframe_encoder_get_funcdesc_at_index (encoder, func_idx);
+ fdep = sframe_encoder_get_funcdesc_at_index (ectx, func_idx);
if (fdep == NULL)
return sframe_set_errno (&err, SFRAME_ERR_FDE_NOTFOUND);
fre_type = sframe_get_fre_type (fdep);
- sf_fre_tbl *fre_tbl = encoder->sfe_fres;
+ sf_fre_tbl *fre_tbl = ectx->sfe_fres;
if (fre_tbl == NULL)
{
@@ -1709,10 +1709,10 @@ sframe_encoder_add_fre (sframe_encoder_ctx *encoder,
esz = sframe_fre_entry_size (frep, fre_type);
fre_tbl->count++;
- encoder->sfe_fres = fre_tbl;
- encoder->sfe_fre_nbytes += esz;
+ ectx->sfe_fres = fre_tbl;
+ ectx->sfe_fre_nbytes += esz;
- ehp = sframe_encoder_get_header (encoder);
+ ehp = sframe_encoder_get_header (ectx);
ehp->sfh_num_fres = fre_tbl->count;
/* Update the value of the number of FREs for the function. */
@@ -1723,17 +1723,17 @@ sframe_encoder_add_fre (sframe_encoder_ctx *encoder,
bad:
if (fre_tbl != NULL)
free (fre_tbl);
- encoder->sfe_fres = NULL;
- encoder->sfe_fre_nbytes = 0;
+ ectx->sfe_fres = NULL;
+ ectx->sfe_fre_nbytes = 0;
return -1;
}
/* Add a new function descriptor entry with START_ADDR, FUNC_SIZE and NUM_FRES
- to the ENCODER. Caller must make sure ENCODER exists. */
+ to the encoder context ECTX. Caller must make sure ECTX exists. */
static int
-sframe_encoder_add_funcdesc_internal (sframe_encoder_ctx *encoder,
- int32_t start_addr,
+sframe_encoder_add_funcdesc_internal (sframe_encoder_ctx *ectx,
+ int64_t start_addr,
uint32_t func_size,
unsigned char func_info,
uint32_t num_fres ATTRIBUTE_UNUSED)
@@ -1743,8 +1743,8 @@ sframe_encoder_add_funcdesc_internal (sframe_encoder_ctx *encoder,
size_t fd_tbl_sz;
int err = 0;
- fd_info = encoder->sfe_funcdesc;
- ehp = sframe_encoder_get_header (encoder);
+ fd_info = ectx->sfe_funcdesc;
+ ehp = sframe_encoder_get_header (ectx);
if (fd_info == NULL)
{
@@ -1781,7 +1781,7 @@ sframe_encoder_add_funcdesc_internal (sframe_encoder_ctx *encoder,
sframe_encoder_add_fre. */
fd_info->entry[fd_info->count].sfde_func_size = func_size;
fd_info->entry[fd_info->count].sfde_func_start_fre_off
- = encoder->sfe_fre_nbytes;
+ = ectx->sfe_fre_nbytes;
#if 0
// Linker optimization test code cleanup later ibhagat TODO FIXME
uint32_t fre_type = sframe_calc_fre_type (func_size);
@@ -1791,25 +1791,25 @@ sframe_encoder_add_funcdesc_internal (sframe_encoder_ctx *encoder,
#endif
fd_info->entry[fd_info->count].sfde_func_info = func_info;
fd_info->count++;
- encoder->sfe_funcdesc = fd_info;
+ ectx->sfe_funcdesc = fd_info;
ehp->sfh_num_fdes++;
return 0;
bad:
if (fd_info != NULL)
free (fd_info);
- encoder->sfe_funcdesc = NULL;
+ ectx->sfe_funcdesc = NULL;
ehp->sfh_num_fdes = 0;
return err;
}
/* Add a new function descriptor entry with START_ADDR, FUNC_SIZE, FUNC_INFO
- and REP_BLOCK_SIZE to the encoder.
+ and REP_BLOCK_SIZE to the SFrame encoder ctx ECTX.
This API is valid only for SFrame format version 2. */
int
-sframe_encoder_add_funcdesc_v2 (sframe_encoder_ctx *encoder,
+sframe_encoder_add_funcdesc_v2 (sframe_encoder_ctx *ectx,
int32_t start_addr,
uint32_t func_size,
unsigned char func_info,
@@ -1819,28 +1819,28 @@ sframe_encoder_add_funcdesc_v2 (sframe_encoder_ctx *encoder,
sf_fde_tbl *fd_info;
int err;
- if (encoder == NULL
- || sframe_encoder_get_version (encoder) == SFRAME_VERSION_1)
+ if (ectx == NULL
+ || sframe_encoder_get_version (ectx) == SFRAME_VERSION_1)
return sframe_set_errno (&err, SFRAME_ERR_INVAL);
- err = sframe_encoder_add_funcdesc_internal (encoder, start_addr, func_size,
+ err = sframe_encoder_add_funcdesc_internal (ectx, start_addr, func_size,
func_info, num_fres);
if (err)
return err;
- fd_info = encoder->sfe_funcdesc;
+ fd_info = ectx->sfe_funcdesc;
fd_info->entry[fd_info->count-1].sfde_func_rep_size = rep_block_size;
return 0;
}
static int
-sframe_sort_funcdesc (sframe_encoder_ctx *encoder)
+sframe_sort_funcdesc (sframe_encoder_ctx *ectx)
{
- sframe_header *ehp = sframe_encoder_get_header (encoder);
+ sframe_header *ehp = sframe_encoder_get_header (ectx);
/* Sort and write out the FDE table. */
- sf_fde_tbl *fd_info = encoder->sfe_funcdesc;
+ sf_fde_tbl *fd_info = ectx->sfe_funcdesc;
if (fd_info)
{
/* The new encoding of sfde_func_start_address means the distances are
@@ -1850,14 +1850,14 @@ sframe_sort_funcdesc (sframe_encoder_ctx *encoder)
for (unsigned int i = 0; i < fd_info->count; i++)
fd_info->entry[i].sfde_func_start_address
- += sframe_encoder_get_offsetof_fde_start_addr (encoder, i, NULL);
+ += sframe_encoder_get_offsetof_fde_start_addr (ectx, i, NULL);
qsort (fd_info->entry, fd_info->count,
sizeof (sframe_func_desc_entry), fde_func);
for (unsigned int i = 0; i < fd_info->count; i++)
fd_info->entry[i].sfde_func_start_address
- -= sframe_encoder_get_offsetof_fde_start_addr (encoder, i, NULL);
+ -= sframe_encoder_get_offsetof_fde_start_addr (ectx, i, NULL);
/* Update preamble's flags. */
ehp->sfh_preamble.sfp_flags |= SFRAME_F_FDE_SORTED;
@@ -1947,10 +1947,10 @@ sframe_encoder_write_fre (char *contents, sframe_frame_row_entry *frep,
}
/* Serialize the core contents of the SFrame section and write out to the
- output buffer held in the ENCODER. Return SFRAME_ERR if failure. */
+ output buffer held in the ECTX. Return SFRAME_ERR if failure. */
static int
-sframe_encoder_write_sframe (sframe_encoder_ctx *encoder)
+sframe_encoder_write_sframe (sframe_encoder_ctx *ectx)
{
char *contents;
size_t buf_size;
@@ -1969,15 +1969,15 @@ sframe_encoder_write_sframe (sframe_encoder_ctx *encoder)
uint32_t fre_type;
int err = 0;
- contents = encoder->sfe_data;
- buf_size = encoder->sfe_data_size;
- num_fdes = sframe_encoder_get_num_fidx (encoder);
+ contents = ectx->sfe_data;
+ buf_size = ectx->sfe_data_size;
+ num_fdes = sframe_encoder_get_num_fidx (ectx);
all_fdes_size = num_fdes * sizeof (sframe_func_desc_entry);
- ehp = sframe_encoder_get_header (encoder);
+ ehp = sframe_encoder_get_header (ectx);
hdr_size = sframe_get_hdr_size (ehp);
- fd_info = encoder->sfe_funcdesc;
- fr_info = encoder->sfe_fres;
+ fd_info = ectx->sfe_funcdesc;
+ fr_info = ectx->sfe_fres;
/* Sanity checks:
- buffers must be malloc'd by the caller. */
@@ -2027,19 +2027,19 @@ sframe_encoder_write_sframe (sframe_encoder_ctx *encoder)
sframe_assert (fre_size == ehp->sfh_fre_len);
sframe_assert (global == ehp->sfh_num_fres);
- sframe_assert ((size_t)(contents - encoder->sfe_data) == buf_size);
+ sframe_assert ((size_t)(contents - ectx->sfe_data) == buf_size);
/* Sort the FDE table */
- sframe_sort_funcdesc (encoder);
+ sframe_sort_funcdesc (ectx);
/* Sanity checks:
- the FDE section must have been sorted by now on the start address
of each function. */
- if (!(sframe_encoder_get_flags (encoder) & SFRAME_F_FDE_SORTED)
+ if (!(sframe_encoder_get_flags (ectx) & SFRAME_F_FDE_SORTED)
|| (fd_info == NULL))
return sframe_set_errno (&err, SFRAME_ERR_FDE_INVAL);
- contents = encoder->sfe_data;
+ contents = ectx->sfe_data;
/* Write out the SFrame header. The SFrame header in the encoder
object has already been updated with correct offsets by the caller. */
memcpy (contents, ehp, hdr_size);
@@ -2056,7 +2056,7 @@ sframe_encoder_write_sframe (sframe_encoder_ctx *encoder)
is updated to the size of the buffer. */
char *
-sframe_encoder_write (sframe_encoder_ctx *encoder,
+sframe_encoder_write (sframe_encoder_ctx *ectx,
size_t *encoded_size, int *errp)
{
sframe_header *ehp;
@@ -2065,29 +2065,28 @@ sframe_encoder_write (sframe_encoder_ctx *encoder,
/* Initialize the encoded_size to zero. This makes it simpler to just
return from the function in case of failure. Free'ing up of
- encoder->sfe_data is the responsibility of the caller. */
+ ectx->sfe_data is the responsibility of the caller. */
*encoded_size = 0;
- if (encoder == NULL || encoded_size == NULL || errp == NULL)
+ if (ectx == NULL || encoded_size == NULL || errp == NULL)
return sframe_ret_set_errno (errp, SFRAME_ERR_INVAL);
- ehp = sframe_encoder_get_header (encoder);
+ ehp = sframe_encoder_get_header (ectx);
hdrsize = sframe_get_hdr_size (ehp);
- fsz = sframe_encoder_get_num_fidx (encoder)
- * sizeof (sframe_func_desc_entry);
- fresz = encoder->sfe_fre_nbytes;
+ fsz = sframe_encoder_get_num_fidx (ectx) * sizeof (sframe_func_desc_entry);
+ fresz = ectx->sfe_fre_nbytes;
/* Encoder writes out data in the latest SFrame format version. */
- if (sframe_encoder_get_version (encoder) != SFRAME_VERSION)
+ if (sframe_encoder_get_version (ectx) != SFRAME_VERSION)
return sframe_ret_set_errno (errp, SFRAME_ERR_VERSION_INVAL);
/* The total size of buffer is the sum of header, SFrame Function Descriptor
Entries section and the FRE section. */
bufsize = hdrsize + fsz + fresz;
- encoder->sfe_data = (char *) malloc (bufsize);
- if (encoder->sfe_data == NULL)
+ ectx->sfe_data = (char *) malloc (bufsize);
+ if (ectx->sfe_data == NULL)
return sframe_ret_set_errno (errp, SFRAME_ERR_NOMEM);
- encoder->sfe_data_size = bufsize;
+ ectx->sfe_data_size = bufsize;
/* Update the information in the SFrame header. */
/* SFrame FDE section follows immediately after the header. */
@@ -2099,18 +2098,18 @@ sframe_encoder_write (sframe_encoder_ctx *encoder,
foreign_endian = need_swapping (ehp->sfh_abi_arch);
/* Write out the FDE Index and the FRE table in the sfe_data. */
- if (sframe_encoder_write_sframe (encoder))
+ if (sframe_encoder_write_sframe (ectx))
return sframe_ret_set_errno (errp, SFRAME_ERR_BUF_INVAL);
/* Endian flip the contents if necessary. */
if (foreign_endian)
{
- if (flip_sframe (encoder->sfe_data, bufsize, 1))
+ if (flip_sframe (ectx->sfe_data, bufsize, 1))
return sframe_ret_set_errno (errp, SFRAME_ERR_BUF_INVAL);
- if (flip_header (encoder->sfe_data, SFRAME_VERSION))
+ if (flip_header (ectx->sfe_data, SFRAME_VERSION))
return sframe_ret_set_errno (errp, SFRAME_ERR_BUF_INVAL);
}
*encoded_size = bufsize;
- return encoder->sfe_data;
+ return ectx->sfe_data;
}
--
2.43.0
More information about the Binutils
mailing list