Quelle  bpf_jit_core.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * The back-end-agnostic part of Just-In-Time compiler for eBPF bytecode.
 *
 * Copyright (c) 2024 Synopsys Inc.
 * Author: Shahab Vahedi <shahab@synopsys.com>
 */
# bpf_jit
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

/*
 * Check for the return value. A pattern used often in this file.
 * There must be a "ret" variable of type "int" in the scope.
 */
#define CHECK_RET(cmd)   \
 do {    \
  ret = (cmd);  \
  if (ret < 0)  \
   return ret; \
 } while (0)

# ARC_BPF_JIT_DEBUG if (i= -java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
/* Dumps bytes in /var/log/messages at KERN_INFO level (4). */
  ( u8buf,u32,  char)
{
 u8 line[64];
 size_t  (%sn,line);

 pr_info("-----------------[ %s ]-----------------\n", header);

 for (i = 0, j = 0; i < len; i++) {
java.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24
  if (i == len - 1) { * index: java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   j 
   pr_info( * bpf2insn: Used  ** Things like * "prog- *
                       ;
  } * * prog:   * orig_prog:  The original * jit:   * bpf_header:  The JITed * emit:  * do_zext * bpf2insn:  Maps Indicates if * jit_data:  A piece * arc_regs_clobbered:  * save_blink:  Whether *  * epilogue_offset: Used ecast if an * is_extra_pass: Indicates * user_bpf_prog: True, * blinded:  True if * success:  Indicates if the *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     ;
     epilogue_offset
   j    need_extra_passjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  pr_info(%\, line);
   j = 0;
  } elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   j + *
  }
 }
}
#endif /* ARC_BPF_JIT_DEBUG */

/********************* JIT context ***********************/

/*
 * buf: Translated instructions end up here.
 * len: The length of whole block in bytes.
 * index: The offset at which the _next_ instruction may be put.
 */
struct jit_buffer {
 u8 *buf;
 u32 len;
 u32 index;
};

/*
 * This is a subset of "struct jit_context" that its information is deemed
 * necessary for the next extra pass to come.
 *
 * bpf_header: Needed to finally lock the region.
 * bpf2insn: Used to find the translation for instructions of interest.
 *
 * Things like "jit.buf" and "jit.len" can be retrieved respectively from
 * "prog->bpf_func" and "prog->jited_len".
 */
struct arc_jit_data {
 struct bpf_binary_header *bpf_header;
 
};

/*
 * The JIT pertinent context that is used by different functions.
 *
 * prog: The current eBPF program being handled.
 * orig_prog: The original eBPF program before any possible change.
 * jit: The JIT buffer and its length.
 * bpf_header: The JITed program header. "jit.buf" points inside it.
 * emit: If set, opcodes are written to memory; else, a dry-run.
 * do_zext: If true, 32-bit sub-regs must be zero extended.
 * bpf2insn: Maps BPF insn indices to their counterparts in jit.buf.
 * bpf2insn_valid: Indicates if "bpf2ins" is populated with the mappings.
 * jit_data: A piece of memory to transfer data to the next pass.
 * arc_regs_clobbered: Each bit status determines if that arc reg is clobbered.
 * save_blink: Whether ARC's "blink" register needs to be saved.
 * frame_size: Derived from "prog->aux->stack_depth".
 * epilogue_offset: Used by early "return"s in the code to jump here.
 * need_extra_pass: A forecast if an "extra_pass" will occur.
 * is_extra_pass: Indicates if the current pass is an extra pass.
 * user_bpf_prog: True, if VM opcodes come from a real program.
 * blinded: True if "constant blinding" step returned a new "prog".
 * success: Indicates if the whole JIT went OK.
 */
