type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
s->intra_matrix[j] =
s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
} |
functions | endif
if (avctx->b_frame_strategy == 2) {
for (i = 0; i < s->max_b_frames + 2; i++) {
s->tmp_frames[i] = av_frame_alloc();
if (!s->tmp_frames[i])
return AVERROR(ENOMEM);
s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
s->tmp_frames[i]->width ... |
functions | int ff_mpv_encode_end(AVCodecContext *avctx)
{
MpegEncContext *s = avctx->priv_data;
int i;
ff_rate_control_uninit(s);
ff_mpv_common_end(s);
if (CONFIG_MJPEG_ENCODER &&
s->out_format == FMT_MJPEG)
ff_mjpeg_encode_close(s);
av_freep(&avctx->extradata);
for (i = 0; i < FF_A... |
functions | int get_sae(uint8_t *src, int ref, int stride)
{
int x,y;
int acc = 0;
for (y = 0; y < 16; y++) {
for (x = 0; x < 16; x++) {
acc += FFABS(src[x + y * stride] - ref);
} |
functions | int get_intra_count(MpegEncContext *s, uint8_t *src,
uint8_t *ref, int stride)
{
int x, y, w, h;
int acc = 0;
w = s->width & ~15;
h = s->height & ~15;
for (y = 0; y < h; y += 16) {
for (x = 0; x < w; x += 16) {
int offset = x + y * stride;
... |
functions | int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
{
return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
s->chroma_x_shift, s->chroma_y_shift, s->out_format,
s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
... |
functions | int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
{
Picture *pic = NULL;
int64_t pts;
int i, display_picture_number = 0, ret;
const int encoding_delay = s->max_b_frames ? s->max_b_frames :
(s->low_delay ? 0 : 1);
int direct = 1;
i... |
functions | int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
{
int x, y, plane;
int score = 0;
int64_t score64 = 0;
for (plane = 0; plane < 3; plane++) {
const int stride = p->f->linesize[plane];
const int bw = plane ? 1 : 2;
for (y = 0; y < s->mb_height * bw; y++) {
... |
functions | int encode_frame(AVCodecContext *c, AVFrame *frame)
{
AVPacket pkt = { 0 } |
functions | int estimate_best_b_count(MpegEncContext *s)
{
AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
AVCodecContext *c = avcodec_alloc_context3(NULL);
const int scale = s->avctx->brd_scale;
int i, j, out_size, p_lambda, b_lambda, lambda2;
int64_t best_rd = INT64_MAX;
int best_b_count = ... |
functions | int select_input_picture(MpegEncContext *s)
{
int i, ret;
for (i = 1; i < MAX_PICTURE_COUNT; i++)
s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
/* set next picture type & ordering */
if (!s->reordered_input_pict... |
functions | else if (s->avctx->b_frame_strategy == 1) {
for (i = 1; i < s->max_b_frames + 1; i++) {
if (s->input_picture[i] &&
s->input_picture[i]->b_frame_score == 0) {
s->input_picture[i]->b_frame_score =
get_intra_cou... |
functions | else if (s->avctx->b_frame_strategy == 2) {
b_frames = estimate_best_b_count(s);
} |
functions | void frame_end(MpegEncContext *s)
{
if (s->unrestricted_mv &&
s->current_picture.reference &&
!s->intra_only) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
int hshift = desc->log2_chroma_w;
int vshift = desc->log2_chroma_h;
s->mpvencdsp.dr... |
functions | void update_noise_reduction(MpegEncContext *s)
{
int intra, i;
for (intra = 0; intra < 2; intra++) {
if (s->dct_count[intra] > (1 << 16)) {
for (i = 0; i < 64; i++) {
s->dct_error_sum[intra][i] >>= 1;
} |
functions | int frame_start(MpegEncContext *s)
{
int ret;
/* mark & release old frames */
if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
s->last_picture_ptr != s->next_picture_ptr &&
s->last_picture_ptr->f->buf[0]) {
ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
} |
functions | else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
} |
functions | int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pic_arg, int *got_packet)
{
MpegEncContext *s = avctx->priv_data;
int i, stuffing_count, ret;
int context_count = s->slice_context_count;
s->vbv_ignore_qmax = 0;
s->picture_in_gop_number++;
... |
functions | it
if (s->pict_type == AV_PICTURE_TYPE_P) {
if (s->flipflop_rounding ||
s->codec_id == AV_CODEC_ID_H263P ||
s->codec_id == AV_CODEC_ID_MPEG4)
s->no_rounding ^= 1;
} |
functions | void dct_single_coeff_elimination(MpegEncContext *s,
int n, int threshold)
{
static const char tab[64] = {
3, 2, 2, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
... |
functions | else if (level > 1) {
return;
} |
functions | void clip_coeffs(MpegEncContext *s, int16_t *block,
int last_index)
{
int i;
const int maxlevel = s->max_qcoeff;
const int minlevel = s->min_qcoeff;
int overflow = 0;
if (s->mb_intra) {
i = 1; // skip clipping of intra dc
} |
functions | else if (level < minlevel) {
level = minlevel;
overflow++;
} |
functions | void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
{
int x, y;
// FIXME optimize
for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) {
int x2, y2;
int sum = 0;
int sqr = 0;
int count = 0;
for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(... |
functions | void encode_mb_internal(MpegEncContext *s,
int motion_x, int motion_y,
int mb_block_height,
int mb_block_width,
int mb_block_cou... |
functions | else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
s->pdsp.get_pixels(... |
functions | FIXME
if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
for (i = 0; i < mb_block_count; i++) {
int j;
if (s->block_last_index[i] > 0) {
for (j = 63; j > 0; j--) {
if (s->block[i][s->intra_scantable.permutated[j]])
... |
functions | void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
{
if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 8, 6);
else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
} |
functions | void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
int i;
memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
/* mpeg1 */
d->mb_skip_run= s->mb_skip_run;
for(i=0; i<3; i++)
d->last_dc[i] = s->last_dc[i];
/* statistics ... |
functions | void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
int i;
memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
/* mpeg1 */
d->mb_skip_run= s->mb_skip_run;
for(i=0; i<3; i++)
d->las... |
functions | void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
int *dmin, int *next_block, int motion_x, int motion_y)
{
int score;
uint8_t *dest_backup[3];
... |
functions | int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
uint32_t *sq = ff_square_tab + 256;
int acc=0;
int x,y;
if(w==16 && h==16)
return s->mecc.sse[0](NULL, src1, src2, stride, 16);
else if(w==8 && h==8)
return s->mecc.sse[1](NULL, src1, src2, stride, 8... |
functions | int sse_mb(MpegEncContext *s){
int w= 16;
int h= 16;
if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
if(w==16 && h==16)
if(s->avctx->mb_cmp == FF_CMP_NSSE){
return s->mecc.nsse[0](s, s->new_picture.f->data[0] + s->mb... |
functions | int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
MpegEncContext *s= *(void**)arg;
s->me.pre_pass=1;
s->me.dia_size= s->avctx->pre_dia_size;
s->first_slice_line=1;
for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x... |
functions | int estimate_motion_thread(AVCodecContext *c, void *arg){
MpegEncContext *s= *(void**)arg;
ff_check_alignment();
s->me.dia_size= s->avctx->dia_size;
s->first_slice_line=1;
for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
s->mb_x=0; //for block init below
ff_init_bloc... |
functions | int mb_var_thread(AVCodecContext *c, void *arg){
MpegEncContext *s= *(void**)arg;
int mb_x, mb_y;
ff_check_alignment();
for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
for(mb_x=0; mb_x < s->mb_width; mb_x++) {
int xx = mb_x * 16;
int yy = mb_y * 16;
ui... |
functions | void write_slice_end(MpegEncContext *s){
if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
if(s->partitioned_frame){
ff_mpeg4_merge_partitions(s);
} |
functions | else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
ff_mjpeg_encode_stuffing(s);
} |
functions | void write_mb_info(MpegEncContext *s)
{
uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
int offset = put_bits_count(&s->pb);
int mba = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
int gobn = s->mb_y / s->gob_index;
int pred_x, pred_y;
if (CONFIG_H263_ENCODER)
ff_h263_pred_mot... |
functions | void update_mb_info(MpegEncContext *s, int startcode)
{
if (!s->mb_info)
return;
if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
s->mb_info_size += 12;
s->prev_mb_info = s->last_mb_info;
} |
functions | int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
{
if ( s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold
&& s->slice_context_count == 1
&& s->pb.buf == s->avctx->internal->byte_buffer) {
int lastgob_pos = s->ptr_lastgob - s->p... |
functions | int encode_thread(AVCodecContext *c, void *arg){
MpegEncContext *s= *(void**)arg;
int mb_x, mb_y, pdif = 0;
int chr_h= 16>>s->chroma_y_shift;
int i, j;
MpegEncContext best_s = { 0 } |
functions | else if(best_s.mv_dir&MV_DIR_BACKWARD){
mx= s->mv[1][0][0];
my= s->mv[1][0][1];
} |
functions | possible
switch(mb_type){
case CANDIDATE_MB_TYPE_INTRA:
s->mv_dir = 0;
s->mb_intra= 1;
motion_x= s->mv[0][0][0] = 0;
motion_y= s->mv[0][0][1] = 0;
break;
case CANDIDATE_MB... |
functions | void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
MERGE(me.scene_change_score);
MERGE(me.mc_mb_var_sum_temp);
MERGE(me.mb_var_sum_temp);
} |
functions | void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
int i;
MERGE(dct_count[0]); //note, the other dct vars are not part of the context
MERGE(dct_count[1]);
MERGE(mv_bits);
MERGE(i_tex_bits);
MERGE(p_tex_bits);
MERGE(i_count);
MERGE(f_count);
MERGE(b_count);
... |
functions | int estimate_qp(MpegEncContext *s, int dry_run){
if (s->next_lambda){
s->current_picture_ptr->f->quality =
s->current_picture.f->quality = s->next_lambda;
if(!dry_run) s->next_lambda= 0;
} |
functions | else if (!s->fixed_qscale) {
s->current_picture_ptr->f->quality =
s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run);
if (s->current_picture.f->quality < 0)
return -1;
} |
functions | void set_frame_distances(MpegEncContext * s){
av_assert1(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
if(s->pict_type==AV_PICTURE_TYPE_B){
s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
assert(s->pb_time > 0... |
functions | int encode_picture(MpegEncContext *s, int picture_number)
{
int i, ret;
int bits;
int context_count = s->slice_context_count;
s->picture_number = picture_number;
/* Reset the average MB variance */
s->me.mb_var_sum_temp =
s->me.mc_mb_var_sum_temp = 0;
/* we need to initialize some ... |
functions | else if(s->pict_type!=AV_PICTURE_TYPE_B){
if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
s->no_rounding ^= 1;
} |
functions | functions
for(i=1; i<context_count; i++){
ret = ff_update_duplicate_context(s->thread_context[i], s);
if (ret < 0)
return ret;
} |
functions | problems
if (s->out_format == FMT_MJPEG) {
const uint16_t * luma_matrix = ff_mpeg1_default_intra_matrix;
const uint16_t *chroma_matrix = ff_mpeg1_default_intra_matrix;
if (s->avctx->intra_matrix) {
chroma_matrix =
luma_matrix = s->avctx->intra_matrix;
} |
functions | else if (CONFIG_MPEG4_ENCODER && s->h263_pred) {
ret = ff_mpeg4_encode_picture_header(s, picture_number);
if (ret < 0)
return ret;
} |
functions | else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
ret = ff_rv10_encode_picture_header(s, picture_number);
if (ret < 0)
return ret;
} |
functions | void denoise_dct_c(MpegEncContext *s, int16_t *block){
const int intra= s->mb_intra;
int i;
s->dct_count[intra]++;
for(i=0; i<64; i++){
int level= block[i];
if(level){
if(level>0){
s->dct_error_sum[intra][i] += level;
level -= s->dct_offset[... |
functions | int dct_quantize_trellis_c(MpegEncContext *s,
int16_t *block, int n,
int qscale, int *overflow){
const int *qmat;
const uint16_t *matrix;
const uint8_t *scantable= s->intra_scantable.scantable;
const uint8_t *perm_scantable= s->intra_sc... |
functions | happened
if(last_non_zero < start_i){
memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
return last_non_zero;
} |
functions | else if(s->out_format == FMT_MJPEG) {
j = s->idsp.idct_permutation[scantable[i]];
unquant_coeff = alevel * matrix[j] * 8;
} |
functions | optimize
if(s->mb_intra){
unquant_coeff = (int)( alevel * qscale * matrix[j]) >> 3;
unquant_coeff = (unquant_coeff - 1) | 1;
} |
functions | level
if(last_non_zero <= 27){
for(; survivor_count; survivor_count--){
if(score_tab[ survivor[survivor_count-1] ] <= best_score)
break;
} |
functions | void build_basis(uint8_t *perm){
int i, j, x, y;
emms_c();
for(i=0; i<8; i++){
for(j=0; j<8; j++){
for(y=0; y<8; y++){
for(x=0; x<8; x++){
double s= 0.25*(1<<BASIS_SHIFT);
int index= 8*i + j;
int perm_index= perm... |
functions | int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
int16_t *block, int16_t *weight, int16_t *orig,
int n, int qscale){
int16_t rem[64];
LOCAL_ALIGNED_16(int16_t, d1, [64]);
const uint8_t *scantable= s->intra_scantable.scantable;
const uint8... |
functions | REFINE_STATS
if(last_non_zero>0){
STOP_TIMER("init rem[]")
} |
functions | endif
for(;;){
int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
int best_coeff=0;
int best_change=0;
int run2, best_unquant_change=0, analyze_gradient;
#ifdef REFINE_STATS
{START_TIMER
#endif
analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shap... |
functions | overflow
if(level){
if(level < 63 && level > -63){
if(i < last_non_zero)
score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
- length[UNI_AC_ENC_INDEX(run, level+64)];
... |
functions | endif
if(best_change){
int j= perm_scantable[ best_coeff ];
block[j] += best_change;
if(best_coeff > last_non_zero){
last_non_zero= best_coeff;
av_assert2(block[j]);
#ifdef REFINE_STATS
after_last++;
#endif
} |
functions | REFINE_STATS
if(block[j]){
if(block[j] - best_change){
if(FFABS(block[j]) > FFABS(block[j] - best_change)){
raise++;
} |
functions | endif
for(; last_non_zero>=start_i; last_non_zero--){
if(block[perm_scantable[last_non_zero]])
break;
} |
functions | REFINE_STATS
if(last_non_zero>0){
STOP_TIMER("iterative search")
} |
functions | void block_permute(int16_t *block, uint8_t *permutation,
const uint8_t *scantable, int last)
{
int i;
int16_t temp[64];
if (last <= 0)
return;
//FIXME it is ok but not clean and might fail for some permutations
// if (permutation[1] == 1)
// return;
for (i... |
functions | int ff_dct_quantize_c(MpegEncContext *s,
int16_t *block, int n,
int qscale, int *overflow)
{
int i, j, level, last_non_zero, q, start_i;
const int *qmat;
const uint8_t *scantable= s->intra_scantable.scantable;
int bias;
int max=0;
unsigned int thre... |
functions | w_err_t parse_version(w_uint32_t version,char *buff,w_int32_t len)
{
wind_memset(buff, 0, len);
wind_sprintf(buff, "%d.%d.%d",DWORD_HBYTE2(version),
DWORD_HBYTE3(version),DWORD_HBYTE4(version));
return W_ERR_OK;
} |
functions | void boot_img_head_print(img_head_s *head)
{
static char *encty_type[4] =
{
"no encrypt",
"RC4"
} |
functions | w_err_t boot_img_head_get(img_head_s *head,w_uint8_t *buff)
{
w_uint32_t crc_calc,crc_read;
w_int32_t index = 0;
head->magic = (~IMG_MAGIC);
wind_to_uint32(&buff[index],&head->magic);
//ÕâÖÖÇé¿öÓ¦¸ÃÊÇbinÎļþûÓаüº¬Í·²¿½á¹¹
//if(head->magic != IMG_MAGIC)
// return W_ERR_OK;
... |
functions | w_err_t boot_img_head_set(img_head_s *head,w_uint8_t *buff)
{
w_uint32_t crc;
w_int32_t index = 0;
wind_memset(buff,0,head->head_len);
wind_from_uint32(&buff[index],head->magic);
index += 4;
wind_from_uint32(&buff[index],head->img_len);
index += 4;
wind_from_uint32(&buff[index... |
defines |
#define AES_TEXT_MSG_LENGTH_BYTES (64) |
functions | NvError PerformCmacOperation(NvDdkBlockDevHandle SeHandle,
NvU8* Key, NvU32 KeyLen, NvU8 *pSrcBuf, NvU8 *pDstBuf, NvU32 SrcBufSize,
NvBool IsFirstChunk, NvBool IsLastChunk)
{
NvError e = NvSuccess;
NvDdkSeAesComputeCmacInInfo CmacInInfo;
NvDdkSeAesComputeCmacOutInfo CmacOutInfo;
CmacInI... |
functions | NvError SeAesVerifyTest(NvU32 Instance)
{
NvError e = NvSuccess;
NvDdkBlockDevHandle SeHandle;
NvDdkSeAesOperation OpInfo;
NvDdkSeAesKeyInfo KeyInfo;
NvDdkSeAesProcessBufferInfo PbInfo;
NvDdkSeAesSetIvInfo SetIvInfo;
NvU8 CmacHash[16];
NvU8 EncryptBuffer[64];
NvU8 DecryptBuffer[64];
... |
defines | #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM |
defines |
#define REMAP(REG) \ |
structs | struct sjlj_lp_info
{
int directly_reachable;
int action_index;
int dispatch_index;
int call_site_index;
}; |
structs | struct reachable_info
{
tree types_caught;
tree types_allowed;
void (*callback) (struct eh_region *, void *);
void *callback_data;
bool saw_any_handlers;
}; |
structs | struct action_record
{
int offset;
int filter;
int next;
}; |
functions | int
doing_eh (int do_warn)
{
if (! flag_exceptions)
{
static int warned = 0;
if (! warned && do_warn)
{
error ("exception handling disabled, use -fexceptions to enable");
warned = 1;
} |
functions | void
init_eh (void)
{
if (! flag_exceptions)
return;
type_to_runtime_map = htab_create_ggc (31, t2r_hash, t2r_eq, NULL);
/* Create the SjLj_Function_Context structure. This should match
the definition in unwind-sjlj.c. */
if (USING_SJLJ_EXCEPTIONS)
{
tree f_jbuf, f_per, f_lsda, f_prev, f_... |
functions | void
init_eh_for_function (void)
{
cfun->eh = ggc_alloc_cleared (sizeof (struct eh_status));
} |
functions | int
get_eh_region_number (struct eh_region *region)
{
return region->region_number;
} |
functions | bool
get_eh_region_may_contain_throw (struct eh_region *region)
{
return region->may_contain_throw;
} |
functions | tree
get_eh_region_tree_label (struct eh_region *region)
{
return region->tree_label;
} |
functions | void
set_eh_region_tree_label (struct eh_region *region, tree lab)
{
region->tree_label = lab;
} |
functions | void
expand_resx_expr (tree exp)
{
int region_nr = TREE_INT_CST_LOW (TREE_OPERAND (exp, 0));
struct eh_region *reg = VEC_index (eh_region,
cfun->eh->region_array, region_nr);
gcc_assert (!reg->resume);
do_pending_stack_adjust ();
reg->resume = emit_jump_insn (gen_rtx_RESX (VOIDmode, region_nr));
e... |
functions | void
note_eh_region_may_contain_throw (struct eh_region *region)
{
while (region && !region->may_contain_throw)
{
region->may_contain_throw = 1;
region = region->outer;
} |
functions | void
note_current_region_may_contain_throw (void)
{
note_eh_region_may_contain_throw (cfun->eh->cur_region);
} |
functions | rtx
get_exception_pointer (struct function *fun)
{
rtx exc_ptr = fun->eh->exc_ptr;
if (fun == cfun && ! exc_ptr)
{
exc_ptr = gen_reg_rtx (ptr_mode);
fun->eh->exc_ptr = exc_ptr;
} |
functions | rtx
get_exception_filter (struct function *fun)
{
rtx filter = fun->eh->filter;
if (fun == cfun && ! filter)
{
filter = gen_reg_rtx (targetm.eh_return_filter_mode ());
fun->eh->filter = filter;
} |
functions | void
collect_eh_region_array (void)
{
struct eh_region *i;
i = cfun->eh->region_tree;
if (! i)
return;
VEC_safe_grow (eh_region, gc, cfun->eh->region_array,
cfun->eh->last_region_number + 1);
VEC_replace (eh_region, cfun->eh->region_array, 0, 0);
while (1)
{
VEC_replace (eh_region, cfun-... |
functions | void
remove_unreachable_regions (rtx insns)
{
int i, *uid_region_num;
bool *reachable;
struct eh_region *r;
rtx insn;
uid_region_num = xcalloc (get_max_uid (), sizeof(int));
reachable = xcalloc (cfun->eh->last_region_number + 1, sizeof(bool));
for (i = cfun->eh->last_region_number; i > 0; --i)
{
... |
functions | void
convert_from_eh_region_ranges (void)
{
rtx insns = get_insns ();
int i, n = cfun->eh->last_region_number;
/* Most of the work is already done at the tree level. All we need to
do is collect the rtl labels that correspond to the tree labels that
collect the rtl labels that correspond to the tree l... |
functions | void
add_ehl_entry (rtx label, struct eh_region *region)
{
struct ehl_map_entry **slot, *entry;
LABEL_PRESERVE_P (label) = 1;
entry = ggc_alloc (sizeof (*entry));
entry->label = label;
entry->region = region;
slot = (struct ehl_map_entry **)
htab_find_slot (cfun->eh->exception_handler_label_map, entr... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.