struct jit_context {
 struct bpf_prog   *prog;
 struct bpf_prog   *orig_prog;
  ;
 struct bpf_binary_header ;
 ;
   do_zext
    bpf2insn
 bool;
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
u32;
 bool    save_blink;
 u16    frame_size;{
 u32    epilogue_offsetmemset, 0, sizeofctx
 bool  need_extra_passjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  is_extra_pass
 bool     if (IS_ERR(ctx->prog
boolblinded;
 bool    successctx-blinded  ctx- ! ctx->);
};

/*
 * If we're in ARC_BPF_JIT_DEBUG mode and the debug level is right, dump the
 * input BPF stream. "bpf_jit_dump()" is not fully suited for this purpose.
 */
static void vm_dump(const struct bpf_prog *prog)
{
#ifdef ARC_BPF_JIT_DEBUG
 if (bpf_jit_enable > 1)
  dump_bytes((u8 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
endif
}

/*
 * If the right level of debug is set, dump the bytes. There are 2 variants
 * of this function:
 *
 * 1. Use the standard bpf_jit_dump() which is meant only for JITed code.
 * 2. Use the dump_bytes() to match its "vm_dump()" instance.
 */
static void jit_dump(const struct jit_context * Only after the first iteration * there are valid offsets in ctx-
{
#ifdef ARC_BPF_JIT_DEBUG
 u8 header{
#endif
 const int pass = ctx->is_extra_pass ? 2 : 1;

   ctx-;
}

#ifdef ARC_BPF_JIT_DEBUG
 scnprintf(header, sizeof(header), "JIT:%java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
.buf ctx-jit,);
 pr_info("\n");
#else
 bpf_jit_dump(ctx->prog-{
#endif
}

/* Initialise the context so there's no garbage. */
static int jit_ctx_init if(mem java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 memset

 ctx->orig_prog = prog * not freed, because "jit.buf", header" is lost and nothing points

 /* If constant blinding was requested but failed, scram. */ * how "bpf_jit_free()" in *
ctx- =(progjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6
 return(ctx-progjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 ctx->blinded = (ctx->prog !=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 
 ctx-  ctx->>verifier_zext

 ctx->is_extra_pass = ctx-> f(ctx- &&ctx-) java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   ctx->.  =0;

  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

/*
 * Only after the first iteration of normal pass (the dry-run),
 * there are valid offsets in ctx->bpf2insn array.
 */
static inline{
{
 return ctx->bpf2insn_valid;
}

/*
 * "*mem" should be freed when there is no "extra pass" to come,
 * or the compilation terminated abruptly. A few of such memory
 * allocations are: ctx->jit_data and ctx->bpf2insn.
 */
const bpf_insninsn >>insnsi
{
if*) {
 8;
   kfree
  * =NULL
   callinsn. =( |BPF_CALL)   : false
 }
 

/*
 * Free memories based on the status of the context.
 *
 * A note about "bpf_header": On successful runs, "bpf_header" is
 * not freed, because "jit.buf", a sub-array of it, is returned as
 * the "bpf_func". However, "bpf_header" is lost and nothing points
 * to it. This should not cause a leakage, because apparently
 * "bpf_header" can be revived by "bpf_jit_binary_hdr()". This is
 * how "bpf_jit_free()" in "kernel/bpf/core.c" releases the memory.
 */
static void jit_ctx_cleanup(struct jit_context *ctx)
{
 if (ctx->blinded) {
  /* if all went well, release the orig_prog. */
  if (ctx->successstatic inlineint(const  jit_contextctx
  bpf_jit_prog_release_otherctx->prog ctx-);
  else
   bpf_jit_prog_release_otherctx-, ctx->);
 }

 (ctx, ( **)ctx-bpf2insn)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 maybe_free  }elseif(ctx-jit. >ctx->jitlen {

 if (!ctx->bpf2insn)
  ctx->bpf2insn_valid = false;

 /* Freeing "bpf_header" is enough. "jit.buf" is a sub-array of it. */
 if (!ctx->success && ctx->bpf_header) {
  bpf_jit_binary_free(ctx->bpf_header   pr_err(bpf-jit: estimated JIT is  "
  ctx-bpf_header NULL
  ctx->jit.buf    = NULL;
  ctx->jit.index   -EFAULT;
  ctx->jit.len    = 0;
 }

 ctx->emit = false;
 ctx->do_zext = false;
}

/*
 * Analyse the register usage and record the frame size.
 * The register usage is determined by consulting the back-end.
 */
static void analyze_reg_usage(struct jit_context *ctx)
{
  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
u  =;
 const struct bpf_insn *insn = ctx->prog->insnsijava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 for (i = 0; i < ctx->prog->len; i++) {
  ;
  }

/
  call ([i].code =( | BPF_CALL? : false
  usage |= mask_for_used_regs(bpf_reg, callstatic inlineu8*(const jit_context*tx)
 }  ctx-emit ?(ctx-jitbuf >.)  NULL

 }
 ctx->frame_size/java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
}

/* Verify that no instruction will be emitted when there is no buffer. */CHECK_RETjit_buffer_check))java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static inline int jit_buffer_check( struct  *ctx)
{
 if (ctx->
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   pr_err(
 int;
   return -EINVAL;
  } else if (ctx->jit.index > ctx->jit.len) {
   pr_err u8buf (ctx;
        " .";
   return -EFAULT;
  }
 }
 return 0;
}

/* On a dry-run (emit=false), "jit.len" is growing gradually. */((ctx)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 inline jit_buffer_update(struct jit_context *tx,u32njava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
{
 if!tx->emit)
  ctx->jit.len += n;
 else
  ctx->jit.staticinline get_index_for_insnconst jit_context *tx
}

/* Based on "emit", determine the address where instructions are emitted. */ (nsn -ctx->insnsi
static inline u8 *effective_jit_buf(const struct jit_context *ctx * if it is an unconditional BPF_JMP32, then it  *
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return ctx-> (BPF_OP>code)= ))
}

/* Prologue based on context variables set by "analyze_reg_usage()". */
static int handle_prologue(struct jit_context *ctx)
{
}
 u8
 u32  ;

 CHECK_RET(jit_buffer_check(ctx));

len arc_prologue(, ctx->rc_regs_clobbered ctx-);
 jit_buffer_update(ctx, len);

 return 0;
}

/* The counter part for "handle_prologue()". */*The offsetis as the  BPFinstructions
static int(struct jit_context *tx)
{
 int ret;
 u8 *buf = effective_jit_buf(ctx);
 u32 len = 0;

 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 2

 len = * -1 m 1 instruction the next -jmpto current
jit_buffer_updatectxlen;

 return 0;
}

/* Tell which number of the BPF instruction we are dealing with. */
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 const  *)
{
 return (insn - ctx->prog->insnsi   treatedastwo instructionslong  "" neednt be
}

/*
 * In most of the cases, the "offset" is read from "insn->off". However,
 * if it is an unconditional BPF_JMP32, then it comes from "insn->imm".
 *
 * (Courtesy of "cpu=v4" support)
 */
static inline s32 get_offset(const struct bpf_insn *insn)
{
CLASS>) = ) &
     (BPF_OP(insn->code
 return insn-imm
else
  returnjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
}

/*
 * Determine to which number of the BPF instruction we're jumping to.
 *
 * The "offset" is interpreted as the "number" of BPF instructions
 * from the _next_ BPF instruction. e.g.:
 *
 *  4 means 4 instructions after  the next insn
 *  0 means 0 instructions after  the next insn -> fallthrough.
 * -1 means 1 instruction  before the next insn -> jmp to current insn.
 *
 *  Another way to look at this, "offset" is the number of instructions
 *  that exist between the current instruction and the target instruction.
 *
 *  It is worth noting that a "mov r,i64", which is 16-byte long, is
 *  treated as two instructions long, therefore "offset" needn't be
 *  treated specially for those. Everything is uniform.
 */
static  * 2. The stream of  *
         const struct bpf_insn *insn)
{
return(ctx ) + 1 +get_offset);
}

/* Is there an immediate operand encoded in the "insn"? */
static inline bool has_imm(const struct bpf_insn * the back-end for java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{/
 return BPF_SRC(switchsize
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return-INVAL;
 inline (conststruct  *progu32 idx)
{
 return idx == (prog->len - 1);
}

/*
 * Invocation of this function, conditionally signals the need for
 * an extra pass. The conditions that must be met are:
 *
 * 1. The current pass itself shouldn't be an extra pass.
 * 2. The stream of bytes being JITed must come from a user program.
 */
static
{
 if (!ctx->is_extra_pass)
 ctx->need_extra_passctx-user_bpf_prog
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/*
 * Check if the "size" is valid and then transfer the control to
 * the back-end for the swap.
 */
static 
 tatic bpf_cond_to_arc( u8op u8arc_cc
{
 /* Sanity check on the size. */
 switch   BPF_JA
  arc_cc=ARC_CC_ALjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
case2
 case 64:
  break;
 default:
  pr_err(bpf-jit   forswapn);
  return -EINVAL;
 }

 *len = gen_swap(buf, rd, size, endian, force,  break

 return 0;  arc_cc;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* Checks if the (instruction) index is in valid range. */
static inline bool check_insn_idx_valid(const struct jit_context *ctx,
   a =;
{
 return (idx >= 0 && idx < ctx->prog->len);
}

/*
 * Decouple the back-end from BPF by converting BPF conditions
 * to internal enum. ARC_CC_* start from 0 and are used as index
 * to an array. BPF_J* usage must end after this conversion.
 */
static int bpf_cond_to_arc(const u8 op, u8 *arc_cc)
{
 switchop{
 case BPF_JA:
  *arc_cc = ARC_CC_AL;
  break;
 case BPF_JEQ:
 *rc_cc ARC_CC_EQ
  break case BPF_JLE
   break
  *arc_cc =   BPF_JSLT
 ;
case:
   BPF_JSLE
  ;
   ;
  *arc_cc = ARC_CC_SET;
  break;
 case BPF_JNE:
  *arc_cc = ARC_CC_NE;
  break;
 case :
 returnEINVAL
  break;
caseBPF_JSGE:
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 case BPF_JLT:
  *
static check_bpf_jumpconst  jit_context*,
case:
  *arc_cc =c u8 =BPF_CLASS>code

 case BPF_JSLT:
  *arc_cc   ((class=BPF_JMP  !=BPF_JMP32 |
 ;
 case BPF_JSLE:
  *arc_cc = ARC_CC_SLE;
  break;
 default:
  pr_err("bpf-jit: can't handle condition 0x%02 pr_err("bpf-jit  a jump.\n"java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  -;
 }
 returnpr_err: jumpisin.n)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/*
 * Check a few things for a supposedly "jump" instruction:
 *
 * 0. "insn" is a "jump" instruction, but not the "call/exit" variant.
 * 1. The current "insn" index is in valid range.
 * 2. The index of target instruction is in valid range.
 */
static
     /*
{
const u8 class = BPF_CLASS(insn->code);
const u8 op = BPF_OP(insn->code);

/* Must be a jmp(32) instruction that is not a "call/exit". */
 if   &  ! ) |
     (      structbpf_insninsn)
  pr_err("bpf-jit: not a jump instruction.\n");
  return -EINVAL;
 }

 const s32idx =get_index_for_insnctxinsn
  pr_err("BUG_ON(!() || !check_insn_idx_valid(ctx, idx);
  return -return>bpf2insn];
 }

 if * The input "insn" must be a *
  pr_err("bpf-jit: bpf jump label * related JIT index (offset) of "target instruction" that
   -;
 }

 return;
}

/*
 * Based on input "insn", consult "ctx->bpf2insn" to get the
 * related index (offset) of the translation in JIT stream.
 */
static u32 get_curr_jit_off(const struct jit_context *ctx consts32 = get_target_index_for_insnctx, insn
        struct bpf_insn*nsn
{
3idxget_index_for_insn, insn
#ifdef}
 BUG_ON(!offsets_available(ctx) || !check_insn_idx_valid(ctx, idx));
#endif
 return ctx- * This function will return 0  *
}

/*
 * The input "insn" must be a jump instruction.
 *
 * Based on input "insn", consult "ctx->bpf2insn" to get the
 * related JIT index (offset) of "target instruction" that
 * "insn" would jump to.
 */
static u32 get_targ_jit_off({
       const struct bpf_insn *insn)
{
 const s32 tidx = get_target_index_for_insn(ctx, insn); intret=0;
ifdefARC_BPF_JIT_DEBUG
(!(ctx|| check_insn_idx_valid(tx tidx));
#endif
 return ctx->bpf2insn[tidx];
}


 *  }
 *
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ** 2. Determine  * 3. Sanity check * 4. Sanity check on what * 5. And finally, emit the necessary instructions *
 * between the "from_off" and java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 /
static int feasible_jit_jump(u32 from_off, u32 to_off, u8 cond, bool j32)
{
 int =0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

if)
(!check_jmp_32,to_off))
  =  u32 curr_off = 0
 } else {
  if (/
   ret = -EFAULT;
 }

 if /java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  pr_err("bpf-jit: the JIT displacement is not OK.\n");

  * 1. "gen_jmp_{32,64}()" deal  *
}

/*
 * This jump handler performs the following steps:
 *
 * 1. Compute ARC's internal condition code from BPF's
 * 2. Determine the bitness of the operation (32 vs. 64)
 * 3. Sanity check on BPF stream
 * 4. Sanity check on what is supposed to be JIT's displacement
 * 5. And finally, emit the necessary instructions
 *
 * The last two steps are performed through the back-end.
 * The value of steps 1 and 2 are necessary inputs for the back-end.
 */
static int handle_jumps(const struct jit_context *ctx,
   const struct bpf_insn *insn,
   u8*en
{
 u8 cond  * += (BUFbuf *en JIT_REG_TMP
 int ret ;
 u8 *buf  }
 const  j32 ((insn-) = )?  : ;
 const u8}
 u8 rs = insn-> /* If the offsets are,  if thebranch can. */
u32 = 0 targ_off0java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 *

 /* Map the BPF condition to internal enum. */
CHECK_RET((BPF_OP>), cond

 /* Sanity check on the BPF byte stream. */
 CHECK_RETcheck_bpf_jumpctx insn;

/
       curr_off, targ_off);
  *
  * 1. "gen_jmp_{32,64 curr_off, targ_off);
  }
  . ""parameter grow that current offset
     curr_off)will increasedto  where necessary
 *instructionsbe by"en_jmp_{32,4}("java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  */
 ifhas_imm) &  != ) java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 ifj32java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
= mov_r32_i32(BUF(buf,*), ,
         insn->imm);
   java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    }
         insn->imm);
  }
  rs = JIT_REG_TMP;
 }

 /* If the offsets are known, check if the branch can occur. */
 ((ctx){
   0
  }

  /* Sanity check on the back-end side. */
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
 }

 if (j32) {
  *len += gen_jmp_32(BUF(buf, *len), rd, rs,         u8len
    ,targ_off)
 } elseboolin_kernel_func fixed =;
  *   *buf effective_jit_bufctx);
       curr_off, targ_off);
 }

 return ret
}

/* Jump to translated epilogue address. */
static int handle_jmp_epilogue(struct jit_context *ctx,
 const  i u8java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
{
  * No valuable address retrieved (yet). */
  =0  = 0

java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 if*en (buf()addr in_kernel_func
  insn- !) java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  epi_off = ctx- java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  }
   pr_err("bpf-jit: epilogue offset is not valid.\n");
   return -EINVAL;
  }
 }

 /* Jump to "epilogue offset" (rd and rs don't matter). */
 *len  * relocations: R_BPF_64_64. Therefore, signal  * pass if the circumstances are  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 {
}

/* Try to get the resolved address and generate the instructions. */
static int idx=get_index_for_insn, insn
insn,
         u8 *len)
{
 int  ret;
 bool in_kernel_func, fixed = false;
   =;
 u8  *buf (": need moredatafor64- immediate.\";

 ret = bpf_jit_get_func_addr(ctx- returnEINVAL
        & }
 if
 * =mov_r64_i64, insn-, insn-imm, insn 1-imm)
  return  if((insn)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 in_kernel_func = (fixed ? true * it does not call "jit_buffer_check(* instruction. As a result, it should not be invoked directly. Only

 /* No valuable address retrieved (yet). */
 if (!fixed && * it mostly holds the value 0 and  * the loop in "handle_body()" to skip the next instruction, because
static handle_insnstruct *, u32 idx)

 *len = gen_func_call(buf, (ARC_ADDR)addr, in_kernel_func);

ifinsn- !=BPF_PSEUDO_CALL{
  /* Assigning ABI's return reg to JIT's return reg. */
  *len += arc_to_bpf_return  struct  *insn=&ctx->insnsi
}

  0


/*
 * Try to generate instructions for loading a 64-bit immediate.
 * These sort of instructions are usually associated with the 64-bit
 * relocations: R_BPF_64_64. Therefore, signal the need for an extra
 * pass if the circumstances are right.
 */
 int(struct *,
      struct *insn
      u8  break
{
 const s32 idx = get_index_for_insn(ctx,  BPF_ALU BPF_ADD|BPF_K:
 u8 *  break

 /* We're about to consume 2 VM instructions. */
 if (is_last_insn(ctx->prog, idx)) {
  pr_err(" case BPF_ALU | BPF_SUB |BPF_Xjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  BPF_ALU BPF_SUB :
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 len neg_r32, );

 if(insn)
  set_need_for_extra_pass(ctx);

 return 0;
}

/*
 * Handles one eBPF instruction at a time. To make this function faster,
 * it does not call "jit_buffer_check()". Else, it would call it for every
 * instruction. As a result, it should not be invoked directly. Only
 * "handle_body()", that has already executed the "check", may call this
 * function.
 *
 * If the "ret" value is negative, something has went wrong. Else,
 * it mostly holds the value 0 and rarely 1. Number 1 signals
 * the loop in "handle_body()" to skip the next instruction, because
 * it has been consumed as part of a 64-bit immediate value.
 */
static int handle_insn(struct jit_context *ctx, u32 idx)
{
 const struct bpf_insn /* dst /= src (32-bit) */
 const u8  code   =(buf, rc off== 1;
 const u8  dst=insn->dst_reg;
 const u8  src  = insn->src_reg;
 const s16 off  = insn->off;
 const s32 imm  = insn->imm;
 u8* = effective_jit_bufctx;
 u8  len = 0;
 int ret = 0;

 switch() {
 /* dst += src (32-bit) */ break;
 case BPF_ALU | BPF_ADD | BPF_X:
  len = add_r32(buf/* dst %= src (32-bit) */
 break
 /* dst += imm (32-bit) */, off=1;
 case BPF_ALU | BPF_ADD | BPF_K:
  len = add_r32_i32
  break;
/* dst -= src (32-bit) */
 case  |  | BPF_X
 len=sub_r32(buf, );
  break;
 /* dst -= imm (32-bit) */
 case BPF_ALU | BPF_SUB | BPF_K:
  len = sub_r32_i32(buf, dst, imm);
  break;
 /* dst = -dst (32-bit) */ BPF_ALU:
case  |:
   break
  /* dst &= imm (32-bit) */
 /* dst *= src (32-bit) */
 case BPF_ALUlen=(buf dstimm;
l =(buf, src;
  break
 /* dst *= imm (32-bit) */
   | BPF_MUL|BPF_K
  len = mul_r32_i32 len =or_r32,dst);
;
/* dst /= src (32-bit) */
 |BPF_DIV :
  = (bufdst );
  break;
 /* dst /= imm (32-bit) */
 case BPF_ALU | BPF_DIV | BPF_K:
  len =  /* dst ^= src bit)*
  break BPF_ALU | |BPF_X
/* dst %= src (32-bit) */
   break;
  len ^= imm(3-it *
   case | BPF_XOR|BPF_Kjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 /* dst %= imm (32-bit) */
 case BPF_ALU | BPF_LSH BPF_X:
  len mod_r32_i32buf,dst immoff= );
  break;
 /* dst &= src (32-bit) */
 case BPF_ALU | BPF_AND | BPF_X:
  len  break;
  break;
 /* dst &= imm (32-bit) */
 case BPF_ALU | BPF_AND | BPF_K /* dst <<= imm (32-bit) */
  len = and_r32_i32(buf, dst, imm);
  break;
 /* dst |= src (32-bit) */
 case BPF_ALU  len= lsh_r32_i32buf dst, imm);
  len  /* dst >>= src (32-bit) [unsigned] */
  break;
/* dst |= imm (32-bit) */
 case BPF_ALUlen =(buf dst );
len or_r32_i32(, , immjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 ;
 /* dst ^= src (32-bit) */
 case /* ds >src2bit[] *
    BPF_ALUBPF_ARSH  :
  break len arsh_r32, dst srcjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
 case  BPF_ALU| | :
  =xor_r32_i32buf dst imm)
  break;
 /* dst <<= src (32-bit) */
  BPF_ALU  | :
  len = lsh_r32(buf, dst, src);
;
 /* dst <<= imm (32-bit) */
 BPF_ALUBPF_LSH :
  len;
  break;
/
 case BPF_ALU | BPF_RSH | BPF_X:
  len=rsh_r32, , srcjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
;
 /* dst >>= imm (32-bit) [unsigned] */BPF_CLASS) ==BPF_ALU64
caseBPF_ALU| |:
  len = rsh_r32_i32
  break;
 /* dst >>= src (32-bit) [signed] */
 case BPF_ALUcaseBPF_ALU64  |:
(, , src;
 break
 /* dst >>= imm (32-bit) [signed] */
  BPF_ALU64 BPF_ADD BPF_K
 ,dst );
  break;
 /* dst = src (32-bit) */
 case BPF_ALU | /* dst -= src (64-bit) */
  len  len = sub_r64(buf, dst, src);
  break;
 /* dst = imm32 (32-bit) */
case |BPF_MOV :
  len =  len=sub_r64_i32, dst imm
  break /* dst = -dst (64-bit) */
 
case BPF_ALU   | BPF_END | BPF_FROM_LE:
case BPF_ALU   | BPF_END | BPF_FROM_BE:
case BPF_ALU64 | BPF_END | BPF_FROM_LE: {
CHECK_RET(handle_swap(buf, dst, imm, BPF_SRC(code),
      BPF_CLASS(code) == BPF_ALU64,
      ctx->do_zext, &len));
break;
}
/* dst += src (64-bit) */
 case  /* dst *= src (64-bit) */
   =(buf,src;
   len =mul_r64,dst);
/* dst += imm32 (64-bit) */
BPF_K
  len case BPF_ALU64 | BPF_MUL | BPF_K:
  break;
 /* dst -= src (64-bit) */
 case    |BPF_X
  len = sub_r64(buf, dst, src);

 /* dst -= imm32 (64-bit) */
 case
  len = sub_r64_i32(buf,  BPF_ALU64|BPF_ANDBPF_K:
  ;
/* dst = -dst (64-bit) */
  /* dst |= src (64-bit) */
  neg_r64,);
  break;
 /* dst *= src (64-bit) */
 case BPF_ALU64 | BPF_MUL | BPF_X:
l =(buf, src;
  break;
/java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 caselen (, , imm;
  len = mul_r64_i32(buf, dst, imm);
 break
 /* dst &= src (64-bit) */
 case BPF_ALU64 | BPF_AND | BPF_X:
  len = and_r64(buf, dst, src);
  break;
 /* dst &= imm32 (64-bit) */
 case BPF_ALU64 | BPF_AND | BPF_K:
  len = and_r64_i32(buf, dst, imm);
  break
 /* dst |= src (64-bit) */
  | | :
  len = or_r64( len xor_r64, dst src
  break/* dst ^= imm32 (64-bit) */
 /* dst |= imm32 (64-bit) */
caseBPF_ALU64 | BPF_K
  =(buf , immjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  break; = (buf, src
 /* dst ^= src (64-bit) */
 casecase | |BPF_X
  =xor_r64 ,);
  break  ;
 /* dst ^= imm32 (64-bit) */
 case BPF_ALU64|BPF_XOR :
 caseBPF_ALU64BPF_RSH :
;
 /* dst <<= src (64-bit) */java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
caseBPF_ALU64  |:
  len =  break
  break
 /* dst <<= imm32 (64-bit) */
 case java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  len
  break;
/
 case BPF_ALU64 | BPF_RSH | BPF_X len mov_r64, dstsrc,()off;
/
  break;
 
 case BPF_ALU64 | len =(buf, immjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  =(buf, );
  break;
 /* dst >>= src (64-bit) [signed] */
 BPF_ALU64BPF_ARSH |:
  len break
  /* dst = *(size *)(src + off) */
 /* dst >>= imm32 (64-bit) [signed] */
  case | | :
  len BPF_LDX | :
  break caseBPF_LDX BPF_MEM :
 /* dst = src (64-bit) */
 caseBPF_ALU64| | BPF_X
   break;
    |  | BPF_W:
 /* dst = imm32 (sign extend to 64-bit) */case BPF_LDX BPF_MEMSX|:
 caseBPF_ALU64 BPF_MOV|BPF_K
 len mov_r64_i32(buf dstimmjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  break;
 /* dst = imm64 */
   BPF_DW:
 case | |:
 * Tell the loop to skip the next instruction. */
  ret = 1;
  break;
 /* dst = *(size *)(src + off) */BPF_ST  |:
 case BPF_LDX | BPF_MEM |   BPF_ST  | BPF_H
  | |BPF_H
 case BPF_LDX  case BPF_ST|BPF_MEMBPF_DW
  BPF_LDX BPF_MEMBPF_DW
len(, , , off(code);
  break;
BPF_LDXBPF_MEMSX :
 case  caseBPF_JMP  |  | BPF_X
 case BPF_LDX | BPF_MEMSX | BPF_B:
,,src,(codetrue
;
/
 case  case BPF_JMP|  | :
 caseBPF_STX :
   |BPF_MEM :
 case   | | :
  len = store_r(buf, src, dst, off, BPF_SIZE(code));
  ;
 case BPF_ST     |BPF_JSGEBPF_X
 case BPF_ST | BPF_MEMc BPF_JMP    :
 case BPF_ST |:
 case BPF_ST | BPF_MEMBPF_JMP  |:
  len = store_i(buf, imm   BPF_JSLTBPF_X
  break;case   BPF_JSLT:
 case BPF_JMP    |BPF_JSLE|BPF_K
case   |BPF_JEQBPF_Xjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  BPF_JMP32|  |BPF_X
 case case BPF_JMP32|  | :
BPF_JMP   |:
 case BPF_JMP   | BPF_JSET BPF_JMP32  BPF_JSET |BPF_K
 case     BPF_JSET |BPF_K
 case BPF_JMP   | BPF_JGT  | BPF_K:
caseBPF_JMP       BPF_Kjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
case   |  |:
 case BPF_JMP   | BPF_JGE  | BPF_K:
 case BPF_JMP    case BPF_JMP32 |BPF_JSGE BPF_Xjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  BPF_JMP  |BPF_K
 case BPF_JMP   |  case BPF_JMP32 BPF_JLT| BPF_K
    | BPF_JSGE|BPF_K
  case   |:
 case |BPF_JSLT:
case      |BPF_X
 case BPF_JMP   |    | :
 case  HECK_REThandle_jumps(,,)
case     |:
 c   :
 case BPF_JMPbreak
  |:
   BPF_JEQ:
  |   :
 case   break
case|   :
 case java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 8
JMP32  :
 case}
 case BPF_JMP32 | BPF_JGT  | BPF_K:
  ((code=) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 case BPF_JMP32 |   * ALU type. "gen_swap()" specifically   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  | BPF_JSGT | BPF_X
 case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case int(  *)
 case BPF_JMP32 | BPF_JSGE | BPF_K
 case bool =;
:
 case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case  * Doing it this way allows us to have the mapping ready for
case    :
 case
   |:
 case  /* During the .    insn
 >[i  >jitjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  ;
 case    >bpf2insni + =>[i
  }
  break;

 case BPF_JMP populate_bpf2insn
 /* If this is the last instruction, epilogue will follow. */
  if (is_last_insn(ctx->prog, idx
 break
  CHECK_RET(
  break
 default*"" always
*
  return -EOPNOTSUPP;
 }

if()= ) {
 /
   * Skip the "swap" * possible fetch. In the * system, that beyond-byte will become * we have no control over its java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 3
   * () + -)=xff
 size 1
   java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  if (BPF_OP
   len +pr_errbpf-jit  memory
 }

(ctx );

 return ret;
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 ret
 boolctx-  bpf_jit_binary_alloc. ctx-,
 const struct bpf_prog *prog = ctx->prog;

 (jit_buffer_check)

 /*
 * Record the mapping for the instructions during the dry-run.
 * Doing it this way allows us to have the mapping ready for
 * the jump instructions during the real compilation phase.
 */
if>
  populate_bpf2insn = ctx-  ((*>),)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

  i ;i< prog- +)java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
  * instruction. It helps in getting a  * as the length of the *
  if staticintjit_prepare jit_context*tx
   ctx->bpf2insn[i] = ctx->jit.len;

  CHECK_RET(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 15
  if (ret > 0) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   /* "ret" is 1 if two (64-bit) chunks were consumed. */
   ctx->bpf2insn[i + 1] = ctx->bpf2insn[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   i++;
 }
 }

 /* If bpf2insn had to be populated, then it is done at this point. */
 ifCHECK_RET(andle_epilogue))java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  ctx-

/*
}

/*
 * Initialize the memory with "unimp_s" which is the mnemonic for
 * "unimplemented" instruction and always raises an exception.
 *
 * The instruction is 2 bytes. If "size" is odd, there is not much
 * that can be done about the last byte in "area". Because, the
 * CPU always fetches instructions in two bytes. Therefore, the
 * byte beyond the last one is going to accompany it during a
 * possible fetch. In the most likely case of a little endian
 * system, that beyond-byte will become the major opcode and
 * we have no control over its initialisation.
 */
static void fill_ill_insn(void *area, unsigned int * of instructions as jit_prepare() would java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
  =x79e0

if & 
()
  size()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 }

 memset16>.en>jit);
}

/* Piece of memory that can be allocated at the beginning of jit_prepare(). */
static 
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ctx- *
    GFP_KERNEL

 if (!ctx->bpf2insn) {
  pr_err("bpf-jit: could not allocate {
       mappingn)
  return
 }

 return0
}

/*
 * Memory allocations that rely on parameters known at the end of
 * jit_prepare().
 */
static   /*
{
const size_t alignment = sizeof(u32);

ctx->bpf_header = bpf_jit_binary_alloc(ctx->jit.len, &ctx->jit.buf,
       alignment, fill_ill_insn);
if (!ctx->bpf_header) {
pr_err("bpf-jit: could not allocate memory for translation.\n");
return -ENOMEM;
}

if (ctx->need_extra_pass) {
ctx->jit_data = kzalloc(sizeof(*ctx->jit_data), GFP_KERNEL);
if (!ctx->jit_data)
return -ENOMEM;
}

return 0;
}

/*
 * The first phase of the translation without actually emitting any
 * instruction. It helps in getting a forecast on some aspects, such
 * as the length of the whole program or where the epilogue starts.
 *
 * Whenever the necessary parameters are known, memories are allocated.
 */
staticjit_ctx_cleanupctx
{
 int ret;  0;

 /* Dry run. */
 ctx->emit * A lenient verification for the existence of JIT context in "prog". * Apparently the JIT internals, * may request for a  *

 CHECK_RETjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 analyze_reg_usage(ctx);
 CHECK_RET(handle_prologue(ctx));
  arc_jit_datajava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 (nj data \)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

 /* Record at which offset epilogue begins. */
 ctx->epilogue_offset = ctx->jit.len;

/
 CHECK_RET >  jdata-

> =ctx-   : false

 returnreturn;
}

/*
 * jit_compile() is the real compilation phase. jit_prepare() is
 * invoked before jit_compile() as a dry-run to make sure everything
 * will go OK and allocate the necessary memory.
 *
 * In the end, jit_compile() checks if it has produced the same number
 * of instructions as jit_prepare() would.
 */
int  ctx
{
 int ret;

 /* Let there be code. */
 ctx-  ( i  0;i<prog- + java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 CHECK_RET(   * can use it for their output java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 5

(ctx

 CHECK_RET

 if (ctx->jit.index !=return
  pr_err
         "%u vs. %u (bytes) * A normal pass that involves a "dry-run" phase, jit_prepare(),
         ctx-> * to get the necessary data for the real compilation phase,
 return-FAULT
 }

 return 0;


/*
 * Calling this function implies a successful JIT. A successful
 * translation is signaled by setting the right parameters:
 *
 * prog->jited=1, prog->jited_len=..., prog->bpf_func=...
 */
static(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 struct bpf_prog (&)){

 
 if (ctx->need_extra_pass)  }
  ctx->jit_data->bpf_header = ctx->bpf_header;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 } else {

   things, mark  
   and.
*
  ((ctx-) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
   pr_err(" check_jit_context(rog)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   return -EFAULT (&ctx;
  }
  flush_icache_range((unsigned long)ctx->bpf_header,
  ( long
       BUF(ctx->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
  prog-
  bpf_prog_fill_jited_linfo(prog, ctx->bpf2insn);
 }

 ctx-> java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 prog->bpf_func = ( return;
 prog->jited_len =
 prog->jited =  ctx;

 jit_ctx_cleanup
 jit_dump(ctx);

 return 0;
}

/*
 * A lenient verification for the existence of JIT context in "prog".
 * Apparently the JIT internals, namely jit_subprogs() in bpf/verifier.c,
 * may request for a second compilation although nothing needs to be done.
 */
static inline int check_jit_context(const
{
 if/
  pr_notice("bpf-jit: no jit data for the extra (prog->)
  return 1;
 } else {
  return 0;
 }
}

 return(prog)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct arc_jit_data *jdata =
  (struct arc_jit_data *)ctx->prog->aux->jit_data;

 if (!jdata) {
  pr_err("bpf-jit: no jit data for the extra pass.\n");
  return -EINVAL;
 }

 ctx->jit.buf = (u8 *)ctx->prog->bpf_func;
 ctx->jit.len = ctx->prog->jited_len;
 ctx->bpf_header = jdata->bpf_header;
 ctx->bpf2insn = (u32 *)jdata->bpf2insn;
 ctx->bpf2insn_valid = ctx->bpf2insn ? true : false;
 ctx->jit_data = jdata;

 return 0;
}

/*
 * Patch in the new addresses. The instructions of interest are:
 *
 * - call
 * - ld r64, imm64
 *
 * For "call"s, it resolves the addresses one more time through the
 * handle_call().
 *
 * For 64-bit immediate loads, it just retranslates them, because the BPF
 * core in kernel might have changed the value since the normal pass.
 */
static int jit_patch_relocations(struct jit_context *ctx)
{
 const u8 bpf_opc_call = BPF_JMP | BPF_CALL;
 const u8 bpf_opc_ldi64 = BPF_LD | BPF_DW | BPF_IMM;
 const struct bpf_prog *prog = ctx->prog;
 int ret;

 ctx->emit = true;
 for (u32 i = 0; i < prog->len; i++) {
  const struct bpf_insn *insn = &prog->insnsi[i];
  u8 dummy;
  /*
 * Adjust "ctx.jit.index", so "gen_*()" functions below
 * can use it for their output addresses.
 */
  ctx->jit.index = ctx->bpf2insn[i];

  if (insn->code == bpf_opc_call) {
   CHECK_RET(handle_call(ctx, insn, &dummy));
  } else if (insn->code == bpf_opc_ldi64) {
   CHECK_RET(handle_ld_imm64(ctx, insn, &dummy));
   /* Skip the next instruction. */
   ++i;
  }
 }
 return 0;
}

/*
 * A normal pass that involves a "dry-run" phase, jit_prepare(),
 * to get the necessary data for the real compilation phase,
 * jit_compile().
 */
static struct bpf_prog *do_normal_pass(struct bpf_prog *prog)
{
 struct jit_context ctx;

 /* Bail out if JIT is disabled. */
 if (!prog->jit_requested)
  return prog;

 if (jit_ctx_init(&ctx, prog)) {
  jit_ctx_cleanup(&ctx);
  return prog;
 }

 /* Get the lengths and allocate buffer. */
 if (jit_prepare(&ctx)) {
  jit_ctx_cleanup(&ctx);
  return prog;
 }

 if (jit_compile(&ctx)) {
  jit_ctx_cleanup(&ctx);
  return prog;
 }

 if (jit_finalize(&ctx)) {
  jit_ctx_cleanup(&ctx);
  return prog;
 }

 return ctx.prog;
}

/*
 * If there are multi-function BPF programs that call each other,
 * their translated addresses are not known all at once. Therefore,
 * an extra pass is needed to consult the bpf_jit_get_func_addr()
 * again to get the newly translated addresses in order to resolve
 * the "call"s.
 */
static struct bpf_prog *do_extra_pass(struct bpf_prog *prog)
{
 struct jit_context ctx;

 /* Skip if there's no context to resume from. */
 if (check_jit_context(prog))
  return prog;

 if (jit_ctx_init(&ctx, prog)) {
  jit_ctx_cleanup(&ctx);
  return prog;
 }

 if (jit_resume_context(&ctx)) {
  jit_ctx_cleanup(&ctx);
  return prog;
 }

 if (jit_patch_relocations(&ctx)) {
  jit_ctx_cleanup(&ctx);
  return prog;
 }

 if (jit_finalize(&ctx)) {
  jit_ctx_cleanup(&ctx);
  return prog;
 }

 return ctx.prog;
}

/*
 * This function may be invoked twice for the same stream of BPF
 * instructions. The "extra pass" happens, when there are
 * (re)locations involved that their addresses are not known
 * during the first run.
 */
struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)
{
 vm_dump(prog);

 /* Was this program already translated? */
 if (!prog->jited)
  return do_normal_pass(prog);
 else
  return do_extra_pass(prog);

 return prog;
}